static async Task <int> MainAsync(string[] args)
{
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Information()
.MinimumLevel.Override("System", LogEventLevel.Information)
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.WriteTo.Console()
.CreateLogger();
try
{
await CreateHostBuilder(args).Build().RunAsync().ConfigureAwait(false);
return(0);
}
catch (Exception ex)
{
Log.Logger.Fatal(ex, "Failed application");
return(1);
}
finally
{
Log.CloseAndFlush();
}
}
public Task OnExitAsync()
{
IsExiting = true;
Log.CloseAndFlush();
Container.Dispose();
return(Task.FromResult(true));
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
SerilogLog.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(LevelSwitch)
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
try
{
CreateWebHostBuilder(args)
.Build()
.Run();
SerilogLog.Information("Start the web host!");
}
catch (System.Exception exp)
{
SerilogLog.Fatal(exp, "Host terminated unexpectedly");
}
finally
{
SerilogLog.Information("Ending the web host!");
SerilogLog.CloseAndFlush();
}
}
public static int Main(string[] args)
{
SLog.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
try
{
SLog.Information("Starting web host");
CreateHostBuilder(args).Build().Run();
return(0);
}
catch (Exception ex)
{
SLog.Fatal(ex, "Host terminated unexpectedly");
return(1);
}
finally
{
SLog.CloseAndFlush();
}
}
public Task OnExitAsync()
{
IsExiting = true;
Log.CloseAndFlush();
FinalizeDatabaseTransaction();
Container.Dispose();
return(Task.FromResult(true));
}
static void Main(string[] args)
{
var clusterConfiguration = new EphemeralClusterConfiguration("7.9.0");
using var cluster = new EphemeralCluster(clusterConfiguration);
cluster.Start(TimeSpan.FromMinutes(2));
var uri = cluster.NodesUris().First();
var nestIndex = "logs-from-nest";
Announce("NEST + Elastic.CommonSchema", nestIndex);
var settings = new ConnectionSettings(uri).EnableDebugMode();
var client = new ElasticClient(settings);
var bulkAll = client.BulkAll(GetEcsEvents(10_000), b => b
.Index(nestIndex)
.Size(1_000)
.RefreshOnCompleted()
.BufferToBulk((bulk, items) => bulk.CreateMany(items))
);
bulkAll.Wait(TimeSpan.FromMinutes(2), r => Console.WriteLine("Indexed 1000 events"));
Check(client, nestIndex);
// Using Serilog ElasticsearchSink
var sinkIndex = "logs-from-sink";
Announce("Elastic.CommonSchema.Serilog", sinkIndex);
var options = new ElasticsearchSinkOptions(uri)
{
CustomFormatter = new EcsTextFormatter(),
IndexFormat = sinkIndex + "-{0:yyyy-MM-dd}",
DetectElasticsearchVersion = true,
BatchAction = ElasticOpType.Create,
BatchPostingLimit = 1_000,
};
var logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Elasticsearch(options)
.CreateLogger();
Log.Logger = logger;
foreach (var e in GetEcsEvents(10_000))
{
Log.Debug("Reusing {field1} by {another_field}: {message}", "some value", true, e.Message);
}
Log.CloseAndFlush();
Check(client, $"{sinkIndex}-*");
}
public async static Task Main(string[] args)
{
SerilogLog.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(LevelSwitch)
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.File(
"logs/log.txt",
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
rollingInterval: RollingInterval.Day,
retainedFileCountLimit: 7,
rollOnFileSizeLimit: true,
shared: true)
.CreateLogger();
try
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
context.Database.Migrate();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception exp)
{
SerilogLog.Error(exp, "An error occurred while migrating or seeding the database.");
}
}
await host.RunAsync();
}
catch (System.Exception exp)
{
SerilogLog.Fatal(exp, "Host terminated unexpectedly");
}
finally
{
SerilogLog.Information("Ending the web host!");
SerilogLog.CloseAndFlush();
}
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(BuildConfiguration())
.CreateLogger();
try
{
Log.Logger.Information("Getting started...");
CreateWebHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Logger.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
public static void Main(string[] args)
{
Log.Logger = LogConfigurationExtensions.GetLogger();
try
{
Domain.Log.Information("Starting up");
Domain.Log.Information($"Currently running on {OsInfo.CurrentOS}");
var host = Host.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureWebHostDefaults(webHostBuilder =>
{
webHostBuilder
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>();
})
.ConfigureLogging(config =>
{
config.ClearProviders();
config.AddFilter(DbLoggerCategory.Database.Command.Name, LogLevel.Warning);
})
.UseSerilog()
.Build();
host.Run();
}
catch (Exception e)
{
Domain.Log.Fatal(e);
}
finally
{
// Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux)
Log.CloseAndFlush();
}
}
public void Flush()
{
SeriLog.CloseAndFlush();
}