public async Task Execute(ILoggingBuilder builder, LoggerItemConfiguration configuration)
{
//反序列化特定配置
var innerConfiguration = JsonSerializerHelper.Deserialize <ApplicationInsightsConfiguration>(JsonSerializerHelper.Serializer(configuration.ConfigurationObj));
//绑定提供方
builder.AddApplicationInsights(innerConfiguration.Key, (opt) =>
{
opt.IncludeScopes = innerConfiguration.IncludeScopes;
opt.TrackExceptionsAsExceptionTelemetry = innerConfiguration.TrackExceptionsAsExceptionTelemetry;
});
//配置级别过滤
foreach (var filterItem in configuration.LogLevels)
{
builder.AddFilter <ApplicationInsightsLoggerProvider>(filterItem.Key, filterItem.Value);
}
//配置其他未指定目录的最低级别
builder.AddFilter <ApplicationInsightsLoggerProvider>((level) =>
{
if (level < configuration.DefaultMinLevel)
{
return(false);
}
return(true);
});
await Task.FromResult(0);
}
public async Task Execute(ILoggingBuilder builder, LoggerItemConfiguration configuration)
{
//反序列化特定配置
var innerConfiguration = JsonSerializerHelper.Deserialize <ExceptionLessConfiguration>(JsonSerializerHelper.Serializer(configuration.ConfigurationObj));
_exceptionLessProvider.Key = innerConfiguration.Key;
if (!string.IsNullOrEmpty(innerConfiguration.ServiceUri))
{
_exceptionLessProvider.ServiceUri = innerConfiguration.ServiceUri;
}
builder.AddProvider(_exceptionLessProvider);
//配置级别过滤
foreach (var filterItem in configuration.LogLevels)
{
builder.AddFilter <ExceptionLessProvider>(filterItem.Key, filterItem.Value);
}
//配置其他未指定目录的最低级别
builder.AddFilter <ExceptionLessProvider>((level) =>
{
if (level < configuration.DefaultMinLevel)
{
return(false);
}
return(true);
});
await Task.FromResult(0);
}
public async Task Execute(ILoggingBuilder builder, LoggerItemConfiguration configuration)
{
//反序列化特定配置
var innerConfiguration = JsonSerializerHelper.Deserialize <ConsoleConfiguration>(JsonSerializerHelper.Serializer(configuration.ConfigurationObj));
//绑定提供方
builder.AddConsole((opt) =>
{
if (innerConfiguration != null)
{
opt.DisableColors = innerConfiguration.DisableColors;
opt.IncludeScopes = innerConfiguration.IncludeScopes;
}
});
//配置级别过滤
foreach (var filterItem in configuration.LogLevels)
{
builder.AddFilter <ConsoleLoggerProvider>(filterItem.Key, filterItem.Value);
}
//配置其他未指定目录的最低级别
builder.AddFilter <ConsoleLoggerProvider>((level) =>
{
if (level < configuration.DefaultMinLevel)
{
return(false);
}
return(true);
});
await Task.FromResult(0);
}
private void ConfigureLogging(ILoggingBuilder builder, string filePath)
{
TestingUtils.ConfigureDefaultLoggingBuilder(builder, filePath);
builder.AddFilter("Runtime.Catalog", LogLevel.Debug);
builder.AddFilter("Runtime.Dispatcher", LogLevel.Trace);
builder.AddFilter("Orleans.GrainDirectory.LocalGrainDirectory", LogLevel.Trace);
}
public async Task Execute(ILoggingBuilder builder, LoggerConfiguration configuration)
{
if (!configuration.RemainAllProvider)
{
builder.ClearProviders();
}
//处理全局日志级别
foreach (var levelItem in configuration.GlobalLogLevels)
{
builder.AddFilter(levelItem.Key, levelItem.Value);
}
//设置全局日志级别（为指定目录）
builder.AddFilter((level) =>
{
if (level < configuration.GlobalLogDefaultMinLevel)
{
return(false);
}
return(true);
});
//处理每一个提供方
foreach (var providerItem in configuration.Providers)
{
providerItem.Value.ConfigurationObj = JsonSerializerHelper.Deserialize <JObject>(JsonSerializerHelper.Serializer(providerItem.Value.Configuration));
var providerHandler = getProviderHandler(providerItem.Key);
await providerHandler.Execute(builder, providerItem.Value);
}
}
private static void LogConfig(ILoggingBuilder log)
{
log.AddConsole();
log.AddFilter("GetOnBoard", LogLevel.Information);
log.AddFilter("Microsoft.AspNetCore.Mvc", LogLevel.Error);
log.AddFilter("Microsoft.AspNetCore.Hosting", LogLevel.Error);
log.AddFilter("Microsoft.AspNetCore.Routing", LogLevel.Error);
}
public static void ConfigureAppSharedLogging(WebHostBuilderContext hostingContext, ILoggingBuilder logging)
{
logging.AddConsole();
logging.AddDebug();
logging.AddFilter(DbLoggerCategory.Database.Connection.Name, LogLevel.Information);
logging.AddFilter("AgencyPro", LogLevel.Debug);
logging.AddFilter("Microsoft.AspNetCore", LogLevel.Warning);
logging.AddFilter("IdentityServer4", LogLevel.Warning);
}
public virtual void OnConfigureLogging(ILoggingBuilder loggingBuilder)
{
loggingBuilder.AddFilter("Microsoft.AspNetCore.DataProtection",
level => (level >= LogLevel.Information)
);
loggingBuilder.AddFilter("System.Net.Http.HttpClient.Default",
LogLevel.Information
);
}
private static void AddConsoleLogger(this ILoggingBuilder loggingBuilder)
{
loggingBuilder.AddConsole(options =>
{
options.DisableColors = false;
options.TimestampFormat = "[HH:mm:ss:fff] ";
});
loggingBuilder.AddFilter <ConsoleLoggerProvider>("System", LogLevel.Warning);
loggingBuilder.AddFilter <ConsoleLoggerProvider>("Microsoft", LogLevel.Warning);
loggingBuilder.AddFilter <ConsoleLoggerProvider>("Default", LogLevel.Information);
}
public static void AddLogging(
this ILoggingBuilder builder,
WebHostBuilderContext hostingContext,
string environment)
{
builder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
builder.AddConsole();
builder.AddDebug();
builder.AddApplicationInsights();
builder.AddFilter <ApplicationInsightsLoggerProvider>("", GetLogLevel(environment));
builder.AddFilter <ApplicationInsightsLoggerProvider>("Microsoft.EntityFrameworkCore", LogLevel.Warning);
}
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 ConfigureLoggingExplicitFilters(ILoggingBuilder builder, LogLevel globalMinLevel = LogLevel.Warning, LogLevel rhetosMinLevel = LogLevel.Information)
{
builder.AddFilter((s, level) =>
s.StartsWith("Rhetos.LanguageServices")
? level >= rhetosMinLevel
: level >= globalMinLevel);
}
/// <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 void ConfigureConsoleLogging(ILoggingBuilder builder)
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddConsole();
}
public static void AddFilter(this ILoggingBuilder builder)
{
builder.AddFilter((category, level) =>
{
if (category.StartsWith("Orleans.Runtime.NoOpHostEnvironmentStatistics", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Error);
}
if (category.StartsWith("Orleans.Runtime.Scheduler", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Error);
}
if (category.StartsWith("Orleans.", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Runtime.", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Microsoft.AspNetCore.", StringComparison.OrdinalIgnoreCase))
{
return(level > LogLevel.Information);
}
return(level >= LogLevel.Information);
});
}
public static ILoggingBuilder AddLogger(this ILoggingBuilder builder, ITargetBlock <string> queue)
{
builder.AddProvider(new TargetBlockLoggerProvider(queue));
builder.AddFilter <TargetBlockLoggerProvider>(x => true);
return(builder);
}
public static ILoggingBuilder AddServiceLogging(this ILoggingBuilder builder, LoggerOptions options = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
options = options ?? new LoggerOptions();
if (options.UseActivityLogger)
{
builder.Services.AddSingleton(typeof(IActivityLogger <>), typeof(ActivityLogger <>));
}
builder.Services.AddSingleton <LoggingLevelSwitch>();
builder.Services.AddTransient <Action <ServiceContext> >(serviceProvider => EnrichLoggerWithContext(serviceProvider));
builder.Services.AddTransient <LoggerConfiguration>(services => GetLoggerConfiguration(services));
builder.Services.AddTransient <ActivityLoggerLogConfigurationAdapter>();
builder.Services.AddTransient <ApplicationInsightsLoggerLogConfigurationAdapter>();
builder.Services.AddSingleton <ILoggerProvider, LoggerProvider>(services => GetLoggerProvider(services, options));
builder.AddFilter <LoggerProvider>(null, LogLevel.Trace);
return(builder);
}
private static void ConfigureLogging(ILoggingBuilder loggingBuilder, HostingOptions hostingOptions)
{
if (loggingBuilder == null)
{
throw new ArgumentNullException(nameof(loggingBuilder));
}
if (hostingOptions == null)
{
throw new ArgumentNullException(nameof(hostingOptions));
}
loggingBuilder.AddFilter((category, level) => level >= LogLevel.Warning || level == LogLevel.Trace);
var hasJournalD = Tmds.Systemd.Journal.IsSupported;
if (hasJournalD)
{
loggingBuilder.AddJournal(options =>
{
options.SyslogIdentifier = "gridfs-server";
options.DropWhenBusy = true;
});
}
if (!hasJournalD || hostingOptions.ForceConsoleLogging)
{
loggingBuilder.AddConsole(options => options.DisableColors = true);
}
}
public static ILoggingBuilder AddMemoryLogger(this ILoggingBuilder builder, BoundedQueue <string> queue)
{
builder.AddProvider(new MemoryLoggerProvider(queue));
builder.AddFilter <MemoryLoggerProvider>(x => true);
return(builder);
}
public static ILoggingBuilder AddVidyanoEntityFrameworkCore(this ILoggingBuilder builder)
{
builder
.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Information)
.AddProvider(new VidyanoEntityFrameworkCoreLoggerProvider());
return(builder);
}
public static ILoggingBuilder ConfigureRecruitLogging(this ILoggingBuilder builder)
{
//Change LogLevel to Trace whilst Debugging to output Mongo commands
builder.AddFilter("Mongo command", LogLevel.None);
return(builder);
}
/// <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);
}
public static ILoggingBuilder AddNLog(this ILoggingBuilder builder, Func <string, Microsoft.Extensions.Logging.LogLevel, bool> filter, string nlogConfigFile = "nlog.config")
{
LayoutExtentions.ReisterNlogLayout();
builder.AddFilter(filter);
builder.Services.AddSingleton <ILoggerProvider>(sp => new NLogProvider());
return(builder);
}
public static ILoggingBuilder AddLogging(this ILoggingBuilder loggingBuilder)
{
loggingBuilder.AddFilter <ApplicationInsightsLoggerProvider>("", LogLevel.Trace);
loggingBuilder.AddAzureWebAppDiagnostics();
loggingBuilder.AddApplicationInsights();
return(loggingBuilder);
}
#pragma warning disable CA1801 // Review unused parameters -- required for other build configuration
#endif
private static void ConfigureLogging(HostBuilderContext builderContext, ILoggingBuilder loggingBuilder)
#if MINIMAL_BUILD
#pragma warning restore CA1801 // Review unused parameters
#endif
{
loggingBuilder.AddFilter(
(category, level) => level >= LogLevel.Warning ||
(level >= LogLevel.Information && !category.StartsWith("Microsoft.AspNetCore.", StringComparison.OrdinalIgnoreCase)));
#if !MINIMAL_BUILD
if (Journal.IsSupported)
{
loggingBuilder.AddJournal(options =>
{
options.SyslogIdentifier = builderContext.HostingEnvironment.ApplicationName;
});
}
#endif
#if !MINIMAL_BUILD
if (builderContext.Configuration.GetValue <bool>("ForceConsoleLogging") ||
!Journal.IsAvailable)
#endif
{
loggingBuilder.AddSystemdConsole(options =>
{
options.IncludeScopes = true;
options.TimestampFormat = "yyyy-MM-ddTHH:mm:ss.fffffffzzz \""
+ Environment.MachineName
+ "\" \""
+ builderContext.HostingEnvironment.ApplicationName
+ ":\" ";
});
}
}
public static ILoggingBuilder __add_logger_filter__(this ILoggingBuilder builder, IConfiguration config)
{
var ignore_logger = (config["ignore_logger"] ?? string.Empty).Split(',').WhereNotEmpty().ToArray();
bool __filter__(string logger, LogLevel level)
{
if (ValidateHelper.IsNotEmpty(logger))
{
if (ignore_logger.Any(x => logger.StartsWith(x, StringComparison.OrdinalIgnoreCase)))
{
if (level < LogLevel.Warning)
{
return(false);
}
}
}
return(true);
}
if (ignore_logger.Any())
{
builder.AddFilter(__filter__);
}
return(builder);
}
private static void DefaultConfigureLoggingBuilderAction(ILoggingBuilder loggingBuilder)
{
//because this management grain is very noisy when using Orleans Dashboard
loggingBuilder.AddFilter("Orleans.Runtime.Management.ManagementGrain", LogLevel.Warning)
.AddFilter("Orleans.Runtime.SiloControl", LogLevel.Warning);
loggingBuilder.AddSerilog(dispose: true);
}
private static void AddFilters(this ILoggingBuilder builder)
{
builder.AddFilter((category, level) =>
{
#if LOG_ALL_IDENTITY_SERVER
if (category.StartsWith("Microsoft.AspNetCore.", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (category.StartsWith("IdentityServer4.", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
#endif
if (level < LogLevel.Information)
{
return(false);
}
if (category.StartsWith("OpenIddict", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Orleans.Runtime.NoOpHostEnvironmentStatistics", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Error);
}
if (category.StartsWith("Orleans.Runtime.SafeTimer", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Error);
}
if (category.StartsWith("Orleans.Runtime.Scheduler", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Orleans.", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Runtime.", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
if (category.StartsWith("Microsoft.AspNetCore.", StringComparison.OrdinalIgnoreCase))
{
return(level >= LogLevel.Warning);
}
return(true);
});
}
/// <summary>
/// Add Steeltoe logger wrapped in a <see cref="IDynamicLoggerProvider"/> that supports
/// dynamically controlling the minimum log level via management endpoints
/// </summary>
/// <param name="builder">The <see cref="ILoggingBuilder"/> for configuring the LoggerFactory </param>
/// <returns>The configured <see cref="ILoggingBuilder"/></returns>
public static ILoggingBuilder AddSerilogDynamicConsole(this ILoggingBuilder builder)
{
builder.AddFilter <DynamicLoggerProvider>(null, LogLevel.Trace);
builder.Services.AddSingleton <ISerilogOptions, SerilogOptions>();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider, SerilogDynamicProvider>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IOptionsChangeTokenSource <ConsoleLoggerOptions>, LoggerProviderOptionsChangeTokenSource <ConsoleLoggerOptions, ConsoleLoggerProvider> >());
builder.Services.AddSingleton <IDynamicLoggerProvider>((p) => p.GetServices <ILoggerProvider>().OfType <IDynamicLoggerProvider>().SingleOrDefault());
return(builder);
}
private static void ConfigureLogger(ILoggingBuilder builder)
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
#if DEBUG
.AddFilter("Microsoft.EntityFrameworkCore.Database", LogLevel.Debug)
#endif
.AddConsole(t => t.DisableColors = true);
}
