public static ILoggerFactory AddLog4Net(this ILoggerFactory factory, Action <Log4NetProviderOptions> log4NetOptions)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (log4NetOptions == null)
{
throw new ArgumentNullException(nameof(log4NetOptions));
}
var options = new Log4NetProviderOptions();
log4NetOptions(options);
ConfigureLog4Net(options);
using (var provider = new Log4NetLoggerProvider(options))
{
provider.Options = options;
factory.AddProvider(provider);
}
return(factory);
}
public static ILoggingBuilder AddLog4Net(this ILoggingBuilder factory, Log4NetProviderOptions options)
{
using (var provider = new Log4NetLoggerProvider(options))
factory.AddProvider(provider);
return(factory);
}
private static IAppender CreateTestAppender(Log4NetProviderOptions options)
{
ILoggerRepository repository = GetOrCreateRepository(options);
return(repository.GetAppenders()
.Where(x => x.Name.Equals("TestAppender", StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault());
}
private static void SetupLog4NetRepository(Log4NetProviderOptions options)
{
ILoggerRepository repository = GetOrCreateRepository(options);
var assemblyFile = new FileInfo(Assembly.GetCallingAssembly().GetAssemblyLocation());
string path = Path.Combine(assemblyFile.Directory.FullName, options.Log4NetConfigFileName);
XmlConfigurator.Configure(repository, File.OpenRead(path));
}
public void Ctor_Should_InitializeWithDefaults()
{
Log4NetProviderOptions options = ConfigureOptions(Log4NetFileOption.NoAppenders);
var sut = new Log4NetLogger(options);
sut.Should().NotBeNull();
sut.Name.Should().Be(options.Name);
}
public MemoryAppender GetTestAppender(Log4NetProviderOptions options)
{
var appender = CreateTestAppender(options);
appender.Should()
.BeOfType <MemoryAppender>();
MemoryAppender testAppender = (MemoryAppender)appender;
return(testAppender);
}
public void WhenScopeFactoryIsNullOnProviderOptions_ThenDefaultLog4NetScopeFactoryIsUsed()
{
var options = new Log4NetProviderOptions
{
ScopeFactory = null
};
var provider = new Log4NetProvider(options);
var logger = provider.CreateLogger("test") as Log4NetLogger;
Assert.IsNotNull(logger?.Options?.ScopeFactory, "Scope factory on logger's options should not be null.");
}
public void Log_Should_IgnoreMessage_When_Empty()
{
Log4NetProviderOptions options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
sut.Log(LogLevel.Trace, _eventId, string.Empty, null, (message, exception) => message);
testAppender.GetEvents()
.Should()
.BeEmpty();
}
public void Ctor_Should_SetDefaultOptions()
{
var sut = new Log4NetProviderOptions();
sut.ExternalConfigurationSetup.Should().BeFalse();
sut.Log4NetConfigFileName.Should().Be("log4net.config");
sut.LoggerRepository.Should().BeNull();
sut.Name.Should().BeEmpty();
sut.OverrideCriticalLevelWith.Should().Be("");
sut.PropertyOverrides.Should().BeEmpty();
sut.ScopeFactory.Should().BeNull();
sut.Watch.Should().BeFalse();
}
public void Log_Should_Not_IgnoreMessage_When_Empty_For_Non_Null_Exception()
{
Log4NetProviderOptions options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
sut.Log(LogLevel.Trace, _eventId, string.Empty, new Exception("Something went wrong"), (message, exception) => message);
testAppender.GetEvents()
.Should()
.NotBeEmpty();
}
/// <inheritdoc />
public virtual ILoggerProvider Configure()
{
var patternLayout = new PatternLayout
{
ConversionPattern = "%utcdate{dd-MM-yyyy HH:mm:ss.ffffff} [%level] %message%newline"
};
patternLayout.ActivateOptions();
var consoleAppender = new ConsoleAppender
{
Layout = patternLayout
};
var hierarchy = (Hierarchy)LogManager
.CreateRepository("default");
hierarchy.Root
.AddAppender(consoleAppender);
hierarchy.Root.Level = this.Options.LogLevel
.GetLogLevel();
hierarchy.Configured = true;
// TODO: Log4Net: Namespace overrides.
//foreach (var logLevelOverride in this.Options.LogLevelOverrides)
//{
// var nestedHierarchy = (Hierarchy)LogManager
// .CreateRepository(logLevelOverride.Namespace);
// nestedHierarchy.Root.Level = logLevelOverride.LogLevel
// .GetLogLevel();
// nestedHierarchy.Root
// .AddAppender(consoleAppender);
// nestedHierarchy.Configured = true;
//}
var providerOptions = new Log4NetProviderOptions
{
ExternalConfigurationSetup = true,
LoggerRepository = hierarchy.Name
};
var provider = new Microsoft.Extensions.Logging.Log4NetProvider(providerOptions);
return(provider);
}
public Log4NetProviderOptions ConfigureOptions(Log4NetFileOption log4NetFile)
{
const string RepositoryName = "Test";
var options = new Log4NetProviderOptions()
{
Log4NetConfigFileName = GetLog4netFilePath(log4NetFile),
LoggerRepository = RepositoryName,
Name = RepositoryName
};
SetupLog4NetRepository(options);
return(options);
}
public void Ctor_Should_SetCustomLog4NetFileName_And_WatchProperties()
{
const string Log4NetFileName = "my.log4net.config";
var sut = new Log4NetProviderOptions(Log4NetFileName, true);
sut.ExternalConfigurationSetup.Should().BeFalse();
sut.Log4NetConfigFileName.Should().Be(Log4NetFileName);
sut.LoggerRepository.Should().BeNull();
sut.Name.Should().BeEmpty();
sut.OverrideCriticalLevelWith.Should().Be("");
sut.PropertyOverrides.Should().BeEmpty();
sut.ScopeFactory.Should().BeNull();
sut.Watch.Should().BeTrue();
}
public void WhenScopeFactoryIsProvidedInProviderOptions_ThenLoggerUsesProvidedScopeFactory()
{
var expectedFactory = new Log4NetScopeFactory(new Log4NetScopeRegistry());
var options = new Log4NetProviderOptions
{
ScopeFactory = expectedFactory
};
var provider = new Log4NetProvider(options);
var logger = provider.CreateLogger("test") as Log4NetLogger;
Assert.IsNotNull(logger?.Options?.ScopeFactory, "Scope factory on logger's options should not be null.");
Assert.AreSame(expectedFactory, logger.Options.ScopeFactory,
"Scope factory on logger does not match factory from provider options.");
}
public void WhenLoggingEventFactoryIsNullOnProviderOptions_ThenDefaultLog4NetLoggingEventFactoryIsUsed()
{
var options = new Log4NetProviderOptions
{
LoggingEventFactory = null
};
var sut = new Log4NetProvider(options);
var logger = sut.CreateLogger("test") as Log4NetLogger;
var internalOptions = GetInternalOptions(logger);
internalOptions.Should().NotBeNull();
internalOptions.LoggingEventFactory.Should().NotBeNull("a default LoggingEventFactory is needed to create LoggingEvents")
.And.BeOfType <Log4NetLoggingEventFactory>("because this is the default factory type");
}
public void WhenScopeFactoryIsNullOnProviderOptions_ThenDefaultLog4NetScopeFactoryIsUsed()
{
var options = new Log4NetProviderOptions
{
ScopeFactory = null
};
var sut = new Log4NetProvider(options);
var logger = sut.CreateLogger("test") as Log4NetLogger;
var internalOptions = GetInternalOptions(logger);
internalOptions.Should().NotBeNull();
internalOptions.ScopeFactory.Should().NotBeNull("Scope factory on logger's options should not be null.");
}
private static ILoggerRepository GetOrCreateRepository(Log4NetProviderOptions options)
{
ILoggerRepository repository = null;
var repositories = LogManager.GetAllRepositories();
if (repositories.Any(x => x.Name.Equals(options.LoggerRepository, StringComparison.InvariantCultureIgnoreCase)))
{
repository = LogManager.GetRepository(options.LoggerRepository);
}
else
{
repository = LogManager.CreateRepository(options.LoggerRepository);
}
return(repository);
}
public void WhenScopeFactoryIsProvidedInProviderOptions_ThenLoggerUsesProvidedScopeFactory()
{
var expectedFactory = new Log4NetScopeFactory(new Log4NetScopeRegistry());
var options = new Log4NetProviderOptions
{
ScopeFactory = expectedFactory
};
var sut = new Log4NetProvider(options);
var logger = sut.CreateLogger("test") as Log4NetLogger;
var internalOptions = GetInternalOptions(logger);
internalOptions.Should().NotBeNull();
internalOptions.ScopeFactory.Should().NotBeNull("Scope factory on logger's options should not be null.")
.And.Be(expectedFactory, "Scope factory on logger does not match factory from provider options.");
}
public void UseWebOrAppConfig_Should_BeEditable()
{
var sut = new Log4NetProviderOptions
{
UseWebOrAppConfig = true
};
sut.ExternalConfigurationSetup.Should().BeFalse();
sut.Log4NetConfigFileName.Should().Be("log4net.config");
sut.LoggerRepository.Should().BeNull();
sut.Name.Should().BeEmpty();
sut.OverrideCriticalLevelWith.Should().Be("");
sut.PropertyOverrides.Should().BeEmpty();
sut.ScopeFactory.Should().BeNull();
sut.Watch.Should().BeFalse();
sut.UseWebOrAppConfig.Should().BeTrue();
}
public void WhenLoggingEventFactoryIsProvidedInProviderOptions_ThenLoggerUsesProvidedLoggingEventFactory()
{
var expectedFactory = new Log4NetLoggingEventFactory();
var options = new Log4NetProviderOptions
{
LoggingEventFactory = expectedFactory
};
var sut = new Log4NetProvider(options);
var logger = sut.CreateLogger("test") as Log4NetLogger;
var internalOptions = GetInternalOptions(logger);
internalOptions.Should().NotBeNull();
internalOptions.LoggingEventFactory.Should().NotBeNull("a LoggingEventFactory was provided in the options")
.And.Be(expectedFactory, "this LoggingEventFactory was provided in the options");
}
public void WhenLogLevelTranslatorIsProvidedInProviderOptions_ThenLoggerUsesProvidedLogLevelTranslator()
{
var expectedTranslator = new Log4NetLogLevelTranslator();
var options = new Log4NetProviderOptions
{
LogLevelTranslator = expectedTranslator
};
var sut = new Log4NetProvider(options);
var logger = sut.CreateLogger("test") as Log4NetLogger;
var internalOptions = GetInternalOptions(logger);
internalOptions.Should().NotBeNull();
internalOptions.LogLevelTranslator.Should().NotBeNull("a LogLevelTranslator was provided in the options")
.And.Be(expectedTranslator, "this LogLevelTranslator was provided in the options");
}
public void Provider_Should_InitializeLogging_When_UsingAppConfigFile()
{
const string message = MessageText;
var options = new Log4NetProviderOptions
{
UseWebOrAppConfig = true
};
using (var provider = new Log4NetProvider(options))
{
var logger = provider.CreateLogger(TestLoggerName);
logger.LogCritical(message);
}
Assert.AreEqual(1, listener.Messages.ToList().Count);
Assert.IsNotNull(listener.Messages.ToList().FirstOrDefault(x => x.Contains(message)), $"Listener should contain the logged message: {message}");
Assert.IsNotNull(listener.Messages.ToList().FirstOrDefault(x => x.StartsWith($"{TestLoggerName}: APP.CONFIG")), $"Listener should start with AppConfig: {message}");
}
private static void ConfigureLog4Net(Log4NetProviderOptions log4NetOptions)
{
XElement log4NetElement = null;
try
{
if (!String.IsNullOrWhiteSpace(log4NetOptions.ConfigurationFileFullName) &&
String.IsNullOrWhiteSpace(log4NetOptions.JsonConfiguration))
{
log4NetElement = ParseLog4NetConfigFile(log4NetOptions.ConfigurationFileFullName);
}
if (!String.IsNullOrWhiteSpace(log4NetOptions.JsonConfiguration))
{
log4NetElement = ParseLog4NetDocument(JsonConvert.DeserializeXNode(log4NetOptions.JsonConfiguration, "root"));
}
if (log4NetElement == null)
{
throw new InvalidOperationException("No log4net configuration defined.");
}
}
catch (Exception ex)
{
throw new InvalidOperationException("No valid configuration provided for log4net.", ex);
}
var serializer = new XmlSerializer(typeof(Logging.Schema.log4net));
log4NetOptions.Log4NetConfiguration = serializer.Deserialize(log4NetElement.CreateReader()) as Logging.Schema.log4net;
log4net.Util.LogLog.InternalDebugging = true;
if (log4NetOptions.Configure != null)
{
log4NetOptions.Configure(log4NetElement);
}
else
{
XmlConfigurator.Configure(LogManager.GetRepository(log4NetOptions.RepositoryAssembly ?? Assembly.GetEntryAssembly()), log4NetElement.ToXmlElement());
}
}
public void LoggingEventFactory_Should_BeEditable()
{
var loggingEventFactory = new Mock <ILog4NetLoggingEventFactory>().Object;
var sut = new Log4NetProviderOptions
{
LoggingEventFactory = loggingEventFactory
};
sut.ExternalConfigurationSetup.Should().BeFalse();
sut.Log4NetConfigFileName.Should().Be("log4net.config");
sut.LoggerRepository.Should().BeNull();
sut.Name.Should().BeEmpty();
sut.OverrideCriticalLevelWith.Should().Be("");
sut.PropertyOverrides.Should().BeEmpty();
sut.ScopeFactory.Should().BeNull();
sut.Watch.Should().BeFalse();
sut.UseWebOrAppConfig.Should().BeFalse();
sut.LoggingEventFactory.Should().Be(loggingEventFactory);
sut.LogLevelTranslator.Should().BeNull();
}
/// <summary>
/// Gets the log4net provider options.
/// </summary>
/// <returns></returns>
private static Log4NetProviderOptions GetLog4NetProviderOptions()
{
var attributes = new Dictionary <string, string>();
attributes.Add("Value", "overridOH.log");
var nodeInfo = new NodeInfo {
XPath = ""
};
var builder = new Log4NetProviderOptions()
{
PropertyOverrides = new List <NodeInfo>
{
new NodeInfo {
XPath = "/log4net/appender[@name='RollingFile']/file",
Attributes = attributes
}
}
};
return(builder);
}
private MemoryAppender GetTestAppender(Log4NetProviderOptions options) => Context.GetTestAppender(options);
