public static void ConfigureLogging(WebHostBuilderContext host, ILoggingBuilder builder)
{
builder.AddConfiguration(host.Configuration.GetSection("Logging"));
builder.AddConsole();
builder.AddDebug();
builder.AddFilter(DbLoggerCategory.Database.Connection.Name, LogLevel.Information);
}
public static void AppConfigure(WebHostBuilderContext hostingContext, ILoggingBuilder logging)
{
// ** Add DotNet.NLogger.NetCore
string logPath = Path.Combine(hostingContext.HostingEnvironment.ContentRootPath, $"nlog.{hostingContext.HostingEnvironment.EnvironmentName}.config");
if (!File.Exists(logPath))
{
throw new MissingMemberException($"Missing NLog configuration file '{logPath}'");
}
var nLoggingConfiguration = new XmlLoggingConfiguration(logPath);
var logJsonCgf = hostingContext.Configuration.GetSection(nameof(NLogLoggerSettings));
if (!logJsonCgf.Exists())
{
throw new MissingMemberException($"Missing configuration section '{nameof(NLogLoggerSettings)}'");
}
logging.AddNLogLogger(logJsonCgf, nLoggingConfiguration);
// ** Add DotNet.Memory.Logger
logJsonCgf = hostingContext.Configuration.GetSection(nameof(MemoryLoggerSettings));
if (!logJsonCgf.Exists())
{
throw new MissingMemberException($"Missing configuration section '{nameof(MemoryLoggerSettings)}'");
}
logging.AddMemoryLogger(logJsonCgf);
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
//logging.AddConsole();
//logging.AddDebug();
}
public static void AddCustomLogger(this ILoggingBuilder configureLogging, IConfiguration configuration)
{
var config = new LoggingConfiguration();
configureLogging.AddConfiguration(configuration.GetSection("Logging"));
// Create targets and add them to the configuration
var fileTarget = GetFileTarget();
config.AddTarget(fileTarget);
// Define logging rules
LoggingRule logRule = new LoggingRule("*", LogLevel.Trace, fileTarget);
// Define filter to ignore logs from Microsoft DLLs
var filterToIgnoreAllMicrosoftLogs = new ConditionBasedFilter
{
Condition = "starts-with(logger, 'Microsoft.')",
Action = FilterResult.Ignore
};
logRule.Filters.Add(filterToIgnoreAllMicrosoftLogs);
// Define wrappers
var asyncWrapper = GetAsyncTargetWrapper();
asyncWrapper.WrappedTarget = fileTarget;
SimpleConfigurator.ConfigureForTargetLogging(asyncWrapper, LogLevel.Trace);
// Activate the configuration
config.LoggingRules.Add(logRule);
LogManager.Configuration = config;
//Add nlog by default
configureLogging.AddNLog(config);
}
public static ILoggingBuilder AddTelegramLogger(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, TelegramLoggerProvider>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IConfigureOptions <TelegramLoggerOptions>, TelegramLoggerOptionsSetup>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IOptionsChangeTokenSource <TelegramLoggerOptions>, LoggerProviderOptionsChangeTokenSource <TelegramLoggerOptions, TelegramLoggerProvider> >());
var telegramLoggerOptions = builder.Services.BuildServiceProvider().GetRequiredService <IOptionsMonitor <TelegramLoggerOptions> >();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, TelegramLoggerProvider>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ITelegramBotClient>(new TelegramBotClient(telegramLoggerOptions.CurrentValue.BotToken)));
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ITelegramMessageService, TelegramMessageService>());
builder.Services.AddHostedService <QueuedHostedService>();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IBackgroundLogMessageEntryQueue, BackgroundLogMessageEntryQueue>());
return(builder);
}
/// <summary>
/// This is the "normal" way to add provider to the list, some DI magic, but in essence it just registers another instance for ILoggerProvider
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static ILoggingBuilder AddInMemoryDebug(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, InMemoryDebugProvider>());
LoggerProviderOptions.RegisterProviderOptions <InMemoryDebugOptions, InMemoryDebugProvider>(builder.Services);
return(builder);
}
public virtual void ConfigureLogging(IConfiguration configuration, ILoggingBuilder logging)
{
Configuration = configuration;
logging.AddConfiguration(configuration.GetSection("Logging"));
logging.AddConsole(); // TODO: logging
}
/// <summary>
/// Adds Dynamic Console Logger Provider
/// </summary>
/// <param name="builder">Your ILoggingBuilder</param>
/// <param name="ensureCleanSetup">If true removes any <see cref="ConsoleLoggerProvider"/>, ensures logging config classes are available</param>
public static ILoggingBuilder AddDynamicConsole(this ILoggingBuilder builder, bool ensureCleanSetup = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (ensureCleanSetup)
{
// remove the original ConsoleLoggerProvider to prevent duplicate logging
var serviceDescriptor = builder.Services.FirstOrDefault(descriptor => descriptor.ImplementationType == typeof(ConsoleLoggerProvider));
if (serviceDescriptor != null)
{
builder.Services.Remove(serviceDescriptor);
}
// make sure logger provider configurations are available
if (!builder.Services.Any(descriptor => descriptor.ServiceType == typeof(ILoggerProviderConfiguration <ConsoleLoggerProvider>)))
{
builder.AddConfiguration();
}
}
builder.AddFilter <DynamicConsoleLoggerProvider>(null, LogLevel.Trace);
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, DynamicConsoleLoggerProvider>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IConfigureOptions <ConsoleLoggerOptions>, ConsoleLoggerOptionsSetup>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IOptionsChangeTokenSource <ConsoleLoggerOptions>, LoggerProviderOptionsChangeTokenSource <ConsoleLoggerOptions, ConsoleLoggerProvider> >());
builder.Services.AddSingleton((p) => p.GetServices <ILoggerProvider>().OfType <IDynamicLoggerProvider>().SingleOrDefault());
return(builder);
}
static void ConfigureLogger(WebHostBuilderContext ctx, ILoggingBuilder logging)
{
// Setups up the logging configuration from the location of our json config information
logging.AddConfiguration(ctx.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
}
/// <summary>
/// Configure Sentry logging.
/// </summary>
public override void ConfigureLogging(WebHostBuilderContext context, ILoggingBuilder logging)
{
base.ConfigureLogging(context, logging);
logging.AddConfiguration(context.Configuration);
logging.Services.AddSingleton <ISentryEventProcessor, SentryGoogleCloudFunctionEventProcessor>();
// TODO: refactor this with SentryWebHostBuilderExtensions
var section = context.Configuration.GetSection("Sentry");
logging.Services.Configure <SentryAspNetCoreOptions>(section);
logging.Services.Configure <SentryAspNetCoreOptions>(options =>
{
// Make sure all events are flushed out
options.FlushOnCompletedRequest = true;
});
logging.Services.AddSingleton <IConfigureOptions <SentryAspNetCoreOptions>, SentryAspNetCoreOptionsSetup>();
logging.Services.AddSingleton <ILoggerProvider, SentryAspNetCoreLoggerProvider>();
logging.AddFilter <SentryAspNetCoreLoggerProvider>(
"Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware",
LogLevel.None);
logging.Services.AddSentry();
}
public static ILoggingBuilder AddWebLogger(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.TryAddEnumerable(
ServiceDescriptor
.Singleton <ILoggerProvider, WebLoggerProvider>()
);
builder.Services.TryAddEnumerable(
ServiceDescriptor.Singleton
<
IConfigureOptions <WebLoggerOptions>,
WebLoggerOptionsSetup
>()
);
builder.Services.TryAddEnumerable(
ServiceDescriptor.Singleton
<
IOptionsChangeTokenSource <WebLoggerOptions>,
LoggerProviderOptionsChangeTokenSource
<
WebLoggerOptions,
WebLoggerProvider
>
>()
);
return(builder);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline
public void Configure(IApplicationBuilder app,
IHostEnvironment env,
ILoggingBuilder loggerFactory,
ISeriLogger seriLogger,
IHostApplicationLifetime appLifetime,
EnvironmentConfig environmentConfig)
{
seriLogger.Configure(loggerFactory, Configuration, appLifetime, env, environmentConfig);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
loggerFactory.AddConfiguration(Configuration.GetSection("Logging"));
loggerFactory.AddConsole();
loggerFactory.AddDebug();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseEndpoints(endpoints => {
endpoints.MapControllers();
});
}
/// <summary>
/// バックグラウンド ロガーを構成します。
/// </summary>
/// <typeparam name="TProvider">構成するロガー プロバイダの型。</typeparam>
/// <param name="builder">ログ構成ビルダー。</param>
/// <param name="defaultMinLevel">ロガーの既定の最小ログ レベル</param>
/// <returns><paramref name="builder"/>。</returns>
/// <exception cref="ArgumentNullException"><paramref name="builder"/> is <c>null</c>.</exception>
public static ILoggingBuilder AddLogger <TProvider>(this ILoggingBuilder builder, LogLevel?defaultMinLevel = null)
where TProvider : class, ILoggerProvider
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddConfiguration();
if (defaultMinLevel != null)
{
builder.Services.Configure <LoggerFilterOptions>(options => {
var defaultRule = new LoggerFilterRule(
providerName: typeof(TProvider).FullName
, categoryName: null
, logLevel: defaultMinLevel
, filter: null
);
options.Rules.Insert(0, defaultRule);
});
}
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, TProvider>());
return(builder);
}
protected virtual void ConfigureLogging(WebHostBuilderContext context, ILoggingBuilder logging)
{
logging.ClearProviders();
logging.AddConfiguration(GetLoggingConfiguration(context.Configuration));
logging.AddConsoleLogger();
logging.AddDebug();
}
/// <summary>
/// Registers Application Insights and <see cref="ApplicationInsightsLoggerProvider"/> with an <see cref="ILoggingBuilder"/>.
/// </summary>
public static ILoggingBuilder AddApplicationInsightsWebJobs(
this ILoggingBuilder builder,
Action <ApplicationInsightsLoggerOptions> configure)
{
builder.AddConfiguration();
builder.Services.AddApplicationInsights(configure);
builder.Services.PostConfigure <LoggerFilterOptions>(o =>
{
// We want all logs to flow through the logger so they show up in QuickPulse.
// To do that, we'll hide all registered rules inside of this one. They will be re-populated
// and used by the FilteringTelemetryProcessor further down the pipeline.
string fullTypeName = typeof(ApplicationInsightsLoggerProvider).FullName;
IList <LoggerFilterRule> matchingRules = o.Rules.Where(r =>
{
return(r.ProviderName == fullTypeName ||
r.ProviderName == ApplicationInsightsLoggerProvider.Alias);
}).ToList();
foreach (var rule in matchingRules)
{
o.Rules.Remove(rule);
}
o.Rules.Add(new ApplicationInsightsLoggerFilterRule(matchingRules));
});
return(builder);
}
/// <summary>
/// Setup Serilog
/// Minimum Level: Verbose
/// Minimum Level Override: Microsoft Verbose
/// Enrich: FromLogContext
/// File: Rolling
/// </summary>
/// <param name="hostingEnvironment">Hosting Environment Information</param>
/// <param name="configuration">Configuration Information</param>
/// <param name="logging">Logging Information</param>
/// <param name="applicationName">Name of Application. I.E: Sentinel.Web, Sentinel.Registration.Api</param>
/// <exception cref="ArgumentNullException"><paramref name="hostingEnvironment"/> is <see langword="null"/></exception>
/// <exception cref="ArgumentException">Condition.</exception>
public static void Configure(IHostingEnvironment hostingEnvironment,
IConfiguration configuration,
ILoggingBuilder logging,
string applicationName)
{
if (hostingEnvironment == null)
{
throw new ArgumentNullException(nameof(hostingEnvironment));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (logging == null)
{
throw new ArgumentNullException(nameof(logging));
}
if (string.IsNullOrWhiteSpace(applicationName))
{
throw new ArgumentException($"{nameof(applicationName)} cannot be empty.");
}
var logDirectory = hostingEnvironment.IsEnvironment(EnvironmentTypes.Local)
? $"log/onion-{applicationName}.log" //local debug (windows)
: $"/var/log/app/onion-{applicationName}.log"; // Docker
var loggerConfig = new LoggerConfiguration();
loggerConfig
.MinimumLevel.Debug()
.MinimumLevel.Override(nameof(Microsoft), LogEventLevel.Information)
.MinimumLevel.Override(nameof(System), LogEventLevel.Information)
.Enrich.FromLogContext()
.Enrich.WithProperty("Application", applicationName)
.WriteTo.File(
logDirectory,
rollingInterval: RollingInterval.Day,
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{u3}] {Message:lj} {Properties}{NewLine}{Exception}");
//only add Seq for local file reading.
//see: https://docs.getseq.net/v4/docs/using-serilog
//for loading Seq locally see: https://docs.getseq.net/v4/docs/getting-started
if (hostingEnvironment.IsEnvironment(EnvironmentTypes.Local))
{
loggerConfig.WriteTo.Console();
loggerConfig.WriteTo.Seq("http://localhost:5341");
}
//Set Serilog
Log.Logger = loggerConfig.CreateLogger();
Log.Information("Updating Logging");
logging
.AddConfiguration(configuration.GetSection(AppSettingsSections.Logging))
.AddConsole()
.AddEventSourceLogger()
.AddDebug();
}
protected override void ConfigureLogging(ILoggingBuilder logging, IExecutionEnvironment executionEnvironment)
{
logging.AddConfiguration(Configuration.GetSection("Logging"));
logging.AddLambdaLogger(Configuration, "Logging");
//#if (AddLoggly)
logging.AddLoggly(Configuration.GetSection("Loggly"));
//#endif
}
/// <summary>
/// Adds a console logger named 'Console' to the factory.
/// </summary>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
public static ILoggingBuilder AddPdmConsole(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, PdmConsoleLoggerProvider>());
LoggerProviderOptions.RegisterProviderOptions <PdmConsoleLoggerOptions, PdmConsoleLoggerProvider>(builder.Services);
return(builder);
}
public static ILoggingBuilder AddZLoggerFile(this ILoggingBuilder builder, string fileName)
{
builder.AddConfiguration();
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, ZLoggerFileLoggerProvider>(x => new ZLoggerFileLoggerProvider(fileName, x.GetService <IOptionsSnapshot <ZLoggerOptions> >())));
LoggerProviderOptions.RegisterProviderOptions <ZLoggerOptions, ZLoggerFileLoggerProvider>(builder.Services);
return(builder);
}
/// <summary>
/// Registers a <see cref="GelfLoggerProvider"/> with the service collection.
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static ILoggingBuilder AddGelf(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.AddSingleton <ILoggerProvider, GelfLoggerProvider>();
builder.Services.TryAddSingleton <IConfigureOptions <GelfLoggerOptions>, GelfLoggerOptionsSetup>();
return(builder);
}
public static ILoggingBuilder AddZLoggerConsole(this ILoggingBuilder builder, bool consoleOutputEncodingToUtf8 = true)
{
builder.AddConfiguration();
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, ZLoggerConsoleLoggerProvider>(x => new ZLoggerConsoleLoggerProvider(consoleOutputEncodingToUtf8, null, x.GetService <IOptionsSnapshot <ZLoggerOptions> >())));
LoggerProviderOptions.RegisterProviderOptions <ZLoggerOptions, ZLoggerConsoleLoggerProvider>(builder.Services);
return(builder);
}
public static ILoggingBuilder AddZLoggerLogProcessor(this ILoggingBuilder builder, IAsyncLogProcessor logProcessor)
{
builder.AddConfiguration();
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, ZLoggerLogProcessorLoggerProvider>(x => new ZLoggerLogProcessorLoggerProvider(logProcessor)));
LoggerProviderOptions.RegisterProviderOptions <ZLoggerOptions, ZLoggerLogProcessorLoggerProvider>(builder.Services);
return(builder);
}
public static ILoggingBuilder AddLightingDb(this ILoggingBuilder builder, string path)
{
builder.AddConfiguration();
builder.Services.TryAddSingleton(r => new LightningLoggingStore(path));
builder.Services.TryAddSingleton <ILoggingStore>(r => r.GetRequiredService <LightningLoggingStore>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, LightningLoggerProvider>(r => new LightningLoggerProvider(r.GetRequiredService <LightningLoggingStore>())));
return(builder);
}
/// <param name="fileNameSelector">DateTimeOffset is date of file open time(UTC), int is number sequence.</param>
/// <param name="timestampPattern">DateTimeOffset is write time of message(UTC). If pattern is different previously then roll new file.</param>
/// <param name="rollSizeKB">Limit size of single file.</param>
public static ILoggingBuilder AddZLoggerRollingFile(this ILoggingBuilder builder, Func <DateTimeOffset, int, string> fileNameSelector, Func <DateTimeOffset, DateTimeOffset> timestampPattern, int rollSizeKB)
{
builder.AddConfiguration();
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, ZLoggerRollingFileLoggerProvider>(x => new ZLoggerRollingFileLoggerProvider(fileNameSelector, timestampPattern, rollSizeKB, x.GetService <IOptionsSnapshot <ZLoggerOptions> >())));
LoggerProviderOptions.RegisterProviderOptions <ZLoggerOptions, ZLoggerRollingFileLoggerProvider>(builder.Services);
return(builder);
}
public static ILoggingBuilder AddZLoggerStream(this ILoggingBuilder builder, Stream stream)
{
builder.AddConfiguration();
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, ZLoggerStreamLoggerProvider>(x => new ZLoggerStreamLoggerProvider(stream, x.GetService <IOptionsMonitor <ZLoggerOptions> >())));
LoggerProviderOptions.RegisterProviderOptions <ZLoggerOptions, ZLoggerStreamLoggerProvider>(builder.Services);
return(builder);
}
public static void ConfigureLogging(WebHostBuilderContext hostingContext, ILoggingBuilder logging)
{
logging.ClearProviders();
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
}
private static void ConfigureLogging(HostBuilderContext hostingContext, ILoggingBuilder logging)
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
// Need to resolve the copy appsettings file
// logging.ClearProviders();
// logging.AddLog4Net(hostingContext.Configuration.GetSection("Log4NetCore").Get<Log4NetProviderOptions>());
}
/// <summary>
/// 配置日志
/// </summary>
/// <param name="hostingContext"></param>
/// <param name="builder"></param>
private static void ConfigLogging(HostBuilderContext hostingContext, ILoggingBuilder builder)
{
builder.ClearProviders();
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
builder.AddConsole();
builder.AddDebug();
}
/// <summary>
/// Adds a console logger named 'Raven' to the factory.
/// </summary>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
public static ILoggingBuilder AddRaven(this ILoggingBuilder builder)
{
builder.AddConfiguration();
builder.Services.AddHttpContextAccessor();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, RavenLoggerProvider>());
LoggerProviderOptions.RegisterProviderOptions <RavenLoggerOptions, RavenLoggerProvider>(builder.Services);
return(builder);
}
private static void SetupLogging(WebHostBuilderContext context, ILoggingBuilder loggingBuilder)
{
loggingBuilder
.AddConfiguration(context.Configuration.GetSection("Logging"))
.AddConsole()
.AddDebug()
.AddEventSourceLogger();
}
public void ConfigureLogging(HostBuilderContext host, ILoggingBuilder logging)
{
Title("Configure Logging");
logging.AddConfiguration(host.Configuration.GetSection("Logging"));
// logging.AddConsole();
// logging.AddDebug();
}
