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));
}
