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