public void ConfigCanBeChangedAfterStarting()
{
var setupTracerFactory = new SetupLog();
var logWriter = new ListLogWriter <TraceEntry>(setupTracerFactory);
var config = new TraceManagerConfig();
// TODO: Rename to tracerConfig?
var traceWriterConfig = config.UseLogWriter(logWriter, "A"); // Only logs for tracer A
TraceManager traceManager;
using (traceManager = new TraceManager(config, setupTracerFactory))
{
var tracerA = traceManager.GetTracer("A");
var tracerB = traceManager.GetTracer("B");
Assert.True(traceManager.IsStarted);
Assert.True(traceManager.LogManager.IsStarted);
Assert.True(tracerA.IsInfoEnabled());
Assert.False(tracerB.IsInfoEnabled());
// Option 1: Change the config
traceWriterConfig.Switches.Add("B", new OnOffTraceSwitch(true));
traceManager.Start(); // Explicit restart required
Assert.True(tracerB.IsInfoEnabled());
Assert.True(tracerB.IsDebugEnabled());
// For option 2, see the next test: AddNewTracerConfigToSameWriterAfterStarting
}
}
public void UnitTestTracingWithGlobalTraceManager(ConfigForm configForm, int iteration)
{
// It can occur that the Tracer was obtained before the test starts
Tracer tracer = TraceManager.Instance.TracerFor(this);
// In a real app you probably don't have to reset the LogManager + TraceManager before configuring.
// However for unit testing it can be a good idea to clear configuration from previous tests.
LogManager.Instance.Reset(true);
TraceManager.Instance.Reset(true);
Assert.Same(LogManager.Instance, TraceManager.Instance.LogManager);
// Traces sent to this list
var setupTracerFactory = TraceManager.Instance.SetupTracerFactory;
var listWriter = new ListLogWriter <TraceEntry>(setupTracerFactory);
// Add the list TraceWriter only for this class
TraceManagerConfig config = TraceManager.Instance.Config;
TraceWriterConfig listTraceConfig;
if (configForm == ConfigForm.ObjectGraph)
{
listTraceConfig = new TraceWriterConfig(listWriter)
{
Switches =
{
{ GetType(), new OnOffTraceSwitch(true) }
}
};
config.Writers.Add(listTraceConfig);
}
else if (configForm == ConfigForm.Fluent)
{
listTraceConfig = config.UseLogWriter(listWriter, GetType(), new OnOffTraceSwitch(true));
}
else
{
throw new NotImplementedException();
}
// restart to load config and assign writers
TraceManager.Instance.Start();
// Ensure start didn't result in any errors
Assert.True(TraceManager.Instance.IsHealthy);
tracer.Info("Info message");
tracer.Debug("Debug message");
Assert.Equal(2, listWriter.Count);
// Remove the TraceWriterConfig just to ensure that everything returns to normal
Assert.True(TraceManager.Instance.Config.Writers.Remove(listTraceConfig));
// restart to reset config
TraceManager.Instance.Start();
LogJam.Internal.UnitTests.Trace.TraceManagerConfigTests.AssertEquivalentToDefaultTraceManagerConfig(TraceManager.Instance);
// Now tracing goes to the debug window only, but not to the list
tracer.Info("Not logged to list, but logged to debug out.");
Assert.Equal(2, listWriter.Count);
}
public void AddNewTracerConfigToSameWriterAfterStarting()
{
var setupTracerFactory = new SetupLog();
var logWriter = new ListLogWriter <TraceEntry>(setupTracerFactory);
var config = new TraceManagerConfig();
config.UseLogWriter(logWriter, "A"); // Only logs for tracer A
TraceManager traceManager;
using (traceManager = new TraceManager(config, setupTracerFactory))
{
var tracerA = traceManager.GetTracer("A");
var tracerB = traceManager.GetTracer("B");
Assert.True(traceManager.IsStarted);
Assert.True(tracerA.IsInfoEnabled());
Assert.False(tracerB.IsInfoEnabled());
// For option 1, see the previous test: ConfigCanBeChangedAfterStarting
// Option 2: Add a new TraceWriterConfig, and restart, to enable B
config.UseLogWriter(logWriter, "B", new OnOffTraceSwitch(true));
Assert.False(tracerB.IsInfoEnabled()); // before the restart, tracerB is disabled
traceManager.Start();
Assert.True(tracerB.IsInfoEnabled());
Assert.True(tracerB.IsDebugEnabled());
}
}
/// <summary>
/// Creates a new <see cref="TraceManager" /> instance using the specified <paramref name="configuration" />.
/// </summary>
/// <param name="configuration">The <see cref="TraceManagerConfig" /> to use to configure this <c>TraceManager</c>.</param>
/// <param name="setupLog">The <see cref="SetupTracerFactory" /> to use for tracing setup operations.</param>
public TraceManager(TraceManagerConfig configuration, SetupLog setupLog = null)
: this(new LogManager(configuration.LogManagerConfig, setupLog), configuration)
{
Contract.Requires <ArgumentNullException>(configuration != null);
// This TraceManager owns the LogManager, so dispose it on this.Dispose()
LinkDispose(_logManager);
}
public static TraceWriterConfig TraceToTestOutput(this TraceManagerConfig traceManagerConfig,
ITestOutputHelper testOutput,
SwitchSet switchSet,
EntryFormatter <TraceEntry> traceFormatter = null)
{
Contract.Requires <ArgumentNullException>(traceManagerConfig != null);
Contract.Requires <ArgumentNullException>(testOutput != null);
Contract.Requires <ArgumentNullException>(switchSet != null);
return(TraceManagerConfigFluentExtensions.TraceTo(traceManagerConfig, new TestOutputLogWriterConfig(testOutput), switchSet, traceFormatter));
}
public void CanRoundTripTraceManagerConfigToJson(TraceManagerConfig traceManagerConfig)
{
JsonSerializerSettings jsonSettings = new JsonSerializerSettings();
jsonSettings.ContractResolver = new JsonConfigContractResolver(jsonSettings.ContractResolver);
string json = JsonConvert.SerializeObject(traceManagerConfig, Formatting.Indented, jsonSettings);
_testOutputHelper.WriteLine(json);
// TODO: Deserialize back to TraceManagerConfig, then validate that the config is equal.
}
public static TraceWriterConfig TraceToTestOutput(this TraceManagerConfig traceManagerConfig,
ITestOutputHelper testOutput,
string tracerName = Tracer.All,
ITraceSwitch traceSwitch = null,
EntryFormatter <TraceEntry> traceFormatter = null)
{
Contract.Requires <ArgumentNullException>(traceManagerConfig != null);
Contract.Requires <ArgumentNullException>(testOutput != null);
Contract.Requires <ArgumentNullException>(tracerName != null);
return(TraceManagerConfigFluentExtensions.TraceTo(traceManagerConfig, new TestOutputLogWriterConfig(testOutput), tracerName, traceSwitch, traceFormatter));
}
/// <summary>
/// Creates a new <see cref="TraceManager" /> instance using the specified <paramref name="logManager" /> and
/// <paramref name="configuration" />.
/// </summary>
/// <param name="logManager">The <see cref="LogManager" /> associated with this <see cref="TraceManager" />.</param>
/// <param name="configuration">The <see cref="TraceManagerConfig" /> to use to configure this <c>TraceManager</c>.</param>
private TraceManager(LogManager logManager, TraceManagerConfig configuration = null)
{
Contract.Requires <ArgumentNullException>(logManager != null);
Contract.Requires <ArgumentException>(configuration == null || ReferenceEquals(logManager.Config, configuration.LogManagerConfig));
if (configuration == null)
{
configuration = new TraceManagerConfig(logManager.Config);
}
_logManager = logManager;
_traceConfig = configuration;
}
public void NoTraceWritersConfiguredWorks()
{
var traceManagerConfig = new TraceManagerConfig();
Assert.Empty(traceManagerConfig.Writers);
using (var traceManager = new TraceManager(traceManagerConfig))
{
traceManager.Start();
var tracer = traceManager.TracerFor(this);
Assert.False(tracer.IsInfoEnabled());
tracer.Info("Info");
}
}
public void CanRoundTripTraceManagerConfigToXml(TraceManagerConfig traceManagerConfig)
{
// Serialize to xml
XmlSerializer xmlSerializer = new XmlSerializer(typeof(TraceManagerConfig));
var sw = new StringWriter();
xmlSerializer.Serialize(sw, traceManagerConfig);
string xml = sw.ToString();
_testOutputHelper.WriteLine(xml);
// Deserialize back to TraceManagerConfig
TraceManagerConfig deserializedConfig = (TraceManagerConfig)xmlSerializer.Deserialize(new StringReader(xml));
Assert.Equal(traceManagerConfig, deserializedConfig);
}
/// <summary>
/// Creates a new <see cref="TraceManager" /> configured to use <paramref name="logWriterConfig" /> and
/// <paramref name="traceSwitch" /> for all <see cref="Tracer" />s.
/// </summary>
/// <param name="logWriterConfig">The <see cref="ILogWriterConfig" /> to use to configure tracing.</param>
/// <param name="traceSwitch">
/// A <see cref="ITraceSwitch" /> to use for all <see cref="Tracer" />s. If
/// <c>null</c>, all <see cref="Tracer" /> calls of severity <see cref="TraceLevel.Info" /> or higher are written.
/// </param>
/// <param name="tracerNamePrefix">
/// The <see cref="Tracer.Name" /> prefix to use. Tracing will not occur if the
/// <c>Tracer.Name</c> doesn't match this prefix. By default, <see cref="Tracer.All" /> is used.
/// </param>
public TraceManager(ILogWriterConfig logWriterConfig, ITraceSwitch traceSwitch = null, string tracerNamePrefix = Tracer.All)
{
Contract.Requires <ArgumentNullException>(logWriterConfig != null);
if (traceSwitch == null)
{
traceSwitch = TraceManagerConfig.CreateDefaultTraceSwitch();
}
// REVIEW: The need for this is messy, and we miss cases (eg multiple existing logwriters used) - perhaps each component manages its own messages?
// If there's an existing LogWriter in the logwriter config, use its SetupLog, if any.
ITracerFactory setupTracerFactory = null;
var useExistingLogWriterConfig = logWriterConfig as UseExistingLogWriterConfig;
if (useExistingLogWriterConfig != null)
{
var component = useExistingLogWriterConfig.LogWriter as ILogJamComponent;
if (component != null)
{
setupTracerFactory = component.SetupTracerFactory;
}
}
_logManager = new LogManager(new LogManagerConfig(), setupTracerFactory);
LinkDispose(_logManager); // b/c the LogManager is owned by this
_traceConfig = new TraceManagerConfig(_logManager.Config)
{
Writers =
{
new TraceWriterConfig(logWriterConfig)
{
Switches =
{
{ tracerNamePrefix, traceSwitch }
}
}
}
};
}
public void RemovingTraceWriterConfigDoesNotRemoveLogWriterConfigs()
{
var textWriterLogWriterConfig = new TextWriterLogWriterConfig(new StringWriter());
var logWriterConfigs = new ILogWriterConfig[]
{
new ListLogWriterConfig <TraceEntry>(),
textWriterLogWriterConfig
};
var traceWriterConfigs = new List <TraceWriterConfig>();
using (var traceManager = new TraceManager())
{
foreach (var logWriterConfig in logWriterConfigs)
{
traceWriterConfigs.Add(new TraceWriterConfig(logWriterConfig, TraceManagerConfig.CreateDefaultSwitchSet()));
}
traceManager.Config.Writers.UnionWith(traceWriterConfigs);
// Test removing each
for (int i = 0; i < logWriterConfigs.Length; ++i)
{
var logWriterConfig = logWriterConfigs[i];
var traceWriterConfig = traceWriterConfigs[i];
// Each logWriterConfig should exist in the LogManagerConfig before it is removed from the TraceManagerConfig
Assert.Contains(traceManager.LogManager.Config.Writers, lwc => lwc == logWriterConfig);
traceManager.Config.Writers.Remove(traceWriterConfig);
Assert.DoesNotContain(traceManager.Config.Writers, twc => twc == traceWriterConfig);
// LogWriters are left in place, because they may be used for other purposes
Assert.Contains(traceManager.LogManager.Config.Writers, lwc => lwc == logWriterConfig);
}
}
}
public void LogManagerCanBePassedToTraceManagerCtor()
{
var setupLog = new SetupLog();
var logConfig = new LogManagerConfig();
// Just a logwriter that is not used for tracing
var messageListWriter = new ListLogWriter <MessageEntry>(setupLog);
var messageListWriterConfig = logConfig.UseLogWriter(messageListWriter);
var logManager = new LogManager(logConfig, setupLog);
// The TraceManagerConfig includes a DebugTraceWriter, which adds to the LogManager.Writers
using (var traceManager = new TraceManager(logManager, TraceManagerConfig.CreateDebugTraceWriterConfig()))
{
traceManager.Start();
// Starting the TraceManager starts the LogManager
Assert.True(logManager.IsStarted);
// There should be two started LogWriters - one is the DebuggerLogWriter for tracing; the other is messageListWriter
Assert.Equal(2, logManager.Config.Writers.Where(writerConfig => ((IStartable)logManager.GetLogWriter(writerConfig)).IsStarted).Count());
Assert.True(logManager.IsHealthy); // Ensure no warnings or errors
}
}
public void AddingTraceWriterConfigUpdatesLogManagerConfig()
{
var textWriterLogWriterConfig = new TextWriterLogWriterConfig(new StringWriter());
var logWriterConfigs = new ILogWriterConfig[]
{
new ListLogWriterConfig <TraceEntry>(),
textWriterLogWriterConfig
};
using (var traceManager = new TraceManager())
{
foreach (var logWriterConfig in logWriterConfigs)
{
traceManager.Config.Writers.Add(new TraceWriterConfig(logWriterConfig, TraceManagerConfig.CreateDefaultSwitchSet()));
Assert.Contains(traceManager.LogManager.Config.Writers, lwc => lwc == logWriterConfig);
}
}
}
static TraceManager()
{
s_instance = new Lazy <TraceManager>(() => new TraceManager(LogManager.Instance, TraceManagerConfig.Default(LogManager.Instance.Config)));
}
/// <summary>
/// Creates a new <see cref="TraceManager" /> instance using default configuration and the specified
/// <paramref name="setupLog" />.
/// </summary>
/// <param name="setupLog"></param>
public TraceManager(SetupLog setupLog)
: this(TraceManagerConfig.Default(new LogManagerConfig()), setupLog)
{
// TODO: Check for local or remote config?
}
/// <summary>
/// Configures console tracing using object graph configuration (newing the config objects).
/// </summary>
public void ObjectGraphConfigForTrace()
{
ConsoleLogWriterConfig = new ConsoleLogWriterConfig();
ConsoleLogWriterConfig.Format(new DefaultTraceFormatter());
TraceManager.Config.Writers.Add(new TraceWriterConfig(ConsoleLogWriterConfig, TraceManagerConfig.CreateDefaultSwitchSet()));
}
