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);
}
public static IServiceCollection AddCustomizedLogging(this IServiceCollection sc)
{
var sp = sc.BuildServiceProvider();
var httpAccessor = sp.GetRequiredService <IHttpContextAccessor>();
var correlationAccessor = sp.GetRequiredService <ICorrelationContextAccessor>();
var configuration = sp.GetRequiredService <IOptions <EnvironmentConfiguration> >();
var logLevelStr = configuration.Value.LOG_LEVEL;
var logLevel = Enum.TryParse(logLevelStr, out LogEventLevel level) ? level : LogEventLevel.Information;
var formatter = new JsonLogFormatter();
var conf = new LoggerConfiguration()
.Enrich.FromLogContext()
.Enrich.With(new HttpEnricher(httpAccessor, correlationAccessor))
.MinimumLevel.ControlledBy(new LoggingLevelSwitch(logLevel))
.MinimumLevel.Override("CorrelationId", LogEventLevel.Error);
conf.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}");
// Add additional sinks (Azure, logentries, etc) here
var serilog = conf.CreateLogger();
Microsoft.Extensions.Logging.ILoggerFactory msLoggerFactory = new SerilogLoggerFactory(serilog);
msLoggerFactory.AddProvider(new SerilogLoggerProvider(serilog));
sc.AddSingleton <ILogger>(serilog);
sc.AddSingleton(msLoggerFactory).AddSingleton(msLoggerFactory.CreateLogger("PROJECT_NAME"));
return(sc);
}
//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());
}
// 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);
}
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);
}
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);
}
/// <inheritdoc />
public void Register([NotNull] IServiceConventionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.Services.AddSingleton <ILoggerFactory>(
_ =>
{
if (_options.WriteToProviders)
{
var providerCollection = _.GetRequiredService <LoggerProviderCollection>();
var factory = new SerilogLoggerFactory(_.GetRequiredService <global::Serilog.ILogger>(), true, providerCollection);
foreach (var provider in _.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
}
return(new SerilogLoggerFactory(_.GetRequiredService <global::Serilog.ILogger>(), true));
}
);
context.Services.AddHostedService <SerilogFinalizerHostedService>();
var loggerConfiguration = context.GetOrAdd(() => new LoggerConfiguration());
if (_options.WriteToProviders)
{
var loggerProviderCollection = context.GetOrAdd(() => new LoggerProviderCollection());
context.Services.AddSingleton(loggerProviderCollection);
loggerConfiguration.WriteTo.Providers(loggerProviderCollection);
}
var serilogBuilder = new SerilogBuilder(
_scanner,
context.AssemblyProvider,
context.AssemblyCandidateFinder,
context.Environment,
context.Configuration,
loggerConfiguration,
_diagnosticSource,
context.Properties
);
var logger = serilogBuilder.Build();
if (!_options.PreserveStaticLogger)
{
Log.Logger = logger;
}
context.Services.AddSingleton(logger);
}
static async Task Main(string[] args)
{
var services = new ServiceCollection();
services.AddDbContextPool <BlogContext>(o =>
{
o.UseSqlServer("Data Source=HOME-PC\\SQLEXPRESS;Initial Catalog=BlogDb;User ID=sa;Password=123456;Pooling=False");
o.UseLazyLoadingProxies();
});
services.AddScoped <DbContext, BlogContext>();
services.AddTransient(typeof(IRepository <>), typeof(ReadOnlyRepository <>));
services.AddTransient(typeof(IMutable <>), typeof(MutableRepository <>));
services.AddLogging();
Log.Logger = new LoggerConfiguration()
.WriteTo.ColoredConsole()
.MinimumLevel.Information()
.CreateLogger();
services.AddSingleton <ILoggerFactory>(services =>
{
var factory = new SerilogLoggerFactory(null, false, null);
foreach (var provider in services.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
var serviceProvider = services.BuildServiceProvider();
var blogRepository = serviceProvider.GetRequiredService <IRepository <Blog> >();
var blog = await blogRepository.FindAsync(1);
var blogA = await blogRepository
.ExcecuteQueryAsync(b => b
.Where(t => t.UserId == 2)
.Select(b => new
{
b.CreationDate,
b.Title,
b.Posts
}).FirstOrDefault());
Log.CloseAndFlush();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var builder = new ConfigurationBuilder()
.SetBasePath(Environment.CurrentDirectory)
.AddJsonFile("LoruleConfig.json");
var config = builder.Build();
var constants = config.GetSection("ServerConfig").Get <ServerConstants>();
var editorSettings = config.GetSection("Editor").Get <EditorOptions>();
using var serviceProvider = new ServiceCollection()
.Configure <LoruleOptions>(config.GetSection("Content"))
.AddOptions()
.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);
})
.AddSingleton(_ => editorSettings)
.AddSingleton <LoadingIndicatorView>()
.AddSingleton <IServerConstants, ServerConstants>(_ => constants)
.AddSingleton <IServerContext, ServerContext>()
.AddSingleton <IObjectManager, ObjectManager>()
.AddSingleton <IArchive, Archive>(_ => new Archive(editorSettings.Location))
.AddSingleton <IPaletteCollection, PaletteCollection>()
.AddScoped <Content.Editor.Editor>()
.AddScoped <AreaBuilderView>()
.BuildServiceProvider();
var frm = serviceProvider.GetService <Content.Editor.Editor>();
if (frm != null)
{
Application.Run(frm);
}
}
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();
}
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();
}
private void RegisterLogging()
{
var logger = new LoggerConfiguration()
.ReadFrom.Configuration(Configuration)
.Enrich.WithExceptionDetails()
.CreateLogger();
ServiceCollection.AddSingleton <ILoggerFactory>(serviceProvider =>
{
var factory = new SerilogLoggerFactory(logger, true);
foreach (ILoggerProvider provider in serviceProvider.GetServices <ILoggerProvider>())
{
factory.AddProvider(provider);
}
return(factory);
});
ServiceCollection.AddLogging(builder => builder.AddSerilog(logger, true));
}
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);
}
//This method creates a hostBuilder that contains all the dependencies for the Scheduler.
static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((_, services) => {
services.AddSingleton <IDBAccess, DBAccess>();
services.AddSingleton <IDBConfig, DBConfig>();
services.AddSingleton <IMessageBroker, RabbitBroker>();
services.AddSingleton <IMessageBrokerConfig, RabbitMQConfig>();
services.AddHostedService <Scheduler>();
services.AddSingleton(new LoggerProviderCollection());
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();
});
/// <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);
}
/// <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();
}
/// <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);
}
