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();
}
catch (InvalidOperationException)
{
throw;
}
finally
{
EnvironmentPermission.RevertAll();
}
Assert.Fail("Permission was not denied.");
}
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);
}
public void CanCreatePoliciesForRollingFlatFileTraceListener()
{
RollingFlatFileTraceListenerData listenerData
= new RollingFlatFileTraceListenerData(
"listener",
Path.Combine(Environment.CurrentDirectory, "test.log"),
"header",
"footer",
100,
"pattern",
RollFileExistsBehavior.Overwrite,
RollInterval.Midnight,
TraceOptions.Callstack | TraceOptions.ProcessId,
"");
listenerData.Filter = SourceLevels.Error;
loggingSettings.TraceListeners.Add(listenerData);
using (var container = CreateContainer())
{
RollingFlatFileTraceListener createdObject =
(RollingFlatFileTraceListener)((ReconfigurableTraceListenerWrapper)container.Resolve <TraceListener>("listener")).InnerTraceListener;
Assert.IsNotNull(createdObject);
Assert.AreEqual(listenerData.TraceOutputOptions, createdObject.TraceOutputOptions);
Assert.IsNotNull(createdObject.Filter);
Assert.IsInstanceOfType(createdObject.Filter, typeof(EventTypeFilter));
Assert.AreEqual(listenerData.Filter, ((EventTypeFilter)createdObject.Filter).EventType);
Assert.IsNull(createdObject.Formatter);
Assert.AreEqual(listenerData.FileName, ((FileStream)((StreamWriter)createdObject.Writer).BaseStream).Name);
}
}
public void RolledFileWithOverwriteWillOverwriteArchiveFileIfDateTemplateMatches()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = this.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, 01));
traceListener.Write("abcde");
}
Assert.IsTrue(File.Exists(this.fileName));
Assert.AreEqual("abcde", File.ReadAllText(this.fileName));
Assert.IsTrue(File.Exists(this.fileNameWithoutExtension + ".2007" + extension));
Assert.AreEqual("12345", File.ReadAllText(this.fileNameWithoutExtension + ".2007" + extension));
string[] archiveFiles = Directory.GetFiles(".", this.fileNameWithoutExtension + ".2007" + extension + "*");
Assert.AreEqual(1, archiveFiles.Length);
}
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);
}
/// <summary>
/// Builds Programmatic Configuration for Logging
/// </summary>
/// <returns>LoggingConfiguration</returns>
public static LoggingConfiguration BuildProgrammaticConfig()
{
ResourceManager resxManager = new ResourceManager(ConfigurationManager.AppSettings["FmoMessages_ResourceFileName"], Assembly.GetExecutingAssembly());
// Formatters
TextFormatter formatter = new TextFormatter(ErrorConstants.Logging_TextFormat);
// Listeners
// var flatFileTraceListener = new FlatFileTraceListener(string.Concat(ConfigurationManager.AppSettings["LogFilePath"], ConfigurationManager.AppSettings["ErrorLogFileName"]), "----------------------------------------", "----------------------------------------", formatter);
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(string.Concat(ConfigurationManager.AppSettings["LogFilePath"], ConfigurationManager.AppSettings["ErrorLogFileName"]), "----------------------------------------", "----------------------------------------", formatter, 20, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.None, 3);
var eventLog = new EventLog(ErrorConstants.Logging_LogName, ".", ErrorConstants.Logging_LogSource);
var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog);
// Build Configuration
var config = new LoggingConfiguration();
config.AddLogSource(ErrorConstants.LogSource_LogSourceName, SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
// config.LogSources["General"].AddTraceListener(flatFileTraceListener);
config.LogSources[ErrorConstants.LogSource_LogSourceName].AddTraceListener(rollingFlatFileTraceListener);
// Special Sources Configuration
config.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(eventLogTraceListener);
return(config);
}
private void UpdateConfigForRollingFlatFileRollExistsOverwrite(LoggingConfiguration loggingConfiguration)
{
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(Path.Combine(strPath, "RollingFlatFile.log"), "----------------------------------------", "----------------------------------------", extendedFormatter, 0, String.Empty, RollFileExistsBehavior.Overwrite, RollInterval.None, 3);
loggingConfiguration.AddLogSource("RollFFOverwrite", SourceLevels.All, true, rollingFlatFileTraceListener);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(rollingFlatFileTraceListener);
}
public void FileIsRolledWhenIntervalSetToMidnightAndOverwrite()
{
fileNameWithoutExtension = Guid.NewGuid().ToString();
fileName = fileNameWithoutExtension + Extension;
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "--header--", "--footer--", null,
0, String.Empty, RollFileExistsBehavior.Overwrite, RollInterval.Midnight))
{
traceListener.TraceData(new TraceEventCache(),
"source",
TraceEventType.Information,
0,
"logged message 1");
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.SetCurrentDateTime(DateTime.Now);
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
dateTimeProvider.SetCurrentDateTime(DateTime.Now.AddDays(1).Date);
//dateTimeProvider.currentDateTime = DateTime.Now.AddMinutes(2);
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.TraceData(new TraceEventCache(), "source", TraceEventType.Information, 1, "logged message 2");
}
Assert.IsTrue(File.Exists(fileName));
Assert.IsTrue(LogFileReader.ReadFileWithoutLock(fileName).Contains("logged message 2"));
Assert.IsFalse(LogFileReader.ReadFileWithoutLock(fileName).Contains("logged message 1"));
string[] archiveFiles = Directory.GetFiles(".", fileNameWithoutExtension + "*");
Assert.AreEqual(1, archiveFiles.Length);
}
private void UpdateConfigForRollingFlatFileRollExistsIncrement(LoggingConfiguration loggingConfiguration)
{
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(Path.Combine(strPath, "RollingFlatFile.log"), "----------------------------------------", "----------------------------------------", extendedFormatter, 1, "yyyy", RollFileExistsBehavior.Increment, RollInterval.None, 3);
loggingConfiguration.AddLogSource("RollFFIncrement", SourceLevels.All, true, rollingFlatFileTraceListener);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(rollingFlatFileTraceListener);
}
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 DontWriteHeaderOrFooterWhenEventsAreFiltered()
{
const string header = "MockHeader";
const string footer = "MockFooter";
const string fileName = "rolling.log";
string filePath = AppDomain.CurrentDomain.BaseDirectory + "\\" + fileName;
try
{
LogEntry log = new LogEntry("Header nor footer written", "Category", 1, 1, TraceEventType.Error, "FilteredEventsDontWriteHeaderNorFooter", null);
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(filePath, header, footer, null, 100, "mmddyyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day);
listener.Filter = new EventTypeFilter(SourceLevels.Off);
listener.TraceData(null, "Error", TraceEventType.Error, 1, log);
listener.Flush();
listener.Close();
Assert.IsTrue(File.Exists(filePath));
StreamReader reader = new StreamReader(filePath);
string content = reader.ReadToEnd();
reader.Close();
Assert.IsFalse(content.Contains(header));
Assert.IsFalse(content.Contains(footer));
}
finally
{
File.Delete(filePath);
}
}
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 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 ArchiveFilesAreWrittenWhenAddingUnprocessedSourceForRollingFlatFile()
{
var config = new LoggingConfiguration();
config.IsTracingEnabled = true;
config.DefaultSource = "General";
config.LogWarningsWhenNoCategoriesMatch = true;
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(Path.Combine(strPath, @"TraceTest.log"),
"----------------------------------------",
"----------------------------------------",
new TextFormatter("Timestamp: {timestamp}{newline}
Message: {message}{newline}
Category: {category}{newline}
Priority: {priority}{newline}
EventId: {eventid}{newline}
Severity: {severity}{newline}
Title:{title}{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})}"),
1, "yyyy", RollFileExistsBehavior.Increment, RollInterval.None, 3);
config.SpecialSources.Unprocessed.Listeners.Add(rollingFlatFileTraceListener);
this.writer = new LogWriter(config);
this.writer.Write("Test Logging Rolling 1");
this.writer.Write("Test Logging Rolling 2");
this.writer.Write("Test Logging Rolling 3");
this.writer.Write("Test Logging Rolling 4");
this.writer.Write("Test Logging Rolling 5");
this.writer.Write("Test Logging Rolling 6");
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "TraceTest.log")));
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "TraceTest" + "." + DateTime.Now.Year + ".1" + ".log")));
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "TraceTest" + "." + DateTime.Now.Year + ".2" + ".log")));
}
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 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 WillNotRollWhenTracingIfNotOverThresholds()
{
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
}
}
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();
}
static 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.LogSources["DiskFiles"].AddTraceListener(xmlTraceListener);
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);
}
/// <summary>
/// Creates a new logger that will send log output to a file. If the file already exists then
/// it is overwritten.
/// </summary>
/// <param name="path">A path to the file to which log output will be written.</param>
public TSharpDatabaseLogger(string path)
{
traceWriter = new RollingFlatFileTraceListener(
path,
null,
null,
1024,
"HHmmssfff",
"yyyyMMdd",
RollFileExistsBehavior.Increment,
RollInterval.Day);
innerWriter = traceWriter.WriteLine;
}
/// <summary>
/// Creates a new logger that will send log output to the console.
/// </summary>
public TSharpDatabaseLogger()
{
traceWriter = new RollingFlatFileTraceListener(
@"App_data\Sqls\trace.csv",
null,
null,
1024,
"yyyyMMddHHmmss",
"yyyyMMdd",
RollFileExistsBehavior.Increment,
RollInterval.Day);
innerWriter = traceWriter.Write;
}
/// <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 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 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 RollIsNecessaryWhenUsingJsonFormatterWithRollingFlatFileTraceListener()
{
this.fileNameWithoutExtension = Guid.NewGuid().ToString();
this.fileName = this.fileNameWithoutExtension + JsonLogFormatterFixture.Extension;
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(this.fileName, "header", "footer", new JsonLogFormatter(JsonFormatting.Indented),
1, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Year))
{
traceListener.RollingHelper.UpdateRollingInformationIfNecessary();
traceListener.Write(new string('c', 1200));
Assert.IsNotNull(traceListener.RollingHelper.CheckIsRollNecessary());
}
}
/// <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 ListenerForExistingFileWillUseCreationDateToCalculateRollDate()
{
File.WriteAllText(this.fileName, "existing text");
File.SetCreationTime(this.fileName, new DateTime(2000, 01, 01));
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "header", "footer", null,
0, "yyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day))
{
traceListener.RollingHelper.DateTimeProvider = this.dateTimeProvider;
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
Assert.AreEqual(traceListener.RollingHelper.CalculateNextRollDate(File.GetCreationTime(this.fileName)), traceListener.RollingHelper.NextRollDateTime);
Assert.AreEqual(this.dateTimeProvider.CurrentDateTime, traceListener.RollingHelper.CheckIsRollNecessary());
}
}
public void RollingFlatFileTraceListenerReplacedInexistingEnviromentVariables()
{
string fileName = @"tmp\%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 expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(fileName);
string expectedFileName = Path.GetFileName(expandedFileName);
bool result = File.Exists(expandedFileName);
Assert.IsTrue(result);
File.Delete(expandedFileName);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// APIREV: make own type like TraceEventType so user won't have a need to add a reference to Logger dll.
// Create log instance
static public 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
}
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 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);
}
}
}
/// <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>
/// 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;
}
private RollingFlatFileTraceListener RollingFlatFileTraceListenerGet()
{
if (this._rollingFlatFileTraceListener == null)
{
this.AttributesSetDefaultValues();
this._rollingFlatFileTraceListener = new RollingFlatFileTraceListener(
this.Attributes[_fileNameAttribute]
, string.Empty
, string.Empty
, null
, this._rollSizeKB
, this._timeStampPattern
, RollFileExistsBehavior.Overwrite
, RollInterval.None
, this._maxArchivedFiles);
}
return this._rollingFlatFileTraceListener;
}
/// <summary>
/// Stops logging and closes the underlying file if output is being written to a file.
/// </summary>
/// <param name="disposing">
/// True to release both managed and unmanaged resources; False to release only unmanaged resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
StopLogging();
if (disposing && traceWriter != null)
{
traceWriter.Dispose();
traceWriter = null;
}
if (disposing && innerWriter != null) innerWriter = null;
}
public void DontWriteHeaderOrFooterWhenEventsAreFiltered()
{
const string header = "MockHeader";
const string footer = "MockFooter";
const string fileName = "rolling.log";
string filePath = AppDomain.CurrentDomain.BaseDirectory + "\\" + fileName;
try
{
LogEntry log = new LogEntry("Header nor footer written", "Category", 1, 1, TraceEventType.Error, "FilteredEventsDontWriteHeaderNorFooter", null);
RollingFlatFileTraceListener listener = new RollingFlatFileTraceListener(filePath, header, footer, null, 100, "mmddyyyy", RollFileExistsBehavior.Overwrite, RollInterval.Day);
listener.Filter = new EventTypeFilter(SourceLevels.Off);
listener.TraceData(null, "Error", TraceEventType.Error, 1, log);
listener.Flush();
listener.Close();
Assert.IsTrue(File.Exists(filePath));
StreamReader reader = new StreamReader(filePath);
string content = reader.ReadToEnd();
reader.Close();
Assert.IsFalse(content.Contains(header));
Assert.IsFalse(content.Contains(footer));
}
finally
{
File.Delete(filePath);
}
}
