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 SharedTraceListener() { var sharedTraceListener = new DefaultTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("General").AddTraceListener(sharedTraceListener); config.AddLogSource("Special", SourceLevels.Critical, true, sharedTraceListener); Assert.AreEqual <int>(2, config.LogSources.Count); Assert.AreEqual <string>("General", config.LogSources.First().Name); Assert.AreEqual <string>("Special", config.LogSources.Last().Name); }
public void AddLogSourcesIsSetAsDefault() { var config = new LoggingConfiguration(); Assert.IsNull(config.DefaultSource); config.AddLogSource("Default"); Assert.AreEqual <string>("Default", config.DefaultSource); config.AddLogSource("Second"); Assert.AreEqual <string>("Default", config.DefaultSource); }
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); }
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); }
/// <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 MessageIsSetWhenUsingJsonFormatter() { LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace(); JsonLogFormatter jsonformatter = new JsonLogFormatter(JsonFormatting.Indented); EmailTraceListener emailListener = new EmailTraceListener(this.toaddress, this.fromaddress, "StartOfSubject", "EndOfSubject", this.smtpserver, jsonformatter); emailListener.Filter = new EventTypeFilter(SourceLevels.All); loggingConfiguration.AddLogSource("Email", SourceLevels.All, true, emailListener); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(emailListener); string message = "Test JSON"; this.writer = new LogWriter(loggingConfiguration); this.writer.Write(message, "General"); this.writer.Dispose(); LogEntry logEntry = LogFileReader.GetLogEntryFromEmail(); Assert.IsTrue(logEntry.Message == message); }
public void JsonFormatterHeadersAreSetWhenSendingEmail() { DateTime messageTimestamp = DateTime.UtcNow; LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace(); JsonLogFormatter jsonformatter = new JsonLogFormatter(JsonFormatting.Indented); EmailTraceListener emailListener = new EmailTraceListener(this.toaddress, this.fromaddress, "StartOfSubject", "EndOfSubject", this.smtpserver, jsonformatter); emailListener.Filter = new EventTypeFilter(SourceLevels.All); loggingConfiguration.AddLogSource("Email", SourceLevels.All, true, emailListener); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(emailListener); string message = "Test JSON"; this.writer = new LogWriter(loggingConfiguration); this.writer.Write(message, "General"); this.writer.Dispose(); string emailText = LogFileReader.GetEmail(); string endOfHeader = "\r\n\r\n"; int index = emailText.IndexOf(endOfHeader); string header = emailText.Substring(0, index); Dictionary <string, string> emailDictionary = Regex.Split(header, "\r\n").Select(e => e.Split(':')).ToDictionary(line => line[0], line => line[1].Trim()); Assert.AreEqual("StartOfSubject Information EndOfSubject", emailDictionary["Subject"]); Assert.AreEqual(this.fromaddress, emailDictionary["From"]); Assert.AreEqual(this.toaddress, emailDictionary["To"]); }
public void AllEntriesAreWrittenWhenUsingAsynchForFormattedDatabase() { this.ClearLogs(); string unique = Guid.NewGuid().ToString(); SqlDatabase dbConnection = new SqlDatabase(connectionString); int messageContents = 0; var configuration = new LoggingConfiguration(); configuration.AddLogSource("TestAsynchLogging In FormattedDatabase") .AddTraceListener(new AsynchronousTraceListenerWrapper( new FormattedDatabaseTraceListener(dbConnection, "WriteLog", "AddCategory", null), ownsWrappedTraceListener: true, bufferSize: 10000)); using (var writer = new LogWriter(configuration)) { Parallel.Invoke(Enumerable.Range(0, 10000).Select(i => new Action(() => { writer.Write(unique + " Test Asynch Message: " + i); })).ToArray()); } using (var connection = new SqlConnection(connectionString)) { connection.Open(); SqlCommand command = new SqlCommand("select COUNT(1) from Log where Message like '" + unique + " Test Asynch Message:%'", connection); messageContents = (Int32)command.ExecuteScalar(); connection.Close(); } Assert.AreEqual(10000, messageContents); }
public void CreatesLoggingExceptionHandlerWithProgrammaticConfiguration() { var loggingConfiguration = new LoggingConfiguration(); var eventLog = new EventLog("Application", ".", "ExceptionHandling.Bvt.Tests - Programmatic"); var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog, new TextFormatter("{message}")); loggingConfiguration.AddLogSource("Sample Category", SourceLevels.All, true).AddTraceListener(eventLogTraceListener); var logWriter = new LogWriter(loggingConfiguration); var excepionPolicies = new List <ExceptionPolicyDefinition>(); var excepionPolicyEntries = new List <ExceptionPolicyEntry>(); var exceptionHandler = new LoggingExceptionHandler("Sample Category", 100, TraceEventType.Transfer, "Sample Title", 4, typeof(TextExceptionFormatter), logWriter); var exceptionPolicy = new ExceptionPolicyEntry(typeof(DivideByZeroException), PostHandlingAction.None, new IExceptionHandler[] { exceptionHandler }); excepionPolicyEntries.Add(exceptionPolicy); excepionPolicies.Add(new ExceptionPolicyDefinition("Logging Policy", excepionPolicyEntries)); var exceptionManager = new ExceptionManager(excepionPolicies); var exceptionTothrow = new DivideByZeroException("error message"); exceptionManager.HandleException(exceptionTothrow, "Logging Policy"); var entry = EventLogEntries.Last; Assert.IsTrue(entry.Message.Contains("Type : " + exceptionTothrow.GetType().FullName)); Assert.IsTrue(entry.Message.Contains("Message : error message")); }
/// <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 MultipleFilesAreWrittenWhenUsingAsynchForRollingFlatFile() { const string Folder = "AsyncFolder"; const string FileNameWithoutExtension = "AsynchTestingForRollingFlatFile"; const string Extension = ".log"; const string FileName = FileNameWithoutExtension + Extension; LogFileReader.CreateDirectory(Folder); var configuration = new LoggingConfiguration(); configuration.AddLogSource("TestAsynchLogging In RollingFlatFile").AddTraceListener(new AsynchronousTraceListenerWrapper( new RollingFlatFileTraceListener(Path.Combine(Folder, FileName), "----", "----", new TextFormatter(), 8, "yyyy", RollFileExistsBehavior.Increment, RollInterval.Minute, 10), ownsWrappedTraceListener: true, bufferSize: 100)); using (var writer = new LogWriter(configuration)) { Parallel.Invoke(Enumerable.Range(0, 100).Select(i => new Action(() => { writer.Write("Test Asynch Message: " + i); })).ToArray()); } Assert.IsTrue(File.Exists(Path.Combine(Folder, FileName))); Assert.IsTrue(File.Exists(Path.Combine(Folder, FileNameWithoutExtension + "." + DateTime.Now.Year + ".1" + Extension))); Assert.IsTrue(File.Exists(Path.Combine(Folder, FileNameWithoutExtension + "." + DateTime.Now.Year + ".5" + Extension))); }
public void AddsLogSourceToCollection() { var config = new LoggingConfiguration(); config.AddLogSource("mock", new MockTraceListener()); Assert.AreEqual<int>(1, config.LogSources["mock"].Listeners.Count); }
public void DisposingWriterDisposesAllTraceListenersOnce() { var traceListener = new MockDisposableTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("cat1", traceListener); config.AddLogSource("cat2", traceListener); config.SpecialSources.AllEvents.Listeners.Add(traceListener); var logWriter = new LogWriter(config); logWriter.Dispose(); Assert.AreEqual(1, traceListener.DisposedCalls); }
/// <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 ThrowsArgumentNullIfAddLogSourceIsNull() { MockDisposableTraceListener listener = null; var config = new LoggingConfiguration(); AssertEx.Throws <ArgumentNullException>(() => config.AddLogSource("test", listener)); }
public void AddsLogSourceToCollection() { var config = new LoggingConfiguration(); config.AddLogSource("mock", new MockTraceListener()); Assert.AreEqual <int>(1, config.LogSources["mock"].Listeners.Count); }
public void ShouldNotAutoflushByDefault() { var config = new LoggingConfiguration(); config.AddLogSource("Default"); Assert.AreEqual <bool>(false, config.LogSources["Default"].AutoFlush); }
private void UpdateConfigForEventlogSourceLogMachineFormatter(LoggingConfiguration loggingConfiguration) { var eventLogTraceListener = new FormattedEventLogTraceListener("Enterprise Library Logging", "Application", ".", briefFormatter); loggingConfiguration.AddLogSource("General", SourceLevels.All, true, eventLogTraceListener); loggingConfiguration.SpecialSources.LoggingErrorsAndWarnings.Listeners.Add(eventLogTraceListener); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(eventLogTraceListener); }
public void ShouldHaveDefaultSourceLevel() { var config = new LoggingConfiguration(); config.AddLogSource("Default"); Assert.AreEqual <SourceLevels>(SourceLevels.All, config.LogSources["Default"].Level); }
private void UpdateConfigForDatabaseTL(LoggingConfiguration loggingConfiguration) { SqlDatabase dbConnection = new SqlDatabase(connectionString); var databaseTraceListener = new FormattedDatabaseTraceListener(dbConnection, "WriteLog", "AddCategory", briefFormatter); loggingConfiguration.AddLogSource("Database", SourceLevels.All, true, databaseTraceListener); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(databaseTraceListener); }
public void UpdateConfigForXMLTL(LoggingConfiguration loggingConfiguration) { var xmlTraceListener = new XmlTraceListener(Path.Combine(strPath, "XmlLogFile.xml")); xmlTraceListener.Filter = new EventTypeFilter(SourceLevels.All); loggingConfiguration.IsTracingEnabled = false; loggingConfiguration.AddLogSource("XML", SourceLevels.All, true, xmlTraceListener); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(xmlTraceListener); }
private static void ConfigureLogger() { var configuration = new LoggingConfiguration(); configuration.AddLogSource("default", new ConsoleTraceListener()); configuration.DefaultSource = "default"; var logWriter = new LogWriter(configuration); Logger.SetLogWriter(logWriter, false); }
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 eventLog = new EventLog("Application", ".", "EnoughPI"); var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog, formatter); var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\trace.log", "----------------------------------------", "----------------------------------------", formatter); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource(Category.General, SourceLevels.All, true).AddTraceListener(eventLogTraceListener); config.AddLogSource(Category.Trace, SourceLevels.ActivityTracing, true).AddTraceListener(flatFileTraceListener); config.IsTracingEnabled = true; return(config); }
/// <summary> /// Create a LogWrite that writes to the MemoryStream. /// </summary> /// <param name="memStream">Log will be written here.</param> /// <returns>A new LogWriter</returns> private static LogWriter CreateLogWriter(MemoryStream memStream) { var config = new LoggingConfiguration(); var source = config.AddLogSource( "All", System.Diagnostics.SourceLevels.All, true); source.AddAsynchronousTraceListener(new FormattedTextWriterTraceListener( memStream, new TextFormatter("{message}\n"))); return(new LogWriter(config)); }
private static LogWriter CreateStandardOutputLogWriter() { var traceListener = new FormattedTextWriterTraceListener( Console.OpenStandardOutput(), new TextFormatter("{timestamp}:\t{message}\n")); var config = new LoggingConfiguration(); config.AddLogSource("StandardOutput", System.Diagnostics.SourceLevels.All, true) .AddAsynchronousTraceListener(traceListener); return(new LogWriter(config)); }
private static void ConfigureXmlLogging(LoggingConfiguration config) { // Create a listener that formats events as XML XmlTraceListener xmllog = new XmlTraceListener(@"C:\temp\application log.xml"); // Set it to only listen to Error AND ABOVE xmllog.Filter = new EventTypeFilter(SourceLevels.Error); // Tell the config to use this (Category = xml) config.AddLogSource("xml", SourceLevels.All, true).AddTraceListener(xmllog); }
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); }
public void CanGetAllTraceListeners() { var listener1 = new MockTraceListener(); var listener2 = new MockTraceListener(); var listener3 = new MockTraceListener(); var listener4 = new MockTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("source1", listener1, listener2); config.AddLogSource("source2", listener2); config.AddLogSource("source3", listener1, listener3); config.AddLogSource("source4"); config.SpecialSources.Unprocessed.AddTraceListener(listener2); config.SpecialSources.Unprocessed.AddTraceListener(listener4); var allListeners = config.AllTraceListeners.ToArray(); Assert.AreEqual(4, allListeners.Length); CollectionAssert.AreEquivalent(new TraceListener[] { listener1, listener2, listener3, listener4 }, allListeners); }
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 CanGetAllTraceListeners() { var listener1 = new MockTraceListener(); var listener2 = new MockTraceListener(); var listener3 = new MockTraceListener(); var listener4 = new MockTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("source1", listener1, listener2); config.AddLogSource("source2", listener2); config.AddLogSource("source3", listener1, listener3); config.AddLogSource("source4"); config.SpecialSources.Unprocessed.AddTraceListener(listener2); config.SpecialSources.Unprocessed.AddTraceListener(listener4); var allListeners = config.AllTraceListeners.ToArray(); Assert.AreEqual(4, allListeners.Length); CollectionAssert.AreEquivalent(new TraceListener[] { listener1, listener2, listener3, listener4 }, allListeners); }
public void DisposingWriterDisposesAllTraceListenersOnce() { var traceListener = new MockDisposableTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("cat1", traceListener); config.AddLogSource("cat2", traceListener); config.SpecialSources.AllEvents.Listeners.Add(traceListener); var logWriter = new LogWriter(config); logWriter.Dispose(); Assert.AreEqual(1, traceListener.DisposedCalls); }
public void ShouldHaveDefaultSourceLevel() { var config = new LoggingConfiguration(); config.AddLogSource("Default"); Assert.AreEqual<SourceLevels>(SourceLevels.All, config.LogSources["Default"].Level); }
public void AddLogSourcesIsSetAsDefault() { var config = new LoggingConfiguration(); Assert.IsNull(config.DefaultSource); config.AddLogSource("Default"); Assert.AreEqual<string>("Default", config.DefaultSource); config.AddLogSource("Second"); Assert.AreEqual<string>("Default", config.DefaultSource); }
public void ShouldNotAutoflushByDefault() { var config = new LoggingConfiguration(); config.AddLogSource("Default"); Assert.AreEqual<bool>(false, config.LogSources["Default"].AutoFlush); }
public void ReconfigureDisposesUnusedListeners() { var traceListener = new MockDisposableTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("General", traceListener); var logWriter = new LogWriter(config); logWriter.Configure((cfg) => { cfg.LogSources.Clear(); cfg.AddLogSource("New", new DefaultTraceListener()); }); Assert.AreEqual(1, traceListener.DisposedCalls); }
public void ReconfigureDoesNotDisposeListenersStillUsedInSpecialSources() { var traceListener = new MockDisposableTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("General", traceListener); var logWriter = new LogWriter(config); logWriter.Configure((cfg) => { cfg.LogSources.Clear(); cfg.AddLogSource("New", new DefaultTraceListener()); cfg.SpecialSources.AllEvents.Listeners.Add(traceListener); }); Assert.AreEqual(0, traceListener.DisposedCalls); }
public void ThrowsArgumentNullIfAddLogSourceIsNull() { MockDisposableTraceListener listener = null; var config = new LoggingConfiguration(); AssertEx.Throws<ArgumentNullException>(() => config.AddLogSource("test", listener)); }
public void CanAddAsynchronousTraceListener() { var listener = new MockTraceListener { Name = "listener", Filter = new EventTypeFilter(SourceLevels.Critical) }; var config = new LoggingConfiguration(); config.AddLogSource("test").AddAsynchronousTraceListener(listener); var addedListener = (AsynchronousTraceListenerWrapper)config.AllTraceListeners.First(); Assert.AreSame(listener, addedListener.TraceListener); Assert.AreEqual("listener", addedListener.Name); Assert.AreEqual(SourceLevels.Critical, ((EventTypeFilter)addedListener.Filter).EventType); }
public void SharedTraceListener() { var sharedTraceListener = new DefaultTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("General").AddTraceListener(sharedTraceListener); config.AddLogSource("Special", SourceLevels.Critical, true, sharedTraceListener); Assert.AreEqual<int>(2, config.LogSources.Count); Assert.AreEqual<string>("General", config.LogSources.First().Name); Assert.AreEqual<string>("Special", config.LogSources.Last().Name); }