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