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