private LogWriter CreateFlatFileLogWriter(FileStream logFile) { // This is our message template for any Sink you add below in our case the Windows Event Log TextFormatter formatter = new TextFormatter("Timestamp: {timestamp}{newline}" + "Message: {message}{newline}" + "Machine: {machine}{newline}{newline}{newline}"); LogSource emptyTraceSource = new LogSource("none"); LogSource errorsTraceSource = new LogSource(CONS_ERROR_CATEGORY, System.Diagnostics.SourceLevels.All); // Create for all Errors a Listener which writes the messages to the Windows Event Log // with the Event Log Source Property "Code Source". The message format is specified by // the TextFormatter which is in our case the template above. errorsTraceSource.Listeners.Add(new FlatFileTraceListener(logFile, formatter)); IDictionary<string, LogSource> traceSources = new Dictionary<string, LogSource>(); // Add to Category "Error" our EventLog Listener with the corresponding category in it. traceSources.Add(errorsTraceSource.Name, errorsTraceSource); return new LogWriter(new ILogFilter[0], // ICollection<ILogFilter> filters traceSources, // IDictionary<string, LogSource> traceSources emptyTraceSource, // LogSource allEventsTraceSource emptyTraceSource, // LogSource notProcessedTraceSource errorsTraceSource, // LogSource errorsTraceSource CONS_ERROR_CATEGORY, // string defaultCategory false, // bool tracingEnabled true); // bool logWarningsWhenNoCategoriesMatch }
private TraceListener CreateListener(IUnityContainer c) { var formatter = new TextFormatter("{message}{dictionary({key} - {value}{newline})}"); var data = new CommonLoggingEntlibTraceListenerData(this.GetType().FullName, "{listenerName}.{sourceName}", "Text Formatter"); var listener = new CommonLoggingEntlibTraceListener(data, formatter); return listener; }
public void ShouldBeAbleToFormatLogWithExtraProperties() { Dictionary<string, object> parameterValues = new Dictionary<string, object>(); parameterValues["one"] = 1; parameterValues["two"] = "two"; TraceLogEntry logEntry = new TraceLogEntry(); logEntry.Categories.Add("General"); logEntry.Categories.Add("Callhandler"); logEntry.Message = "Logging call"; logEntry.ExtendedProperties = parameterValues; logEntry.TypeName = GetType().Name; logEntry.MethodName = "SomeMethod"; logEntry.ReturnValue = 42.ToString(); string template = @"Message logged on {timestamp}{newline}{message}{newline} Call on type {property(TypeName)} method {property(MethodName)}{newline} Parameter values:{newline} {dictionary({key} = {value}{newline})}{newline} Return value: {property(ReturnValue)}{newline}"; TextFormatter formatter = new TextFormatter(template); string formatted = formatter.Format(logEntry); Assert.IsTrue(formatted.Contains("Logging call")); Assert.IsTrue( formatted.Contains("Call on type TraceLogEntryFixture method SomeMethod\r\n")); Assert.IsTrue(formatted.Contains("one = 1\r\n")); Assert.IsTrue(formatted.Contains("two = two\r\n")); Assert.IsTrue(formatted.Contains("Return value: 42\r\n")); }
static LogService() { var formatter = new TextFormatter ("Timestamp: {timestamp}{newline}" + "Message: {message}{newline}" + "Category: {category}{newline}"); //Create the Trace listeners var logFileListener = new FlatFileTraceListener(@"C:\temp\temp.log", "", "", formatter); //Add the trace listeners to the source var mainLogSource = new LogSource("MainLogSource", SourceLevels.All); mainLogSource.Listeners.Add(logFileListener); var nonExistantLogSource = new LogSource("Empty"); IDictionary<string, LogSource> traceSources = new Dictionary<string, LogSource> {{"Info", mainLogSource}, {"Warning", mainLogSource}, {"Error", mainLogSource}}; Writer = new LogWriterImpl(new ILogFilter[0], traceSources, nonExistantLogSource, nonExistantLogSource, mainLogSource, "Info", false, true); }
/// <summary> /// Distribute a log entry to the sinks using a <see cref="LogDistributor"/>. /// </summary> /// <param name="logEntry">Message body</param> public void SendLog(LogEntry logEntry) { this.logDistributor.ProcessLog(logEntry); TextFormatter formatter = new TextFormatter(new TextFormatterData()); string message = formatter.Format(logEntry); LoggingLogDistributedEvent.Fire(message); }
public void LogSendingMessageException(Exception ex, string sink, LogEntry logEntry) { logger.AddMessage(Header, SR.InvalidSink(sink)); TextFormatter formatter = new TextFormatter(new TextFormatterData()); string formattedMessage = formatter.Format(logEntry); logger.AddMessage(logEntry.Category, SR.InvalidSinkMessage(formattedMessage)); logger.WriteToLog(ex, Severity.Warning); }
public void LogProcessLogException(LogEntry logEntry, Exception ex) { // distribution failed so write the event to the event log as a backup logger.AddMessage(Header, SR.ProcessMessageFailed); TextFormatter formatter = new TextFormatter(new TextFormatterData()); string formattedMessage = formatter.Format(logEntry); logger.AddMessage(SR.ProcessMessageFailed2, SR.ProcessMessageFailed3(formattedMessage)); logger.WriteToLog(ex, Severity.Error); }
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); }
private Logger() { string connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString; TextFormatter formatter = new TextFormatter(); var databaseTraceListener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString) , "WriteLog", "AddCategory", formatter); var config = new LoggingConfiguration(); config.AddLogSource(LogCategories.General.ToString(), SourceLevels.All, true).AddTraceListener(databaseTraceListener); writer = new LogWriter(config); writer.Write("Starting...", LogCategories.General.ToString(), 9, 0, TraceEventType.Verbose, "Log Starting"); }
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); }
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; }
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 DynamicELLogger(string logRoot, IEnumerable<string> applications) { string[] categories = new string[] { "Info", "Error", "Debug", "Perf" }; LoggingSettings loggingSetting = LoggingSettings.GetLoggingSettings(ConfigurationSourceFactory.Create()); Dictionary<string, TextFormatter> formatters = new Dictionary<string, TextFormatter>(categories.Count(), StringComparer.OrdinalIgnoreCase); foreach (string cate in categories) { var formatData = loggingSetting.Formatters.Where(f => f.Name.Equals(cate, StringComparison.OrdinalIgnoreCase)).SingleOrDefault() as TextFormatterData; if (formatData == null) throw new Exception(string.Format("Missing logging formatter \"{0}\"", cate)); TextFormatter formatter = new TextFormatter(formatData.Template); formatters[cate] = formatter; } string baseLogPath = Path.Combine(logRoot, "{0}.log"); string logPath = Path.Combine(logRoot, "{0}\\{1}.log"); List<LogSource> logSources = new List<LogSource>(); foreach (var cate in categories) { logSources.Add(new LogSource(cate, new List<TraceListener> { new RollingFlatFileTraceListener(string.Format(baseLogPath, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day) }, SourceLevels.All)); } foreach (var app in applications) { foreach (var cate in categories) { logSources.Add(new LogSource(app + "." + cate, new List<TraceListener> { new RollingFlatFileTraceListener(string.Format(logPath, app, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day) }, SourceLevels.All)); } } var nonExistantLog = new LogSource("Empty"); m_Writer = new LogWriter(new ILogFilter[0], logSources, nonExistantLog, categories[0]); }
/// <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 }
private LogWriter CreateEventLogWriter() { // This is our message template for any Sink you add below in our case the Windows Event Log TextFormatter formatter = new TextFormatter("Timestamp: {timestamp}{newline}" + "Message: {message}{newline}" + "Category: {category}{newline}" + "Priority: {priority}{newline}" + "Severity: {severity}{newline}" + "Title:{title}{newline}" + "Application Domain: {appDomain}{newline} " + "Process Id: {processId}{newline}" + "Process Name: {processName}{newline}" + "Win32 Thread Id: {win32ThreadId}{newline}" + "Thread Name: {threadName}{newline}" + "Extended Properties: {dictionary({key} - {value})}{newline}"); LogSource emptyTraceSource = new LogSource("none"); LogSource errorsTraceSource = new LogSource(CONS_ERROR_CATEGORY, System.Diagnostics.SourceLevels.All); // Create for all Errors a Listener which writes the messages to the Windows Event Log // with the Event Log Source Property "Code Source". The message format is specified by // the TextFormatter which is in our case the template above. if (!EventLog.SourceExists(LoggingConstants.CONS_LOG_SOURCE)) EventLog.CreateEventSource(LoggingConstants.CONS_LOG_SOURCE, LoggingConstants.CONS_LOG_NAME); EventLog eventLog = new EventLog(); eventLog.Source = LoggingConstants.CONS_LOG_SOURCE; eventLog.Log = LoggingConstants.CONS_LOG_NAME; errorsTraceSource.Listeners.Add(new FormattedEventLogTraceListener(eventLog, formatter)); IDictionary<string, LogSource> traceSources = new Dictionary<string, LogSource>(); // Add to Category "Error" our EventLog Listener with the corresponding category in it. traceSources.Add(errorsTraceSource.Name, errorsTraceSource); return new LogWriter(new ILogFilter[0], // ICollection<ILogFilter> filters traceSources, // IDictionary<string, LogSource> traceSources emptyTraceSource, // LogSource allEventsTraceSource emptyTraceSource, // LogSource notProcessedTraceSource errorsTraceSource, // LogSource errorsTraceSource CONS_ERROR_CATEGORY, // string defaultCategory false, // bool tracingEnabled true); // bool logWarningsWhenNoCategoriesMatch }
internal static LoggingConfiguration BuildLoggingConfig(GlobalStateModel model) { // 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})}"); TextFormatter errorFormatter = new TextFormatter("{timestamp} {message}"); TextFormatter consoleFormatter = new TextFormatter("{timestamp} {severity} : {message}"); // Listeners var errorFlatFileTraceListener = new FlatFileTraceListener(Directory.GetCurrentDirectory() + "\\" + "Error.log", "----------------------------------------", "----------------------------------------", errorFormatter); var outputFlatFileTraceListener = new FlatFileTraceListener(Directory.GetCurrentDirectory() + "\\" + "Output.log", "----------------------------------------", "----------------------------------------", errorFormatter); var outputViewTraceListener = new OutputViewTraceListener(model, consoleFormatter); //var consoleTraceListener = new CustomTraceListener(); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource("Error", SourceLevels.All, true).AddTraceListener(errorFlatFileTraceListener); config.AddLogSource("Output", SourceLevels.All, true).AddTraceListener(outputViewTraceListener); config.LogSources["Output"].AddTraceListener(outputFlatFileTraceListener); config.AddLogSource("Debug", SourceLevels.All, true).AddTraceListener(outputViewTraceListener); config.AddLogSource("OutputToFile", SourceLevels.All, true).AddTraceListener(outputFlatFileTraceListener); return config; }
public static LoggingConfiguration BuildProgrammaticConfig() { // Formatter TextFormatter briefFormatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}"); // Trace Listener var flatFileTraceListener = new FlatFileTraceListener( @"C:\Temp\jarwin.log", "----------------------------------------", "----------------------------------------", briefFormatter); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource("jarwin", SourceLevels.All, true) .AddTraceListener(flatFileTraceListener); config.IsLoggingEnabled = Convert.ToBoolean(ConfigurationManager.AppSettings["loggingEnabled"]); return config; }
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 SetupLogWriter() { writer = new StringWriter(); TextFormatter formatter = new TextFormatter(preCallTemplate); listener = new FormattedTextWriterTraceListener(writer, formatter); LogSource logSource = new LogSource("Logging"); logSource.Listeners.Add(listener); log = new LogWriterImpl(new ILogFilter[0], new LogSource[] { logSource }, logSource, logSource, logSource, "General", true, true); }
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\SalaryCalculator.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; }
/// <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; }
/// <summary> /// Write the log entry to the configured event log. /// </summary> /// <param name="logEntry"><see cref="LogEntry"></see> to be written to the event log</param> public void SendMessage(LogEntry logEntry) { try { short categoryID = GetCategoryId(logEntry); logEntry.AddErrorMessage(SR.DefaultLogDestinationMessage); TextFormatter formatter = formatter = new TextFormatter(new TextFormatterData()); string message = FormatEntry(formatter, logEntry); EventLog.WriteEntry( eventLogSourceName, message, SeverityMap.GetEventLogEntryType(logEntry.Severity), logEntry.EventId, categoryID); LoggingLogDeliveryFailureEvent.Fire(message); } catch (Exception e) { throw new LoggingException(SR.DefaultLogDestinationFailed, e); } catch { throw new LoggingException(SR.DefaultLogDestinationFailed); } }
public void SetupLogWriter() { writer = new StringWriter(); TextFormatter formatter = new TextFormatter(preCallTemplate); listener = new FormattedTextWriterTraceListener(writer, formatter); LogSource logSource = new LogSource("Logging", new[] { listener }, SourceLevels.All); log = new LogWriter(new ILogFilter[0], new LogSource[] { logSource }, logSource, logSource, logSource, "General", true, true); Logger.SetLogWriter(this.log, false); }
static LogEntry() { isFullyTrusted = typeof(LogEntry).Assembly.IsFullyTrusted; toStringFormatter = new TextFormatter(); }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// // APIREV: make own type like TraceEventType so user won't have a need to add a reference to Logger dll. // Create log instance public static void Initialize(string logFilePath, int logFileSize, TraceEventType minimalSeverity, bool isLogEnabled) { if (logFileSize < 1) throw new SettingsException(Properties.Resources.LogFileCantBeSmall); _minimalSeverity = minimalSeverity; _isLogEnabled = isLogEnabled; // Create message formatter TextFormatter formatter = new TextFormatter(MESSAGE_FORMAT); // Create Log sources LogSource emptyTraceSource = new LogSource("EmptySource"); LogSource errorsTraceSource = new LogSource("Logger", SourceLevels.All); // Create listener for rolling log file RollingFlatFileTraceListener rollingTrace = new RollingFlatFileTraceListener(logFilePath, "", "", formatter, logFileSize, "yyyy - MM - dd", RollFileExistsBehavior.Overwrite, RollInterval.Year); errorsTraceSource.Listeners.Add(rollingTrace); // Create and fill sources array IDictionary<string, LogSource> traceSources = new Dictionary<string, LogSource>(); traceSources.Add(TraceEventType.Critical.ToString(), errorsTraceSource); traceSources.Add(TraceEventType.Error.ToString(), errorsTraceSource); traceSources.Add(TraceEventType.Warning.ToString(), errorsTraceSource); traceSources.Add(TraceEventType.Information.ToString(), errorsTraceSource); // create default category string string defaultCategory = _minimalSeverity.ToString(); ICollection<ILogFilter> filters = new ILogFilter[0]; _logWriter = new LogWriter(filters, // filters collection traceSources, // sources array emptyTraceSource, // all events trace source emptyTraceSource, // not processed trace source errorsTraceSource, // errors trace source defaultCategory, // string defaultCategory false, // enable tracing true); // save message as warning, when no categories match }
private LoggingConfiguration BuildProgrammaticConfig() { // Formatters TextFormatter briefFormatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}"); TextFormatter extendedFormatter = new TextFormatter("Timestamp: {timestamp}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}Severity: {severity}{newline}Title: {title}{newline}Activity ID: {property(ActivityId)}{newline}Machine: {localMachine}{newline}App Domain: {localAppDomain}{newline}ProcessId: {localProcessId}{newline}Process Name: {localProcessName}{newline}Thread Name: {threadName}{newline}Win32 ThreadId:{win32ThreadId}{newline}Extended Properties: {dictionary({key} - {value}{newline})}"); // Category Filters ICollection<string> categories = new List<string>(); categories.Add("BlockedByFilter"); // Log Filters var priorityFilter = new PriorityFilter("Priority Filter", 2, 99); var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true); var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.AllowAllExceptDenied); // Trace Listeners //var causeLoggingErrorTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("DoesNotExist"), "WriteLog", "AddCategory", null); //var databaseTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("ExampleDatabase"), "WriteLog", "AddCategory", extendedFormatter); var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter); var eventLog = new EventLog("Application", ".", "Enterprise Library Logging"); var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog); var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(@"C:\Temp\RollingFlatFile.log", "----------------------------------------", "----------------------------------------", extendedFormatter, 20, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.None, 3); var unprocessedFlatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\Unprocessed.log", "----------------------------------------", "----------------------------------------", extendedFormatter); var xmlTraceListener = new XmlTraceListener(@"C:\Temp\XmlLogFile.xml"); xmlTraceListener.Filter = new EventTypeFilter(SourceLevels.Error); // Build Configuration var config = new LoggingConfiguration(); config.Filters.Add(priorityFilter); config.Filters.Add(logEnabledFilter); config.Filters.Add(categoryFilter); config.AddLogSource("BlockedByFilter", SourceLevels.All, true).AddTraceListener(eventLogTraceListener); //config.AddLogSource("CauseLoggingError", SourceLevels.All, true).AddTraceListener(causeLoggingErrorTraceListener); //config.AddLogSource("Database", SourceLevels.All, true).AddTraceListener(databaseTraceListener); // The defaults for the asynchronous wrapper are: // bufferSize: 30000 // disposeTimeout: infinite //config.AddLogSource("AsyncDatabase", SourceLevels.All, true).AddAsynchronousTraceListener(databaseTraceListener); config.AddLogSource("DiskFiles", SourceLevels.All, true).AddTraceListener(flatFileTraceListener); config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(eventLogTraceListener); config.AddLogSource("Important", SourceLevels.All, true).AddTraceListener(eventLogTraceListener); config.LogSources["Important"].AddTraceListener(rollingFlatFileTraceListener); // Special Sources Configuration config.SpecialSources.Unprocessed.AddTraceListener(unprocessedFlatFileTraceListener); config.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(eventLogTraceListener); return config; }