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();
}
/// <summary>
/// Initialize a new instance of a <see cref="CategoryTraceSourceNode"/> class with a <see cref="TraceSourceData"/> instance.
/// </summary>
/// <param name="traceSourceData">A <see cref="TraceSourceData"/> instance.</param>
public CategoryTraceSourceNode(TraceSourceData traceSourceData)
{
if (null == traceSourceData) throw new ArgumentNullException("traceSourceData");
Rename(traceSourceData.Name);
SourceLevels = traceSourceData.DefaultLevel;
}
private static TypeRegistration CreateLogSourceRegistration(TraceSourceData traceSourceData, string name)
{
var registration = traceSourceData.GetRegistrations();
registration.Name = name;
return(registration);
}
private EntLib.TraceSourceData GetAllEventsSource(SourceLevels level)
{
var source = new EntLib.TraceSourceData();
source.DefaultLevel = level;
this.AddEventLogTraceListenerReference(source);
return source;
}
public void CreatedTraceSourceWithNoListenersFromConfigurationIsEmpty()
{
MockLogObjectsHelper helper = new MockLogObjectsHelper();
TraceSourceData sourceData = new TraceSourceData("notfromconfiguration", SourceLevels.All);
LogSource traceSource
= LogSourceCustomFactory.Instance.Create(context, sourceData, helper.configurationSource, reflectionCache, traceListenerCache);
Assert.IsNotNull(traceSource);
Assert.AreEqual("notfromconfiguration", traceSource.Name);
Assert.AreEqual(SourceLevels.All, traceSource.Level);
Assert.AreEqual(0, traceSource.Listeners.Count);
}
private LogSource BuildTraceSource(TraceSourceData tsd, Dictionary <string, TraceListener> listeners)
{
var sourceListeners =
tsd.TraceListeners.Select(
tln =>
{
TraceListener listener;
if (!listeners.TryGetValue(tln.Name, out listener))
{
listener = this.BuildTraceListener(tln.Name, tln);
listeners[tln.Name] = listener;
}
return(listener);
});
return(new LogSource(tsd.Name, sourceListeners, tsd.DefaultLevel, tsd.AutoFlush));
}
/// <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 void CreatedTraceSourceWithListenersFromConfigurationHasCorrectCountOfListeners()
{
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock1"));
helper.loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock2"));
TraceSourceData sourceData = new TraceSourceData("notfromconfiguration", SourceLevels.All);
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock2"));
LogSource traceSource
= LogSourceCustomFactory.Instance.Create(context, sourceData, helper.configurationSource, reflectionCache, traceListenerCache);
Assert.IsNotNull(traceSource);
Assert.AreEqual("notfromconfiguration", traceSource.Name);
Assert.AreEqual(SourceLevels.All, traceSource.Level);
Assert.AreEqual(2, traceSource.Listeners.Count);
Assert.AreSame(typeof(MockTraceListener), traceSource.Listeners[0].GetType());
Assert.AreEqual("mock1", traceSource.Listeners[0].Name);
Assert.AreSame(typeof(MockTraceListener), traceSource.Listeners[1].GetType());
Assert.AreEqual("mock2", traceSource.Listeners[1].Name);
}
public void ManyTraceSourcesWithReferenceToSameTraceListenerGetSameInstanceIfSharingCache()
{
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock1"));
helper.loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock2"));
TraceSourceData sourceData1 = new TraceSourceData("notfromconfiguration1", SourceLevels.All);
sourceData1.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
sourceData1.TraceListeners.Add(new TraceListenerReferenceData("mock2"));
TraceSourceData sourceData2 = new TraceSourceData("notfromconfiguration2", SourceLevels.All);
sourceData2.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
LogSource traceSource1
= LogSourceCustomFactory.Instance.Create(context, sourceData1, helper.configurationSource, reflectionCache, traceListenerCache);
LogSource traceSource2
= LogSourceCustomFactory.Instance.Create(context, sourceData2, helper.configurationSource, reflectionCache, traceListenerCache);
Assert.IsNotNull(traceSource1);
Assert.IsNotNull(traceSource2);
Assert.IsFalse(traceSource1 == traceSource2);
Assert.AreEqual("mock1", traceSource1.Listeners[0].Name);
Assert.AreEqual("mock1", traceSource2.Listeners[0].Name);
Assert.AreSame(traceSource1.Listeners[0], traceSource2.Listeners[0]);
}
public void TraceManagerPolicyCreationDoesNotTryToCreateALogWriter_Bug17444()
{
loggingSettings.TraceListeners.Add(new FakeTraceListenerData("fake"));
TraceSourceData sourceData = new TraceSourceData("name", SourceLevels.All);
sourceData.TraceListeners.Add(new TraceListenerReferenceData("fake"));
loggingSettings.TraceSources.Add(sourceData);
loggingSettings.SpecialTraceSources = new SpecialTraceSourcesData();
loggingSettings.SpecialTraceSources.AllEventsTraceSource = new TraceSourceData("all", SourceLevels.All);
loggingSettings.SpecialTraceSources.NotProcessedTraceSource = new TraceSourceData("not processed", SourceLevels.Warning);
loggingSettings.SpecialTraceSources.ErrorsTraceSource = new TraceSourceData("errors", SourceLevels.Error);
loggingSettings.DefaultCategory = "name";
loggingSettings.LogWarningWhenNoCategoriesMatch = true;
loggingSettings.TracingEnabled = false;
// the order in which the extensions are added should not matter because they should only record policies
// but the bug caused an attempt to actually try to build a log writer, and this set up would cause
// an error because a required extension was not added yet.
InitializeContainer();
}
/// <summary>
/// Initializes a new instance of <see cref="SpecialTraceSourcesData"/>.
/// </summary>
/// <param name="mandatory">The configuration for the optional trace source to send all messages received.</param>
/// <param name="notProcessed">The configuration for the optional to send messages with unknown categories.</param>
/// <param name="errors">The configuration for the mandatory trace source to log processing errors.</param>
public SpecialTraceSourcesData(TraceSourceData mandatory, TraceSourceData notProcessed, TraceSourceData errors)
{
this.AllEventsTraceSource = mandatory;
this.NotProcessedTraceSource = notProcessed;
this.ErrorsTraceSource = errors;
}
private static TypeRegistration CreateLogSourceRegistration(TraceSourceData traceSourceData, string name)
{
var registration = traceSourceData.GetRegistrations();
registration.Name = name;
return registration;
}
ILoggingConfigurationCustomCategoryStart ILoggingConfigurationContd.LogToCategoryNamed(string categoryName)
{
if (string.IsNullOrEmpty(categoryName))
throw new ArgumentException(CommonResources.ExceptionStringNullOrEmpty, "categoryName");
currentTraceSource = new TraceSourceData()
{
Name = categoryName
};
loggingSettings.TraceSources.Add(currentTraceSource);
return this;
}
public void CanCreateLogWriter()
{
CategoryFilterData data = new CategoryFilterData();
data.Type = typeof(CategoryFilter);
data.Name = "name";
data.CategoryFilterMode = CategoryFilterMode.DenyAllExceptAllowed;
data.CategoryFilters.Add(new CategoryFilterEntry("foo"));
data.CategoryFilters.Add(new CategoryFilterEntry("bar"));
loggingSettings.LogFilters.Add(data);
loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock1"));
loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock2"));
TraceSourceData sourceData = new TraceSourceData("name", SourceLevels.All);
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock2"));
loggingSettings.TraceSources.Add(sourceData);
loggingSettings.SpecialTraceSources = new SpecialTraceSourcesData();
loggingSettings.SpecialTraceSources.AllEventsTraceSource = new TraceSourceData("all", SourceLevels.All);
loggingSettings.SpecialTraceSources.NotProcessedTraceSource = new TraceSourceData("not processed", SourceLevels.Warning);
loggingSettings.SpecialTraceSources.ErrorsTraceSource = new TraceSourceData("errors", SourceLevels.Error);
loggingSettings.SpecialTraceSources.ErrorsTraceSource.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
loggingSettings.DefaultCategory = "name";
loggingSettings.LogWarningWhenNoCategoriesMatch = true;
loggingSettings.TracingEnabled = false;
InitializeContainer();
LogWriter createdObject = container.Resolve<LogWriter>();
Assert.IsNotNull(createdObject);
CategoryFilter filter = createdObject.GetFilter<CategoryFilter>();
Assert.IsNotNull(filter);
Assert.AreEqual(2, filter.CategoryFilters.Count);
Assert.IsTrue(filter.CategoryFilters.Contains("foo"));
Assert.IsTrue(filter.CategoryFilters.Contains("bar"));
Assert.AreEqual(1, createdObject.TraceSources.Count);
}
private void AddApplicationCategorySource(EntLib.LoggingSettings entLibSettings)
{
var source = new EntLib.TraceSourceData(ApplicationEventsCategory, ApplicationLoggingLevel);
this.AddEventLogTraceListenerReference(source);
entLibSettings.TraceSources.Add(source);
}
private LogSource BuildTraceSource(TraceSourceData tsd, Dictionary<string, TraceListener> listeners)
{
var sourceListeners =
tsd.TraceListeners.Select(
tln =>
{
TraceListener listener;
if (!listeners.TryGetValue(tln.Name, out listener))
{
listener = this.BuildTraceListener(tln.Name, tln);
listeners[tln.Name] = listener;
}
return listener;
});
return new LogSource(tsd.Name, sourceListeners, tsd.DefaultLevel, tsd.AutoFlush);
}
public void CreateTraceSourceWithAutoFlushSetToFalse()
{
bool autoFlush = false;
TraceSourceData sourceData = new TraceSourceData("notfromconfiguration", SourceLevels.All, autoFlush);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
LogSource logSource = LogSourceCustomFactory.Instance.Create(context, sourceData, helper.configurationSource, reflectionCache, traceListenerCache);
Assert.IsNotNull(logSource);
Assert.AreEqual(autoFlush, logSource.AutoFlush);
}
private EntLib.TraceSourceData GetErrorsSource(EntLib.LoggingSettings entLibSettings)
{
var source = new EntLib.TraceSourceData();
source.DefaultLevel = SourceLevels.Warning;
this.AddEventLogTraceListenerReference(source);
return source;
}
/// <summary>
/// Initializes a new instance of <see cref="SpecialTraceSourcesData"/>.
/// </summary>
/// <param name="mandatory">The configuration for the optional trace source to send all messages received.</param>
/// <param name="notProcessed">The configuration for the optional to send messages with unknown categories.</param>
/// <param name="errors">The configuration for the mandatory trace source to log processing errors.</param>
public SpecialTraceSourcesData(TraceSourceData mandatory, TraceSourceData notProcessed, TraceSourceData errors)
{
this.AllEventsTraceSource = mandatory;
this.NotProcessedTraceSource = notProcessed;
this.ErrorsTraceSource = errors;
}
public void CanCreateTraceSource()
{
loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock1"));
loggingSettings.TraceListeners.Add(new MockTraceListenerData("mock2"));
TraceSourceData sourceData = new TraceSourceData("name", SourceLevels.All);
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock1"));
sourceData.TraceListeners.Add(new TraceListenerReferenceData("mock2"));
loggingSettings.TraceSources.Add(sourceData);
InitializeContainer();
LogSource createdObject = container.Resolve<LogSource>("name");
Assert.IsNotNull(createdObject);
Assert.AreEqual("name", createdObject.Name);
Assert.AreEqual(SourceLevels.All, createdObject.Level);
Assert.AreEqual(2, createdObject.Listeners.Count);
Assert.AreSame(typeof(ReconfigurableTraceListenerWrapper), createdObject.Listeners[0].GetType());
Assert.AreEqual("mock1", createdObject.Listeners[0].Name);
Assert.AreSame(typeof(ReconfigurableTraceListenerWrapper), createdObject.Listeners[1].GetType());
Assert.AreEqual("mock2", createdObject.Listeners[1].Name);
}