public static LoggingConfiguration BuildProgrammaticConfig(bool isAsync = false)
{
var formatter = new TextFormatter();
var flatFileTraceListener = new FlatFileTraceListener(@"FlatFile.log",
"----------------------------------------",
"----------------------------------------",
formatter);
// var eventLog = new EventLog("Application", ".", "LoggingApplication");
// var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog, formatter);
// Build Configuration
var config = new LoggingConfiguration();
if (isAsync == false)
{
config.AddLogSource("General", SourceLevels.All, true)
// .AddTraceListener(eventLogTraceListener);
.AddTraceListener(flatFileTraceListener);
}
else
{
config.AddLogSource("General", SourceLevels.All, true)
// .AddTraceListener(eventLogTraceListener);
.AddAsynchronousTraceListener(flatFileTraceListener);
}
config.IsTracingEnabled = true;
return(config);
}
public void FlatFileListenerReplacedEnviromentVariablesWillFallBackIfNotPrivilegesToRead()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "foo.log");
EnvironmentPermission denyPermission = new EnvironmentPermission(PermissionState.Unrestricted);
denyPermission.Deny();
try
{
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
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 void FlatFileListenerWillFallbackIfNotPriviledgesToWrite()
{
string fileName = @"trace.log";
string fullPath = String.Format(@"{0}\{1}", Directory.GetCurrentDirectory(), fileName);
File.Delete(fileName);
FileIOPermission fileIOPerm1 = new FileIOPermission(PermissionState.None);
fileIOPerm1.SetPathList(FileIOPermissionAccess.Read, fullPath);
fileIOPerm1.PermitOnly();
try
{
FlatFileTraceListener listener = new FlatFileTraceListener(fileName, "---header---", "***footer***",
new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
source.TraceData(TraceEventType.Error, 0,
new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
listener.Dispose();
}
catch (SecurityException)
{
FileIOPermission.RevertAll();
throw;
}
}
public void EntryIsWrittenWhenFlatFileUnprocessedCategory()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateFlatFileForConfig(loggingConfiguration);
var unprocessedFlatFileTraceListener = new FlatFileTraceListener(
Path.Combine(strPath, "Unprocessed.log"),
"----------------------------------------",
"----------------------------------------",
null);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(unprocessedFlatFileTraceListener);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging");
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "FlatFile.log")));
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "Unprocessed.log")));
string strFileData1 = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "FlatFile.log"));
Assert.IsTrue(strFileData1.Contains("Message: Test Logging"));
Assert.IsTrue(strFileData1.Contains("Category: General"));
string strFileData = LogFileReader.ReadFileWithoutLock((Path.Combine(this.strPath, "Unprocessed.log")));
Assert.IsTrue(strFileData.Contains("Message: Test Logging"));
Assert.IsTrue(strFileData.Contains("Unprocessed Category Information: 1"));
}
private static LogSource BuildErrorsLogSource()
{
var formatter = new TextFormatter(
@"Timestamp: {timestamp}
Category: {category}
Message: {message}
Priority: {priority}
EventId: {eventid}
Severity: {severity}
Title:{title}
Machine: {machine}
Application Domain: {appDomain}
Process Id: {processId}
Process Name: {processName}
Win32 Thread Id: {win32ThreadId}
Thread Name: {threadName}
Extended Properties: {dictionary({key} - {value})}"
);
var fileListener = new FlatFileTraceListener("ErrorLog.txt");
fileListener.Formatter = formatter;
var listeners = new TraceListener[] { fileListener };
var source = new LogSource("FlatFileTraceListener", listeners, SourceLevels.All);
return(source);
}
static LoggingConfiguration BuildProgrammaticConfig()
{
// Formatters
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}");
// 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 flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\ConfigSampleFlatFile.log", "----------------------------------------", "----------------------------------------", formatter);
// Build Configuration
var config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource("General", SourceLevels.All, true, flatFileTraceListener);
return(config);
}
public void FlatFileListenerWillFallbackIfNotPriviledgesToWrite()
{
string fileName = @"trace.log";
string fullPath = String.Format(@"{0}\{1}", Directory.GetCurrentDirectory(), fileName);
File.Delete(fileName);
FileIOPermission fileIOPerm1 = new FileIOPermission(PermissionState.None);
fileIOPerm1.SetPathList(FileIOPermissionAccess.Read, fullPath);
fileIOPerm1.PermitOnly();
try
{
FlatFileTraceListener listener = new FlatFileTraceListener(fileName, "---header---", "***footer***", new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
source.Dispose();
}
catch (SecurityException)
{
FileIOPermission.RevertAll();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseLibraryLoggerAdapter"/> class.
/// </summary>
static EnterpriseLibraryLoggerAdapter()
{
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})}");
TextFormatter _briefFormatter = new TextFormatter("{timestamp(local)};{message};{category};{priority};{eventid};{severity};{title}");
// Category Filters
ICollection <string> _categories = new List <string>();
_categories.Add("BlockedByFilter");
// Log Filters
PriorityFilter _priorityFilter = new PriorityFilter("Priority Filter", -1, 99);
LogEnabledFilter _logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
CategoryFilter _categoryFilter = new CategoryFilter("Category Filter", _categories, CategoryFilterMode.AllowAllExceptDenied);
FlatFileTraceListener _flatFileTraceListener = new FlatFileTraceListener($"{nameof(ConfigurationEditorBase)}.log", string.Empty, string.Empty, _briefFormatter);
LoggingConfiguration _configuration = new LoggingConfiguration();
_configuration.Filters.Add(_priorityFilter);
_configuration.Filters.Add(_logEnabledFilter);
_configuration.Filters.Add(_categoryFilter);
_configuration.AddLogSource("Debug", System.Diagnostics.SourceLevels.All, true, _flatFileTraceListener);
FlatFileTraceListener unprocessedFlatFileTraceListener = new FlatFileTraceListener(@"Unprocessed.log", "----------------------------------------", "----------------------------------------", _extendedFormatter);
_configuration.SpecialSources.Unprocessed.AddTraceListener(unprocessedFlatFileTraceListener);
FlatFileTraceListener _LoggingErrorsAndWarningsTraceListener = new FlatFileTraceListener(@"LoggingErrorsAndWarnings.log", "----------------------------------------", "----------------------------------------", _extendedFormatter);
_configuration.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(_LoggingErrorsAndWarningsTraceListener);
Logger.SetLogWriter(new LogWriter(_configuration));
}
public void FlatFileListenerReplacedEnviromentVariables()
{
string fileName = @"%USERPROFILE%\foo.log";
string fileNameFromListener = string.Empty;
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(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 static void CheckListener()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "test.log");
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
}
private void UpdateFlatFileForConfigNullParams(LoggingConfiguration loggingConfiguration)
{
// Trace Listeners
var flatFileTraceListener = new FlatFileTraceListener(Path.Combine(strPath, "FlatFile.log"), null, null, null);
flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All);
// Special Sources Configuration
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener);
}
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);
}
public void UpdateConfiguration()
{
numUpdates++;
Logger.Writer.Configure(config =>
{
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}");
var newDest = new FlatFileTraceListener(@"C:\Temp\trace-" + numUpdates + @".log", "----------------------------------------", "----------------------------------------", formatter);
config.SpecialSources.AllEvents.Listeners.Clear();
config.SpecialSources.AllEvents.AddTraceListener(newDest);
});
}
private void UpdateFlatFileForConfigStreamWriter(LoggingConfiguration loggingConfiguration)
{
// Trace Listeners
StreamWriter writer = new StreamWriter(Path.Combine(strPath, "FlatFileStreamWriter.log"));
FlatFileTraceListener flatFileTraceListener = new FlatFileTraceListener(writer);
flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All);
// Special Sources Configuration
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener);
}
private void UpdateFlatFileForConfigFileStream(LoggingConfiguration loggingConfiguration)
{
// Trace Listeners
FileStream stream = new FileStream(Path.Combine(strPath, "FlatFileFileStream.log"), FileMode.OpenOrCreate);
FlatFileTraceListener flatFileTraceListener = new FlatFileTraceListener(stream);
//var flatFileTraceListener = new FlatFileTraceListener(Path.Combine(strPath, "FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter);
flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All);
// Special Sources Configuration
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener);
}
public LoggingViewModel()
{
var logFormatter = new TextFormatter();
var flatFileTraceListener = new FlatFileTraceListener("log.hblog", "-------------------------",
"-------------------------", logFormatter);
var config = new LoggingConfiguration();
config.AddLogSource("Hummingbird", SourceLevels.All, true).AddTraceListener(flatFileTraceListener);
Logger = new LogWriter(config);
}
/// <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
}
static void Main(string[] args)
{
TextFormatter briefFormatter = new TextFormatter();
var flatFileTraceListerner = new FlatFileTraceListener(@"C:\temp\xxx.log",
"-------------------------------",
"-------------------------------",
briefFormatter);
var config = new LoggingConfiguration();
config.AddLogSource("my_log", System.Diagnostics.SourceLevels.All, true).AddTraceListener(flatFileTraceListerner);
LogWriter logger = new LogWriter(config);
}
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
FlatFileTraceListenerData castedObjectConfiguration
= (FlatFileTraceListenerData)objectConfiguration;
ILogFormatter formatter = GetFormatter(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new FlatFileTraceListener(
castedObjectConfiguration.FileName,
castedObjectConfiguration.Header,
castedObjectConfiguration.Footer,
formatter);
return(createdObject);
}
public void MessageIsWrittenWhenUsingJsonFormatterWithFlatFileTraceListener()
{
this.fileNameWithoutExtension = Guid.NewGuid().ToString();
this.fileName = this.fileNameWithoutExtension + JsonLogFormatterFixture.Extension;
using (FlatFileTraceListener tracelistener = new FlatFileTraceListener(this.fileName, null, null, new JsonLogFormatter(JsonFormatting.Indented)))
{
tracelistener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
tracelistener.Dispose();
Assert.IsTrue(File.Exists(this.fileName));
string strLog = LogFileReader.ReadFileWithoutLock(this.fileName);
StringAssert.Contains(strLog, "source Error: 1 : This is a test\r\n");
}
}
private static LoggingConfiguration BuildProgrammaticConfig()
{
var formatter = new TextFormatter();
var flatFileTraceListener = new FlatFileTraceListener(
"log.txt",
"----------------------------------------",
"----------------------------------------",
formatter);
var config = new LoggingConfiguration();
config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(flatFileTraceListener);
config.IsTracingEnabled = true;
return(config);
}
public void ListenerWithHeaderAndFooterWillUseFormatterIfExists()
{
File.Delete("tracewithheaderandfooter.log");
FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfooter.log", "--------header------", "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
listener.Dispose();
string strFileContents = GetFileContents("tracewithheaderandfooter.log");
Assert.AreEqual("--------header------" + Environment.NewLine + "DUMMY" + Environment.NewLine + "DUMMY" + Environment.NewLine + "=======footer===========" + Environment.NewLine, strFileContents);
}
public void TraceListenerIsSingletonInContainer()
{
FormatterData data = new TextFormatterData("formattername", "template");
loggingSettings.Formatters.Add(data);
TraceListenerData traceListenerData = new FlatFileTraceListenerData("name", "filename.log", "formattername");
loggingSettings.TraceListeners.Add(traceListenerData);
container.AddExtension(new LoggingBlockExtension());
FlatFileTraceListener createdObject1 = (FlatFileTraceListener)container.Resolve <TraceListener>("name");
FlatFileTraceListener createdObject2 = (FlatFileTraceListener)container.Resolve <TraceListener>("name");
Assert.AreSame(createdObject1, createdObject2);
}
public void ListenerWithHeaderAndFooterWillUseFormatterIfExists()
{
File.Delete("tracewithheaderandfooter.log");
FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfooter.log", "--------header------", "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
listener.Dispose();
string strFileContents = GetFileContents("tracewithheaderandfooter.log");
Assert.AreEqual("--------header------" + Environment.NewLine + "DUMMY" + Environment.NewLine + "DUMMY" + Environment.NewLine + "=======footer===========" + Environment.NewLine, strFileContents);
}
private static void ConfigureSimpleLogging(LoggingConfiguration config)
{
// Create a briefformatter object to write the log out
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}");
// Create a txt file listener and point to the formatter
var flatFileTraceListener
= new FlatFileTraceListener(
@"C:\Temp\FlatFile.log",
"----------------------------------------",
"----------------------------------------",
briefFormatter);
// Tell the config to use this (Category = Simple)
config.AddLogSource("Simple", SourceLevels.All, true)
.AddTraceListener(flatFileTraceListener);
}
private void ConfigureLogging()
{
// Formatter
TextFormatter fm = new TextFormatter();
var flatFileTraceListener = new
FlatFileTraceListener(@"trace.log", "----------------------------------------", "----------------------------------------", fm);
// Build Configuration
var config = new LoggingConfiguration();
config.AddLogSource("General", SourceLevels.All,
true).AddTraceListener(flatFileTraceListener);
config.IsTracingEnabled = true;
config.SpecialSources.AllEvents.AddTraceListener(flatFileTraceListener);
Logger.SetLogWriter(new LogWriter(config));
}
public void ListenerWillFallbackToTraceEntryToStringIfFormatterDoesNotExists()
{
LogEntry testLogEntry = new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null);
StreamWriter writer = new StreamWriter("trace.log");
FlatFileTraceListener listener = new FlatFileTraceListener(writer);
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
source.TraceData(TraceEventType.Error, 0, testLogEntry);
listener.Dispose();
string strFileContents = GetFileContents("trace.log");
string testLogEntryAsString = testLogEntry.ToString();
Assert.IsTrue(-1 != strFileContents.IndexOf(testLogEntryAsString));
}
private static LoggingConfiguration BuildProgrammaticConfig()
{
// Formatter
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}");
// Trace Listeners
var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\trace.log", "----------------------------------------", "----------------------------------------", formatter);
var asyncTraceListener = new AsynchronousTraceListenerWrapper(flatFileTraceListener);
// Build Configuration
var config = new LoggingConfiguration();
config.AddLogSource(Category.Trace, SourceLevels.ActivityTracing, true).AddAsynchronousTraceListener(asyncTraceListener);
config.IsTracingEnabled = true;
return(config);
}
public void ListenerWillFallbackToTraceEntryToStringIfFormatterDoesNotExists()
{
LogEntry testLogEntry = new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null);
StreamWriter writer = new StreamWriter("trace.log");
FlatFileTraceListener listener = new FlatFileTraceListener(writer);
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
source.TraceData(TraceEventType.Error, 0, testLogEntry);
listener.Dispose();
string strFileContents = GetFileContents("trace.log");
string testLogEntryAsString = testLogEntry.ToString();
Assert.IsTrue(-1 != strFileContents.IndexOf(testLogEntryAsString));
}
private static LoggingConfiguration BuildLoggingConfig()
{
// Formatters
TextFormatter formatter =
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})}");
// Listeners
var flatFileTraceListener =
new FlatFileTraceListener(
@"C:\Temp\Puzzler.log",
"----------------------------------------",
"----------------------------------------",
formatter);
var eventLog =
new EventLog("Application", ".",
"Enterprise Library Logging");
var eventLogTraceListener = new
FormattedEventLogTraceListener(eventLog);
// Build Configuration
var config = new LoggingConfiguration();
config.AddLogSource("General", SourceLevels.All, true)
.AddTraceListener(eventLogTraceListener);
config.LogSources["General"]
.AddTraceListener(flatFileTraceListener);
// Special Sources Configuration
config.SpecialSources.LoggingErrorsAndWarnings
.AddTraceListener(eventLogTraceListener);
return(config);
}
public void FlatFileListenerReplacedInexistingEnviromentVariables()
{
string fileName = @"a\%FOO%\%MY_VARIABLE%\foo.log";
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
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);
}
public void FlatFileTraceListenerMultipleWrites()
{
File.Delete("tracewithheaderandfooter.log");
string header = "--------header------";
int numberOfWrites = 4;
FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfooter.log", header, "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
for (int writeLoop = 0; writeLoop < numberOfWrites; writeLoop++)
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
source.Dispose();
StreamReader reader = new StreamReader("tracewithheaderandfooter.log");
int headersFound = NumberOfItems("tracewithheaderandfooter.log", header);
Assert.AreEqual(numberOfWrites,headersFound);
}
public void FlatFileListenerReplacedEnviromentVariablesWillFallBackIfNotPrivilegesToRead()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "foo.log");
EnvironmentPermission denyPermission = new EnvironmentPermission(PermissionState.Unrestricted);
denyPermission.Deny();
try
{
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
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 CanCreateTraceListenerWithReferenceToFormatter()
{
FormatterData data = new TextFormatterData("formattername", "template");
loggingSettings.Formatters.Add(data);
TraceListenerData traceListenerData = new FlatFileTraceListenerData("name", "filename.log", "formattername");
traceListenerData.Filter = SourceLevels.Critical;
traceListenerData.TraceOutputOptions = TraceOptions.ProcessId;
loggingSettings.TraceListeners.Add(traceListenerData);
container.AddExtension(new LoggingBlockExtension());
FlatFileTraceListener createdObject = (FlatFileTraceListener)container.Resolve <TraceListener>("name");
Assert.IsNotNull(createdObject);
Assert.AreEqual("name", createdObject.Name);
Assert.AreEqual(SourceLevels.Critical, ((EventTypeFilter)createdObject.Filter).EventType);
Assert.AreEqual(TraceOptions.ProcessId, createdObject.TraceOutputOptions);
Assert.IsNotNull(createdObject.Formatter);
Assert.AreEqual("template", ((TextFormatter)createdObject.Formatter).Template);
}
public void FlatFileTraceListenerMultipleWrites()
{
File.Delete("tracewithheaderandfootermultiplewrites.log");
string header = "--------header------";
int numberOfWrites = 4;
FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfootermultiplewrites.log", header, "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY"));
// need to go through the source to get a TraceEventCache
LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
for (int writeLoop = 0; writeLoop < numberOfWrites; writeLoop++)
{
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
listener.Dispose();
StreamReader reader = new StreamReader("tracewithheaderandfootermultiplewrites.log");
int headersFound = NumberOfItems("tracewithheaderandfootermultiplewrites.log", header);
Assert.AreEqual(numberOfWrites, headersFound);
}
public static void CheckListener()
{
string environmentVariable = "%USERPROFILE%";
string fileName = Path.Combine(environmentVariable, "test.log");
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
}
public void FlatFileListenerReplacedInexistingEnviromentVariables()
{
string fileName = @"%FOO%\%MY_VARIABLE%\foo.log";
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
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 FlatFileListenerReplacedEnviromentVariables()
{
string fileName = @"%USERPROFILE%\foo.log";
string fileNameFromListener = string.Empty;
FlatFileTraceListener listener = new FlatFileTraceListener(fileName);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test");
listener.Dispose();
string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(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);
}
