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); }