private static ILoggerFactory GetNLogLoggerFactory()
{
LoggingConfiguration loggerConfig = new NLog.Config.LoggingConfiguration();
FileTarget fileTarget = new NLog.Targets.FileTarget()
{
Name = "logfile",
FileName = "log.txt",
Layout = "${longdate}|${level:uppercase=true}|${logger}|${event-context:item=EventId}|${message}|${ndc}"
};
loggerConfig.AddTarget(fileTarget);
loggerConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Info, fileTarget));
//NLogLoggerFactory test = new NLogLoggerFactory(new NLogLoggerProvider(new NLogProviderOptions()));
NLogLoggerFactory logLoggerFactory = new NLogLoggerFactory();
NLogProviderOptions op = new NLogProviderOptions
{
CaptureMessageProperties = true,
CaptureMessageTemplates = true,
EventIdSeparator = "|",
IgnoreEmptyEventId = false,
IncludeScopes = true,
//ParseMessageTemplates = true
//ShutdownOnDispose = true
};
NLogLoggerProvider p = new NLogLoggerProvider(op, loggerConfig.LogFactory);
logLoggerFactory.AddProvider(p);
return(logLoggerFactory);
//loggerFactory.AddNLog(new NLog.LogFactory(loggerConfig));
}
public static void AddLog(this IServiceCollection services)
{
services.AddLogging((builder) => builder.SetMinimumLevel(LogLevel.Trace));
services.AddScoped(typeof(ILogger <>), typeof(Logger <>));
services.AddSingleton <ILoggerFactory>(p =>
{
var factory = new LoggerFactory();
var options = new NLogProviderOptions
{
CaptureMessageTemplates = true,
CaptureMessageProperties = true
};
factory.AddNLog(options);
var config = new LoggingConfiguration();
var target = new FileTarget("application");
target.FileName = Path.Combine(p.GetService <Storage>().LogDirectory, "application.log");
config.AddTarget(target);
var rule = new LoggingRule("*", NLog.LogLevel.Debug, target);
config.LoggingRules.Add(rule);
factory.ConfigureNLog(config);
return(factory);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
ILoggerFactory loggerFactory, SchoolContext context)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug((category, logLevel) =>
{ return(category.StartsWith("Microsoft.EntityFrameworkCore")); });
NLogProviderOptions options = new NLogProviderOptions();
loggerFactory.AddNLog(options);
//loggerFactory.CreateLogger("Microsoft.EntityFrameworkCore");
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
SchoolInitializer.Initialize(context);
}
protected T GetRunner <T>(NLogProviderOptions options = null) where T : class
{
// Start program
var runner = ConfigureTransientService <T>(null, options).GetRequiredService <T>();
return(runner);
}
/// <summary>
/// Enable NLog as logging provider in .NET Core.
/// </summary>
/// <param name="factory"></param>
/// <param name="options">NLog options</param>
/// <returns>ILoggerFactory for chaining</returns>
public static ILoggerFactory AddNLog(this ILoggerFactory factory, NLogProviderOptions options)
{
//ignore this
LogManager.AddHiddenAssembly(Assembly.Load(new AssemblyName("Microsoft.Extensions.Logging")));
LogManager.AddHiddenAssembly(Assembly.Load(new AssemblyName("Microsoft.Extensions.Logging.Abstractions")));
try
{
//try the Filter ext
var filterAssembly = Assembly.Load(new AssemblyName("Microsoft.Extensions.Logging.Filter"));
LogManager.AddHiddenAssembly(filterAssembly);
}
catch (Exception)
{
//ignore
}
LogManager.AddHiddenAssembly(typeof(ConfigureExtensions).GetTypeInfo().Assembly);
using (var provider = new NLogLoggerProvider(options))
{
factory.AddProvider(provider);
}
return(factory);
}
private CustomLoggerPropertyTestRunner GetRunner(NLogProviderOptions options = null)
{
SetupTestRunner <CustomLoggerPropertyTestRunner>(typeof(SameAssemblyLogger <>), options);
var runner = GetRunner <CustomLoggerPropertyTestRunner>();
return(runner);
}
/// <summary>
/// Enable and configure NLog as a logging provider for buildable generic host (.NET Core 2.1+).
/// Can be used in discrete containers as well.
/// </summary>
/// <param name="builder"></param>
/// <param name="options">NLogProviderOptions object to configure NLog behavior</param>
/// <returns>IHostBuilder for chaining</returns>
public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOptions options)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.ConfigureServices((hostbuilder, services) =>
{
ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(ConfigureExtensions).GetTypeInfo()
.Assembly);
services.AddSingleton <ILoggerProvider>(serviceProvider =>
{
var provider = new NLogLoggerProvider(options ?? new NLogProviderOptions());
if (hostbuilder.Configuration != null)
{
ConfigSettingLayoutRenderer.DefaultConfiguration = hostbuilder.Configuration;
if (options == null)
{
provider.Configure(hostbuilder.Configuration.GetSection("Logging:NLog"));
}
}
return(provider);
});
});
return(builder);
}
/// <summary>
/// 初始化 Console 应用。
/// 项目下必须包含 appsettings.json 和 nlog.config 文件。
/// </summary>
/// <param name="setup"></param>
public static void Init(Action <IConfiguration, ServiceCollection> setup)
{
// 1、Load Configurations
// Console App 没有 ASPNETCORE_ENVIRONMENT 变量
// var envName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
Configuration = new ConfigurationBuilder()
//.SetBasePath(Directory.GetCurrentDirectory())
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("appsettings.json", optional: false)
//.AddJsonFile($"appsettings.{envName}.json", optional: true)
.Build();
// 2、Build IoC Services
var services = new ServiceCollection();
services.AddSingleton(Configuration);
services.AddLogging(b => b.AddConfiguration(Configuration.GetSection("Logging")));
setup(Configuration, services);
ServiceProvider = services.BuildServiceProvider();
// 3、Config Logging
var loggerFactory = ServiceProvider.GetRequiredService <ILoggerFactory>();
var nlogOptions = new NLogProviderOptions
{
CaptureMessageTemplates = true,
CaptureMessageProperties = true
};
loggerFactory.AddConsole(); // LogLevel.Debug
loggerFactory.AddNLog(nlogOptions);
NLog.LogManager.LoadConfiguration("nlog.config");
}
public void UseNLog_withOptionsParam_WorksWithNLog()
{
var someParam = new NLogProviderOptions {
CaptureMessageProperties = false, CaptureMessageTemplates = false
};
var actual = new HostBuilder().UseNLog(someParam).Build();
TestHostingResult(actual, true);
}
/// <summary>
/// Enable and configure NLog as a logging provider for buildable generic host (.NET Core 2.1+).
/// Can be used in discrete containers as well.
/// </summary>
/// <param name="builder"></param>
/// <param name="options">NLogProviderOptions object to configure NLog behavior</param>
/// <returns>IHostBuilder for chaining</returns>
public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOptions options)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.ConfigureServices((builderContext, services) => AddNLogLoggerProvider(services, builderContext.Configuration, builderContext.HostingEnvironment, options, CreateNLogLoggerProvider));
return(builder);
}
/// <summary>
/// Enable NLog as logging provider in .NET Core.
/// </summary>
/// <param name="factory"></param>
/// <param name="options">NLog options</param>
/// <returns>ILoggerFactory for chaining</returns>
public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, NLogProviderOptions options)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
using (var provider = new NLogLoggerProvider(options))
{
factory.AddProvider(provider);
}
return(factory);
}
/// <summary>
/// adds NLog to the logger factory
/// </summary>
/// <param name="loggerFactory">logger factory</param>
/// <param name="configFilePath">the path to the config (if none is given, NLog will search for it)</param>
public static void AddNLog(this ILoggerFactory loggerFactory, string configFilePath = null)
{
// register target class
ConfigurationItemFactory.Default.Targets.RegisterDefinition("AppCenter", typeof(AppCenterTarget));
LogManager.Configuration = new XmlLoggingConfiguration(configFilePath);
var options = new NLogProviderOptions();
var nlogProvider = new NLogLoggerProvider(options);
loggerFactory.AddProvider(nlogProvider);
}
private NLogProviderOptions GetDefaultOptions()
{
NLogProviderOptions options = new NLogProviderOptions();
options.CaptureMessageProperties = true;
options.CaptureMessageTemplates = true;
options.EventIdSeparator = ".";
options.IgnoreEmptyEventId = true;
return(options);
}
public static ILoggerFactory CreateLogging()
{
var options = new NLogProviderOptions {
CaptureMessageTemplates = true, CaptureMessageProperties = true
};
var loggerFactory = new LoggerFactory().AddNLog(options);
loggerFactory.ConfigureNLog("nlog.config");
return(loggerFactory);
}
public void UseNLog_withOptionsParam_buildsAndExposesValidIServiceCollection()
{
var someParam = new NLogProviderOptions {
CaptureMessageProperties = false, CaptureMessageTemplates = false
};
var actual = new HostBuilder().UseNLog(someParam).Build();
var serviceCount = actual.Services.GetServices <ILoggerFactory>().Count();
Assert.NotNull(actual);
Assert.Equal(2, serviceCount);
}
public void UseNLog_withConfiguration_WorksWithNLog()
{
var memoryConfig = new Dictionary <string, string>();
memoryConfig["NLog:CaptureMessageProperties"] = "true";
memoryConfig["NLog:CaptureMessageTemplates"] = "false";
memoryConfig["NLog:IgnoreScopes"] = "false";
var someParam = new NLogProviderOptions {
CaptureMessageProperties = false, CaptureMessageTemplates = false
};
var actual = new HostBuilder().ConfigureHostConfiguration(config => config.AddInMemoryCollection(memoryConfig)).UseNLog(someParam).Build();
TestHostingResult(actual, true);
}
public void TestExtraMessagePropertySayHi()
{
var options = new NLogProviderOptions {
CaptureMessageTemplates = false
};
var runner = GetRunner(options);
var target = CreateMemoryTarget();
ConfigureNLog(target);
runner.SayHigh5();
Assert.Single(target.Logs);
Assert.Equal(@"Hi 5|ActivityId=42, 0=5", target.Logs[0]);
}
/// <summary>
/// Enable and configure NLog as a logging provider for buildable generic host (.NET Core 2.1+).
/// Can be used in discrete containers as well.
/// </summary>
/// <param name="builder"></param>
/// <param name="options">NLogProviderOptions object to configure NLog behavior</param>
/// <returns>IHostBuilder for chaining</returns>
public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOptions options)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.ConfigureServices(services =>
{
ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(ConfigureExtensions).GetTypeInfo()
.Assembly);
services.AddSingleton(new LoggerFactory().AddNLog(options));
});
return(builder);
}
public void AddNLog_withShutdownOnDispose_worksWithNLog()
{
var someParam = new NLogProviderOptions {
ShutdownOnDispose = true
};
var actual = new HostBuilder().ConfigureLogging(l => l.AddNLog(someParam)).Build();
try
{
TestHostingResult(actual, false);
Assert.NotNull(LogManager.Configuration);
}
finally
{
actual.Dispose();
Assert.Null(LogManager.Configuration);
}
}
/// <summary>
/// Add Microsoft.Extensions.Logging and NLog to service collection.
/// </summary>
/// <param name="serviceCollection">The service collection to add services to.</param>
/// <param name="nLogConfigurationPath">The path to the NLog configuration file.</param>
/// <param name="optionsBuilder">Actions to configure NLog options.</param>
/// <param name="loggingBuilder">Actions to configure Microsoft.Extensions.Logging.</param>
/// <returns>The modified service collection.</returns>
public static IServiceCollection AddNLog(this IServiceCollection serviceCollection,
string nLogConfigurationPath,
Action <NLogProviderOptions> optionsBuilder,
Action <ILoggingBuilder> loggingBuilder)
{
if (!string.IsNullOrEmpty(nLogConfigurationPath))
{
NLog.LogManager.LoadConfiguration(nLogConfigurationPath);
}
return(serviceCollection.AddLogging(builder =>
{
loggingBuilder(builder);
var configuredOptions = new NLogProviderOptions();
optionsBuilder(configuredOptions);
builder.AddNLog(configuredOptions);
}));
}
protected NLogLoggerProvider ConfigureLoggerProvider(NLogProviderOptions options = null, Action <ServiceCollection> configureServices = null)
{
if (_serviceProvider == null)
{
var logFactory = new LogFactory();
LoggerProvider = new NLogLoggerProvider(options ?? new NLogProviderOptions {
CaptureMessageTemplates = true, CaptureMessageProperties = true
}, logFactory);
var services = new ServiceCollection();
services.AddSingleton <ILoggerFactory, LoggerFactory>();
services.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
configureServices?.Invoke(services);
_serviceProvider = services.BuildServiceProvider();
var loggerFactory = _serviceProvider.GetRequiredService <ILoggerFactory>();
loggerFactory.AddProvider(LoggerProvider);
}
return(LoggerProvider);
}
public void AddNLog_LoggingBuilder_LogInfoWithEventId_ShouldLogToNLogWithEventId(string eventPropery, string expectedEventInLog)
{
// Arrange
ILoggingBuilder builder = new LoggingBuilderStub();
var config = CreateConfigWithMemoryTarget(out var memoryTarget, $"${{event-properties:{eventPropery}}} - ${{message}}");
var options = new NLogProviderOptions {
EventIdSeparator = "_"
};
// Act
builder.AddNLog(config, options);
var provider = GetLoggerProvider(builder);
var logger = provider.CreateLogger("logger1");
logger.LogInformation(new EventId(2, "eventId2"), "test message with {0} arg", 1);
// Assert
AssertSingleMessage(memoryTarget, $"{expectedEventInLog} - test message with 1 arg");
}
public static void LoadNLogConfiguration(IServiceContainer container, IServiceProvider provider, string logConfigurationFile)
{
var loggerFactory = provider.GetRequiredService <ILoggerFactory>();
// post-configure NLog Instance from the service provider
var options = new NLogProviderOptions
{
CaptureMessageTemplates = true,
CaptureMessageProperties = true,
};
loggerFactory.AddNLog(options);
if (File.Exists(logConfigurationFile))
{
NLog.LogManager.LoadConfiguration(logConfigurationFile);
}
container.RegisterInstance <ILoggerFactory>(loggerFactory);
container.Register(typeof(ILogger <>), typeof(Logger <>), new PerContainerLifetime());
container.RegisterConstructorDependency((factory, info) => loggerFactory.CreateLogger(info.Member.DeclaringType));
}
private static void AddNLogLoggerProvider(IServiceCollection services, IConfiguration configuration, NLogProviderOptions options, Func <IServiceProvider, IConfiguration, NLogProviderOptions, NLogLoggerProvider> factory)
{
ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(ConfigureExtensions).GetTypeInfo().Assembly);
services.TryAddNLogLoggingProvider((svc, addlogging) => svc.AddLogging(addlogging), configuration, options, factory);
}
private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serviceProvider, IConfiguration configuration, IHostEnvironment hostEnvironment, NLogProviderOptions options)
{
NLogLoggerProvider provider = new NLogLoggerProvider(options);
configuration = SetupConfiguration(serviceProvider, configuration);
if (serviceProvider != null && provider.Options.RegisterServiceProvider)
{
provider.LogFactory.ServiceRepository.RegisterService(typeof(IServiceProvider), serviceProvider);
}
if (configuration != null)
{
provider.Configure(configuration.GetSection("Logging:NLog"));
provider.TryLoadConfigurationFromSection(configuration);
}
var contentRootPath = hostEnvironment?.ContentRootPath;
if (!string.IsNullOrEmpty(contentRootPath))
{
TryLoadConfigurationFromContentRootPath(provider.LogFactory, contentRootPath);
}
if (provider.Options.ShutdownOnDispose)
{
provider.LogFactory.AutoShutdown = false;
}
return(provider);
}
private static void AddNLogLoggerProvider(IServiceCollection services, IConfiguration configuration, IHostEnvironment hostEnvironment, NLogProviderOptions options, Func <IServiceProvider, IConfiguration, IHostEnvironment, NLogProviderOptions, NLogLoggerProvider> factory)
{
ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(ConfigureExtensions).GetTypeInfo().Assembly);
LogManager.AddHiddenAssembly(typeof(ConfigureExtensions).GetTypeInfo().Assembly);
services.TryAddNLogLoggingProvider((svc, addlogging) => svc.AddLogging(addlogging), configuration, options, (provider, cfg, opt) => factory(provider, cfg, hostEnvironment, opt));
}
/// <summary>
/// New provider with options
/// </summary>
/// <param name="options"></param>
public NLogLoggerProvider(NLogProviderOptions options)
{
Options = options;
}
private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serviceProvider, IConfiguration configuration, NLogProviderOptions options)
{
configuration = SetupConfiguration(serviceProvider, configuration);
NLogLoggerProvider provider = new NLogLoggerProvider(options);
if (configuration != null && options == null)
{
provider.Configure(configuration.GetSection("Logging:NLog"));
}
return(provider);
}
protected void SetupTestRunner <TRunner>(Type implType, NLogProviderOptions options = null) where TRunner : class
{
ConfigureTransientService <TRunner>(s => s.AddSingleton(typeof(ILogger <>), implType), options);
}
protected IServiceProvider ConfigureTransientService <T>(Action <ServiceCollection> configureServices = null, NLogProviderOptions options = null) where T : class
{
if (_serviceProvider == null)
{
ConfigureLoggerProvider(options, s => { s.AddTransient <T>(); configureServices?.Invoke(s); });
}
return(_serviceProvider);
}
