public static LoggingConfiguration Create(string name, string filePath = null)
{
if (string.IsNullOrWhiteSpace(name))
{
name = "Default";
}
// Trace Listeners
var listener = new RollingFlatFileTraceListener((filePath ?? "Logging") + "\\" + name + ".log",
header: string.Empty, footer: string.Empty, formatter: _SimplyFormatter,
rollFileExistsBehavior: RollFileExistsBehavior.Increment, rollInterval: RollInterval.Day, maxArchivedFiles: 30);
// Build Configuration
var config = new LoggingConfiguration();
config.DefaultSource = LogLevel.Information.ToString();
config.IsLoggingEnabled = true;
//config.AddLogSource(Logger.InformationCategoryName, SourceLevels.All, autoFlush: true).AddAsynchronousTraceListener(listener);
// Special Sources Configuration
//config.SpecialSources.Unprocessed.AddTraceListener(listener);
config.SpecialSources.Unprocessed.Level = SourceLevels.All;
config.SpecialSources.Unprocessed.AutoFlush = true;
var eventLogListener = CreateEventLogTraceListener();
config.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(eventLogListener);
config.SpecialSources.LoggingErrorsAndWarnings.Level = SourceLevels.All;
config.SpecialSources.LoggingErrorsAndWarnings.AutoFlush = true;
// All Event
config.SpecialSources.AllEvents.AddAsynchronousTraceListener(listener);
config.SpecialSources.AllEvents.Level = SourceLevels.All;
config.SpecialSources.AllEvents.AutoFlush = true;
return config;
}
/// <summary>
/// Initializes a new instance of the <see cref="StreamWriterRollingHelper"/>.
/// </summary>
/// <param name="owner">The <see cref="RollingFlatFileTraceListener"/> to use.</param>
public StreamWriterRollingHelper(RollingFlatFileTraceListener owner)
{
this.owner = owner;
this.dateTimeProvider = new DateTimeProvider();
this.performsRolling = this.owner.rollInterval != RollInterval.None || this.owner.rollSizeInBytes > 0;
}
/// <summary>
/// Initialize a new instance of the <see cref="StreamWriterRollingHelper"/> class with a <see cref="RollingFlatFileTraceListener"/>.
/// </summary>
/// <param name="owner">The <see cref="RollingFlatFileTraceListener"/> to use.</param>
public StreamWriterRollingHelper(RollingFlatFileTraceListener owner)
{
this.owner = owner;
dateTimeProvider = new DateTimeProvider();
performsRolling = this.owner.rollInterval != RollInterval.None || this.owner.rollSizeInBytes > 0;
}
public static void CheckListener()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "test.log");
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(fileName, "header", "footer", null, 1, "", RollFileExistsBehavior.Increment, RollInterval.Day);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
}
public void WriterKeepsTally()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null, 10, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.Write("12345");
Assert.AreEqual(5L, ((RollingFlatFileTraceListener.TallyKeepingFileStreamWriter)traceListener.Writer).Tally);
}
}
public void ListenerForNewFileWillUseCreationDateToCalculateRollDate()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
Assert.AreEqual(traceListener.RollingHelper.CalculateNextRollDate(File.GetCreationTime(fileName)), traceListener.RollingHelper.NextRollDateTime);
Assert.IsNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
}
public static LogWriter ConfigureLogWriter()
{
//var textFileFormatter = new TextFormatter();
var flatFileListener = new RollingFlatFileTraceListener(@"C:\Temp\EntLibLgoFile.log");
var asynFlatFileTraceListener = new AsynchronousTraceListenerWrapper(flatFileListener, true);
EventLog ev = new EventLog("Application", ".", "EntLibLogging");
EventLog eventLog = new EventLog("Application");
var eventLogListener = new EventLogTraceListener(ev);
var asyncEventLogListener = new AsynchronousTraceListenerWrapper(eventLogListener, true);
var loggingConfig = new LoggingConfiguration();
loggingConfig.AddLogSource("EntLibFlatFileLogging", SourceLevels.All, false, asynFlatFileTraceListener);
loggingConfig.AddLogSource("EntLibEventLogLogging", SourceLevels.All, false, asyncEventLogListener);
logWriter = new LogWriter(loggingConfig);
return logWriter;
}
/// <summary>
/// Static constructor
/// </summary>
static Logger() {
string LogFile = ConfigurationManager.AppSettings["LogFile"].ToString();// a static constructor works because changing the web.config restarts the appliaction.
// this defaults to the namespace WebForms even when used in another application so it's not used
//string LogFile=Properties.Settings.Default.LogFile;
if(ConfigurationManager.AppSettings["LogErr"].ToString().ToLower()=="yes") {
LogErr=true;
}
if(ConfigurationManager.AppSettings["LogInfo"].ToString().ToLower()=="yes") {
LogInfo=true;
}
// formatter
TextFormatter formatter = new TextFormatter("[{timestamp(local)}] [{machine}] {category} \t: {message}");
// listeners
FlatFileTraceListener logFileListener=new FlatFileTraceListener(LogFile,"","",formatter);
RollingFlatFileTraceListener rollingFlatFileListener=new RollingFlatFileTraceListener(LogFile,"","",formatter,1000,"yyyy-MM-dd",RollFileExistsBehavior.Increment,RollInterval.Day);
//uncomment if an event log is needed
//FormattedEventLogTraceListener logEventListener = new FormattedEventLogTraceListener("Enterprise Library Logging",formatter);
// Sources
LogSource mainLogSource = new LogSource("MainLogSource",SourceLevels.All);
//mainLogSource.Listeners.Add(logFileListener);//regular flat file
mainLogSource.Listeners.Add(rollingFlatFileListener);
//uncomment if an event log is needed
//LogSource errorLogSource = new LogSource("ErrorLogSource",SourceLevels.Error);
//errorLogSource.Listeners.Add(logEventListener);
// empty source
LogSource nonExistantLogSource = new LogSource("Empty");//non matching category.
// trace sources
IDictionary<string,LogSource> traceSources = new Dictionary<string,LogSource>();
//traceSources.Add("Error",errorLogSource);//uncomment if an event log is needed
traceSources.Add("Warning",mainLogSource);
traceSources.Add("Information",mainLogSource);
// log writer
writer = new LogWriter(new ILogFilter[0],traceSources,mainLogSource,nonExistantLogSource,
mainLogSource,"Error",false,true);
//writer = new LogWriter(new ILogFilter[0],traceSources,mainLogSource,nonExistantLogSource,
//errorLogSource,"Error",false,true);//uncomment if 'internal' error are to be logged to an event log is needed
}
public void ListenerForExistingFileWillUseCreationDateToCalculateRollDate()
{
File.WriteAllText(fileName, "existing text");
File.SetCreationTime(fileName, new DateTime(2000, 01, 01));
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
dateTimeProvider.currentDateTime = new DateTime(2008, 01, 01);
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
Assert.AreEqual(traceListener.RollingHelper.CalculateNextRollDate(File.GetCreationTime(fileName)), traceListener.RollingHelper.NextRollDateTime);
Assert.AreEqual(dateTimeProvider.CurrentDateTime, traceListener.RollingHelper.CheckIsRollNecessary());
}
}
public void RollingFlatFileTraceListenerReplacedEnviromentVariablesWillFallBackIfNotPrivilegesToRead()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "foo.log");
EnvironmentPermission denyPermission = new EnvironmentPermission(PermissionState.Unrestricted);
denyPermission.Deny();
try
{
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(fileName, "header", "footer", null, 1, "", RollFileExistsBehavior.Increment, RollInterval.Day);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
}
finally
{
EnvironmentPermission.RevertAll();
}
Assert.Fail("Permission was not denied.");
}
public void RolledAtMidnight()
{
DateTime rollDate = DateTime.Now.AddDays(1).Date;
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Midnight))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.currentDateTime = rollDate;
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
Assert.IsNotNull(traceListener.RollingHelper.NextRollDateTime);
Assert.IsNotNull(traceListener.RollingHelper.CheckIsRollNecessary());
Assert.AreEqual(rollDate, traceListener.RollingHelper.NextRollDateTime);
}
}
public void WillRollExistingFileIfOverDateThreshold()
{
string existingPayload = new string('c', 10);
DateTime currentDateTime = new DateTime(2007, 1, 1);
File.WriteAllText(fileName, existingPayload);
File.SetCreationTime(fileName, currentDateTime);
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
1, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.currentDateTime = currentDateTime.AddDays(2);
traceListener.TraceData(new TraceEventCache(),
"source",
TraceEventType.Error,
0,
"logged message");
}
Assert.AreEqual(existingPayload, File.ReadAllText(fileNameWithoutExtension + ".2007" + extension));
Assert.IsTrue(File.ReadAllText(fileName).Contains("logged message"));
}
public void WillTruncateExistingFileIfOverSizeThresholdAndNoPatternIsSpecifiedForOverwriteBehavior()
{
string existingPayload = new string('c', 5000);
DateTime currentDateTime = new DateTime(2007, 1, 1);
File.WriteAllText(fileName, existingPayload);
File.SetCreationTime(fileName, currentDateTime);
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
1, "", RollFileExistsBehavior.Overwrite, RollInterval.None))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.currentDateTime = currentDateTime;
traceListener.TraceData(new TraceEventCache(),
"source",
TraceEventType.Error,
0,
"logged message");
}
Assert.IsFalse(File.ReadAllText(fileName).Contains(existingPayload));
Assert.IsTrue(File.ReadAllText(fileName).Contains("logged message"));
}
public void WillNotRollWhenTracingIfNotOverThresholds()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
}
}
private LoggingConfiguration BuildProgrammaticConfig()
{
// Formatters
TextFormatter briefFormatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}");
TextFormatter extendedFormatter = new TextFormatter("Timestamp: {timestamp}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}Severity: {severity}{newline}Title: {title}{newline}Activity ID: {property(ActivityId)}{newline}Machine: {localMachine}{newline}App Domain: {localAppDomain}{newline}ProcessId: {localProcessId}{newline}Process Name: {localProcessName}{newline}Thread Name: {threadName}{newline}Win32 ThreadId:{win32ThreadId}{newline}Extended Properties: {dictionary({key} - {value}{newline})}");
// Category Filters
ICollection<string> categories = new List<string>();
categories.Add("BlockedByFilter");
// Log Filters
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.AllowAllExceptDenied);
// Trace Listeners
//var causeLoggingErrorTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("DoesNotExist"), "WriteLog", "AddCategory", null);
//var databaseTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("ExampleDatabase"), "WriteLog", "AddCategory", extendedFormatter);
var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter);
var eventLog = new EventLog("Application", ".", "Enterprise Library Logging");
var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog);
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(@"C:\Temp\RollingFlatFile.log", "----------------------------------------", "----------------------------------------", extendedFormatter, 20, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.None, 3);
var unprocessedFlatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\Unprocessed.log", "----------------------------------------", "----------------------------------------", extendedFormatter);
var xmlTraceListener = new XmlTraceListener(@"C:\Temp\XmlLogFile.xml");
xmlTraceListener.Filter = new EventTypeFilter(SourceLevels.Error);
// Build Configuration
var config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource("BlockedByFilter", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
//config.AddLogSource("CauseLoggingError", SourceLevels.All, true).AddTraceListener(causeLoggingErrorTraceListener);
//config.AddLogSource("Database", SourceLevels.All, true).AddTraceListener(databaseTraceListener);
// The defaults for the asynchronous wrapper are:
// bufferSize: 30000
// disposeTimeout: infinite
//config.AddLogSource("AsyncDatabase", SourceLevels.All, true).AddAsynchronousTraceListener(databaseTraceListener);
config.AddLogSource("DiskFiles", SourceLevels.All, true).AddTraceListener(flatFileTraceListener);
config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
config.AddLogSource("Important", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
config.LogSources["Important"].AddTraceListener(rollingFlatFileTraceListener);
// Special Sources Configuration
config.SpecialSources.Unprocessed.AddTraceListener(unprocessedFlatFileTraceListener);
config.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(eventLogTraceListener);
return config;
}
public void RolledFileWillHaveCurrentDateForTimestamp()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
10, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
traceListener.Write("1234567890");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 01));
traceListener.Write("12345");
Assert.AreEqual(5L, ((RollingFlatFileTraceListener.TallyKeepingFileStreamWriter)traceListener.Writer).Tally);
}
Assert.IsTrue(File.Exists(fileName));
Assert.AreEqual("12345", File.ReadAllText(fileName));
Assert.IsTrue(File.Exists(fileNameWithoutExtension + ".2007" + extension));
Assert.AreEqual("1234567890", File.ReadAllText(fileNameWithoutExtension + ".2007" + extension));
}
public void FallbackFileNameIsUsedForRoll()
{
using (FileStream fileStream = File.Open(fileName, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
10, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
traceListener.Write("1234567890");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 01));
traceListener.Write("12345");
Assert.AreEqual(5L, ((RollingFlatFileTraceListener.TallyKeepingFileStreamWriter)traceListener.Writer).Tally);
}
}
}
public void RolledFileWithOverwriteAndCapWillCreateArchiveFileIfDateTemplateDoesNotMatchAndKeepTheNewest()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(
fileName,
"header",
"footer",
null,
0,
"yyyy",
RollFileExistsBehavior.Overwrite,
RollInterval.Day,
1))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
traceListener.Write("1234567890");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 01));
traceListener.Write("12345");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2008, 01, 01));
traceListener.Write("abcde");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2009, 01, 01));
traceListener.Write("edcbe");
}
Assert.IsTrue(File.Exists(fileName));
Assert.AreEqual("edcbe", File.ReadAllText(fileName));
Assert.IsTrue(File.Exists(fileNameWithoutExtension + ".2009" + extension));
Assert.AreEqual("abcde", File.ReadAllText(fileNameWithoutExtension + ".2009" + extension));
Assert.IsFalse(File.Exists(fileNameWithoutExtension + ".2008" + extension));
Assert.IsFalse(File.Exists(fileNameWithoutExtension + ".2007" + extension));
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds a <see cref="FlatFileTraceListener"/> based on an instance of <see cref="FlatFileTraceListenerData"/>.
/// </summary>
/// <seealso cref="TraceListenerCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="FlatFileTraceListenerData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="FlatFileTraceListener"/>.</returns>
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
RollingFlatFileTraceListenerData castObjectConfiguration
= (RollingFlatFileTraceListenerData)objectConfiguration;
ILogFormatter formatter = GetFormatter(context, castObjectConfiguration.Formatter, configurationSource, reflectionCache);
RollingFlatFileTraceListener createdObject
= new RollingFlatFileTraceListener(
castObjectConfiguration.FileName,
castObjectConfiguration.Header,
castObjectConfiguration.Footer,
formatter,
castObjectConfiguration.RollSizeKB,
castObjectConfiguration.TimeStampPattern,
castObjectConfiguration.RollFileExistsBehavior,
castObjectConfiguration.RollInterval
);
return createdObject;
}
/// <summary>Builds the configuration used to log entries to the file system.</summary>
/// <returns>A <see cref="LoggingConfiguration"/> with default settings.</returns>
private LoggingConfiguration BuildLoggingConfiguration()
{
TextFormatter formatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}");
ICollection<string> categories = new List<string> { "BlockedByFilter" };
PriorityFilter priorityFilter = new PriorityFilter("PriorityFilter", -1);
LogEnabledFilter logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
CategoryFilter categoryFilter = new CategoryFilter("CategoryFilter", categories, CategoryFilterMode.AllowAllExceptDenied);
RollingFlatFileTraceListener rollingFileListener = new RollingFlatFileTraceListener(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"SCH\Logs\Everything.log"),
"----------------------------------------",
"----------------------------------------",
formatter,
200,
"yyyy-MM-dd",
RollFileExistsBehavior.Increment,
RollInterval.None,
5);
RollingFlatFileTraceListener errorFileListener = new RollingFlatFileTraceListener(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"SCH\Logs\Errors.log"),
"----------------------------------------",
"----------------------------------------",
formatter,
200,
"yyyy-MM-dd",
RollFileExistsBehavior.Increment,
RollInterval.None,
2);
// Build Configuration
LoggingConfiguration config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource(LoggingConstants.CategoryGeneralConst, SourceLevels.All, true, rollingFileListener);
config.AddLogSource(LoggingConstants.CategoryCompilerConst, SourceLevels.All, true, rollingFileListener);
config.AddLogSource(LoggingConstants.CategoryErrorConst, SourceLevels.Warning, true, errorFileListener);
return config;
}
public void RollingFlatFileTraceListenerReplacedEnviromentVariables()
{
string fileName = @"%USERPROFILE%\foo.log";
string fileNameFromListener = string.Empty;
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(fileName, "header", "footer", null, 1, "", RollFileExistsBehavior.Increment, RollInterval.Day);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
string expandedFileName = Environment.ExpandEnvironmentVariables(fileName);
bool result = File.Exists(expandedFileName);
Assert.IsTrue(result);
using (FileStream stream = File.Open(expandedFileName, FileMode.Open))
{
fileNameFromListener = stream.Name;
}
File.Delete(expandedFileName);
Assert.AreEqual(expandedFileName, fileNameFromListener);
}
public void RollingFlatFileTraceListenerReplacedInexistingEnviromentVariables()
{
string fileName = @"%FOO%\%MY_VARIABLE%\foo.log";
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(fileName, "header", "footer", null, 1, "", RollFileExistsBehavior.Increment, RollInterval.Day);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
string fileNameFromListener = string.Empty;
string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(fileName);
string expectedFileName = Path.GetFileName(expandedFileName);
bool result = File.Exists(expandedFileName);
Assert.IsTrue(result);
File.Delete(expandedFileName);
Assert.AreEqual(expectedFileName, expandedFileName);
}
public void WillRollForDateIfEnabled()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.currentDateTime = DateTime.Now;
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
dateTimeProvider.currentDateTime = DateTime.Now.AddDays(2);
Assert.IsNotNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.None))
{
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.currentDateTime = DateTime.Now;
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
dateTimeProvider.currentDateTime = DateTime.Now.AddDays(2);
Assert.IsNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
}
public void RolledFileWithOverwriteWillFallBackToUniqueNameIfDateTemplateMatchesButArchiveFileIsInUse()
{
string targetArchiveFile = fileNameWithoutExtension + ".2007" + extension;
using (FileStream stream = File.Open(targetArchiveFile, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
traceListener.Write("1234567890");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 01));
traceListener.Write("12345");
}
}
Assert.IsTrue(File.Exists(fileName));
Assert.AreEqual("12345", File.ReadAllText(fileName));
Assert.IsTrue(File.Exists(targetArchiveFile));
Assert.AreEqual("", File.ReadAllText(targetArchiveFile)); // couldn't archive
string[] archiveFiles = Directory.GetFiles(".", targetArchiveFile + "*");
Assert.AreEqual(2, archiveFiles.Length);
foreach (string archiveFile in archiveFiles)
{
if (!Path.GetFileName(archiveFile).Equals(targetArchiveFile))
{
Assert.AreEqual("1234567890", File.ReadAllText(archiveFile));
}
}
}
public void WillRollForSize()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
1, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Year))
{
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
traceListener.Write(new string('c', 1200));
Assert.IsNotNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Year))
{
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
traceListener.Write(new string('c', 1200));
Assert.IsNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
}
public void RolledFileWithIncrementWillCreateArchiveFileWithMaxSequenceIfDateTemplateDoesMatch()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
traceListener.Write("1234567890");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 01));
traceListener.Write("12345");
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.RollingHelper.PerformRoll(new DateTime(2007, 01, 02));
traceListener.Write("abcde");
}
Assert.IsTrue(File.Exists(fileName));
Assert.AreEqual("abcde", File.ReadAllText(fileName));
Assert.IsTrue(File.Exists(fileNameWithoutExtension + ".2007.2" + extension));
Assert.AreEqual("12345", File.ReadAllText(fileNameWithoutExtension + ".2007.2" + extension));
Assert.IsTrue(File.Exists(fileNameWithoutExtension + ".2007.1" + extension));
Assert.AreEqual("1234567890", File.ReadAllText(fileNameWithoutExtension + ".2007.1" + extension));
string[] archiveFiles = Directory.GetFiles(".", fileNameWithoutExtension + ".2007*" + extension + "*");
Assert.AreEqual(2, archiveFiles.Length);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// APIREV: make own type like TraceEventType so user won't have a need to add a reference to Logger dll.
// Create log instance
public static void Initialize(string logFilePath, int logFileSize,
TraceEventType minimalSeverity, bool isLogEnabled)
{
if (logFileSize < 1)
throw new SettingsException(Properties.Resources.LogFileCantBeSmall);
_minimalSeverity = minimalSeverity;
_isLogEnabled = isLogEnabled;
// Create message formatter
TextFormatter formatter = new TextFormatter(MESSAGE_FORMAT);
// Create Log sources
LogSource emptyTraceSource = new LogSource("EmptySource");
LogSource errorsTraceSource = new LogSource("Logger", SourceLevels.All);
// Create listener for rolling log file
RollingFlatFileTraceListener rollingTrace = new RollingFlatFileTraceListener(logFilePath, "", "", formatter, logFileSize, "yyyy - MM - dd", RollFileExistsBehavior.Overwrite, RollInterval.Year);
errorsTraceSource.Listeners.Add(rollingTrace);
// Create and fill sources array
IDictionary<string, LogSource> traceSources = new Dictionary<string, LogSource>();
traceSources.Add(TraceEventType.Critical.ToString(), errorsTraceSource);
traceSources.Add(TraceEventType.Error.ToString(), errorsTraceSource);
traceSources.Add(TraceEventType.Warning.ToString(), errorsTraceSource);
traceSources.Add(TraceEventType.Information.ToString(), errorsTraceSource);
// create default category string
string defaultCategory = _minimalSeverity.ToString();
ICollection<ILogFilter> filters = new ILogFilter[0];
_logWriter = new LogWriter(filters, // filters collection
traceSources, // sources array
emptyTraceSource, // all events trace source
emptyTraceSource, // not processed trace source
errorsTraceSource, // errors trace source
defaultCategory, // string defaultCategory
false, // enable tracing
true); // save message as warning, when no categories match
}
