Question about core 2

[danjohnso]

So with Core 2 moving the logging configuration into Program.cs, what is the correct way to read in the configuration for setting logger?

The sample here shows just reading from appsettings.json, but the main reason I use the configuration file is so I can vary my config by environment using the environment files. Seems like the configuration is not yet available for logging to read it in or am I missing something obvious?

[merbla]

@danjohnso not entirely the same thing however there is some related discussion and info over at the following links.

• .NET Core 2.0 minimum level handling/roadmap serilog-extensions-logging#98 (comment)
• UseSerilog() goodness serilog-extensions-logging#101

[hexawyz]

@danjohnso You should be able to access the configuration from the WebHostBuilderContext in the ConfigureLogging method.

Here's an example of what you could do in your Program.Main() method to get this working:

var host = new WebHostBuilder()
    .UseKestrel()
    .UseContentRoot(Directory.GetCurrentDirectory())
    .ConfigureAppConfiguration
    (
        (hostingContext, configurationBuilder) =>
        {
            configurationBuilder.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true)
                .AddEnvironmentVariables();
        }
    )
    .ConfigureLogging
    (
        (hostingContext, loggingBuilder) =>
            loggingBuilder.AddSerilog
            (
                new LoggerConfiguration()
                    .ReadFrom.ConfigurationSection(hostingContext.Configuration.GetSection("Serilog"))
                    .CreateLogger()
            )
    )
    .UseIISIntegration()
    .UseStartup<Startup>()
    .Build();

@nblumhardt Do you know if there is already an example of this kind of setup somewhere?

[nblumhardt]

@GoldenCrystal @danjohnso does this one help?

https://github.com/serilog/serilog-aspnetcore/blob/dev/samples/SimpleWebSample/Program.cs#L13

There are some notes on the new package here: https://github.com/serilog/serilog-aspnetcore - keen to know your impressions.

Cheers!

[hexawyz]

There are slight differences in what you propose with this new package, even though it is certainly a welcome simplification.

Reading the ASPNETCORE_ENVIRONMENT environment variable seems a bit clumsy to me because we lose the default value of Production provided by ASP.NET Core.

But more importantly, as I found out, there is a subtle difference between UseConfiguration and ConfigureAppConfiguration:

UseConfiguration only copies the configuration settings to the WebHost's internal IConfiguration, instead of directly using the specified IConfiguration instance.
(This can be seen here: https://github.com/aspnet/Hosting/blob/master/src/Microsoft.AspNetCore.Hosting.Abstractions/HostingAbstractionsWebHostBuilderExtensions.cs#L22)
This means that configuration settings are used earlier during WebHost construction (they can override things such as hosting URLs), but also that auto-reloading of configuration settings will not work when using UseConfiguration on IWebHostBuilder.
This may not really matter for Serilog, but may very well matter for the application itself.

I'd rather have an extension method like this one, in addition to the proposed UseSerilog method:

/// <summary>Sets Serilog as the logging provider.</summary>
/// <param name="builder">The web host builder to configure.</param>
/// <param name="configureSerilog">The delegate for configuring the <see cref="LoggerConfiguration" /> that will be used to construct a <see cref="Logger" />.</param>
/// <returns>The web host builder.</returns>
public static IWebHostBuilder UseSerilog(this IWebHostBuilder builder, Action<WebHostBuilderContext, LoggerConfiguration> configureSerilog)
{
    if (builder == null) throw new ArgumentNullException(nameof(builder));
    if (configureSerilog == null) throw new ArgumentNullException(nameof(configureSerilog));
    builder.ConfigureServices
    (
        (context, collection) =>
        {
            var loggerConfiguration = new LoggerConfiguration();
            configureSerilog(context, loggerConfiguration);
            collection.AddSingleton<ILoggerFactory>(new SerilogLoggerFactory(loggerConfiguration.CreateLogger(), true));
        }
    );
    return builder;
}

I think this blends more nicely with the out-of-the-box patterns used for building the web hosts:

public class Program
{
    public static void Main()
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .ConfigureAppConfiguration // NB: Application configuration is not used by the web host itself. UseConfiguration() should still be used for modifying WebHostBuilder's own configuration.
            (
                (hostingContext, configurationBuilder) =>
                {
                    configurationBuilder
                        .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                        .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true)
                        .AddEnvironmentVariables();
                }
            )
            .UseSerilog((hostingContext, loggerConfiguration) => loggerConfiguration.ReadFrom.Configuration(hostingContext.Configuration))
            .UseIISIntegration()
            .UseStartup<Startup>()
            .Build();

        host.Run();
    }
}

@nblumhardt Would you be okay with providing such a method ?

[danjohnso]

@nblumhardt perfect! @GoldenCrystal biggest problem with that pattern is you lose the ability to log the setup of the WebHostbuilder. I was having issues with a reserved configuration key causing .Build() to fail, never would have seen it without being able to log around the WebHost initialization. The whole point of the logging changes in 2.0 into Program.cs was to be able to log right away at application start.

[nblumhardt]

That's great, thanks @danjohnso @GoldenCrystal . Reopening to continue the discussion of @GoldenCrystal's points.

I've added the "Production" fallback to the sample, but its still more a basic illustration than complete solution.

The WebHostBuilder config copying is a bit of a quandary - follows the theme of many other chicken/egg problems in the loading of logging/config/DI :-(

I'd personally still use the current very explicit approach, but everyone prefers different trade-offs. Would you be open to sending a pull request on the https://github.com/serilog/serilog-aspnetcore repository with it?

[hexawyz]

Yeah, discovering that the configuration was merely copied was a disappointment for me, but since UseConfiguration is documented as setting the configuration for the web host, I guess that was somehow expected.
I will send you a pull request with full example included as soon as I can.

[nblumhardt]

Thanks, that would be awesome 👍

[GraemeF]

If anyone else is looking for a workaround, we have been using this:

   public static class SerilogExtensions
    {
        public static IWebHostBuilder UseSerilogWithApplicationConfiguration(
            this IWebHostBuilder builder,
            string[] args)
        {
            return builder.UseSerilog(new LoggerConfiguration()
                                      .ReadFrom.Configuration(LoadConfigurationFromDefaultWebHostBuilder(args))
                                      .CreateLogger());
        }

        private static IConfiguration LoadConfigurationFromDefaultWebHostBuilder(string[] args)
        {
            using (var tempWebHost = WebHost.CreateDefaultBuilder<StartupToCaptureDefaultConfiguration>(args).Build())
                return tempWebHost.Services.GetRequiredService<IConfiguration>();
        }

        private class StartupToCaptureDefaultConfiguration
        {
            public void Configure(IApplicationBuilder app)
            {
            }
        }
    }

Another set of tradeoffs - this one being that we use another DefaultWebHostBuilder just to load the config first. So it's loaded twice, but we've reused the behaviour of DefaultWebHostBuilder rather than copied it. Reloading will still work as the "live" configuration is unaffected (although I doubt logging config changes would take effect!).

Given that, our Program class is simply:

    public static class Program
    {
        public static void Main(string[] args)
        {
            WebHost.CreateDefaultBuilder(args)
                   .UseStartup<Startup>()
                   .UseSerilogWithApplicationConfiguration(args)
                   .Build()
                   .Run();
        }
    }