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