private static Microsoft.Extensions.Logging.ILogger GetLogger()
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.Providers(providers)
.CreateLogger();
var services = new ServiceCollection();
services.AddSingleton(providers);
services.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
services.AddLogging(l => l.AddConsole());
var serviceProvider = services.BuildServiceProvider();
var logger = serviceProvider.GetRequiredService <Microsoft.Extensions.Logging.ILogger <Program> >();
return(logger);
}
//This method makes a service provider which contains all the dependencies of the runner
public IServiceProvider Build()
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.MongoDB(Environment.GetEnvironmentVariable("MP_CONNECTIONSTRING") + "/" + Environment.GetEnvironmentVariable("MP_DATABASE"),
collectionName: Environment.GetEnvironmentVariable("MP_LOGCOLLECTION"))
.WriteTo.Providers(providers)
.CreateLogger();
var container = new ServiceCollection();
container.AddSingleton <IApp, App>();
container.AddSingleton <IMessageBroker, RabbitBroker>();
container.AddSingleton <IMessageBrokerConfig, RabbitMQConfig>();
container.AddSingleton <IDockerService, DockerService>();
container.AddSingleton(providers);
container.AddSingleton <ILoggerFactory>(sc => {
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
container.AddLogging();
return(container.BuildServiceProvider());
}
public static IHostBuilder UseSerilog(
this IHostBuilder builder,
Action <HostBuilderContext, LoggerConfiguration> configureLogger,
bool preserveStaticLogger = false,
bool writeToProviders = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureLogger == null)
{
throw new ArgumentNullException(nameof(configureLogger));
}
builder.ConfigureServices((context, collection) =>
{
var loggerConfiguration = new LoggerConfiguration();
LoggerProviderCollection loggerProviders = null;
if (writeToProviders)
{
loggerProviders = new LoggerProviderCollection();
loggerConfiguration.WriteTo.Providers(loggerProviders);
}
configureLogger(context, loggerConfiguration);
var logger = loggerConfiguration.CreateLogger();
Serilog.ILogger registeredLogger = null;
if (preserveStaticLogger)
{
registeredLogger = logger;
}
else
{
// Passing a `null` logger to `SerilogLoggerFactory` results in disposal via
// `Log.CloseAndFlush()`, which additionally replaces the static logger with a no-op.
Log.Logger = logger;
}
collection.AddSingleton <ILoggerFactory>(services =>
{
var factory = new SerilogLoggerFactory(registeredLogger, true, loggerProviders);
if (writeToProviders)
{
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
}
return(factory);
});
ConfigureServices(collection, logger);
});
return(builder);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(Configuration).CreateLogger();
ConfigureCors(services);
ConfigureSwagger(services);
services.AddSingleton(providers);
services.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
services.AddControllers();
ConfigureDatabase(services);
ConfigureCustomServices(services);
}
public static IServiceCollection AddDefaultSerilog(this IServiceCollection serviceDescriptors, WebApiConfig apiConfig = null, Action <LoggerConfiguration> configureLogger = null, bool preserveStaticLogger = false, bool writeToProviders = true)
{
var loggerConfiguration = new LoggerConfiguration();
LoggerProviderCollection loggerProviders = null;
if (writeToProviders)
{
loggerProviders = new LoggerProviderCollection();
loggerConfiguration.WriteTo.Providers(loggerProviders);
}
apiConfig = apiConfig ?? new WebApiConfig();
configFromWebApiConfig(loggerConfiguration, apiConfig);
configureLogger?.Invoke(loggerConfiguration);
var logger = loggerConfiguration.CreateLogger();
Serilog.ILogger registeredLogger = null;
if (preserveStaticLogger)
{
registeredLogger = logger;
}
else
{
Log.Logger = logger;
}
// 去除内置的LoggerProvider
var removeProviders = serviceDescriptors.Where(x => x.ServiceType == typeof(ILoggerProvider)).ToList();
removeProviders.ForEach(p =>
{
serviceDescriptors.Remove(p);
});
serviceDescriptors.AddSingleton <ILoggerFactory>(services =>
{
var factory = new SerilogLoggerFactory(registeredLogger, true, loggerProviders);
if (writeToProviders)
{
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
}
return(factory);
});
// 日志定时清理托管服务
serviceDescriptors.AddHostedService <ClearLogsHostService>();
return(serviceDescriptors);
}
public HomeController(
ILogger <HomeController> logger,
IDiagnosticContext diagnosticContext,
LoggerProviderCollection loggerProviderCollection)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
DiagnosticContext = diagnosticContext ?? throw new ArgumentNullException(nameof(diagnosticContext));
LoggerProviderCollection = loggerProviderCollection ?? throw new ArgumentNullException(nameof(loggerProviderCollection));
}
public ViewResult Index([FromQuery] string name = "SinjulMSBH")
{
Logger.LogInformation("Hello, {Name} .. !!!!", name);
DiagnosticContext.Set("IndexCallCount", Interlocked.Increment(ref _callCount));
IEnumerable <ILoggerProvider> providers = new LoggerProviderCollection().Providers;
return(View());
}
public ViewResult Index([FromQuery] string name = "SinjulMSBH")
{
Logger.LogInformation("Hello, {Name} .. !!!!", name);
DiagnosticContext.Set("IndexCallCount", Interlocked.Increment(ref _callCount));
IEnumerable <ILoggerProvider> providers = new LoggerProviderCollection().Providers;
Log.ForContext <ShoppingCartService>().Information("Adding {ItemId} x {Quantity} to cart", itemId, quantity);
return(View());
}
/// <summary>
/// Write Serilog events to the providers in <paramref name="providers"/>.
/// </summary>
/// <param name="configuration">The `WriteTo` object.</param>
/// <param name="providers">A <see cref="LoggerProviderCollection"/> to write events to.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param>
/// <param name="levelSwitch">A switch allowing the pass-through minimum level
/// to be changed at runtime.</param>
/// <returns>A <see cref="LoggerConfiguration"/> to allow method chaining.</returns>
public static LoggerConfiguration Providers(
this LoggerSinkConfiguration configuration,
LoggerProviderCollection providers,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
LoggingLevelSwitch levelSwitch = null)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (providers == null)
{
throw new ArgumentNullException(nameof(providers));
}
return(configuration.Sink(new LoggerProviderCollectionSink(providers), restrictedToMinimumLevel, levelSwitch));
}
public static void Main(string[] args)
{
var providers = new LoggerProviderCollection();
var seriConfig = new LoggerConfiguration()
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("System", LogEventLevel.Error)
.MinimumLevel.Override("Serilog.Ext.Logging.Bug._174.Controllers.WeatherForecastController", LogEventLevel.Verbose)
.Enrich.FromLogContext()
;
seriConfig.WriteTo.Console(
restrictedToMinimumLevel: LevelConvert.ToSerilogLevel(LogLevel.Information),
standardErrorFromLevel: LogEventLevel.Error);
Log.Logger = seriConfig.CreateLogger();
System.Diagnostics.Activity.DefaultIdFormat = System.Diagnostics.ActivityIdFormat.W3C;
CreateHostBuilder(args).Build().Run();
}
private static void Main(string[] args)
{
var providers = new LoggerProviderCollection();
var logTemplate = "[{Level:u}] {Message}{NewLine}{Exception}";
Log.Logger = new LoggerConfiguration()
.WriteTo.File("Hades_General.txt")
.WriteTo.File("Hades_Exceptions.txt", Serilog.Events.LogEventLevel.Error)
.WriteTo.File("Hades_CrashLogs.txt", Serilog.Events.LogEventLevel.Fatal)
.WriteTo.Console(Serilog.Events.LogEventLevel.Verbose, outputTemplate: logTemplate)
.CreateLogger();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("LoruleConfig.json");
var config = builder.Build();
var constants = config.GetSection("ServerConfig").Get <ServerConstants>();
var serviceProvider = new ServiceCollection()
.AddOptions()
.AddSingleton(providers)
.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
})
.AddLogging(l => l.AddConsole())
.Configure <LoruleOptions>(config.GetSection("Content"))
.AddSingleton <IServerConstants, ServerConstants>(_ => constants)
.AddSingleton <IServerContext, ServerContext>()
.AddSingleton <IObjectManager, ObjectManager>()
.AddSingleton <IServer, Server>()
.BuildServiceProvider();
serviceProvider.GetService <IServer>();
Thread.CurrentThread.Join();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureLogging(log =>
{
var providers = new LoggerProviderCollection();
var loggerConfig = new LoggerConfiguration()
.WriteTo.Providers(providers)
.WriteTo.Console()
.WriteTo.File(new JsonFormatter(), "log/log.json")
.CreateLogger();
log.ClearProviders(); // agar provider default tidak di ikut sertakan
log.AddSerilog(loggerConfig);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
});
private static void Main()
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration()
.WriteTo.File(new CompactJsonFormatter(), "lorule_logs.txt")
.WriteTo.Console()
.CreateLogger();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("ServerConfig.Local.json");
var config = builder.Build();
var constants = config.GetSection("ServerConfig").Get <ServerConstants>();
var serviceProvider = new ServiceCollection()
.AddOptions()
.AddSingleton(providers)
.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
})
.AddLogging(l => l.AddConsole())
.Configure <LoruleOptions>(config.GetSection("Content"))
.AddSingleton <IServerConstants, ServerConstants>(_ => constants)
.AddSingleton <IServerContext, ServerContext>()
.AddSingleton <IObjectManager, ObjectManager>()
.AddSingleton <IServer, Server>()
.BuildServiceProvider();
serviceProvider.GetService <IServer>();
Thread.CurrentThread.Join();
}
public static IServiceCollection ConfigureLogger(this IServiceCollection services, IConfiguration configuration)
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(configuration).CreateLogger();
services.AddSingleton(providers);
services.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
return(services);
}
/// <summary>
/// Helper de configuração de logs da applicação
/// </summary>
/// <param name="services"><see cref="IServiceCollection"/> contendo os serviços da aplicação</param>
private static void ConfigureLogger(this IServiceCollection services)
{
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.Providers(providers)
.CreateLogger();
services.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
}
private static (IHostBuilder, Initialization) CreateHostBuilder(string[] args)
{
Initialization initializer = new Initialization();
IHostBuilder builder = Host.CreateDefaultBuilder(args);
builder.ConfigureServices((env, services) =>
{
Initialization.Configure(services);
services.AddSingleton <LoggerProviderCollection>();
Log.Logger = Initialization.Logging(env.HostingEnvironment.ContentRootPath);
services.AddSingleton <ILoggerFactory>(sp =>
{
LoggerProviderCollection loggerProviderCollection = sp.GetRequiredService <LoggerProviderCollection>();
SerilogLoggerFactory serilogLoggerFactory = new SerilogLoggerFactory(dispose: true, providerCollection: loggerProviderCollection);
foreach (var provider in sp.GetServices <ILoggerProvider>())
{
serilogLoggerFactory.AddProvider(provider);
}
return(serilogLoggerFactory);
});
});
return(builder, initializer);
}
/// <summary>
/// Sets Serilog as the logging provider.
/// Copied from https://github.com/serilog/serilog-aspnetcore/blob/dev/src/Serilog.AspNetCore/SerilogWebHostBuilderExtensions.cs
/// </summary>
/// <param name="builder">The web host builder to configure.</param>
/// <param name="logger">The Serilog logger; if not supplied, the static <see cref="Serilog.Log"/> will be used.</param>
/// <param name="dispose">When true, dispose <paramref name="logger"/> when the framework disposes the provider. If the
/// logger is not specified but <paramref name="dispose"/> is true, the <see cref="Log.CloseAndFlush()"/> method will be
/// called on the static <see cref="Log"/> class instead.</param>
/// <param name="providers">A <see cref="LoggerProviderCollection"/> registered in the Serilog pipeline using the
/// <c>WriteTo.Providers()</c> configuration method, enabling other <see cref="ILoggerProvider"/>s to receive events. By
/// default, only Serilog sinks will receive events.</param>
/// <returns>The host builder.</returns>
public static IHostBuilder UseSerilog(
this IHostBuilder builder,
Serilog.ILogger logger = null,
bool dispose = false,
LoggerProviderCollection providers = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.ConfigureServices(collection =>
{
if (providers != null)
{
collection.AddSingleton <ILoggerFactory>(services =>
{
var factory = new SerilogLoggerFactory(logger, dispose, providers);
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
}
else
{
collection.AddSingleton <ILoggerFactory>(services => new SerilogLoggerFactory(logger, dispose));
}
ConfigureServices(collection, logger);
});
return(builder);
}
/// <inheritdoc />
public void Register(IConventionContext context, IConfiguration configuration, IServiceCollection services)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// removes default console loggers and such
foreach (var item in services
.Where(
x => x.ImplementationType?.FullName?.StartsWith("Microsoft.Extensions.Logging", StringComparison.Ordinal) == true &&
x.ImplementationType?.FullName?.EndsWith("Provider", StringComparison.Ordinal) == true
)
.ToArray()
)
{
services.Remove(item);
}
LoggerProviderCollection?loggerProviders = null;
if (_options.WriteToProviders)
{
#pragma warning disable CA2000
loggerProviders = new LoggerProviderCollection();
#pragma warning restore CA2000
}
services.AddSingleton <ILoggerFactory>(
_ =>
{
var log = _.GetRequiredService <ILogger>();
ILogger?registeredLogger = null;
if (_options.PreserveStaticLogger)
{
registeredLogger = log;
}
else
{
// Passing a `null` logger to `SerilogLoggerFactory` results in disposal via
// `Log.CloseAndFlush()`, which additionally replaces the static logger with a no-op.
Log.Logger = log;
}
var factory = new SerilogLoggerFactory(registeredLogger, true, loggerProviders);
if (_options.WriteToProviders)
{
foreach (var provider in _.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
}
return(factory);
}
);
if (context.Get <ILogger>() is { } logger)
{
services.AddSingleton(logger);
}
// *******************************************************************
// Public methods.
// *******************************************************************
#region Public methods
/// <summary>
/// This method adds standard serilog based logging strategies to the
/// logging service.
/// </summary>
/// <param name="serviceCollection">The service collection to use for
/// the operation.</param>
/// <param name="serviceLifetime">The service lifetime to use for the operation.</param>
/// <param name="configuration">The configuration to use for the operation.</param>
/// <returns>The value of the <paramref name="serviceCollection"/>
/// parameter, for chaining calls together.</returns>
public static IServiceCollection AddSerilogLoggingStrategies(
this IServiceCollection serviceCollection,
IConfiguration configuration,
ServiceLifetime serviceLifetime = ServiceLifetime.Scoped
)
{
// Validate the parameters before attempting to use them.
Guard.Instance().ThrowIfNull(serviceCollection, nameof(serviceCollection))
.ThrowIfNull(configuration, nameof(configuration));
// Get the application's friendly name.
var friendlyName = AppDomain.CurrentDomain.FriendlyNameEx(true);
// Create a logger configuration, for Serilog.
var loggerConfiguration = new LoggerConfiguration();
// Are we already pointed at the Serilog section?
if (configuration.GetPath().EndsWith("Serilog"))
{
// If we get here then we have to back up a level because the
// Serilog method we'll use, to read the configuration section
// from, wants to move down, internally, into a 'Serilog' section,
// before it reads the configuration values.
// Get the parent section.
configuration = configuration.GetParentSection();
}
// How should we setup Serilog?
if (configuration.GetChildren().Any())
{
// If we get here then we can setup Serilog logging services using
// whatever happens to be in the configuration section.
// Setup serilog from the configuration.
loggerConfiguration.ReadFrom.Configuration(
configuration
);
}
else
{
// If we get here then nothing was configured in the standard
// location for a Serilog logging service. So, we'll make some
// assumptions here and try to come up with a decent "default"
// configuration.
// Setup serilog with defaults.
loggerConfiguration
.Enrich.WithExceptionDetails()
.Enrich.FromLogContext()
.WriteTo.Console(theme: AnsiConsoleTheme.Code)
.WriteTo.File(
formatter: new RenderedCompactJsonFormatter(),
path: $"{friendlyName}-.log",
rollingInterval: RollingInterval.Day,
rollOnFileSizeLimit: true
);
}
// Either way, we want to add these enrichers.
loggerConfiguration.Enrich.WithProperty("ApplicationName", friendlyName);
loggerConfiguration.Enrich.WithProperty("MachineName", Environment.MachineName);
#if DEBUG
loggerConfiguration.Enrich.WithProperty("DebuggerAttached", Debugger.IsAttached);
#endif
// Register the logger configuration.
serviceCollection.AddSingleton(loggerConfiguration);
// Register a logger factory.
serviceCollection.AddSingleton <ILoggerFactory>(services =>
{
// Get the logger configuration.
var loggerConfiguration = services.GetRequiredService <LoggerConfiguration>();
// Write our configuration out as providers.
var providerCollection = new LoggerProviderCollection();
loggerConfiguration.WriteTo.Providers(
providerCollection
);
// Create the logger factory.
var factory = new SerilogLoggerFactory(
null,
true,
providerCollection
);
// Return the logger factory.
return(factory);
});
// Create the static Serilog logger instance.
Log.Logger = loggerConfiguration.CreateLogger();
// Register the logger instance.
serviceCollection.AddSingleton(Log.Logger);
// Return the service collection.
return(serviceCollection);
}
/// <summary>Sets Serilog as the logging provider.</summary>
/// <remarks>
/// A <see cref="HostBuilderContext"/> is supplied so that configuration and hosting information can be used.
/// The logger will be shut down when application services are disposed.
/// </remarks>
/// <param name="builder">The host builder to configure.</param>
/// <param name="configureLogger">The delegate for configuring the <see cref="Serilog.LoggerConfiguration" /> that will be used to construct a <see cref="Serilog.Core.Logger" />.</param>
/// <param name="preserveStaticLogger">Indicates whether to preserve the value of <see cref="Serilog.Log.Logger"/>.</param>
/// <param name="writeToProviders">By default, Serilog does not write events to <see cref="ILoggerProvider"/>s registered through
/// the Microsoft.Extensions.Logging API. Normally, equivalent Serilog sinks are used in place of providers. Specify
/// <c>true</c> to write events to all providers.</param>
/// <returns>The host builder.</returns>
public static IHostBuilder UseSerilog(
this IHostBuilder builder,
Action <HostBuilderContext, IServiceProvider, LoggerConfiguration> configureLogger,
bool preserveStaticLogger = false,
bool writeToProviders = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureLogger == null)
{
throw new ArgumentNullException(nameof(configureLogger));
}
builder.ConfigureServices((context, collection) =>
{
LoggerProviderCollection loggerProviders = null;
if (writeToProviders)
{
loggerProviders = new LoggerProviderCollection();
}
collection.AddSingleton(services =>
{
var loggerConfiguration = new LoggerConfiguration();
if (loggerProviders != null)
{
loggerConfiguration.WriteTo.Providers(loggerProviders);
}
configureLogger(context, services, loggerConfiguration);
var logger = loggerConfiguration.CreateLogger();
return(new RegisteredLogger(logger));
});
collection.AddSingleton(services =>
{
// How can we register the logger, here, but not have MEDI dispose it?
// Using the `NullEnricher` hack to prevent disposal.
var logger = services.GetRequiredService <RegisteredLogger>().Logger;
return(logger.ForContext(new NullEnricher()));
});
collection.AddSingleton <ILoggerFactory>(services =>
{
var logger = services.GetRequiredService <RegisteredLogger>().Logger;
ILogger registeredLogger = null;
if (preserveStaticLogger)
{
registeredLogger = logger;
}
else
{
// Passing a `null` logger to `SerilogLoggerFactory` results in disposal via
// `Log.CloseAndFlush()`, which additionally replaces the static logger with a no-op.
Log.Logger = logger;
}
var factory = new SerilogLoggerFactory(registeredLogger, true, loggerProviders);
if (writeToProviders)
{
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
}
return(factory);
});
// Null is passed here because we've already (lazily) registered `ILogger`
ConfigureServices(collection, null);
});
return(builder);
}
public static void Main(string[] args)
{
// Creating a `LoggerProviderCollection` lets Serilog optionally write
// events through other dynamically-added MEL ILoggerProviders.
var providers = new LoggerProviderCollection();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.Providers(providers)
.CreateLogger();
var services = new ServiceCollection();
services.AddSingleton(providers);
services.AddSingleton <ILoggerFactory>(sc =>
{
var providerCollection = sc.GetService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(null, true, providerCollection);
foreach (var provider in sc.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
services.AddLogging(l => l.AddConsole());
var serviceProvider = services.BuildServiceProvider();
var logger = serviceProvider.GetRequiredService <ILogger <Program> >();
var startTime = DateTimeOffset.UtcNow;
logger.LogInformation(1, "Started at {StartTime} and 0x{Hello:X} is hex of 42", startTime, 42);
try
{
throw new Exception("Boom!");
}
catch (Exception ex)
{
logger.LogCritical("Unexpected critical error starting application", ex);
logger.Log(LogLevel.Critical, 0, "Unexpected critical error", ex, null);
// This write should not log anything
logger.Log <object>(LogLevel.Critical, 0, null, null, null);
logger.LogError("Unexpected error", ex);
logger.LogWarning("Unexpected warning", ex);
}
using (logger.BeginScope("Main"))
{
logger.LogInformation("Waiting for user input");
var key = Console.Read();
logger.LogInformation("User pressed {@KeyInfo}", new { Key = key, KeyChar = (char)key });
}
var endTime = DateTimeOffset.UtcNow;
logger.LogInformation(2, "Stopping at {StopTime}", endTime);
logger.LogInformation("Stopping");
logger.LogInformation(Environment.NewLine);
logger.LogInformation("{Result,-10:l}{StartTime,15:l}{EndTime,15:l}{Duration,15:l}", "RESULT", "START TIME", "END TIME", "DURATION(ms)");
logger.LogInformation("{Result,-10:l}{StartTime,15:l}{EndTime,15:l}{Duration,15:l}", "------", "----- ----", "--- ----", "------------");
logger.LogInformation("{Result,-10:l}{StartTime,15:mm:s tt}{EndTime,15:mm:s tt}{Duration,15}", "SUCCESS", startTime, endTime, (endTime - startTime).TotalMilliseconds);
serviceProvider.Dispose();
}
public static IHostBuilder UseSerilog(this IHostBuilder builder, ILogger logger = null, bool dispose = false, LoggerProviderCollection providers = null)
{
return(SerilogHostBuilderExtensions.UseSerilog(builder, logger, dispose, providers));
}
/// <summary>Sets Serilog as the logging provider.</summary>
/// <remarks>
/// A <see cref="HostBuilderContext"/> is supplied so that configuration and hosting information can be used.
/// The logger will be shut down when application services are disposed.
/// </remarks>
/// <param name="builder">The host builder to configure.</param>
/// <param name="configureLogger">The delegate for configuring the <see cref="Serilog.LoggerConfiguration" /> that will be used to construct a <see cref="Serilog.Core.Logger" />.</param>
/// <param name="preserveStaticLogger">Indicates whether to preserve the value of <see cref="Serilog.Log.Logger"/>.</param>
/// <param name="writeToProviders">By default, Serilog does not write events to <see cref="ILoggerProvider"/>s registered through
/// the Microsoft.Extensions.Logging API. Normally, equivalent Serilog sinks are used in place of providers. Specify
/// <c>true</c> to write events to all providers.</param>
/// <remarks>If the static <see cref="Log.Logger"/> is a bootstrap logger (see
/// <c>LoggerConfigurationExtensions.CreateBootstrapLogger()</c>), and <paramref name="preserveStaticLogger"/> is
/// not specified, the the bootstrap logger will be reconfigured through the supplied delegate, rather than being
/// replaced entirely or ignored.</remarks>
/// <returns>The host builder.</returns>
public static IHostBuilder UseSerilog(
this IHostBuilder builder,
Action <HostBuilderContext, IServiceProvider, LoggerConfiguration> configureLogger,
bool preserveStaticLogger = false,
bool writeToProviders = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureLogger == null)
{
throw new ArgumentNullException(nameof(configureLogger));
}
// This check is eager; replacing the bootstrap logger after calling this method is not supported.
#if !NO_RELOADABLE_LOGGER
var reloadable = Log.Logger as ReloadableLogger;
var useReload = reloadable != null && !preserveStaticLogger;
#else
const bool useReload = false;
#endif
builder.ConfigureServices((context, collection) =>
{
LoggerProviderCollection loggerProviders = null;
if (writeToProviders)
{
loggerProviders = new LoggerProviderCollection();
}
collection.AddSingleton(services =>
{
ILogger logger;
#if !NO_RELOADABLE_LOGGER
if (useReload)
{
reloadable !.Reload(cfg =>
{
if (loggerProviders != null)
{
cfg.WriteTo.Providers(loggerProviders);
}
configureLogger(context, services, cfg);
return(cfg);
});
logger = reloadable.Freeze();
}
else
#endif
{
var loggerConfiguration = new LoggerConfiguration();
if (loggerProviders != null)
{
loggerConfiguration.WriteTo.Providers(loggerProviders);
}
configureLogger(context, services, loggerConfiguration);
logger = loggerConfiguration.CreateLogger();
}
return(new RegisteredLogger(logger));
});
collection.AddSingleton(services =>
{
// How can we register the logger, here, but not have MEDI dispose it?
// Using the `NullEnricher` hack to prevent disposal.
var logger = services.GetRequiredService <RegisteredLogger>().Logger;
return(logger.ForContext(new NullEnricher()));
});
collection.AddSingleton <ILoggerFactory>(services =>
{
var logger = services.GetRequiredService <RegisteredLogger>().Logger;
ILogger registeredLogger = null;
if (preserveStaticLogger)
{
registeredLogger = logger;
}
else
{
// Passing a `null` logger to `SerilogLoggerFactory` results in disposal via
// `Log.CloseAndFlush()`, which additionally replaces the static logger with a no-op.
Log.Logger = logger;
}
var factory = new SerilogLoggerFactory(registeredLogger, !useReload, loggerProviders);
if (writeToProviders)
{
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
}
return(factory);
});
// Null is passed here because we've already (lazily) registered `ILogger`
ConfigureServices(collection, null);
});
return(builder);
}
