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 }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Initializes a new instance of the <see cref="LogWriterStructureHolder"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list of a log entry is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> /// <param name="revertImpersonation">true if impersonation should be reverted while logging.</param> public LogWriterStructureHolder( IEnumerable<ILogFilter> filters, IDictionary<string, LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch, bool revertImpersonation) { if (filters == null) throw new ArgumentNullException("filters"); if (traceSources == null) throw new ArgumentNullException("traceSources"); if (errorsTraceSource == null) throw new ArgumentNullException("errorsTraceSource"); this.filters = filters; this.traceSources = traceSources; this.allEventsTraceSource = allEventsTraceSource; this.notProcessedTraceSource = notProcessedTraceSource; this.errorsTraceSource = errorsTraceSource; this.defaultCategory = defaultCategory; this.tracingEnabled = tracingEnabled; this.logWarningsWhenNoCategoriesMatch = logWarningsWhenNoCategoriesMatch; this.revertImpersonation = revertImpersonation; }
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); }
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]); }
public LogSource Create(IBuilderContext context, TraceSourceData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache, TraceListenerCustomFactory.TraceListenerCache traceListenersCache) { List <TraceListener> traceListeners = new List <TraceListener>(objectConfiguration.TraceListeners.Count); foreach (TraceListenerReferenceData traceListenerReference in objectConfiguration.TraceListeners) { TraceListener traceListener = TraceListenerCustomFactory.Instance.Create(context, traceListenerReference.Name, configurationSource, reflectionCache, traceListenersCache); traceListeners.Add(traceListener); } LogSource createdObject = new LogSource(objectConfiguration.Name, traceListeners, objectConfiguration.DefaultLevel, objectConfiguration.AutoFlush); InstrumentationAttachmentStrategy instrumentationAttacher = new InstrumentationAttachmentStrategy(); instrumentationAttacher.AttachInstrumentation(createdObject, configurationSource, reflectionCache); return(createdObject); }
/// <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 }
/// <summary> /// Initializes a new instance of the <see cref="LogWriter"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> public LogWriter(ICollection <ILogFilter> filters, ICollection <LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch) : this(filters, CreateTraceSourcesDictionary(traceSources), allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch) { }
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 }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Builds a <see cref="LogWriterStructureHolder"/> described by the <see cref="LoggingSettings"/> configuration section. /// </summary> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="name">The name of the instance to build. It is part of the <see cref="ICustomFactory.CreateObject(IBuilderContext, string, IConfigurationSource, ConfigurationReflectionCache)"/> method, but it is not used in this implementation.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <returns>A fully initialized instance of <see cref="LogWriterStructureHolder"/>.</returns> public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { LoggingSettings loggingSettings = LoggingSettings.GetLoggingSettings(configurationSource); ValidateLoggingSettings(loggingSettings); TraceListenerCustomFactory.TraceListenerCache traceListenerCache = TraceListenerCustomFactory.CreateTraceListenerCache(loggingSettings.TraceListeners.Count); ICollection <ILogFilter> logFilters = new List <ILogFilter>(); foreach (LogFilterData logFilterData in loggingSettings.LogFilters) { logFilters.Add(LogFilterCustomFactory.Instance.Create(context, logFilterData, configurationSource, reflectionCache)); } IDictionary <string, LogSource> traceSources = new Dictionary <string, LogSource>(); foreach (TraceSourceData traceSourceData in loggingSettings.TraceSources) { traceSources.Add(traceSourceData.Name, LogSourceCustomFactory.Instance.Create(context, traceSourceData, configurationSource, reflectionCache, traceListenerCache)); } LogSource allEventsTraceSource = LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.AllEventsTraceSource, configurationSource, reflectionCache, traceListenerCache); LogSource notProcessedTraceSource = LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.NotProcessedTraceSource, configurationSource, reflectionCache, traceListenerCache); LogSource errorsTraceSource = LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.ErrorsTraceSource, configurationSource, reflectionCache, traceListenerCache); LogWriterStructureHolder createdObject = new LogWriterStructureHolder( logFilters, traceSources, allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, loggingSettings.DefaultCategory, loggingSettings.TracingEnabled, loggingSettings.LogWarningWhenNoCategoriesMatch); return(createdObject); }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Builds a <see cref="LogSource"/> based on an instance of <see cref="TraceSourceData"/>. /// </summary> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="objectConfiguration">The configuration object that describes the object to build.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <param name="traceListenersCache">The cache of already built trace listeners, used to share trace listeners across <see cref="LogSource"/> instances.</param> /// <returns>A fully initialized instance of <see cref="LogSource"/>.</returns> public LogSource Create(IBuilderContext context, TraceSourceData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache, TraceListenerCustomFactory.TraceListenerCache traceListenersCache) { List<TraceListener> traceListeners = new List<TraceListener>(objectConfiguration.TraceListeners.Count); foreach (TraceListenerReferenceData traceListenerReference in objectConfiguration.TraceListeners) { TraceListener traceListener = TraceListenerCustomFactory.Instance.Create(context, traceListenerReference.Name, configurationSource, reflectionCache, traceListenersCache); traceListeners.Add(traceListener); } LogSource createdObject = new LogSource(objectConfiguration.Name, traceListeners, objectConfiguration.DefaultLevel); InstrumentationAttachmentStrategy instrumentationAttacher = new InstrumentationAttachmentStrategy(); instrumentationAttacher.AttachInstrumentation(createdObject, configurationSource, reflectionCache); return createdObject; }
public static void InitializeLogManager() { if (formatter == null) { formatter = new TextFormatter() { Template = " ------------------------------------------------------{newline}Timestamp:{timestamp}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}Title:{title}{newline}Machine: {localMachine}{newline}App Domain: {localAppDomain}{newline}Process Name: {localProcessName}{newline}Thread Name: {threadName}{newline}-----------------------------------------)}", }; } if (flatFileTraceListener == null) { flatFileTraceListener = new FlatFileTraceListener(formatter) { }; } if (logSource == null) { logSource = new LogSource("Logging", new List<TraceListener>() { flatFileTraceListener }, SourceLevels.Information); } }
/// <summary> /// Initializes a new instance of the <see cref="LogWriterImpl"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list of a log entry is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> public LogWriterImpl( IEnumerable <ILogFilter> filters, IDictionary <string, LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch) : this( filters, traceSources, allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch, true) { }
/// <summary> /// Initializes a new instance of the <see cref="LogWriterImpl"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> /// <param name="instrumentationProvider">The instrumentation provider to use.</param> public LogWriterImpl(IEnumerable <ILogFilter> filters, IEnumerable <LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch, ILoggingInstrumentationProvider instrumentationProvider) : this(filters, CreateTraceSourcesDictionary(traceSources), allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch, true, instrumentationProvider) { }
static LogWriterStructureHolder CreateStructureHolder( ICollection <ILogFilter> filters, IDictionary <string, LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch, bool revertImpersonation) { return(new LogWriterStructureHolder( filters, traceSources, allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch, revertImpersonation)); }
/// <summary> /// This constructor supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Initializes a new instance of the <see cref="LogWriterStructureHolder"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSourceNames">Names of the trace sources to dispatch entries to.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list of a log entry is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> /// <param name="revertImpersonation">true if impersonation should be reverted while logging.</param> public LogWriterStructureHolder( IEnumerable <ILogFilter> filters, IEnumerable <string> traceSourceNames, IEnumerable <LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch, bool revertImpersonation) : this( filters, traceSourceNames.ToDictionary(traceSources), allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch, revertImpersonation) { }
private void ReportExceptionDuringTracing(Exception exception, LogEntry log, LogSource traceSource) { try { NameValueCollection additionalInfo = new NameValueCollection(); additionalInfo.Add(ExceptionFormatter.Header, string.Format(Resources.Culture, Resources.TraceSourceFailed, traceSource.Name)); additionalInfo.Add(Resources.TraceSourceFailed2, string.Format(Resources.Culture, Resources.TraceSourceFailed3, log.ToString())); ExceptionFormatter formatter = new ExceptionFormatter(additionalInfo, Resources.DistributorEventLoggerDefaultApplicationName); LogEntry reportingLogEntry = new LogEntry(); reportingLogEntry.Severity = TraceEventType.Error; reportingLogEntry.Message = formatter.GetMessage(exception); reportingLogEntry.EventId = LogWriterFailureEventID; structureHolder.ErrorsTraceSource.TraceData(reportingLogEntry.Severity, reportingLogEntry.EventId, reportingLogEntry); } catch (Exception ex) { instrumentationProvider.FireFailureLoggingErrorEvent(Resources.FailureWhileTracing, ex); } }
/// <summary> /// This constructor supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Initializes a new instance of the <see cref="LogWriterStructureHolder"/> class. /// </summary> /// <param name="filters">The collection of filters to use when processing an entry.</param> /// <param name="traceSourceNames">Names of the trace sources to dispatch entries to.</param> /// <param name="traceSources">The trace sources to dispatch entries to.</param> /// <param name="allEventsTraceSource">The special <see cref="LogSource"/> to which all log entries should be logged.</param> /// <param name="notProcessedTraceSource">The special <see cref="LogSource"/> to which log entries with at least one non-matching category should be logged.</param> /// <param name="errorsTraceSource">The special <see cref="LogSource"/> to which internal errors must be logged.</param> /// <param name="defaultCategory">The default category to set when entry categories list of a log entry is empty.</param> /// <param name="tracingEnabled">The tracing status.</param> /// <param name="logWarningsWhenNoCategoriesMatch">true if warnings should be logged when a non-matching category is found.</param> /// <param name="revertImpersonation">true if impersonation should be reverted while logging.</param> public LogWriterStructureHolder( IEnumerable<ILogFilter> filters, IEnumerable<string> traceSourceNames, IEnumerable<LogSource> traceSources, LogSource allEventsTraceSource, LogSource notProcessedTraceSource, LogSource errorsTraceSource, string defaultCategory, bool tracingEnabled, bool logWarningsWhenNoCategoriesMatch, bool revertImpersonation) : this( filters, traceSourceNames.ToDictionary(traceSources), allEventsTraceSource, notProcessedTraceSource, errorsTraceSource, defaultCategory, tracingEnabled, logWarningsWhenNoCategoriesMatch, revertImpersonation) { }
private void DisposeSpecialLogSource(LogSource specialLogSource) { if (specialLogSource != null) { specialLogSource.Dispose(); } }
private static bool IsValidTraceSource(LogSource traceSource) { return(traceSource != null && traceSource.Listeners.Count > 0); }
/// <summary> /// Creates an Enterprise Library exception handler that utilizes /// a rolling flat file trace listener to write to log files. /// </summary> /// <param name="Name">The name of the <see cref="EnterpriseExceptionLogging.LoggingExceptionHandler"/>.</param> /// <param name="FilePath">Location of log file. If this is not provided, <see cref="DEFAULT_CONFIG_FILE_PATH"/> is used to try and retrieve file path from Web.config file.</param> /// <param name="FileName">Name of log file. If this is not provided, "default_rolling.log" is used.</param> /// <param name="Interval">How often a new file should be created.</param> /// <param name="Save">States whether or not to store the handler in memory.</param> /// <returns></returns> private EnterpriseExceptionLogging.LoggingExceptionHandler CreateTempLogger(string Name = "", string FilePath = "", string FileName = "", LoggingInterval Interval = LoggingInterval.Day, /*bool ForceCreate = false,*/ bool Save = true) { string default_file_path = FilePath; if (string.IsNullOrEmpty(default_file_path)) { try { default_file_path = ConfigurationManager.AppSettings[DEFAULT_CONFIG_FILE_PATH]; } catch (ConfigurationErrorsException) { } } if (string.IsNullOrEmpty(default_file_path)) { return(default(EnterpriseExceptionLogging.LoggingExceptionHandler)); } if (string.IsNullOrEmpty(Name)) { Name = default_file_path + (!string.IsNullOrEmpty(FileName) ? FileName : "default_rolling.log"); } string FullName = default_file_path + (!string.IsNullOrEmpty(FileName) ? FileName : "default_rolling.log"); if (!FullName.EndsWith(".log")) { FullName += ".log"; } if (_temp_enterprise_loggers.ContainsKey(Name)) { return(_temp_enterprise_loggers[Name]); } EnterpriseExceptionLogging.LoggingExceptionHandler handler = default(EnterpriseExceptionLogging.LoggingExceptionHandler); try { //EnterpriseLogging.LogWriter writer = default(EnterpriseLogging.LogWriter); //using (EnterpriseLogging.LogWriterFactory factory = new EnterpriseLogging.LogWriterFactory()) //using (writer = factory.CreateDefault()) //{ // if (writer == null) // return handler; // if (!ForceCreate && writer.TraceSources.Count > 0) // { // // there already exists listeners in web config that we do // // not want to overwrite, so there is no need to create a // // default listener // return handler; // } //} // create formatter for rolling log file EnterpriseLogging.Formatters.TextFormatter formatter = new EnterpriseLogging.Formatters.TextFormatter( template: "GMT Timestamp: {timestamp(MM/dd/yyyy HH:mm:ss)}\n" + "Local Timestamp: {timestamp(local:hh:mm:ss:tt)}\n" + "Message: {message}\n" + "Category: {category}\n" + "Priority: {priority}\n" + "EventId: {eventid}\n" + "Severity: {severity}\n" + "Title:{title}\n" + "Machine: {machine}\n" + "Application Domain: {appDomain}\n" + "Process Id: {processId}\n" + "Process Name: {processName}\n" + "Win32 Thread Id: {win32ThreadId}\n" + "Thread Name: {threadName}\n" + "Extended Properties: {dictionary({key} - {value})}\n"); EnterpriseLogging.TraceListeners.RollInterval interval; if (!Enum.TryParse(Enum.GetName(typeof(LoggingInterval), Interval), true, out interval)) { interval = EnterpriseLogging.TraceListeners.RollInterval.Day; } // create trace listener for exception handler EnterpriseLogging.TraceListeners.RollingFlatFileTraceListener listener = new EnterpriseLogging.TraceListeners.RollingFlatFileTraceListener( fileName: FullName, header: "----------------------------------------", footer: "----------------------------------------", formatter: formatter, rollSizeKB: 0, timeStampPattern: "yyyy-MM-dd", rollFileExistsBehavior: EnterpriseLogging.TraceListeners.RollFileExistsBehavior.Overwrite, rollInterval: interval); listener.TraceOutputOptions = TraceOptions.None; listener.Name = "Default Rolling Flat File Trace Listener"; // add trace listener to the log writer's sources //if (OverwriteTraceListeners) // writer.TraceSources.Clear(); //if (writer.TraceSources.ContainsKey("General")) // writer.TraceSources["General"].Listeners.Add(listener); //else // writer.TraceSources.Add( // key: "General", // value: new EnterpriseLogging.LogSource( // name: "Default Enterprise Logger", // level: SourceLevels.All, // traceListeners: new List<TraceListener>(1) { listener }, // autoFlush: true // )); // create the exception handler that will handle the exceptions //handler = new EnterpriseExceptionLogging.LoggingExceptionHandler( // logCategory: "General", // eventId: 100, // severity: TraceEventType.Error, // title: "Default Enterprise Library Exception Handler", // priority: 0, // formatterType: typeof(TextExceptionFormatter), // writer: writer); //List<EnterpriseLogging.Filters.LogFilter> filters = new List<EnterpriseLogging.Filters.LogFilter>(); //EnterpriseLogging.LogSource main_source = new EnterpriseLogging.LogSource( // name: "Default Enterprise Logger", // level: SourceLevels.All, // traceListeners: new List<TraceListener>(1) { listener }, // autoFlush: true // ); //IDictionary<string, EnterpriseLogging.LogSource> trace_sources = new Dictionary<string, EnterpriseLogging.LogSource>(); //trace_sources.Add("General", main_source); //EnterpriseLogging.LogWriterStructureHolder holder = new EnterpriseLogging.LogWriterStructureHolder(filters, trace_sources, main_source, main_source, main_source, "General", true, true, false); //EnterpriseLogging.LogWriterImpl writer = new EnterpriseLogging.LogWriterImpl(holder, new EnterpriseLogging.Instrumentation.LoggingInstrumentationProvider(false, true, "EnhancedPartnerCenter"), new EnterpriseLogging.LoggingUpdateCoordinator(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ConfigurationChangeEventSourceImpl())); //handler = new EnterpriseExceptionLogging.LoggingExceptionHandler( // logCategory: "General", // eventId: 100, // severity: TraceEventType.Error, // title: "Default Enterprise Library Exception Handler", // priority: 0, // formatterType: typeof(TextExceptionFormatter), // writer: writer); //if (Save) // _temp_enterprise_loggers.Add(Name, handler); // Try to fix this to work.. List <EnterpriseLogging.Filters.LogFilter> filters = new List <EnterpriseLogging.Filters.LogFilter>(); EnterpriseLogging.LogSource main_source = new EnterpriseLogging.LogSource( name: "Default Enterprise Logger", level: SourceLevels.All, traceListeners: new List <TraceListener>(1) { listener }, autoFlush: true ); IDictionary <string, EnterpriseLogging.LogSource> trace_sources = new Dictionary <string, EnterpriseLogging.LogSource>(); trace_sources.Add("General", main_source); EnterpriseLogging.LogWriterFactory factory_writer = new EnterpriseLogging.LogWriterFactory(); EnterpriseLogging.LogWriterStructureHolder holder = new EnterpriseLogging.LogWriterStructureHolder(filters, trace_sources, main_source, main_source, main_source, "General", true, true, false); EnterpriseLogging.LogWriter writer = factory_writer.Create(); // this is where chiz hit the fan writer.Configure(new Action <EnterpriseLogging.LoggingConfiguration>((EnterpriseLogging.LoggingConfiguration lc) => { lc.AddLogSource(""); })); handler = new EnterpriseExceptionLogging.LoggingExceptionHandler( logCategory: "General", eventId: 100, severity: TraceEventType.Error, title: "Default Enterprise Library Exception Handler", priority: 0, formatterType: typeof(TextExceptionFormatter), writer: writer); } catch (Exception) { handler = default(EnterpriseExceptionLogging.LoggingExceptionHandler); } return(handler); }
internal static SpecialLogSourceData FromLogSource(LogSource logSource) { return new SpecialLogSourceData(logSource.Name, logSource.Level, logSource.AutoFlush, logSource.Listeners.ToArray()); }
internal static SpecialLogSourceData FromLogSource(LogSource logSource) { return(new SpecialLogSourceData(logSource.Name, logSource.Level, logSource.AutoFlush, logSource.Listeners.ToArray())); }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// // 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 }