private SessionOptions InitSessionOptions() { LoggerFactory factory = new LoggerFactory(); var testSwitch = new SourceSwitch("sourceSwitch", "Test Logging"); string logParam = TestContext.Parameters.Get("Log", string.Empty); logParam = logParam == string.Empty ? TestContext.Parameters.Get("log", string.Empty) : logParam; if (logParam.ToLower() == "failed") { testSwitch.Level = SourceLevels.Error; factory.AddTraceSource(testSwitch, new TextWriterTraceListener(TestContext.Out, "TestContextOut")); return(new SessionOptions { LoggerFactory = factory }); } else if (logParam.ToLower() == "full") { testSwitch.Level = SourceLevels.All; factory.AddTraceSource(testSwitch, new TextWriterTraceListener(TestContext.Out, "TestContextOut")); //isLogAllowed = true; return(new SessionOptions { LoggerFactory = factory }); } return(null); }
public static void DiagnosticsScope_PushesAndPops_LogicalOperationStack() { // Arrange var baseState = "base"; Trace.CorrelationManager.StartLogicalOperation(baseState); var state = "1337state7331"; var factory = new LoggerFactory(); var logger = factory.CreateLogger("Test"); factory.AddTraceSource(new SourceSwitch("TestSwitch"), new ConsoleTraceListener()); // Act var a = Trace.CorrelationManager.LogicalOperationStack.Peek(); var scope = logger.BeginScopeImpl(state); var b = Trace.CorrelationManager.LogicalOperationStack.Peek(); scope.Dispose(); var c = Trace.CorrelationManager.LogicalOperationStack.Peek(); // Assert Assert.Same(a, c); Assert.Same(state, b); }
public static void MultipleLoggers_IsEnabledReturnsCorrectValue(SourceLevels first, SourceLevels second, bool expected) { // Arrange var firstSwitch = new SourceSwitch("FirstSwitch", "First Test Switch"); firstSwitch.Level = first; var secondSwitch = new SourceSwitch("SecondSwitch", "Second Test Switch"); secondSwitch.Level = second; var factory = new LoggerFactory(); var logger = factory.CreateLogger("Test"); // Act factory.AddTraceSource(firstSwitch, new ConsoleTraceListener()); factory.AddTraceSource(secondSwitch, new ConsoleTraceListener()); // Assert Assert.Equal(expected, logger.IsEnabled(LogLevel.Information)); }
public override void BeforeTest(ITest test) { LoggerFactory factory = new LoggerFactory(); var testSwitch = new SourceSwitch("sourceSwitch", "Test Logging"); testSwitch.Level = Level; factory.AddTraceSource(testSwitch, new TextWriterTraceListener(TestContext.Out, "TestContextOut")); test.Properties.Set(propertyKey, factory); base.BeforeTest(test); }
public IActionResult About() { ViewData["Message"] = "Your application description page."; traceSource.TraceEvent(TraceEventType.Information, 1001, "TraceSource from About controller: {0}", Guid.NewGuid()); var loggerFactory = new LoggerFactory(); loggerFactory.AddTraceSource(new SourceSwitch("sourceSwitch") { Level = SourceLevels.All }); var logger = loggerFactory.CreateLogger("Logger.TestAspNetCoreOnNetFx"); logger.LogInformation(1002, "Logger from About controller: {0}", Guid.NewGuid()); return(View()); }
public static void IsEnabledReturnsCorrectValue() { // Arrange var testSwitch = new SourceSwitch("TestSwitch", "Level will be set to warning for this test"); testSwitch.Level = SourceLevels.Warning; var factory = new LoggerFactory(); var logger = factory.CreateLogger("Test"); // Act factory.AddTraceSource(testSwitch, new ConsoleTraceListener()); // Assert Assert.True(logger.IsEnabled(LogLevel.Critical)); Assert.True(logger.IsEnabled(LogLevel.Error)); Assert.True(logger.IsEnabled(LogLevel.Warning)); Assert.False(logger.IsEnabled(LogLevel.Information)); Assert.False(logger.IsEnabled(LogLevel.Verbose)); }
/// <summary> /// Configuration options: /// LogLevel /// "Console" /// "Debug" /// "LocalTraceFile" /// </summary> /// <param name="settingsPath"></param> /// <returns></returns> public static ILogger GetLogger(string settingsPath) { lock (_objLock) { // Read from Configuration for Internal Loggging IConfiguration config = DefaultConfiguration.LoadConfig(settingsPath, "appsettings.json"); var logLevelSection = config.GetSection(LoggingSettingsConfig.LoggingSection).GetSection(LoggingSettingsConfig.LogLevelSection); LogLevel logLevelDefault = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelDefaultKey, LogLevel.None); // Use Default as the loglevel for the types we support LogLevel logLevelConsole = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelConsoleKey, logLevelDefault); LogLevel logLevelDebug = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelDebugKey, logLevelDefault); LogLevel logLevelLocalTraceFile = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelLocalTraceFileKey, logLevelDefault); // Logger Factory for Options Factory = new LoggerFactory(); // Console, Debug if (logLevelConsole < LogLevel.None) { Factory.AddConsole(logLevelConsole); } if (logLevelDebug < LogLevel.None) { Factory.AddDebug(logLevelDebug); } // Write to Local File and Trace (DbgView) if (logLevelLocalTraceFile < LogLevel.None) { var fileSwitch = new SourceSwitch("fileSwitch"); fileSwitch.Level = ConvertToTraceListenerLogLevel(logLevelLocalTraceFile); // SourceLevels.All; Factory.AddTraceSource(fileSwitch, new TextWriterTraceListener(File.Open(LocalFileName(), FileMode.OpenOrCreate | FileMode.Append, FileAccess.Write, FileShare.Write))); Trace.AutoFlush = true; } // Create ILogger here Logger = Factory.CreateLogger <InternalLogger>(); } return(Logger); }
static void Main(string[] args) { Console.WriteLine("Microsoft.Extensions.Logging (.NET 4.5.1)"); ILoggerFactory loggerFactory = new LoggerFactory(); // loggerFactory.AddConsole(); loggerFactory.AddTraceSource("Example.Switch"); ILogger <Program> logger1 = loggerFactory.CreateLogger <Program>(); logger1.LogInformation(2001, "Test message: {0}", Guid.NewGuid()); try { throw new NotSupportedException("Test exception"); } catch (Exception ex) { logger1.LogError(5001, ex, "Error occurred: {0}", new Random().Next()); } ILogger logger2 = loggerFactory.CreateLogger("ExtensionsLoggingNet451.Foo.Bar"); ILogger logger3 = loggerFactory.CreateLogger("ExtensionsLoggingNet451.Foo.Waz"); logger2.LogInformation(3001, "Information to Foo.Bar - should not display"); using (var scope = logger3.BeginScope <string>("Test Scope")) { logger2.LogWarning(4001, "Warning to Foo.Bar"); logger3.LogWarning(4002, "Warning to Foo.Waz"); } logger3.LogInformation(3002, "Information to Foo.Waz"); Console.ReadLine(); }
/// <summary> /// Initializes a new instance of the <see cref="Log"/> class. /// </summary> /// <param name="logDest">logging destination</param> /// <param name="categoryName">category name for log messages</param> /// <param name="listener">optional trace listener for the TraceSource logging destination</param> public Log(LogDestination logDest, string categoryName, TraceListener listener = null) { var loggerFactory = new LoggerFactory(); this.logger = loggerFactory.CreateLogger(categoryName); if (logDest == LogDestination.Debug) { // the following produces debug output visible in the visual studio output window loggerFactory.AddDebug(); } else if (logDest == LogDestination.Console) { // the following produces output visible in a console window loggerFactory.AddConsole(); } else if (logDest == LogDestination.TraceSource) { if (listener == null) { throw new ArgumentNullException("listener is null"); } var source = new SourceSwitch("sourceSwitch"); source.Level = SourceLevels.All; loggerFactory.AddTraceSource(source, listener); } else if (logDest == LogDestination.EventSource) { // create an event listener var eventListener = new LogEventListener(); // the following produces event source debug output loggerFactory.AddEventSourceLogger(); } }
/// <summary> /// Run the demo. /// </summary> public static void Run() { // in debugging mode, the default trace listner write logs to debug console. Console.WriteLine($"Is debugging: {Debugger.IsAttached}"); Console.WriteLine(); // create file based logger factory string logFilePath = Path.Combine(AppContext.BaseDirectory, "TraceSourceLogDemo.log"); Stream logStream = File.Create(logFilePath); TextWriterTraceListener fileListener = new TextWriterTraceListener(logStream); // Information, Warning, Error, Critical, Verbose (Trace/Debug) SourceSwitch fileSwitch = new SourceSwitch("FileSwtich", "Verbose"); ILoggerFactory fileLoggerFactory = new LoggerFactory(); fileLoggerFactory.AddTraceSource(fileSwitch, fileListener); // create console based logger factory TextWriterTraceListener consoleListener = new TextWriterTraceListener(Console.Out); SourceSwitch consoleSwitch = new SourceSwitch("ConsoleSwitch", "Warning"); ILoggerFactory consoleLoggerFactory = new LoggerFactory(); consoleLoggerFactory.AddTraceSource(consoleSwitch, consoleListener); EventId eventId = new EventId(1003, "TraceSourceLogDemoEvent"); IEnumerable <LogLevel> logLevels = Enum.GetValues(typeof(LogLevel)) .Cast <LogLevel>() .Except(new[] { LogLevel.None }); Action <ILoggerFactory, string> loggerDemoAction = (factory, loggerName) => { Console.WriteLine($"Logger name: {loggerName}"); // also support factory.CreateLogger<T>(); ILogger logger = factory.CreateLogger(loggerName); foreach (var logLevel in logLevels) { bool isEnabled = logger.IsEnabled(logLevel); Console.WriteLine($"\t[{(int)logLevel}]{logLevel} is enabled: ".PadRight(30, ' ') + isEnabled); } // file and console linster not support scopes using (logger.BeginScope("[{LOGGER}]TraceSourceLogDemoScope", loggerName)) { logger.LogTrace(eventId, "LogTrace from {LOGGER}", loggerName); logger.LogDebug(eventId, "LogDebug from {LOGGER}", loggerName); logger.LogInformation(eventId, "LogInformation from {LOGGER}", loggerName); logger.LogWarning(eventId, "LogWarning from {LOGGER}", loggerName); logger.LogError(eventId, "LogError from {LOGGER}", loggerName); logger.LogCritical(eventId, "LogCritical from {LOGGER}", loggerName); } Console.WriteLine(); }; // console log level: >= Warning, loggerDemoAction(consoleLoggerFactory, "ConsoleLogger"); // file log level: >= Verbose, loggerDemoAction(fileLoggerFactory, "FileLogger"); // dispose file logger factory to release the log file handler. fileLoggerFactory.Dispose(); // print log file. Console.WriteLine($"[Trace] log file path: {logFilePath}"); Console.WriteLine(File.ReadAllText(logFilePath, Encoding.UTF8)); }