public void SetUp() { configurationSource = new DictionaryConfigurationSourceWithHandlersQuery(); InstrumentationConfigurationSection instrumentationConfig = new InstrumentationConfigurationSection(true, true, true); configurationSource.Add(InstrumentationConfigurationSection.SectionName, instrumentationConfig); settings = new LoggingSettings(); configurationSource.Add(LoggingSettings.SectionName, settings); settings.SpecialTraceSources.ErrorsTraceSource = new TraceSourceData("error", SourceLevels.Off); TraceSourceData traceSourceData = new TraceSourceData("blocking", SourceLevels.All); traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener1")); settings.TraceSources.Add(traceSourceData); traceSourceData = new TraceSourceData("nonblocking", SourceLevels.All); traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener2")); settings.TraceSources.Add(traceSourceData); TraceListenerData traceListenerData = new CustomTraceListenerData("listener1", typeof(MockBlockingCustomTraceListener), "init 1"); settings.TraceListeners.Add(traceListenerData); traceListenerData = new MockTraceListenerData("listener2"); settings.TraceListeners.Add(traceListenerData); reflectionCache = new ConfigurationReflectionCache(); MockTraceListener.Reset(); MockBlockingCustomTraceListener.Reset(); }
public void CanDeserializeSerializedConfiguration() { LoggingSettings rwLoggingSettings = new LoggingSettings(); rwLoggingSettings.TraceListeners.Add( new EmailTraceListenerData("listener", "[email protected]", "*****@*****.**", "EntLib-Logging:", "has occurred", "smtphost", 25, "formatter")); rwLoggingSettings.TraceListeners.Add( new EmailTraceListenerData("listener2", "[email protected]", "*****@*****.**", "EntLib-Logging:", "has occurred", "smtphost", 25, "formatter")); ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = "test.exe.config"; System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); rwConfiguration.Sections.Remove(LoggingSettings.SectionName); rwConfiguration.Sections.Add(LoggingSettings.SectionName, rwLoggingSettings); File.SetAttributes(fileMap.ExeConfigFilename, FileAttributes.Normal); rwConfiguration.Save(); System.Configuration.Configuration roConfiguration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); LoggingSettings roLoggingSettings = roConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; Assert.AreEqual(2, roLoggingSettings.TraceListeners.Count); Assert.IsNotNull(roLoggingSettings.TraceListeners.Get("listener")); Assert.IsNotNull(roLoggingSettings.TraceListeners.Get("listener2")); }
protected override void Arrange() { base.Arrange(); IConfigurationSource source = new DictionaryConfigurationSource(); ConfigurationSourceBuilder sourceBuiler = new ConfigurationSourceBuilder(); sourceBuiler.ConfigureLogging() .WithOptions.DisableTracing() .DoNotRevertImpersonation() .FilterOnPriority("prio filter").StartingWithPriority(10) .FilterOnCategory("categoryFiler").AllowAllCategoriesExcept("cat1") .LogToCategoryNamed("General") .SendTo.EventLog("Event Log Listener") .FormatWith(new FormatterBuilder().TextFormatterNamed("Default")) .LogToCategoryNamed("Critical") .SendTo.SharedListenerNamed("Event Log Listener") .SendTo.Custom<MyCustomListener>("Custom Listener") .SendTo.Email("Email Listener") .SendTo.SystemDiagnosticsListener("system diagnostics") .LogToCategoryNamed("msmq") .SendTo.Msmq("msmq"); sourceBuiler.UpdateConfigurationWithReplace(source); LoggingSection = (LoggingSettings)source.GetSection(LoggingSettings.SectionName); }
public void CanDeserializeSerializedConfiguration() { string name = "name"; string source = "source"; string log = "log"; string machine = "machine"; string formatter = "formatter"; TraceListenerData data = new FormattedEventLogTraceListenerData(name, source, log, machine, formatter, TraceOptions.Callstack); LoggingSettings settings = new LoggingSettings(); settings.TraceListeners.Add(data); IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(); sections[LoggingSettings.SectionName] = settings; IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections); LoggingSettings roSettigs = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName); Assert.AreEqual(1, roSettigs.TraceListeners.Count); Assert.IsNotNull(roSettigs.TraceListeners.Get(name)); Assert.AreEqual(TraceOptions.Callstack, roSettigs.TraceListeners.Get(name).TraceOutputOptions); Assert.AreSame(typeof(FormattedEventLogTraceListenerData), roSettigs.TraceListeners.Get(name).GetType()); Assert.AreSame(typeof(FormattedEventLogTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType); Assert.AreSame(typeof(FormattedEventLogTraceListener), roSettigs.TraceListeners.Get(name).Type); Assert.AreEqual(formatter, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter); Assert.AreEqual(log, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Log); Assert.AreEqual(machine, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).MachineName); Assert.AreEqual(source, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Source); }
private void ValidateLoggingSettings(LoggingSettings loggingSettings) { if (loggingSettings == null) { throw new System.Configuration.ConfigurationErrorsException(Resources.ExceptionLoggingSectionNotFound); } }
public void CanDeserializeSerializedCollection() { LoggingSettings rwLoggingSettings = new LoggingSettings(); rwLoggingSettings.TraceListeners.Add(new FormattedEventLogTraceListenerData("listener1", CommonUtil.EventLogSourceName, "formatter")); rwLoggingSettings.TraceListeners.Add(new SystemDiagnosticsTraceListenerData("listener2", typeof(FormattedEventLogTraceListener), CommonUtil.EventLogSourceName)); rwLoggingSettings.TraceListeners.Add(new SystemDiagnosticsTraceListenerData("listener3", typeof(XmlWriterTraceListener), "foobar.txt")); ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = "test.exe.config"; System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); rwConfiguration.Sections.Remove(LoggingSettings.SectionName); rwConfiguration.Sections.Add(LoggingSettings.SectionName, rwLoggingSettings); File.SetAttributes(fileMap.ExeConfigFilename, FileAttributes.Normal); rwConfiguration.Save(); System.Configuration.Configuration roConfiguration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); LoggingSettings roLoggingSettings = roConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; Assert.AreEqual(3, roLoggingSettings.TraceListeners.Count); Assert.IsNotNull(roLoggingSettings.TraceListeners.Get("listener1")); Assert.AreEqual(roLoggingSettings.TraceListeners.Get("listener1").GetType(), typeof(FormattedEventLogTraceListenerData)); Assert.AreSame(roLoggingSettings.TraceListeners.Get("listener1").Type, typeof(FormattedEventLogTraceListener)); Assert.IsNotNull(roLoggingSettings.TraceListeners.Get("listener2")); Assert.AreEqual(roLoggingSettings.TraceListeners.Get("listener2").GetType(), typeof(SystemDiagnosticsTraceListenerData)); Assert.AreSame(roLoggingSettings.TraceListeners.Get("listener2").Type, typeof(FormattedEventLogTraceListener)); Assert.IsNotNull(roLoggingSettings.TraceListeners.Get("listener3")); Assert.AreEqual(roLoggingSettings.TraceListeners.Get("listener3").GetType(), typeof(SystemDiagnosticsTraceListenerData)); Assert.AreSame(roLoggingSettings.TraceListeners.Get("listener3").Type, typeof(XmlWriterTraceListener)); }
public void CanDeserializeSerializedConfiguration() { string name = "name"; string write = "write"; string add = "add"; string database = "database"; string formatter = "formatter"; TraceListenerData data = new FormattedDatabaseTraceListenerData(name, write, add, database, formatter, TraceOptions.Callstack); LoggingSettings settings = new LoggingSettings(); settings.TraceListeners.Add(data); IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(); sections[LoggingSettings.SectionName] = settings; IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections); LoggingSettings roSettigs = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName); Assert.AreEqual(1, roSettigs.TraceListeners.Count); Assert.IsNotNull(roSettigs.TraceListeners.Get(name)); Assert.AreEqual(TraceOptions.Callstack, roSettigs.TraceListeners.Get(name).TraceOutputOptions); Assert.AreSame(typeof(FormattedDatabaseTraceListenerData), roSettigs.TraceListeners.Get(name).GetType()); Assert.AreSame(typeof(FormattedDatabaseTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType); Assert.AreSame(typeof(FormattedDatabaseTraceListener), roSettigs.TraceListeners.Get(name).Type); Assert.AreEqual(add, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).AddCategoryStoredProcName); Assert.AreEqual(database, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).DatabaseInstanceName); Assert.AreEqual(formatter, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter); Assert.AreEqual(write, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).WriteLogStoredProcName); }
protected override void Arrange() { base.Arrange(); var builder = new ConfigurationSourceBuilder(); builder.ConfigureLogging() .LogToCategoryNamed("category") .SendTo .EventLog("listener") .SpecialSources .AllEventsCategory .SendTo .EventLog("listener") .SpecialSources .LoggingErrorsAndWarningsCategory .SendTo .EventLog("listener") .SpecialSources .UnprocessedCategory .SendTo .EventLog("listener"); var source = new DictionaryConfigurationSource(); builder.UpdateConfigurationWithReplace(source); ElementLookup = Container.Resolve<ElementLookup>(); LoggingSection = (LoggingSettings)source.GetSection(LoggingSettings.SectionName); }
public void CanDeserializeSerializedConfiguration() { string name = "name"; string filename = "filename"; string header = "header"; string footer = "footer"; string formatter = "formatter"; TraceListenerData data = new FlatFileTraceListenerData(name, filename, header, footer, formatter, TraceOptions.Callstack); LoggingSettings settings = new LoggingSettings(); settings.TraceListeners.Add(data); IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(); sections[LoggingSettings.SectionName] = settings; IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections); LoggingSettings roSettigs = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName); Assert.AreEqual(1, roSettigs.TraceListeners.Count); Assert.IsNotNull(roSettigs.TraceListeners.Get(name)); Assert.AreEqual(TraceOptions.Callstack, roSettigs.TraceListeners.Get(name).TraceOutputOptions); Assert.AreSame(typeof(FlatFileTraceListenerData), roSettigs.TraceListeners.Get(name).GetType()); Assert.AreSame(typeof(FlatFileTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType); Assert.AreSame(typeof(FlatFileTraceListener), roSettigs.TraceListeners.Get(name).Type); Assert.AreEqual(filename, ((FlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).FileName); Assert.AreEqual(footer, ((FlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Footer); Assert.AreEqual(formatter, ((FlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter); Assert.AreEqual(header, ((FlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Header); }
public void SetUp() { loggingSettings = new LoggingSettings(); connectionStringsSection = new ConnectionStringsSection(); configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, loggingSettings); configurationSource.Add("connectionStrings", connectionStringsSection); }
/// <summary> /// Main entry point to configuration a <see cref="LoggingSettings"/> section. /// </summary> /// <param name="configurationSourceBuilder">The builder interface to extend.</param> /// <returns></returns> public static ILoggingConfigurationStart ConfigureLogging(this IConfigurationSourceBuilder configurationSourceBuilder) { if(configurationSourceBuilder == null) throw new ArgumentNullException("configurationSourceBuilder"); LoggingSettings loggingSettings = new LoggingSettings(); configurationSourceBuilder.AddSection(LoggingSettings.SectionName, loggingSettings); return new LoggingConfigurationBuilder(loggingSettings); }
public void SetUp() { instrumentationSettings = new InstrumentationConfigurationSection(true, true); loggingSettings = new LoggingSettings(); configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, loggingSettings); container = new UnityContainer(); }
ConfigurationSection GetLoggingSettings() { LoggingSettings loggingConfiguration = null; if (!_cache.ContainsKey(LoggingSettingsKey)) { lock (_sync) { if (!_cache.ContainsKey(LoggingSettingsKey)) { loggingConfiguration = new LoggingSettings(); loggingConfiguration.Name = "Logging Application Block"; loggingConfiguration.TracingEnabled = true; loggingConfiguration.DefaultCategory = "General"; loggingConfiguration.LogWarningWhenNoCategoriesMatch = true; var customTraceListenerData = new CustomTraceListenerData { ListenerDataType = Type.GetType( "Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.CustomTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"), TraceOutputOptions = TraceOptions.None, Filter = SourceLevels.All, Type = Type.GetType( "NCommons.Logging.EnterpriseLibrary.Specs.TraceListenerSpy, NCommons.Logging.EnterpriseLibrary.Specs"), Name = "Custom Trace Listener", Formatter = "Text Formatter" }; loggingConfiguration.TraceListeners.Add(customTraceListenerData); var textFormatterData = new TextFormatterData { Name = "Text Formatter", Type = Type.GetType( "Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"), Template = "{message}" }; loggingConfiguration.Formatters.Add(textFormatterData); loggingConfiguration.SpecialTraceSources.AllEventsTraceSource.TraceListeners.Add( new TraceListenerReferenceData("Custom Trace Listener")); loggingConfiguration.SpecialTraceSources.AllEventsTraceSource.DefaultLevel = SourceLevels.All; loggingConfiguration.SpecialTraceSources.AllEventsTraceSource.Name = "All Events"; _cache[LoggingSettingsKey] = loggingConfiguration; } } } return _cache[LoggingSettingsKey]; }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A <see cref="FormattedEventLogTraceListener"/>. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var formatter = this.BuildFormatterSafe(settings, this.Formatter); return(new FormattedEventLogTraceListener( this.Source, this.Log, this.MachineName, formatter)); }
public LogImplementation(SourceLevels level) { var factory = new LoggingConfigurationSourceFactory(); var configurationSource = factory.Create(level); this.entLibSettings = configurationSource.GetSection(EntLib.LoggingSettings.SectionName) as EntLib.LoggingSettings; this.logWriter = new LogWriterFactory(configurationSource).Create(); this.loggingEnabled = true; }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A <see cref="FlatFileTraceListener"/>. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var formatter = this.BuildFormatterSafe(settings, this.Formatter); return(new FlatFileTraceListener( this.FileName, this.Header, this.Footer, formatter)); }
private EntLib.LoggingSettings CreateLoggingSettings(SourceLevels level) { var entLibSettings = new EntLib.LoggingSettings(); this.AddFormatters(entLibSettings); this.AddEventLogTraceListener(entLibSettings); this.AddApplicationCategorySource(entLibSettings); this.AddSpecialSources(level, entLibSettings); return entLibSettings; }
public void CanCreateInstanceFromConfigurationFile() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add(new SystemDiagnosticsTraceListenerData("listener", typeof(EventLogTraceListener), "Entlib Tests")); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(EventLogTraceListener)); Assert.AreEqual("Entlib Tests", ((EventLogTraceListener)listener).EventLog.Source); }
public void CanCreateInstanceFromConfigurationFile() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add( new WmiTraceListenerData("listener")); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(WmiTraceListener)); }
public LoggingSectionViewModel(IUnityContainer builder, string sectionName, ConfigurationSection section) : base(builder, sectionName, section) { if (section as LoggingSettings == null) throw new ArgumentException("section"); loggingSettings = section as LoggingSettings; loggingSettings.SpecialTraceSources.AllEventsTraceSource.Name = "All Events"; loggingSettings.SpecialTraceSources.ErrorsTraceSource.Name = "Logging Errors & Warnings"; loggingSettings.SpecialTraceSources.NotProcessedTraceSource.Name = "Unprocessed Category"; }
public void CanCreateInstanceFromConfigurationFile() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add(new SystemDiagnosticsTraceListenerData("listener", typeof(EventLogTraceListener), "Entlib Tests")); TraceListener listener = GetListener("listener\u200cimplementation", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings)); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(EventLogTraceListener)); Assert.AreEqual("Entlib Tests", ((EventLogTraceListener)listener).EventLog.Source); }
public void WhenCreatingListener_ThenCreatesListenerWithSingleArgConstructor() { var settings = new LoggingSettings { }; var listener = (MockSystemDiagsTraceListener)listenerData.BuildTraceListener(settings); Assert.IsNotNull(listener); Assert.AreEqual("custom trace listener", listener.Name); Assert.AreSame("someInitData", listener.Value); Assert.AreEqual(TraceOptions.None, listener.TraceOutputOptions); Assert.IsNull(listener.Filter); Assert.AreEqual(0, listener.Attributes.Count); }
public void CanCreateInstanceFromConfigurationFileWithoutFormatter() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add( new EmailTraceListenerData("listener", "[email protected]", "*****@*****.**", "EntLib-Logging:", "has occurred", "smtphost", 25, null)); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(EmailTraceListener)); Assert.IsNull(((EmailTraceListener)listener).Formatter); }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A trace listener. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var listener = base.CoreBuildTraceListener(settings); var customTraceListener = listener as CustomTraceListener; if (customTraceListener != null && !string.IsNullOrEmpty(this.Formatter)) { customTraceListener.Formatter = this.BuildFormatterSafe(settings, this.Formatter); } return(listener); }
public void CanCreateFormatterFromContainerFromGivenName() { FormatterData data = new BinaryLogFormatterData("ignore"); LoggingSettings settings = new LoggingSettings(); settings.Formatters.Add(data); DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, settings); ILogFormatter formatter = GetFormatter("ignore", configurationSource); Assert.IsNotNull(formatter); Assert.AreEqual(formatter.GetType(), typeof(BinaryLogFormatter)); }
public void CanCreateFormatterFromFactoryFromGivenName() { FormatterData data = new BinaryLogFormatterData("ignore"); LoggingSettings settings = new LoggingSettings(); settings.Formatters.Add(data); DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, settings); ILogFormatter formatter = LogFormatterCustomFactory.Instance.Create(context, "ignore", configurationSource, reflectionCache); Assert.IsNotNull(formatter); Assert.AreEqual(formatter.GetType(), typeof(BinaryLogFormatter)); }
private static LoggingSettings GenerateLoggingSettings() { LoggingSettings result = new LoggingSettings(); result.LoggingEnabled = true; result.TracingEnabled = true; result.MinimumPriority = 5; result.DistributionStrategy = "InProc"; result.CategoryFilterMode = CategoryFilterMode.AllowAllExceptDenied; result.DistributionStrategies.Add( new InProcDistributionStrategyData("InProc")); return result; }
public void CanCreateInstanceFromConfigurationFile() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.Formatters.Add(new TextFormatterData("formatter", "foobar template")); loggingSettings.TraceListeners.Add(new FormattedDatabaseTraceListenerData("listener", "WriteLog", "AddCategory", "LoggingDb", "formatter")); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(FormattedDatabaseTraceListener)); Assert.IsNotNull(((FormattedDatabaseTraceListener)listener).Formatter); Assert.AreEqual(((FormattedDatabaseTraceListener)listener).Formatter.GetType(), typeof(TextFormatter)); Assert.AreEqual("foobar template", ((TextFormatter)((FormattedDatabaseTraceListener)listener).Formatter).Template); }
public void WhenCreatingListener_ThenCreatesListenerWithSingleArgConstructor() { var settings = new LoggingSettings { Formatters = { new TextFormatterData { Name = "formatter", Template = "template" } } }; var listener = (MockCustomTraceListener)listenerData.BuildTraceListener(settings); Assert.IsNotNull(listener); Assert.AreEqual("custom trace listener", listener.Name); Assert.AreSame("someInitData", listener.initData); Assert.AreEqual(TraceOptions.None, listener.TraceOutputOptions); Assert.IsNull(listener.Filter); Assert.IsNotNull(listener.Formatter); Assert.AreEqual("template", ((TextFormatter)listener.Formatter).Template); Assert.AreEqual(0, listener.Attributes.Count); }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A trace listener. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var formatter = this.BuildFormatterSafe(settings, this.Formatter); return(new RollingFlatFileTraceListener( this.FileName, this.Header, this.Footer, formatter, this.RollSizeKB, this.TimeStampPattern, this.RollFileExistsBehavior, this.RollInterval, this.MaxArchivedFiles)); }
public void CanBuildCustomLogFormatterFromGivenConfiguration() { CustomFormatterData customData = new CustomFormatterData("formatter", typeof(MockCustomLogFormatter)); customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1"); LoggingSettings settings = new LoggingSettings(); settings.Formatters.Add(customData); DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, settings); ILogFormatter formatter = GetFormatter("formatter", configurationSource); Assert.IsNotNull(formatter); Assert.AreSame(typeof(MockCustomLogFormatter), formatter.GetType()); Assert.AreEqual("value1", ((MockCustomLogFormatter)formatter).customValue); }
public void CanCreateInstanceFromConfigurationFile() { SystemDiagnosticsTraceListenerData listenerData = new SystemDiagnosticsTraceListenerData("listener", typeof(DelimitedListTraceListener), "log.txt"); listenerData.SetAttributeValue("delimiter", "||"); LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add(listenerData); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual("listener", listener.Name); Assert.AreEqual(typeof(DelimitedListTraceListener), listener.GetType()); Assert.AreEqual("||", ((DelimitedListTraceListener)listener).Delimiter); }
public void CanCreateInstanceFromConfigurationFile() { LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.Formatters.Add(new FormatterData(formatterName, typeof(BinaryLogFormatter))); loggingSettings.TraceListeners.Add(new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, formatterName)); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(MsmqTraceListener)); MsmqTraceListener msmqTraceListener = listener as MsmqTraceListener; Assert.IsNotNull(msmqTraceListener.Formatter); Assert.AreEqual(msmqTraceListener.Formatter.GetType(), typeof(BinaryLogFormatter)); Assert.AreEqual(CommonUtil.MessageQueuePath, msmqTraceListener.QueuePath); }
public void CanCreateInstanceFromConfigurationFile() { SystemDiagnosticsTraceListenerData listenerData = new SystemDiagnosticsTraceListenerData("listener", typeof(TextWriterTraceListener), "log.txt"); listenerData.TraceOutputOptions = TraceOptions.Callstack; LoggingSettings loggingSettings = new LoggingSettings(); loggingSettings.TraceListeners.Add(listenerData); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual(listener.GetType(), typeof(TextWriterTraceListener)); Assert.AreEqual(TraceOptions.Callstack, listener.TraceOutputOptions); }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// An <see cref="EmailTraceListener"/>. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var formatter = this.BuildFormatterSafe(settings, this.Formatter); return(new EmailTraceListener( this.ToAddress, this.FromAddress, this.SubjectLineStarter, this.SubjectLineEnder, this.SmtpServer, this.SmtpPort, formatter, this.AuthenticationMode, this.UserName, this.Password, this.UseSSL)); }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A <see cref="FlatFileTraceListener"/>. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { var formatter = this.BuildFormatterSafe(settings, this.Formatter); //This is due to an error inside .net core which does not create the file stream using this constructor #if NET45 || NET46 || NET461 || NET462 || NET47 || NET471 || NET472 return(new FlatFileTraceListener( this.FileName, this.Header, this.Footer, formatter)); #else FileStream stream = File.Create(this.FileName); return(new FlatFileTraceListener( stream, this.Name, formatter)); #endif }
protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { this.CheckQueuePath(); this.CheckFormatter(); var formatter = this.BuildFormatterSafe(settings, this.Formatter); return(new MsmqTraceListener( this.Name, this.QueuePath, formatter, this.MessagePriority, this.Recoverable, this.TimeToReachQueue, this.TimeToBeReceived, this.UseAuthentication, this.UseDeadLetterQueue, this.UseEncryption, this.TransactionType)); }
/// <summary> /// Builds the log formatter represented by the name <paramref name="formatterName"/> in <paramref name="settings"/>. /// </summary> /// <param name="settings">The logging settings.</param> /// <param name="formatterName">The formatter name, or a null or empty string.</param> /// <returns>A new formatter if <paramref name="formatterName"/> is not null or empty; otherwise, null.</returns> protected ILogFormatter BuildFormatterSafe(LoggingSettings settings, string formatterName) { if (string.IsNullOrEmpty(formatterName)) { return(null); } var formatterData = settings.Formatters.Get(formatterName); if (formatterData == null) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, Resources.ExceptionFormatterNotDefined, formatterName, this.ElementInformation.Source, this.ElementInformation.LineNumber)); } return(formatterData.BuildFormatter()); }
/// <summary> /// Builds the log <see cref="ApplicationInsightsTraceListener"/> object represented by this configuration object /// </summary> /// <param name="settings">The configuration settings for logging</param> /// <returns>An Application Insights trace listener</returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) => new ApplicationInsightsTraceListener(this.InstrumentationKey) { Formatter = this.BuildFormatterSafe(settings, this.Formatter) };
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// A trace listener. /// </returns> protected virtual TraceListener CoreBuildTraceListener(LoggingSettings settings) { throw new NotImplementedException(Resources.ExceptionMethodMustBeImplementedBySubclasses); }
/// <summary> /// Builds the <see cref="TraceListener" /> object represented by this configuration object. /// </summary> /// <param name="settings">The logging configuration settings.</param> /// <returns> /// An <see cref="XmlTraceListener"/>. /// </returns> protected override TraceListener CoreBuildTraceListener(LoggingSettings settings) { return(new XmlTraceListener(this.FileName)); }