public void Fact2() { LoggingLevelSwitch category1Switch = new LoggingLevelSwitch(); bool CategoriesBelowCertainLevel(LogEvent e) { return(Matching.FromSource("Category1").Invoke(e) && e.Level < category1Switch.MinimumLevel); } Logger logger = new LoggerConfiguration() .Enrich.FromLogContext() .MinimumLevel.Verbose() .Filter.ByExcluding(CategoriesBelowCertainLevel) //.AuditTo.Sink() .WriteTo.Logger(configuration => configuration .MinimumLevel.Warning() .MinimumLevel.Override("Category1", LogEventLevel.Information) .WriteTo.File("file1.log")) .WriteTo.Console() .CreateLogger(); Serilog.ILogger category1Logger = logger.ForContext(Constants.SourceContextPropertyName, "Category1"); Serilog.ILogger category2Logger = logger.ForContext(Constants.SourceContextPropertyName, "Category2"); category1Logger.Information("visible"); category2Logger.Information("invisible"); category1Logger.Information("invisible"); category2Logger.Information("visible"); }
public static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning) .Enrich.FromLogContext() .Filter.ByExcluding(Matching.WithProperty("contextType")) .WriteTo.Console() //.WriteTo.File(new RenderedCompactJsonFormatter(), "Logs/log.ndjson") // New sub-logger with separate excluding rules .WriteTo.Logger(l => l .Filter.ByExcluding(Matching.FromSource("Microsoft.EntityFrameworkCore.Database.Command")) .WriteTo.File(new RenderedCompactJsonFormatter(), "Logs/development.ndjson")) .CreateLogger(); try { Log.Information("Starting server"); CreateHostBuilder(args).Build().Run(); } catch (Exception ex) { Log.Fatal(ex, "Failed starting server"); } finally { Log.CloseAndFlush(); } }
public Reporter() { IMetricsReporterBuilder builder = new MetricsReporterBuilder( _activationFactory, _simpleConfig, TelemetryTagContext.Default); Metric = builder.Build(); var activation = _activationFactory.Create(); //var configuration = new ConfigurationBuilder() // .AddJsonFile("TelemetryConfig.json") // .Build(); var logConfig = new LoggerConfiguration(); logConfig = logConfig//.ReadFrom.AppSettings() .MinimumLevel.Verbose() .MinimumLevel.Override("WebToInfluxTake2.Controllers.DataController", LogEventLevel.Warning) .WriteTo.File("log.debug.txt", restrictedToMinimumLevel: LogEventLevel.Debug, outputTemplate: FORMAT) .WriteTo.File("log.error.txt", restrictedToMinimumLevel: LogEventLevel.Error, outputTemplate: FORMAT) .WriteTo.File("log.warn.txt", restrictedToMinimumLevel: LogEventLevel.Warning, outputTemplate: FORMAT) .WriteTo.Logger(l => l .Filter.ByIncludingOnly(Matching.FromSource("WebToInfluxTake2.Controllers.DataController")) .WriteTo.File("log.data.txt", outputTemplate: FORMAT)) ; //.WriteTo.WithActivation( // activation, "seq", // s => s.Seq("http://localhost:5341",restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Debug)); LogFactory = new LogFactory(logConfig, activation); PushContext = _telemetryPushContext; }
static async Task Start() { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .Filter.ByExcluding(Matching.FromSource("NServiceBus.Transport.Msmq.QueuePermissions")) .WriteTo.Console() .CreateLogger(); LogManager.Use <SerilogFactory>(); Console.Title = "Billing"; var config = new EndpointConfiguration("OnlyOnce.Demo0.Billing"); config.UsePersistence <InMemoryPersistence>(); var transport = config.UseTransport <MsmqTransport>(); transport.Transactions(TransportTransactionMode.ReceiveOnly); transport.Routing().RegisterPublisher(typeof(ItemAdded), "OnlyOnce.Demo0.Orders"); config.Recoverability().Immediate(x => x.NumberOfRetries(5)); config.Recoverability().Delayed(x => x.NumberOfRetries(0)); config.SendFailedMessagesTo("error"); config.EnableInstallers(); var endpoint = await Endpoint.Start(config).ConfigureAwait(false); while (true) { Console.WriteLine("Press <enter> to exit."); Console.ReadLine(); } }
public Startup(IConfiguration configuration, IWebHostEnvironment environment) { Configuration = configuration; Directory.CreateDirectory(Path.Combine(environment.ContentRootPath, "logs")); Log.Logger = new LoggerConfiguration() .MinimumLevel.Verbose() .MinimumLevel.Override("Microsoft", LogEventLevel.Error) .MinimumLevel.Override("Hangfire", LogEventLevel.Information) .WriteTo.File(Path.Combine(environment.ContentRootPath, "logs", "Log-.txt"), fileSizeLimitBytes: 10 * 1024 * 1024, rollOnFileSizeLimit: true, shared: true, flushToDiskInterval: TimeSpan.FromSeconds(1), rollingInterval: RollingInterval.Day ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(Matching.FromSource("PointOfSales.DataCenter.Infrastructure.Persistence.Services.Email")) .WriteTo.File(Path.Combine(environment.ContentRootPath, "logs", "EmailLogs-.txt"), fileSizeLimitBytes: 10 * 1024 * 1024, rollOnFileSizeLimit: true, shared: true, flushToDiskInterval: TimeSpan.FromSeconds(1), rollingInterval: RollingInterval.Day )) .CreateLogger(); }
public async void InvokeTest_TestWithSerilogAndNormal() { var formatter = new CustomJsonFormatter("testapp"); Serilog.Log.Logger = new Serilog.LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Logger(lc => lc .Filter.ByExcluding(Matching.FromSource("performance")) .WriteTo.RollingFile(formatter, Path.Combine(".\\logs\\", "log-{Date}.log")) .WriteTo.Console(formatter)) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(Matching.FromSource("performance")) .WriteTo.RollingFile(formatter, Path.Combine(".\\logs\\", "log-perf-{Date}.log")) .WriteTo.Console(formatter)) .CreateLogger(); //Arrange var builder = new WebHostBuilder() .Configure((app) => { var loggerFactory = app.ApplicationServices.GetService <ILoggerFactory>(); loggerFactory.AddSerilog(); app.UseMiddleware <CorrelationIdMiddleware>("X-Correlation-Id"); app.UsePerformanceLog(options => options.Configure().WithFormat("request to {operation} took {duration}ms")); app.UseMiddleware <FakeMiddleware>(TimeSpan.FromMilliseconds(20)); }); var server = new TestServer(builder); //Act var requestMessage = new HttpRequestMessage(new HttpMethod("GET"), "/delay/"); requestMessage.Headers.TryAddWithoutValidation("X-Correlation-Id", "jonas"); var responseMessage = await server.CreateClient().SendAsync(requestMessage); }
private static void CreateLogger() { // Enable the selflog output SelfLog.Enable(Console.Error); Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter.ByExcluding(Matching.FromSource("System")) .WriteTo.Console(theme: SystemConsoleTheme.Literate) .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri(Configuration.GetConnectionString("elasticsearch"))) // for the docker-compose implementation { AutoRegisterTemplate = true, OverwriteTemplate = true, DetectElasticsearchVersion = true, AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv7, NumberOfReplicas = 1, NumberOfShards = 2, FailureCallback = e => Console.WriteLine("Unable to submit event " + e.MessageTemplate), EmitEventFailure = EmitEventFailureHandling.WriteToSelfLog | EmitEventFailureHandling.WriteToFailureSink | EmitEventFailureHandling.RaiseCallback, FailureSink = new FileSink("./fail.txt", new JsonFormatter(), null, null) }) .CreateLogger(); Log.Information("Logger Created!"); }
public static int Main(string[] args) { var ls = new LoggingLevelSwitch(); var isService = Matching.FromSource("LogService.Subscribe"); ls.MinimumLevel = ((LogEventLevel)1 + (int)LogEventLevel.Fatal); Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .Filter.ByIncludingOnly(isService) .WriteTo .File(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs/log.txt"), fileSizeLimitBytes: 1_000_000, rollOnFileSizeLimit: true, shared: true, flushToDiskInterval: TimeSpan.FromSeconds(1)) .CreateLogger(); try { Log.Information("Starting web host"); CreateHostBuilder(args).Build().Run(); return(0); } catch (Exception ex) { Log.Fatal(ex, "Host terminated unexpectedly"); return(1); } finally { Log.CloseAndFlush(); } }
public static int Main(string[] args) { var configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true) .AddEnvironmentVariables() .Build(); Log.Logger = new LoggerConfiguration() .ReadFrom.Configuration(configuration) .Filter.ByExcluding(logEvent => Matching.FromSource <Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware>().Invoke(logEvent)) .CreateLogger(); try { Log.Information("Starting web host..."); CreateHostBuilder(args).Build().Run(); return(0); } catch (Exception ex) { Log.Fatal(ex, "Host terminated unexpectedly."); return(1); } finally { Log.CloseAndFlush(); } }
public static async Task Main(string[] args) { var builder = new HostBuilder() .ConfigureAppConfiguration((hostingContext, config) => { config .SetBasePath(Directory.GetCurrentDirectory()) .AddEnvironmentVariables(); }) .ConfigureServices((hostContext, services) => { services .Configure <ConsoleLifetimeOptions>(o => o.SuppressStatusMessages = true) .AddLogging() .AddQuartz() .AddSingleton <PCloudApi>() .AddSingleton <ZipService>() .AddSingleton <BackupConfig>(hostContext.Configuration.Get <BackupConfig>()) .AddTransient <BackupJob>() .AddHostedService <BackupService>(); }) .UseSerilog((hostingContext, loggerConfiguration) => { loggerConfiguration .MinimumLevel.Information() .Filter.ByExcluding(Matching.FromSource("Quartz")) .WriteTo.Console(outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3} {SourceContext} {Message}{NewLine}{Exception}"); }); await builder.RunConsoleAsync(); }
private ILogger SetupLogging() { const string fileOutputTemplate = "{Timestamp:dd-MM-yyyy HH:mm:ss.fff} [{Level}] {Message:lj}{NewLine}{Exception}"; string basePath = MiscellaneousUtils.GetLogsPath(); var logs = new Dictionary <string, string> { { typeof(NavPageViewModel).Namespace, "vm_.log" }, { $"{typeof(SyncService).FullName}", "sync_service_.log" }, { $"{typeof(TaskListDataService).FullName}", "data_tasklist_service_.log" }, { $"{typeof(TaskDataService).FullName}", "data_task_service_.log" }, { $"{typeof(UserDataService).FullName}", "data_user_service_.log" }, { $"{typeof(MiraiNotesDataService).FullName}", "data_main_service_.log" }, { $"{typeof(SyncBackgroundTask).FullName}", "bg_sync_.log" }, { $"{typeof(MarkAsCompletedBackgroundTask).FullName}", "bg_marktaskascompleted_.log" }, { $"{typeof(AuthenticatedHttpClientHandler).FullName}", "auth_http_handler_.txt" } }; var loggerConfig = new LoggerConfiguration() .MinimumLevel.Verbose(); foreach (var kvp in logs) { loggerConfig.WriteTo.Logger(l => l .Filter.ByIncludingOnly(Matching.FromSource(kvp.Key)) .WriteTo.File( Path.Combine(basePath, kvp.Value), rollingInterval: RollingInterval.Day, rollOnFileSizeLimit: true, outputTemplate: fileOutputTemplate, shared: true)); } Log.Logger = loggerConfig.CreateLogger(); return(Log.Logger); }
private static void Sample1() { Log.Logger = new LoggerConfiguration() .Enrich.With <Enrichment>() .Enrich.WithProperty("UserName", Environment.UserName) .Enrich.WithProperty("Version", Assembly.GetExecutingAssembly().GetName().Version) .WriteTo.Console(outputTemplate: LOG_FORMAT) .Destructure.ByTransforming <Tuple <int, int, int> >(t => new { Good = t.Item1, Bad = t.Item2, Ugly = t.Item3 }) //.WriteTo.ColoredConsole(outputTemplate: LOG_FORMAT) //.WriteTo.Console(outputTemplate: LOG_FORMAT) .WriteTo.File("log-.txt", rollingInterval: RollingInterval.Minute, outputTemplate: LOG_FORMAT) //.Filter.ByIncludingOnly(l => //{ // LogEventPropertyValue val; // if (!l.Properties.TryGetValue("SourceContext", out val)) // return false; // var target = val.ToString(); // target = target.Substring(1, target.Length - 2); // LogEventLevel level; // if (!_enableLog.TryGetValue(target, out level)) // return false; // return l.Level >= level; //}) .Filter.ByIncludingOnly(Matching.FromSource <MyClass>()) .CreateLogger(); var my = new MyClass(); my.Hello(1, "hi"); }
// 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) { Log.Logger = new LoggerConfiguration() .ReadFrom.Configuration(Configuration) .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter.ByExcluding(Matching.FromSource("System")) .Enrich.FromLogContext() .CreateLogger(); loggerFactory.AddSerilog(); if (env.IsDevelopment()) { app.UseBrowserLink(); app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseStaticFiles(); app.UseMiddleware <UserNameEnricher>(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter .ByExcluding(Matching.FromSource("System")) .Enrich.FromLogContext() .MinimumLevel.Information() .WriteTo.File(new CompactJsonFormatter(), "Logs/Neon.homecontrol.log", rollingInterval: RollingInterval.Day) .WriteTo.Console( theme: AnsiConsoleTheme.Literate, outputTemplate: "{Timestamp:HH:mm:ss} [{Level}] [{SourceContext:u3}] {Message}{NewLine}{Exception}") .CreateLogger(); try { CreateWebHostBuilder(args).Build().Run(); //string input = ReadLine.Read("(prompt)> "); //while (input != "exit") //{ // input = ReadLine.Read("(prompt)> "); //} } finally { Log.CloseAndFlush(); } }
private void ConfigureLogger(IConfigManager configManager) { if (_configManager == null) { Log.Logger = new LoggerConfiguration() .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter .ByExcluding(Matching.FromSource("System")) .Enrich.FromLogContext() .MinimumLevel.Debug() .WriteTo.File(new CompactJsonFormatter(), "logs/Argon.log", rollingInterval: RollingInterval.Day) .WriteTo.Console( theme: AnsiConsoleTheme.Code, outputTemplate: "{Timestamp:HH:mm:ss} [{Level}] [{SourceContext:u3}] {Message}{NewLine}{Exception}") .CreateLogger(); } else { var logConfiguration = new LoggerConfiguration() .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter .ByExcluding(Matching.FromSource("System")) .Enrich.FromLogContext(); if (_configManager.Configuration.EngineConfig.Logger.Level == LogLevelEnum.Debug) { logConfiguration = logConfiguration.MinimumLevel.Debug(); } if (_configManager.Configuration.EngineConfig.Logger.Level == LogLevelEnum.Info) { logConfiguration = logConfiguration.MinimumLevel.Information(); } if (_configManager.Configuration.EngineConfig.Logger.Level == LogLevelEnum.Warning) { logConfiguration = logConfiguration.MinimumLevel.Warning(); } if (_configManager.Configuration.EngineConfig.Logger.Level == LogLevelEnum.Error) { logConfiguration = logConfiguration.MinimumLevel.Error(); } if (!string.IsNullOrEmpty(_configManager.Configuration.EngineConfig.Logger.LogDirectory)) { logConfiguration = logConfiguration.WriteTo.File(new CompactJsonFormatter(), _fileSystemManager.BuildFilePath(Path.Combine(_configManager.Configuration.EngineConfig.Logger.LogDirectory, "Argon.log")), rollingInterval: RollingInterval.Day); } logConfiguration = logConfiguration.WriteTo.Console( theme: AnsiConsoleTheme.Code, outputTemplate: "{Timestamp:HH:mm:ss} [{Level}] [{SourceContext:u3}] {Message}{NewLine}{Exception}"); Log.Logger = logConfiguration.CreateLogger(); } }
public Startup(IWebHostEnvironment env) { _basePath = env.ContentRootPath; _env = env; // Set up configuration sources. var builder = new ConfigurationBuilder() .SetBasePath(_basePath) .AddJsonFile("appsettings.json", false, true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddJsonFile("appsettings.override.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables(); Configuration = builder.Build(); Log.Logger = new LoggerConfiguration() .MinimumLevel.Is(env.IsProduction() ? Serilog.Events.LogEventLevel.Error : Serilog.Events.LogEventLevel.Debug) .WriteTo.RollingFile(Path.Combine(_basePath, "Log/log-{Date}.txt")) .WriteTo.Logger(lc => lc.Filter.ByIncludingOnly(le => Matching.FromSource <BackgroundJobService>()(le) || Matching.FromSource <JobTaskRunner>()(le) || Matching.FromSource <ElasticSearchUpdateService>()(le)) .WriteTo.RollingFile(Path.Combine(_basePath, "Log/job-{Date}.txt"))) .CreateLogger(); if (!env.IsProduction()) { Log.Logger.Error("Non production build!"); } _dataDbConnectionString = Configuration.GetConnectionString("GmGardData").Replace("|DataDirectory|", Path.Combine(_basePath, "App_Data")); _userDbConnectionString = Configuration.GetConnectionString("GmGardUser").Replace("|DataDirectory|", Path.Combine(_basePath, "App_Data")); }
static Task Main(string[] args) { // Setup Serilog Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.Logger(lc => { lc.Filter.ByExcluding(Matching.FromSource("Quartz")); lc.WriteTo.Console( outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] ({SourceContext}) {Message:lj}{NewLine}{Exception}"); }) .WriteTo.Logger(lc => { lc.WriteTo.File(path: "centcom-parser-server.txt", outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] ({SourceContext}) {Message:lj}{NewLine}{Exception}"); }) .CreateLogger(); Log.Logger.ForContext <Program>() .Information($"Starting CentCom Server v{Assembly.GetExecutingAssembly().GetName().Version}"); return(CreateHostBuilder(args).RunConsoleAsync()); }
public static IWebHost BuildWebHost(string[] args) { return(new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .ConfigureAppConfiguration((hostBuilder, config) => { config .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables(); }) .UseStartup <Startup>() .UseSerilog((hostingContext, loggerConfiguration) => { var connectionString = hostingContext.Configuration["App:elasticSearch:ConnectionString"]; var port = hostingContext.Configuration["App:elasticSearch:Port"]; var uri = new Uri($"http://{connectionString}:{port}"); loggerConfiguration .ReadFrom.Configuration(hostingContext.Configuration) .WriteTo.Async( a => a.Elasticsearch( new ElasticsearchSinkOptions(uri) { AutoRegisterTemplate = true, AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv6 }).Filter.ByExcluding(Matching.FromSource("Microsoft"))) .WriteTo.Async(a => a.Console()); }) .Build()); }
public Kernel BuildKernel(bool overwrite = false, string overrideNetworkFile = null) { _overwrite = overwrite; _configCopier.RunConfigStartUp(_targetConfigFolder, NetworkType.Devnet, null, _overwrite, overrideNetworkFile); var config = _configurationBuilder.Build(); var configurationModule = new ConfigurationModule(config); ContainerBuilder.RegisterInstance(config); ContainerBuilder.RegisterModule(configurationModule); if (!string.IsNullOrEmpty(_withPersistence)) { var repoFactory = RepositoryFactory.BuildSharpRepositoryConfiguation(config.GetSection(_withPersistence)); ContainerBuilder.RegisterSharpRepository(repoFactory); } Logger = new LoggerConfiguration() .ReadFrom .Configuration(configurationModule.Configuration).WriteTo .File(Path.Combine(_targetConfigFolder, _fileName), rollingInterval: RollingInterval.Day, outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u3}] ({MachineName}/{ThreadId}) {Message} ({SourceContext}){NewLine}{Exception}") .Filter.ByExcluding(Matching.FromSource("Microsoft")) .Filter.ByExcluding(Matching.FromSource("LibP2P")) .CreateLogger() .ForContext(MethodBase.GetCurrentMethod().DeclaringType); ContainerBuilder.RegisterLogger(Logger); Log.Logger = Logger; return(this); }
public static void Main(string[] args) { Log.Logger = new LoggerConfiguration() // .MinimumLevel.Information() //.MinimumLevel.Override("Microsoft", LogEventLevel.Information) // Filter out ASP.NET Core infrastructre logs that are Information and below // .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Information) .Enrich.FromLogContext() .Filter.ByExcluding(c => c.Properties.Any(p => p.Value.ToString().Contains("swagger"))) .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Hosting.Internal.WebHost")) .WriteTo.Console() .WriteTo.File(new CompactJsonFormatter(), "Logs/Logs/logs.json", rollingInterval: RollingInterval.Day) .CreateLogger(); // Wrap creating and running the host in a try-catch block try { Log.Information("Starting host"); CreateHostBuilder(args).Build().Run(); // return 0; } catch (Exception ex) { Log.Fatal(ex, "Host terminated unexpectedly"); // return 1; } finally { Log.CloseAndFlush(); } }
public static void Main(string[] args) { var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); var config = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: false) .AddJsonFile("appsettings.local.json", optional: true) .AddJsonFile($"appsettings.{environmentName}.json", optional: true) .AddJsonFile($"appsettings.{environmentName}.local.json", optional: true) .Build(); var logConfig = new LoggerConfiguration() .MinimumLevel.Debug() .Filter.ByIncludingOnly(e => e.Level >= LogEventLevel.Information || Matching.FromSource("TodoAndWorkLog")(e)) .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Literate) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(e => e.Level >= LogEventLevel.Warning || Matching.FromSource("EventServer")(e)) .WriteTo.File(new CompactJsonFormatter(), @"Logs\.clef", rollingInterval: RollingInterval.Day, shared: true)); Log.Logger = logConfig.CreateLogger(); try { CreateHostBuilder(args).Build().Run(); } catch (Exception ex) { Log.Fatal(ex, "Host terminated unexpectedly"); } finally { Log.CloseAndFlush(); } }
public static IWebHostBuilder CreateWebHostBuilder(string[] args) => Microsoft.AspNetCore.WebHost.CreateDefaultBuilder(args) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); logging.AddDebug(); logging.AddSerilog(new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.RollingFile("Logs/identity-{Date}.log") .Filter.ByIncludingOnly(Matching.FromSource("IdentityServer4")) .CreateLogger()); }) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); logging.AddDebug(); logging.AddSerilog(new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.RollingFile("Logs/host-{Date}.log") .Filter.ByIncludingOnly(Matching.FromSource("MAA.ActionTracking.STS")) .CreateLogger()); }) .UseStartup <Startup>();
protected void Application_Start() { Log.Logger = new Serilog.LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.Trace(new Serilog.Formatting.Json.JsonFormatter()) .WriteTo.File(new Serilog.Formatting.Json.JsonFormatter(), "c:\\logs\\log.json") .WriteTo.Logger(cfg => cfg .Filter.ByIncludingOnly(Matching.FromSource <ILogModule>()) .Enrich.With <RequeUriEnricher>() .WriteTo.Elasticsearch(new Serilog.Sinks.Elasticsearch.ElasticsearchSinkOptions(new Uri("http://localhost:9200/")) { AutoRegisterTemplate = true, IndexFormat = "logstash3-{0:yyyy.MM.dd}", InlineFields = true, OverwriteTemplate = true, TypeName = "logevent2" }) ) .CreateLogger(); AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); }
public static void AddSerilog(IConfiguration configuration) { var elasticUri = configuration["ElasticConfiguration:Uri"]; var elasticUsername = configuration["ElasticConfiguration:Username"]; var elasticPassword = configuration["ElasticConfiguration:Password"]; var elasticIndex = configuration["ElasticConfiguration:Index"]; Log.Logger = new LoggerConfiguration() .Enrich.WithProperty("ApplicationName", $"API Exemplo - {Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}") .Enrich.FromLogContext() .Enrich.WithMachineName() .Enrich.WithEnvironmentUserName() .Enrich.WithDemystifiedStackTraces() .WriteTo.Debug() .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.StaticFiles")) .Filter.ByExcluding(z => z.MessageTemplate.Text.Contains("erro de negócio")) .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri(elasticUri)) { MinimumLogEventLevel = LogEventLevel.Warning, AutoRegisterTemplate = true, ModifyConnectionSettings = x => x.BasicAuthentication(elasticUsername, elasticPassword), IndexFormat = $"{elasticIndex}-{{0:yyyy.MM.dd}}", FailureCallback = e => FailureCallbackEvent(e), EmitEventFailure = EmitEventFailureHandling.WriteToFailureSink | EmitEventFailureHandling.RaiseCallback | EmitEventFailureHandling.ThrowException, FailureSink = new LoggerConfiguration().WriteTo.File($"./failures.log", rollingInterval: RollingInterval.Day).CreateLogger() }) .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj} {Properties:j}{NewLine}{Exception}") .CreateLogger(); }
public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddEnvironmentVariables(); //if (env.IsDevelopment()) //{ // builder.AddUserSecrets<Startup>(); //} Configuration = builder.Build(); Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.LiterateConsole() .WriteTo.Logger(l => l .Filter.ByIncludingOnly(Matching.FromSource("Microsoft.EntityFrameworkCore")) .WriteTo.RollingFile("logs\\EF-{Date}.log")) .WriteTo.RollingFile("logs\\{Date}.log", restrictedToMinimumLevel: LogEventLevel.Warning) .CreateLogger(); }
public static LoggerConfiguration FilterExcludeLevelsFromCategory(this LoggerConfiguration lc, string category, Func <LogEvent, bool> include, params LogEventLevel[] excludeLevels) { return(lc.Filter.ByExcluding( e => excludeLevels.Contains(e.Level) && Matching.FromSource(category).Invoke(e))); }
public static LoggerConfiguration GetClassLoggerConfiguration <T>(LoggerConfiguration logger) { return(logger .WriteTo.Logger(l => l .Filter.ByIncludingOnly(Matching.FromSource <T>()) .WriteTo.RollingFile("./Logs/" + typeof(T).Name + "-{Date}.txt") )); }
private static Logger SetupSerilog(IConfiguration configuration) { var builder = new LoggerConfiguration() .ReadFrom.Configuration(configuration) .Enrich.FromLogContext(); // Build DEBUG logger if (EnvironmentName == "Development") { builder.WriteTo.Debug(); } builder // Build INSTALL logger .WriteTo.Conditional(Matching.FromSource("Install"), a => a.Async(logger => { logger.File("App_Data/Logs/install-.log", //restrictedToMinimumLevel: LogEventLevel.Debug, outputTemplate: "{Timestamp:G} [{Level:u3}] {Message:lj}{NewLine}{Exception}", fileSizeLimitBytes: 100000000, rollOnFileSizeLimit: true, shared: true, rollingInterval: RollingInterval.Day, flushToDiskInterval: TimeSpan.FromSeconds(5)); })) // Build FILE logger (also replaces the Smartstore classic "TraceLogger") .WriteTo.Logger(logger => { logger .Enrich.FromLogContext() // Allow only "File[/{path}]" sources .Filter.ByIncludingOnly(IsFileSource) // Extracts path from source and adds it as log event property name. .Enrich.With <LogFilePathEnricher>() .WriteTo.Map(LogFilePathEnricher.LogFilePathPropertyName, (logFilePath, wt) => { wt.Async(c => c.File($"{logFilePath}", //restrictedToMinimumLevel: LogEventLevel.Debug, outputTemplate: "{Timestamp:G} [{Level:u3}] {Message:lj} {RequestPath} (UserId: {CustomerId}, Username: {UserName}){NewLine}{Exception}", fileSizeLimitBytes: 100000000, rollOnFileSizeLimit: true, shared: true, rollingInterval: RollingInterval.Day, flushToDiskInterval: TimeSpan.FromSeconds(5))); }, sinkMapCountLimit: 10); }) // Build "SmartDbContext" logger .WriteTo.Logger(logger => { logger .Enrich.FromLogContext() // Do not allow system/3rdParty noise less than WRN level .Filter.ByIncludingOnly(IsDbSource) .WriteTo.DbContext(period: TimeSpan.FromSeconds(5), batchSize: 50, eagerlyEmitFirstEvent: false, queueLimit: 1000); }, restrictedToMinimumLevel: LogEventLevel.Information, levelSwitch: null); return(builder.CreateLogger()); }
private static WebApplication BuildWebApplication( Application application, string[] args, ILogEventSink?sink) { var builder = WebApplication.CreateBuilder(args); // Logging for this application builder.Host.UseSerilog((context, configuration) => { configuration .MinimumLevel.Verbose() .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore")) .Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions")) .Filter.ByExcluding(Matching.FromSource("Microsoft.Hosting")) .Enrich .FromLogContext() .WriteTo .Console(); if (sink is object) { configuration.WriteTo.Sink(sink, LogEventLevel.Verbose); } }); builder.Services.AddRazorPages(o => o.RootDirectory = "/Dashboard/Pages"); builder.Services.AddServerSideBlazor(); builder.Services.AddOptions <StaticFileOptions>() .PostConfigure(o => { var fileProvider = new ManifestEmbeddedFileProvider(typeof(TyeHost).Assembly, "wwwroot"); // Make sure we don't remove the existing file providers (blazor needs this) o.FileProvider = new CompositeFileProvider(o.FileProvider, fileProvider); }); builder.Services.AddCors( options => { options.AddPolicy( "default", policy => { policy .AllowAnyOrigin() .AllowAnyHeader() .AllowAnyMethod(); }); }); builder.Services.AddSingleton(application); var app = builder.Build(); return(app); }
public void ConfigureSerilog() { Log.Logger = new LoggerConfiguration() // IMPORTANT, clears all the extra logging messages that microsoft forces into the app: .Filter.ByExcluding(Matching.FromSource("Microsoft")) .WriteTo.Console() .MinimumLevel.Information() .CreateLogger(); }