public void DestinationExceptionsShouldGoToErrorHandler()
{
var gotError = false;
void DestinationErrorOccured(object sender, LogErrorEventArgs e)
{
gotError = true;
}
LogErrorHandler.Instance.ErrorOccured += DestinationErrorOccured;
try
{
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock((message) => throw new System.Exception()));
Assert.False(gotError);
logAdministrator.GetLogger(GetType()).Info("");
Assert.True(gotError);
}
finally
{
LogErrorHandler.Instance.ErrorOccured -= DestinationErrorOccured;
}
}
public void HttpDestinationTest()
{
var config = ConfigurationReader.ReadConfiguration <HttpDestinationConfig>();
if (config == null)
{
return;
}
LogConfigurationMapper.Instance.AddToMapping <HttpDestination>();
using var admin = LogAdministrator.CreateNew();
admin
.SetLogLevel(LogLevel.Debug)
.SetCollectMiddleware <ConcurrentCollectMiddleware, HttpDestination>()
.AddMiddleware <JsonFormatMiddleware, HttpDestination>()
.AddHttpDestination(config.Url, config.Token);
var logger = admin.GetLogger(typeof(HttpDestinationTests));
foreach (var i in Enumerable.Range(0, 500))
{
logger.Info(i);
}
}
public static ILoggingBuilder AddNajlotLog(this ILoggingBuilder builder, Action <LogAdministrator> configure)
{
var admin = LogAdministrator.CreateNew();
configure(admin);
return(builder.AddNajlotLog(admin));
}
public void NullShouldBeLoggedAsEmpty()
{
var output = "";
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock(msg => output = msg.Message));
var log = logAdministrator.GetLogger("default");
// null as args -> nothing will be parsed
log.Info("This is null: {var}.", null);
Assert.Contains("This is null: {var}.", output);
output = "";
log.Info("This is null: {null}.", default(DestinationMock));
Assert.Contains("This is null: .", output);
output = "";
log.Info("This is one {one} and this is null: {null}.", 1, null);
Assert.Contains("This is one 1 and this is null: .", output);
output = "";
log.Info("This is one {one} and this is null: {null:D3}.", 1, null);
Assert.Contains("This is one 1 and this is null: .", output);
var now = DateTime.Now;
var formattedNow = now.ToString("yyyy-MM-dd HH:mm:ss.fff");
output = "";
log.Info("This is a time: {time:yyyy-MM-dd HH:mm:ss.fff}", now);
Assert.Contains($"This is a time: {formattedNow}", output);
}
private static void ReadConfiguration(string path, LogAdministrator logAdministrator)
{
var xmlSerializer = new XmlSerializer(typeof(Configurations));
Configurations fileConfigurations;
using (var streamReader = new StreamReader(path))
{
fileConfigurations = xmlSerializer.Deserialize(streamReader) as Configurations;
}
logAdministrator.SetLogLevel(fileConfigurations.LogLevel);
foreach (var config in fileConfigurations.Destinations)
{
var parameterDictionary = config.Parameters
.ToDictionary(parameter => parameter.Name, parameter => parameter.Value);
logAdministrator.SetDestinationConfiguration(config.Name, parameterDictionary);
if (!string.IsNullOrWhiteSpace(config.CollectMiddleware?.Name))
{
logAdministrator.SetCollectMiddleware(config.Name, config.CollectMiddleware?.Name);
}
if (config.Middlewares != null)
{
var names = config.Middlewares
.Select(m => m.Name)
.Where(m => !string.IsNullOrWhiteSpace(m));
logAdministrator.SetMiddlewareNames(config.Name, names);
}
}
}
/// <summary>
/// Reads configuration from an XML file
/// </summary>
/// <param name="logAdministrator">LogAdministrator instance</param>
/// <param name="path">Path to the XML file</param>
/// <param name="listenForChanges">Should the changes happened at runtime be reflected to the logger</param>
/// <param name="writeExampleIfSourceDoesNotExists">Should an example be written when file does not exist</param>
/// <returns></returns>
public static LogAdministrator ReadConfigurationFromXmlFile(this LogAdministrator logAdministrator, string path, bool listenForChanges = true, bool writeExampleIfSourceDoesNotExists = false)
{
try
{
if (File.Exists(path))
{
ReadConfiguration(path, logAdministrator);
if (listenForChanges)
{
EnableChangeListener(logAdministrator, path);
}
}
else if (writeExampleIfSourceDoesNotExists)
{
WriteXmlConfigurationFile(logAdministrator, path);
}
}
catch (Exception ex)
{
LogErrorHandler.Instance.Handle("Error reading xml configuration file", ex);
}
return(logAdministrator);
}
private static void EnableChangeListener(LogAdministrator logAdministrator, string path)
{
var dir = Path.GetDirectoryName(path);
if (string.IsNullOrWhiteSpace(dir))
{
dir = Directory.GetCurrentDirectory();
}
var fileSystemWatcher = new FileSystemWatcher(dir, Path.GetFileName(path));
fileSystemWatcher.Changed += (object sender, FileSystemEventArgs e) =>
{
// Ensure the file is not accessed any more
Thread.Sleep(75);
try
{
ReadConfiguration(path, logAdministrator);
}
catch (Exception ex)
{
LogErrorHandler.Instance.Handle("Error reading xml configuration file", ex);
}
};
fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;
fileSystemWatcher.EnableRaisingEvents = true;
}
public void ScopesMustNotBeSharedBetweenThreads()
{
var error = false;
using (var logAdministrator = LogAdministrator.CreateNew())
{
logAdministrator.SetLogLevel(LogLevel.Info)
.AddCustomDestination(new DestinationMock((msg) =>
{
if (Environment.CurrentManagedThreadId != (int)msg.State)
{
error = true;
}
}));
void Action()
{
var log = logAdministrator.GetLogger("test");
using (log.BeginScope(Environment.CurrentManagedThreadId))
{
for (var i = 0; i < 10; i++)
{
log.Info("");
}
}
}
var actions = Enumerable.Range(0, 20).Select <int, Action>(i => Action).ToArray();
Parallel.Invoke(actions);
}
Assert.False(error);
}
public static ILoggerFactory AddNajlotLog(this ILoggerFactory loggerFactory, Action <LogAdministrator> configure)
{
var admin = LogAdministrator.CreateNew();
configure(admin);
return(loggerFactory.AddNajlotLog(admin));
}
private static void WriteXmlConfigurationFile(LogAdministrator logAdministrator, string path)
{
try
{
logAdministrator
.GetLogLevel(out var logLevel)
.GetDestinationNames(out var destinationNames);
var configurations = new Configurations()
{
LogLevel = logLevel,
Destinations = destinationNames
.Select(name =>
{
logAdministrator
.GetDestinationConfiguration(name, out var configuration)
.GetCollectMiddlewareName(name, out var collectMiddlewareName)
.GetMiddlewareNames(name, out var middlewareNames);
return(new DestinationEntry
{
Name = name,
Parameters = configuration
.Select(c => new Parameter {
Name = c.Key, Value = c.Value
})
.ToList(),
CollectMiddleware = new ConfigurationEntry {
Name = collectMiddlewareName
},
Middlewares = middlewareNames
.Select(n => new ConfigurationEntry {
Name = n
})
.ToList(),
});
})
.ToList()
};
using (var stringWriter = new CustomStringWriter(Encoding.UTF8))
{
using (var xmlWriter = new XmlTextWriter(stringWriter)
{
Formatting = Formatting.Indented
})
{
var xmlSerializer = new XmlSerializer(typeof(Configurations));
xmlSerializer.Serialize(xmlWriter, configurations);
File.WriteAllText(path, stringWriter.ToString(), Encoding.UTF8);
}
}
}
catch (Exception ex)
{
LogErrorHandler.Instance.Handle("Error writing xml configuration file", ex);
}
}
public void StructuredLoggingMustParseCorrect()
{
var output = "";
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock(msg => output = msg.Message));
var log = logAdministrator.GetLogger("default");
log.Info("User {User} logon from {IP}", "admin", "127.0.0.1");
Assert.Contains("User admin logon from 127.0.0.1", output);
output = "";
log.Info("User {User} logon. {User} comes from ip {IP}", "admin", "127.0.0.1");
Assert.Contains("User admin logon. admin comes from ip 127.0.0.1", output);
output = "";
log.Info("All users logged out. Going into idle mode.");
Assert.Contains("All users logged out. Going into idle mode.", output);
output = "";
log.Info("{count} users {{logged} out. Going into idle mode.", 10);
Assert.Contains("10 users {logged} out. Going into idle mode.", output);
output = "";
log.Info("User {User} logon from {}", "admin", "127.0.0.1");
Assert.Contains("User admin logon from 127.0.0.1", output);
output = "";
log.Info("User {User} logon from {ip}", "admin");
Assert.Contains("User admin logon from ", output);
output = "";
log.Info("{{User} {User} logon", "admin");
Assert.Contains("{User} admin logon", output);
output = "";
log.Info("User {{{User}} logon from {IP}", "admin", "127.0.0.1");
Assert.Contains("User {admin} logon from 127.0.0.1", output);
output = "";
log.Info("ip {", "127.0.0.1");
Assert.Contains("ip {", output);
output = "";
log.Info("ip: {ip} {", "127.0.0.1");
Assert.Contains("ip: 127.0.0.1 {", output);
output = "";
log.Info("", 1, 2, 3);
Assert.Contains(LogLevel.Info.ToString().ToUpper(), output);
output = "";
log.Info("{{", 1, 2, 3);
Assert.Contains(LogLevel.Info.ToString().ToUpper(), output);
}
public void CheckIsLogLevelEnabled()
{
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.SetLogLevel(LogLevel.Warn);
var logger = logAdministrator.GetLogger(GetType());
Assert.False(logger.IsEnabled(LogLevel.Info));
Assert.True(logger.IsEnabled(LogLevel.Warn));
Assert.True(logger.IsEnabled(LogLevel.Error));
}
public void NullMessageShouldNotThrowExceptions()
{
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock(msg => _ = msg.Message));
var log = logAdministrator.GetLogger("default");
// log null variables must not produce exceptions
log.Info(null);
log.Info(default(string), 0);
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_logAdministrator.Dispose();
_logAdministrator = null;
}
public void LoggerMustLogObjectAndExceptionWithCorrectLogLevel()
{
var gotLogMessage = false;
var ex = new Exception("Something bad happened!");
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator
.SetLogLevel(LogLevel.Fatal)
.AddCustomDestination(new DestinationMock(msg =>
{
gotLogMessage = true;
}));
var log = logAdministrator.GetLogger(GetType());
var obj = new object();
foreach (var logLevel in _logLevels)
{
logAdministrator.SetLogLevel(logLevel);
var shouldGetMessage = logLevel <= LogLevel.Trace;
log.Trace(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Trace message");
gotLogMessage = false;
shouldGetMessage = logLevel <= LogLevel.Debug;
log.Debug(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Debug message");
gotLogMessage = false;
shouldGetMessage = logLevel <= LogLevel.Info;
log.Info(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Info message");
gotLogMessage = false;
shouldGetMessage = logLevel <= LogLevel.Warn;
log.Warn(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Warn message");
gotLogMessage = false;
shouldGetMessage = logLevel <= LogLevel.Error;
log.Error(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Error message");
gotLogMessage = false;
shouldGetMessage = logLevel <= LogLevel.Fatal;
log.Fatal(ex, obj);
Assert.True(gotLogMessage == shouldGetMessage, $"{logLevel}, but did not got Fatal message");
gotLogMessage = false;
}
}
public void Only_one()
{
LogMessage message = null;
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddMiddleware <AddToArgsMiddlewareMock1, DestinationMock>();
logAdministrator.AddCustomDestination(new DestinationMock((msg) =>
{
message = msg;
}));
var logger = logAdministrator.GetLogger("");
logger.Fatal("{Nr}");
Assert.Equal("1", message.RawArguments[0].ToString());
}
public void NestedScopesMustBeLogged()
{
var scopesAreCorrect = true;
object state = null;
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock((msg) =>
{
if (!scopesAreCorrect)
{
return;
}
state = msg.State;
scopesAreCorrect = msg.RawMessage == state?.ToString();
}));
var log = logAdministrator.GetLogger(GetType());
using (log.BeginScope("scope 1"))
{
log.Info("scope 1");
using (log.BeginScope("scope 2"))
{
log.Info("scope 2");
log.Info("scope 2");
using (log.BeginScope("scope 3"))
{
log.Info("scope 3");
}
log.Info("scope 2");
}
log.Info("scope 1");
}
Assert.True(scopesAreCorrect, "scopes are not correct");
log.Info("out of scope");
Assert.Null(state);
}
public void CachingShouldNotBreakFollowing()
{
string output;
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock(msg => output = msg.Message));
var log = logAdministrator.GetLogger("default");
log.Info("User {user_id} writes Order {order_id} into DB.");
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.", "U123");
Assert.Contains("User U123 writes Order into DB.", output);
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.", "U123", 5243);
Assert.Contains("User U123 writes Order 5243 into DB.", output);
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.", null, null);
Assert.Contains("User writes Order into DB.", output);
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.", "U123");
Assert.Contains("User U123 writes Order into DB.", output);
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.");
Assert.Contains("User {user_id} writes Order {order_id} into DB.", output);
output = "";
log.Info("User {user_id} writes Order {order_id} into DB.", 123, 456);
Assert.Contains("User 123 writes Order 456 into DB.", output);
output = "";
log.Info("User {user_id:D3} writes Order {order_id} into DB.", 1, 2);
Assert.Contains("User 001 writes Order 2 into DB.", output);
output = "";
log.Info("User {user_id:D3} writes Order {order_id} into DB.", "db", 2);
Assert.Contains("User db writes Order 2 into DB.", output);
}
public void LogConfigurationsShouldBeRead()
{
var configName = nameof(LogConfigurationsShouldBeRead) + ".config";
if (File.Exists(configName))
{
File.Delete(configName);
}
using (var admin = LogAdministrator.CreateNew())
{
admin
.AddCustomDestination(new DestinationMock(m => { }))
.SetCollectMiddleware <ConcurrentCollectMiddleware, DestinationMock>()
.AddMiddleware <JsonFormatMiddleware, DestinationMock>()
.ReadConfigurationFromXmlFile(configName, false, true);
}
Assert.True(File.Exists(configName));
using (var admin = LogAdministrator.CreateNew())
{
var name = LogConfigurationMapper.Instance.GetName <DestinationMock>();
var concurrentCollectMiddlewareName = LogConfigurationMapper.Instance.GetName <ConcurrentCollectMiddleware>();
var jsonFormatMiddlewareName = LogConfigurationMapper.Instance.GetName <JsonFormatMiddleware>();
admin
.AddCustomDestination(new DestinationMock(m => { }))
.GetCollectMiddlewareName(name, out var collectMiddlewareName);
// Standard should not be ConcurrentCollectMiddleware
Assert.NotEqual(concurrentCollectMiddlewareName, collectMiddlewareName);
admin
.ReadConfigurationFromXmlFile(configName, true, false)
.GetCollectMiddlewareName(name, out collectMiddlewareName)
.GetMiddlewareNames(name, out var middlewareNames);
Assert.Equal(concurrentCollectMiddlewareName, collectMiddlewareName);
Assert.Equal(jsonFormatMiddlewareName, middlewareNames.First(n => n == jsonFormatMiddlewareName));
}
}
public void With_Configuration_File()
{
LogMessage message = null;
const string path = "AddToArgsMiddlewareMock1And2.config";
using (var logAdministrator = LogAdministrator.CreateNew())
{
logAdministrator.SetCollectMiddleware <ConcurrentCollectMiddleware, DestinationMock>();
logAdministrator.AddMiddleware <AddToArgsMiddlewareMock1, DestinationMock>();
logAdministrator.AddMiddleware <AddToArgsMiddlewareMock2, DestinationMock>();
logAdministrator.AddCustomDestination(new DestinationMock((msg) => { }));
if (File.Exists(path))
{
File.Delete(path);
}
logAdministrator.ReadConfigurationFromXmlFile(path, false, true);
}
using (var logAdministrator = LogAdministrator.CreateNew())
{
var logger = logAdministrator.GetLogger("");
logAdministrator.ReadConfigurationFromXmlFile(path, false, false);
logAdministrator.AddCustomDestination(new DestinationMock((msg) =>
{
message = msg;
}));
logger.Fatal("{Nr2}{Nr1}");
logAdministrator.GetCollectMiddlewareName(nameof(DestinationMock), out var collectMiddlewareName);
Assert.Equal(nameof(ConcurrentCollectMiddleware), collectMiddlewareName);
}
Assert.Equal("1", message.RawArguments[0].ToString());
Assert.Equal("2", message.RawArguments[1].ToString());
}
public void StructuredLoggingMustFormatCorrect()
{
var output = "";
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddCustomDestination(new DestinationMock(msg => output = msg.Message));
var log = logAdministrator.GetLogger("default");
log.Info("Number of users: {users:D3}", 50);
Assert.Contains("Number of users: 050", output);
output = "";
log.Info("Three digits {num:D3} and five {num:D5}", 50);
Assert.Contains("Three digits 050 and five 00050", output);
output = "";
log.Info("Three and five digits {num:D3}{num2:D5}", 50, 60);
Assert.Contains("Three and five digits 05000060", output);
}
public void MiddlewareCreationExceptionsShouldGoToErrorHandler()
{
var gotError = false;
void CreationErrorOccured(object sender, LogErrorEventArgs e)
{
gotError = true;
}
LogErrorHandler.Instance.ErrorOccured += CreationErrorOccured;
using (var logAdministrator = LogAdministrator.CreateNew())
{
logAdministrator.AddCustomDestination(new DestinationMock((message) => { }));
Assert.False(gotError);
logAdministrator.AddMiddleware <CtorExceptionThrowingMiddleware, DestinationMock>();
Assert.True(gotError);
}
LogErrorHandler.Instance.ErrorOccured -= CreationErrorOccured;
}
public void IsEnabledMustReturnCorrectLogLevelEnabled()
{
using var loggerFactory = new LoggerFactory();
LogAdministrator logAdministrator = null;
loggerFactory.AddNajlotLog((administrator) =>
{
logAdministrator = administrator.AddConsoleDestination();
});
logAdministrator.SetLogLevel(LogLevel.Trace);
var logger = loggerFactory.CreateLogger("default");
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Trace));
logAdministrator.SetLogLevel(LogLevel.Debug);
Assert.False(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Trace));
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug));
logAdministrator.SetLogLevel(LogLevel.Info);
Assert.False(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug));
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Information));
logAdministrator.SetLogLevel(LogLevel.Warn);
Assert.False(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Information));
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Warning));
logAdministrator.SetLogLevel(LogLevel.Error);
Assert.False(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Warning));
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error));
logAdministrator.SetLogLevel(LogLevel.Fatal);
Assert.False(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error));
Assert.True(logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Critical));
logAdministrator.SetLogLevel(LogLevel.Info);
logger.LogInformation("Done!");
}
public void After_collection_middleware_added()
{
LogMessage message = null;
using (var logAdministrator = LogAdministrator.CreateNew())
{
logAdministrator.SetCollectMiddleware <ConcurrentCollectMiddleware, DestinationMock>();
logAdministrator.AddMiddleware <AddToArgsMiddlewareMock2, DestinationMock>();
logAdministrator.AddMiddleware <AddToArgsMiddlewareMock1, DestinationMock>();
logAdministrator.AddCustomDestination(new DestinationMock((msg) =>
{
message = msg;
}));
logAdministrator.GetLogger("").Fatal("{Nr2}{Nr1}");
}
Assert.Equal("2", message.RawArguments[0].ToString());
Assert.Equal("1", message.RawArguments[1].ToString());
}
public void LoggerBuilderMustProduceLogger()
{
const string logFile = "LoggingBuilderExtension.log";
if (File.Exists(logFile))
{
File.Delete(logFile);
}
var services = new ServiceCollection();
LogAdministrator logAdministrator = null;
services.AddLogging(loggerBuilder =>
{
loggerBuilder.AddNajlotLog((admin) =>
{
logAdministrator = admin;
logAdministrator.AddFileDestination(logFile);
});
});
using (logAdministrator)
{
services.AddTransient <DependencyInjectionLoggerService>();
var serviceProvider = services.BuildServiceProvider();
var service = serviceProvider.GetService <DependencyInjectionLoggerService>();
service.GetLogger().LogInformation("Logger created!");
service.GetLogger().LogTrace("This should not be logged!");
}
var content = File.ReadAllText(logFile);
Assert.Contains("Logger created!", content);
Assert.DoesNotContain("This should not be logged!", content);
Assert.Contains(typeof(DependencyInjectionLoggerService).FullName, content);
}
public void DestinationConfigurationShouldBeWrittenCorrect()
{
using var logAdministrator = LogAdministrator.CreateNew();
var destination = new FileDestination();
logAdministrator.AddCustomDestination(destination);
var fileDestinationConfiguration = new Dictionary <string, string>
{
["OutputPath"] = "my test path",
["KeepFileOpen"] = "true",
["MaxFiles"] = "10",
["LogFilesPath"] = null
};
logAdministrator.SetDestinationConfiguration(nameof(FileDestination), fileDestinationConfiguration);
Assert.Equal("my test path", destination.OutputPath);
Assert.True(destination.KeepFileOpen);
Assert.Equal(10, destination.MaxFiles);
Assert.Null(destination.LogFilesPath);
}
public void ScopesMustNotBeSharedBetweenThreadsInTask()
{
var error = false;
using (var logAdministrator = LogAdministrator.CreateNew())
{
logAdministrator.SetLogLevel(LogLevel.Info)
.AddCustomDestination(new DestinationMock((msg) =>
{
// state must be the same thread id the message comes from
if (msg.RawMessage != msg.State.ToString())
{
error = true;
}
}));
void Action()
{
Task.Factory.StartNew(() =>
{
var log = logAdministrator.GetLogger("test");
using (log.BeginScope(Environment.CurrentManagedThreadId))
{
for (var i = 0; i < 10; i++)
{
log.Info(Environment.CurrentManagedThreadId);
}
}
}).Wait();
}
var actions = Enumerable.Range(0, 20).Select <int, Action>(i => Action).ToArray();
Parallel.Invoke(actions);
}
Assert.False(error);
}
public void DestinationConfigurationShouldBeReadCorrect()
{
using var logAdministrator = LogAdministrator.CreateNew();
logAdministrator.AddConsoleDestination(true);
logAdministrator.AddFileDestination("my logfile path", 123);
logAdministrator.GetDestinationConfiguration(nameof(ConsoleDestination), out var consoleDestinationConfiguration);
Assert.Equal(1, consoleDestinationConfiguration.Count);
Assert.Contains("UseColors", consoleDestinationConfiguration.Keys);
logAdministrator.GetDestinationConfiguration(nameof(FileDestination), out var fileDestinationConfiguration);
Assert.Equal(4, fileDestinationConfiguration.Count);
Assert.Contains("OutputPath", fileDestinationConfiguration.Keys);
Assert.Contains("KeepFileOpen", fileDestinationConfiguration.Keys);
Assert.Contains("MaxFiles", fileDestinationConfiguration.Keys);
Assert.Contains("LogFilesPath", fileDestinationConfiguration.Keys);
Assert.Equal("my logfile path", fileDestinationConfiguration["OutputPath"]);
Assert.False(bool.Parse(fileDestinationConfiguration["KeepFileOpen"]));
Assert.Equal(123, int.Parse(fileDestinationConfiguration["MaxFiles"]));
Assert.Null(fileDestinationConfiguration["LogFilesPath"]);
}
public NajlotLogProvider(LogAdministrator logConfigurator)
{
_logAdministrator = logConfigurator;
}
public static ILoggingBuilder AddNajlotLog(this ILoggingBuilder builder, LogAdministrator logConfigurator)
{
builder.AddProvider(new NajlotLogProvider(logConfigurator));
return(builder);
}
