public void GetLoggerConfigurations_ReturnsExpected_After_SetLogLevel()
{
// arrange
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
// act I
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
var logConfig = provider.GetLoggerConfigurations();
// assert I
Assert.Equal(6, logConfig.Count);
Assert.Contains(new LoggerConfiguration("Default", LogLevel.Information, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C.D.TestClass", null, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C.D", null, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C", null, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A.B", null, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A", LogLevel.Information, LogLevel.Information), logConfig);
// act II
provider.SetLogLevel("A.B", LogLevel.Trace);
logConfig = provider.GetLoggerConfigurations();
// assert II
Assert.Equal(6, logConfig.Count);
Assert.Contains(new LoggerConfiguration("Default", LogLevel.Information, LogLevel.Information), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C.D.TestClass", null, LogLevel.Trace), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C.D", null, LogLevel.Trace), logConfig);
Assert.Contains(new LoggerConfiguration("A.B.C", null, LogLevel.Trace), logConfig);
Assert.Contains(new LoggerConfiguration("A.B", null, LogLevel.Trace), logConfig);
Assert.Contains(new LoggerConfiguration("A", LogLevel.Information, LogLevel.Information), logConfig);
}
/// <summary>
/// Register the Loggers endpoint, middleware and options<para />Steeltoe's <see cref="DynamicConsoleLogger"/> will be configured and included in the DI container
/// </summary>
/// <param name="container">Autofac DI <see cref="ContainerBuilder"/></param>
/// <param name="config">Your application's <see cref="IConfiguration"/></param>
/// <param name="loggerProvider">Your pre-existing <see cref="DynamicLoggerProvider"/> will be created if not provided</param>
/// <param name="loggerFactory">Your pre-existing <see cref="ILoggerFactory"/>. A new <see cref="LoggerFactory"/> will be added if not provided</param>
public static void RegisterLoggersActuator(this ContainerBuilder container, IConfiguration config, DynamicLoggerProvider loggerProvider = null, ILoggerFactory loggerFactory = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (loggerProvider == null)
{
loggerProvider = new DynamicLoggerProvider(new ConsoleLoggerSettings().FromConfiguration(config));
}
if (loggerFactory == null)
{
loggerFactory = new LoggerFactory(new List <ILoggerProvider> {
loggerProvider
});
}
container.RegisterLogging(config);
container.RegisterInstance(loggerProvider).As <ILoggerProvider>();
container.RegisterInstance(new LoggersOptions(config)).As <ILoggersOptions>();
container.RegisterType <LoggersEndpoint>().SingleInstance();
container.RegisterType <LoggersEndpointOwinMiddleware>().SingleInstance();
}
/// <summary>
/// Register the Loggers endpoint, middleware and options<para />Steeltoe's <see cref="DynamicConsoleLogger"/> will be configured and included in the DI container
/// </summary>
/// <param name="container">Autofac DI <see cref="ContainerBuilder"/></param>
/// <param name="config">Your application's <see cref="IConfiguration"/></param>
/// <param name="loggerProvider">Your pre-existing <see cref="DynamicLoggerProvider"/> will be created if not provided</param>
/// <param name="loggerFactory">Your pre-existing <see cref="ILoggerFactory"/>. A new <see cref="LoggerFactory"/> will be added if not provided</param>
public static void RegisterLoggersActuator(this ContainerBuilder container, IConfiguration config, DynamicLoggerProvider loggerProvider = null, ILoggerFactory loggerFactory = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (loggerProvider == null)
{
loggerProvider = new DynamicLoggerProvider(new ConsoleLoggerSettings().FromConfiguration(config));
}
container.RegisterLogging(config);
container.RegisterInstance(loggerProvider).As <IDynamicLoggerProvider>();
container.Register(c =>
{
var options = new LoggersEndpointOptions(config);
var mgmtOptions = c.Resolve <IEnumerable <IManagementOptions> >();
foreach (var mgmt in mgmtOptions)
{
mgmt.EndpointOptions.Add(options);
}
return(options);
}).As <ILoggersOptions>().IfNotRegistered(typeof(ILoggersOptions));
container.RegisterType <LoggersEndpoint>().SingleInstance();
container.RegisterType <LoggersEndpointOwinMiddleware>().SingleInstance();
}
public void UseLoggersActuator_ThrowsIfConfigNull()
{
IAppBuilder builder = new AppBuilder();
var provider = new DynamicLoggerProvider(new ConsoleLoggerSettings());
var exception = Assert.Throws <ArgumentNullException>(() => builder.UseLoggersActuator(null, provider));
Assert.Equal("config", exception.ParamName);
}
public void Create_CreatesCorrectLogger()
{
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
Assert.NotNull(logger);
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
}
public void SetLogLevel_Works_OnDefault()
{
// arrange
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
var originalLogConfig = provider.GetLoggerConfigurations();
// act
provider.SetLogLevel("Default", LogLevel.Trace);
var updatedLogConfig = provider.GetLoggerConfigurations();
// assert
Assert.Contains(new LoggerConfiguration("Default", LogLevel.Information, LogLevel.Information), originalLogConfig);
Assert.Contains(new LoggerConfiguration("Default", LogLevel.Information, LogLevel.Trace), updatedLogConfig);
}
public void SetLogLevel_UpdatesNamespaceDescendants()
{
// arrange (A* should log at Information)
var provider = new DynamicLoggerProvider(GetLoggerSettings());
// act I: with original setup
var childLogger = provider.CreateLogger("A.B.C");
var configurations = provider.GetLoggerConfigurations();
var tierOneNamespace = configurations.First(n => n.Name == "A");
// assert I: base namespace is in the response, correctly
Assert.Equal(LogLevel.Information, tierOneNamespace.EffectiveLevel);
// act II: set A.B* to log at Trace
provider.SetLogLevel("A.B", LogLevel.Trace);
configurations = provider.GetLoggerConfigurations();
tierOneNamespace = configurations.First(n => n.Name == "A");
var tierTwoNamespace = configurations.First(n => n.Name == "A.B");
// assert II: base hasn't changed but the one set at runtime and all descendants (including a concrete logger) have
Assert.Equal(LogLevel.Information, tierOneNamespace.EffectiveLevel);
Assert.Equal(LogLevel.Trace, tierTwoNamespace.EffectiveLevel);
Assert.True(childLogger.IsEnabled(LogLevel.Trace));
// act III: set A to something else, make sure it inherits down
provider.SetLogLevel("A", LogLevel.Error);
configurations = provider.GetLoggerConfigurations();
tierOneNamespace = configurations.First(n => n.Name == "A");
tierTwoNamespace = configurations.First(n => n.Name == "A.B");
var grandchildLogger = provider.CreateLogger("A.B.C.D");
// assert again
Assert.Equal(LogLevel.Error, tierOneNamespace.EffectiveLevel);
Assert.Equal(LogLevel.Error, tierTwoNamespace.EffectiveLevel);
Assert.False(childLogger.IsEnabled(LogLevel.Warning));
Assert.False(grandchildLogger.IsEnabled(LogLevel.Warning));
}
public void SetLogLevel_Can_Reset_to_Default()
{
// arrange (A* should log at Information)
var provider = new DynamicLoggerProvider(GetLoggerSettings());
// act I: with original setup
var firstLogger = provider.CreateLogger("A.B.C");
var configurations = provider.GetLoggerConfigurations();
var tierOneNamespace = configurations.First(n => n.Name == "A");
// assert I: base namespace is in the response, correctly
Assert.Equal(LogLevel.Information, tierOneNamespace.EffectiveLevel);
// act II: set A.B* to log at Trace
provider.SetLogLevel("A.B", LogLevel.Trace);
configurations = provider.GetLoggerConfigurations();
tierOneNamespace = configurations.First(n => n.Name == "A");
var tierTwoNamespace = configurations.First(n => n.Name == "A.B");
// assert II: base hasn't changed but the one set at runtime and all descendants (including a concrete logger) have
Assert.Equal(LogLevel.Information, tierOneNamespace.EffectiveLevel);
Assert.Equal(LogLevel.Trace, tierTwoNamespace.EffectiveLevel);
Assert.True(firstLogger.IsEnabled(LogLevel.Trace));
// act III: reset A.B
provider.SetLogLevel("A.B", null);
configurations = provider.GetLoggerConfigurations();
tierOneNamespace = configurations.First(n => n.Name == "A");
tierTwoNamespace = configurations.First(n => n.Name == "A.B");
var secondLogger = provider.CreateLogger("A.B.C.D");
// assert again
Assert.Equal(LogLevel.Information, tierOneNamespace.EffectiveLevel);
Assert.Equal(LogLevel.Information, tierTwoNamespace.EffectiveLevel);
Assert.True(firstLogger.IsEnabled(LogLevel.Information));
Assert.True(secondLogger.IsEnabled(LogLevel.Information));
}
public void SetLogLevel_UpdatesLogger()
{
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
Assert.NotNull(logger);
Assert.True(logger.IsEnabled(LogLevel.Critical));
Assert.True(logger.IsEnabled(LogLevel.Error));
Assert.True(logger.IsEnabled(LogLevel.Warning));
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
provider.SetLogLevel("A", LogLevel.Debug);
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.True(logger.IsEnabled(LogLevel.Debug));
provider.SetLogLevel("A", LogLevel.Information);
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
}
public void LoggerLogs_At_Configured_Setting()
{
// arrange
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
// act I - log at all levels, expect Info and above to work
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged = unConsole.ToString();
// assert I
Assert.Contains("Critical message", logged);
Assert.Contains("Error message", logged);
Assert.Contains("Warning message", logged);
Assert.Contains("Informational message", logged);
Assert.DoesNotContain("Debug message", logged);
Assert.DoesNotContain("Trace message", logged);
}
// act II - adjust rules, expect Error and above to work
provider.SetLogLevel("A.B.C.D", LogLevel.Error);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged2 = unConsole.ToString();
// assert II
Assert.Contains("Critical message", logged2);
Assert.Contains("Error message", logged2);
Assert.DoesNotContain("Warning message", logged2);
Assert.DoesNotContain("Informational message", logged2);
Assert.DoesNotContain("Debug message", logged2);
Assert.DoesNotContain("Trace message", logged2);
}
// act III - adjust rules, expect Trace and above to work
provider.SetLogLevel("A", LogLevel.Trace);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged3 = unConsole.ToString();
// assert III
Assert.Contains("Critical message", logged3);
Assert.Contains("Error message", logged3);
Assert.Contains("Warning message", logged3);
Assert.Contains("Informational message", logged3);
Assert.Contains("Debug message", logged3);
Assert.Contains("Trace message", logged3);
}
// act IV - adjust rules, expect nothing to work
provider.SetLogLevel("A", LogLevel.None);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged4 = unConsole.ToString();
// assert IV
Assert.DoesNotContain("Critical message", logged4);
Assert.DoesNotContain("Error message", logged4);
Assert.DoesNotContain("Warning message", logged4);
Assert.DoesNotContain("Informational message", logged4);
Assert.DoesNotContain("Debug message", logged4);
Assert.DoesNotContain("Trace message", logged4);
}
// act V - reset the rules, expect Info and above to work
provider.SetLogLevel("A", null);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged5 = unConsole.ToString();
// assert V
Assert.NotNull(provider.GetLoggerConfigurations().First(c => c.Name == "A"));
Assert.Contains("Critical message", logged5);
Assert.Contains("Error message", logged5);
Assert.Contains("Warning message", logged5);
Assert.Contains("Informational message", logged5);
Assert.DoesNotContain("Debug message", logged5);
Assert.DoesNotContain("Trace message", logged5);
}
}
public static void ConfigureLogging()
{
LoggerProvider = new DynamicLoggerProvider(new ConsoleLoggerSettings().FromConfiguration(Configuration));
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(LoggerProvider);
}
