private static TraceListener GetListener(string name, IConfigurationSource configurationSource) { DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(configurationSource.GetSection), false); var settings = LoggingSettings.GetLoggingSettings(configurationSource); return(settings.TraceListeners.Get(name).BuildTraceListener(settings)); }
protected override TraceListenerData GetConfiguration(string name, IConfigurationSource configurationSource) { LoggingSettings settings = LoggingSettings.GetLoggingSettings(configurationSource); ValidateSettings(settings); TraceListenerData objectConfiguration = settings.TraceListeners.Get(name); ValidateConfiguration(objectConfiguration, name); return(objectConfiguration); }
public void ConfigExistsTest() { LoggingSettings msConfig = null; try { msConfig = LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()); } catch { Assert.Fail("Error"); } Assert.IsNotNull(msConfig); }
private static LogglyTraceListenerData GetLogglyTraceListenerSettings() { LogglyTraceListenerData traceListenerSettings = null; using (var configurationSource = ConfigurationSourceFactory.Create()) { var loggingSettings = LoggingSettings.GetLoggingSettings(configurationSource); traceListenerSettings = loggingSettings.TraceListeners .Where(l => l is LogglyTraceListenerData) .Single() as LogglyTraceListenerData; } return(traceListenerSettings); }
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]); }
static void Main(string[] args) { var configSource = ConfigurationSourceFactory.Create(); var logglyLoggingSettings = (LogglyTraceListenerData)LoggingSettings.GetLoggingSettings(configSource).TraceListeners.Get("Loggly Listener"); string logglyInputKey = logglyLoggingSettings.LogglyInputKey; Console.WriteLine("Testing logging for Loggly input key: {0}", logglyInputKey); if (Logger.IsLoggingEnabled()) { for (int i = 1; i < GetRandom.PositiveInt(9) + 1; i++) { var message = string.Format("Test {0}", i); Console.WriteLine(message); Logger.Write(message); } } }
public void EmptyCategoriesRevertToDefaultCategory() { MockTraceListener.Reset(); LoggingSettings settings = LoggingSettings.GetLoggingSettings(new SystemConfigurationSource()); LogEntry log = new LogEntry(); log.EventId = 1; log.Message = "test"; log.Categories = new string[0]; log.Severity = TraceEventType.Error; Logger.Write(log); Assert.IsNotNull(MockTraceListener.LastEntry); Assert.AreEqual("test", MockTraceListener.LastEntry.Message); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(settings.DefaultCategory)); }
/// <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> /// Gets the logging output from the app.config (loggingConfiguration section) /// </summary> private static void GetLoggingSettings() { IConfigurationSource configSource = Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceFactory.Create(); LoggingSettings logSettings = LoggingSettings.GetLoggingSettings(configSource); TraceListenerDataCollection dataCollection = logSettings.TraceListeners; if (dataCollection.Count == 0) { return; } TraceListenerData traceListenerData = dataCollection.Get(0); if (traceListenerData is RollingFlatFileTraceListenerData) { RollingFlatFileTraceListenerData tld = (RollingFlatFileTraceListenerData)traceListenerData; loggingOutputFileName = tld.FileName; } }
public void ConfigValidFileTest() { RollingFlatFileTraceListenerData fileTraceListener = LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("Rolling Flat File Trace Listener") as RollingFlatFileTraceListenerData; string filePath = fileTraceListener == null ? string.Empty : fileTraceListener.FileName; if (File.Exists(filePath)) { File.Delete(filePath); } string message = "This is Test Message"; LogEntry logEntry = new LogEntry() { Message = message, Severity = TraceEventType.Critical }; Logger.SetLogWriter(new LogWriterFactory().Create()); Logger.Write(logEntry); Logger.Reset(); Assert.IsTrue(File.ReadAllText(filePath).Contains(message)); }
private void UpdateLoggingTemplate() { var originalSettings = LoggingSettings.GetLoggingSettings(secondSource); var newSettings = new LoggingSettings(originalSettings.Name, originalSettings.TracingEnabled, originalSettings.DefaultCategory) { SpecialTraceSources = originalSettings.SpecialTraceSources, LogWarningWhenNoCategoriesMatch = originalSettings.LogWarningWhenNoCategoriesMatch, RevertImpersonation = originalSettings.RevertImpersonation }; CopyData(originalSettings.TraceListeners, tl => newSettings.TraceListeners.Add(tl)); CopyData(originalSettings.Formatters, f => newSettings.Formatters.Add(f)); CopyData(originalSettings.LogFilters, lf => newSettings.LogFilters.Add(lf)); CopyData(originalSettings.TraceSources, ts => newSettings.TraceSources.Add(ts)); var formatter = (TextFormatterData)newSettings.Formatters.Get("Text Formatter"); formatter.Template = "*** " + formatter.Template; secondSource.Save(LoggingSettings.SectionName, newSettings); }
private static TraceListener GetListener(string name, IConfigurationSource configurationSource) { var settings = LoggingSettings.GetLoggingSettings(configurationSource); return(settings.TraceListeners.Get(name).BuildTraceListener(settings)); }
public void ConfigListenerExistsTest() { Assert.IsTrue(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Count > 0); }
private static ILogFilter GetFilter(string name, IConfigurationSource configurationSource) { var settings = LoggingSettings.GetLoggingSettings(configurationSource); return(settings.LogFilters.Get(name).BuildFilter()); }
private void DisplayConfiguration() { try { // Get configuration settings for Logging and Instrmentation Application Block. // This assumes the configuration source is the SystemConfigurationSource, which // is the default setting when the QuickStart ships. LoggingSettings settings = LoggingSettings.GetLoggingSettings(new SystemConfigurationSource()); string defaultCategory = settings.DefaultCategory; StringBuilder results = new StringBuilder(); results.Append("Current Configuration"); results.Append(Environment.NewLine); results.Append("---------------------------------"); results.Append(Environment.NewLine); results.Append(Environment.NewLine); results.Append("Default Category: " + settings.DefaultCategory + Environment.NewLine + Environment.NewLine); results.Append("Categories and category listeners"); results.Append(Environment.NewLine); results.Append(Environment.NewLine); // Grab the list of categories and loop through for display. NamedElementCollection <TraceSourceData> sources = settings.TraceSources; foreach (TraceSourceData source in sources) { results.Append(" " + source.Name); // Flag any of the categories that would be denied based upon // the current category filter configuration. if (!Logger.GetFilter <CategoryFilter>().ShouldLog(source.Name)) { results.Append("*"); } // Loop through the list of trace listeners for the category. NamedElementCollection <TraceListenerReferenceData> TraceListeners = source.TraceListeners; StringBuilder listener = new StringBuilder(); listener.Append(" - "); foreach (TraceListenerReferenceData listenerData in TraceListeners) { listener.Append(listenerData.Name + ", "); } // Remove trailing comma and space listener.Remove(listener.Length - 2, 2); results.Append(listener.ToString()); results.Append(Environment.NewLine); } results.Append(Environment.NewLine); results.Append(" * Events in category will not be logged"); this.resultsTextBox.Text += results.ToString(); } catch (Exception ex) { ProcessUnhandledException(ex); } finally { Cursor.Current = Cursors.Default; } }
public void ConfigFileListenerExistsTest() { Assert.IsNotNull(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("Rolling Flat File Trace Listener")); }
public void ConfigConsoleAppenderExistsTest() { Assert.IsTrue(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("System Diagnostics Trace Listener").Type == typeof(ConsoleTraceListener)); }