TelemetryConfiguration.Active is deprecated

[mikegoatly]

Context: I've been working to upgrade some applications to .NET Core 3.0 - this has led me to update a number of packages as well, including App Insights.

Previously the recommendation was to configure AppInsights and Serilog together using the IHostBuilder in Program.cs, e.g.:

return builder
    .UseApplicationInsights()
    .UseSerilog((context, configuration) =>
{
    var telemetry = TelemetryConfiguration.Active;

    configuration
        .ReadFrom.Configuration(context.Configuration)
        .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
        .Enrich.FromLogContext()
        .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Literate)
        .WriteTo.ApplicationInsights(telemetry, new TraceTelemetryConverter());
},
writeToProviders: true);

But after upgrading to the latest AppInsights, I'm starting to get the warnings (as errors):

'ApplicationInsightsWebHostBuilderExtensions.UseApplicationInsights(IWebHostBuilder)' is obsolete: 'This method is deprecated in favor of AddApplicationInsightsTelemetry() extension method on IServiceCollection.'

and

'TelemetryConfiguration.Active' is obsolete: 'We do not recommend using TelemetryConfiguration.Active on .NET Core. See https://github.com/microsoft/ApplicationInsights-dotnet/issues/1152 for more details'

The first can be overcome by configuring App Insights during ConfigureServices, but I'm left a bit stumped as to how to configure Serilog without TelemetryConfiguration.Active - is there a recommended way to do this?

Apologies if I've missed something in the documentation - I couldn't spot anything relevant to this.

[cmeeren]

Yes, this is puzzling. Logging is set up in UseSerilog, but the logging setup depends on a telemetry configuration that isn't set up before ConfigureServices (in the call to AddApplicationInsightsTelemetry).

Any insights are most welcome.

Related: serilog/serilog-aspnetcore#84

[cmeeren]

Cross-posting potential workaround from serilog/serilog-aspnetcore#84 (comment):

After checking library sources and experimenting for many hours today, here is a workaround I have arrived at which seems to work. Let me know if I'm shooting myself in the foot.

In doing this I have sacrificed logging early startup errors (in main or Startup.ConfigureServices up to and including where I configure the logger), but I am successfully logging "late" startup errors (e.g. in the Startup.Configure method) to Application Insights, and everything else seems to work as normal after (very) cursory testing.

Program.fs

[<EntryPoint>]
let main args =
  WebHost
    .CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)
    .UseSerilog(dispose = true)
    .UseStartup<Startup>()
    .Build()
    .Run()
  0

Startup.fs

type Startup() =

  member __.ConfigureServices(services: IServiceCollection) : unit =
    services.AddApplicationInsightsTelemetry() |> ignore
    let sp = services.BuildServiceProvider()
    let telemetryConfig = sp.GetRequiredService<TelemetryConfiguration>()

    Log.Logger <-
      LoggerConfiguration()
        .WriteTo.ApplicationInsights(telemetryConfig, TelemetryConverter.Traces)
        .CreateLogger()

    services.AddSingleton<ILogger>(Log.Logger) |> ignore

[Lybecker]

@cmatskas it works for me 👍

[crgolden]

I changed it like this and it seems to be working for me:

var log = new LoggerConfiguration()
    .WriteTo
	.ApplicationInsights(TelemetryConfiguration.CreateDefault(), TelemetryConverter.Events)
    .CreateLogger();

[cmeeren]

@crgolden AFAIK that will only work if you don't otherwise configure the telemetry configuration through DI (in ConfigureServices). Once you start adding telemetry processors and initializers, or changing other telemetry settings, those changes will not apply to the configuration you create directly in WriteTo.ApplicationInsights (or configurations you create directly any other places for that matter).

In my AspNetCore 3.0 web app, I got this working with the recommended way of setting up logging in Program.cs with the following code:

private static IHostBuilder CreateHostBuilder(string[] args) =>
	Host.CreateDefaultBuilder(args)
		.ConfigureWebHostDefaults(webBuilder =>
		{
			webBuilder
				.ConfigureLogging((hostingContext, logging) => logging.ClearProviders())
				.UseSerilog((hostingContext, loggerConfiguration) =>
				{
					var telemetryConfiguration = TelemetryConfiguration.CreateDefault();
					telemetryConfiguration.InstrumentationKey = hostingContext.Configuration["ApplicationInsights:InstrumentationKey"];

					loggerConfiguration
						.MinimumLevel.Information()
						.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
						.MinimumLevel.Override("System", LogEventLevel.Warning)
#if DEBUG
						.MinimumLevel.Verbose()
						.WriteTo.Console()
						.WriteTo.Debug()
#endif
						.Enrich.FromLogContext()
						.Enrich.WithMachineName()
						.WriteTo.ApplicationInsights(telemetryConfiguration, TelemetryConverter.Traces);
				})
				.UseStartup<Startup>();
		});

In addition to the code above, I also have the normal services.AddApplicationInsightsTelemetry() in Startup/ConfigureServices and the "default" appsetting:

  "ApplicationInsights": {
    "InstrumentationKey": "mykey"
  },

However, I don't have a ApplicationInsights.config at all. I suspect that file won't be read with this code.

[cmeeren]

@MathiasRonnblom-Cint I think my comment above applies to your solution, as well. Since you instantiate a new TelemetryConfiguration and pass it to WriteTo.ApplicationInsights, you won't get telemetry initializers/processors (configured in ConfigureServices) added to the one passed to WriteTo.ApplicationInsights.

[JasonTheProgrammer]

@cmeeren

Startup.fs

type Startup() =

  member __.ConfigureServices(services: IServiceCollection) : unit =
    services.AddApplicationInsightsTelemetry() |> ignore
    let sp = services.BuildServiceProvider()
    let telemetryConfig = sp.GetRequiredService<TelemetryConfiguration>()

    Log.Logger <-
      LoggerConfiguration()
        .WriteTo.ApplicationInsights(telemetryConfig, TelemetryConverter.Traces)
        .CreateLogger()

    services.AddSingleton<ILogger>(Log.Logger) |> ignore

I'd be a little wary of using BuildServiceProvider(). When the Startup class is constructed by the framework, there will already be a service provider built. If you built another one, it will not have the same lifetime scope, which could be problematic for singletons (which I think you'll find, is how TelemetryConfiguration is registered).

Instead, as I posted over in issue 84, I'd recommend using the constructor of Startup to request an instance of TelemetryConfiguration. serilog/serilog-aspnetcore#84 (comment)

Also, I agree with your feedback above about people creating new instances of TelemetryConfiguration. It will "work" at a superficial level, but you won't be sharing around the same instance, which would cause unexpected outcomes if you do any further configuration on the instance.

[cwoolum]

I got this working in AspNet Core 3.0 and I believe it avoids the pitfalls of the previous solutions. I had to replace UseSerilog with my own registration to access the built IServiceProvider.

return Host.CreateDefaultBuilder(args)
                .ConfigureAppConfiguration((context, config) =>
                {
                    // Add Key Vault or whatever
                })
                .ConfigureLogging((context, logging) =>
                {
                    logging.ClearProviders();
                })
                .ConfigureServices((HostBuilderContext context, IServiceCollection services) =>
                {
                    // Explicitly use the configuration previously built above
                    services.AddApplicationInsightsTelemetry(context.Configuration);
                    // Add enrichers and processors
                    services.AddApplicationInsightsKubernetesEnricher();
                    services.AddApplicationInsightsTelemetryProcessor<HealthCheckTelemetryFilter>();
                    
                    services.AddSingleton<ILoggerFactory>(provider =>
                    {
                        TelemetryConfiguration telemetryConfiguration = provider.GetRequiredService<TelemetryConfiguration>();
                        var loggerConfiguration = new LoggerConfiguration();

                        loggerConfiguration.ReadFrom.Configuration(context.Configuration)
                           .Enrich.WithExceptionDetails()
                           .Enrich.FromLogContext()
                           .WriteTo.Console()
                           .WriteTo.ApplicationInsights(telemetryConfiguration, TelemetryConverter.Traces);

                        Serilog.Core.Logger logger = loggerConfiguration.CreateLogger();
                       
                        Log.Logger = logger;

                        var factory = new SerilogLoggerFactory(logger, true);

                        return factory;
                    });
                })
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<T>();
                });

[cmeeren]

By removing UseSerilog you miss out on additional work done by that method (directly or through internal helper functions). In your case, that seems to be limited to registering the IDiagnosticsContext:

https://github.com/serilog/serilog-aspnetcore/blob/71165692d5f66c811c3b251047b12c259ac2fe23/src/Serilog.AspNetCore/SerilogWebHostBuilderExtensions.cs#L149-L156

If additional arguments were supplied to the initial UseSerilog call, even more functionality must be duplicated, starting to destroy the purpose of having a library in the first place.

[cwoolum]

Yeah, I do register those manually for my own app but left them out of the example code above.

[MattMinke]

So far the conversation has focused on asp.net core applications but this also needs to be solved for non-http context applications and console applications. for console applications I think something like this should work but have yet to figure out why it is not. Any feed back on how to make this work or improve this is appreciated

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WorkerService;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.Extensions.DependencyInjection;
using PowerArgs;
using Serilog;
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WorkerService;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Serilog.Events;
using Serilog.Exceptions;
using Serilog.Extensions.Logging;
using System.Collections.Generic;
using System.Text;

namespace YourApplication
{

    class Program
    {

        static int Main(string[] args)
        {
            using (var source = new CancellationTokenSource())
            {
                Console.CancelKeyPress += (sender, e) =>
                {
                    source.Cancel();
                };


                return MainAsync( source.Token)
                    .GetAwaiter()
                    .GetResult();
            }
        }

        private static async Task<int> MainAsync(CancellationToken cancellationToken)
        {
            ServiceProvider serviceProvider = null;
            TelemetryClient telemetryClient = null;
            try
            {
                serviceProvider = Bootstrapper.ConfigureServices()
                        .BuildServiceProvider();

                telemetryClient = serviceProvider.GetRequiredService<TelemetryClient>();


                var httpClient = new HttpClient();
                var logger = serviceProvider.GetService<ILogger>();
                var i = 0;
                while (i < 10) // This app runs indefinitely. replace with actual application termination logic.
                {
                    logger.Information("Worker running at: {time}", DateTimeOffset.Now);

                    // Replace with a name which makes sense for this operation.
                    using (telemetryClient.StartOperation<RequestTelemetry>("operation"))
                    {
                        logger.Warning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                        logger.Information("Calling bing.com");
                        var res = await httpClient.GetAsync("https://bing.com");
                        logger.Information("Calling bing completed with status:" + res.StatusCode);
                        logger.Fatal("Fatal action");
                        telemetryClient.TrackEvent("Bing call event completed");
                    }

                    await Task.Delay(1000);
                    i++;
                }
                return 0;
            }
            catch (Exception e)
            {
                ILogger logger = null;
                try
                {
                    if (serviceProvider != null)
                    {
                        logger = serviceProvider.GetService<ILogger>();
                    }
                }
                catch { }

                if (logger != null)
                {
                    logger.Error(e, "An error has occurred");
                }
                else
                {
                    Console.Error.WriteLine("An error has occurred" + e.ToString());
                }
                return -500;
            }
            finally
            {
                Log.CloseAndFlush();


                // This is to ensure that even if application terminates, telemetry is sent to the back-end.
                if (telemetryClient != null)
                {
                    telemetryClient.Flush();
                    await Task.Delay(5000);
                }

                if (serviceProvider != null)
                {
                    serviceProvider.Dispose();
                }
            }
        }
    }


    public static class Bootstrapper
    {
        private const string InstrumentationKeyFromConfig = "ApplicationInsights:InstrumentationKey";

        public static ServiceCollection ConfigureServices()
        {
            var config = BuildConfiguration();
            var services = new ServiceCollection();
            services.AddSingleton(provider => config);
            // https://docs.microsoft.com/en-us/azure/azure-monitor/app/worker-service
            services.AddApplicationInsightsTelemetryWorkerService(config[InstrumentationKeyFromConfig]);
            services.ConfigureLogging();
            return services;
        }

        private static IConfiguration BuildConfiguration() => new ConfigurationBuilder()
                .AddJsonFile("config/ai.json", false, true)
                .Build();

        private static void ConfigureLogging(this IServiceCollection services)
        {
            services.AddSingleton<Serilog.ILogger>(provider =>
            {
                var configuration = provider.GetRequiredService<IConfiguration>();
                var telemetryConfiguration = provider.GetRequiredService<TelemetryConfiguration>();

                var logger = new LoggerConfiguration()
                    .ReadFrom.Configuration(configuration)
                    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                    .MinimumLevel.Override("System", LogEventLevel.Warning)

                    .Enrich.FromLogContext()
                    .Enrich.WithMachineName()
                    .Enrich.WithExceptionDetails()
                    .WriteTo.Console()
                    .WriteTo.ApplicationInsights(telemetryConfiguration, TelemetryConverter.Traces)
                    .CreateLogger();

                Log.Logger = logger;
                return Log.Logger;
            });

            services.AddSingleton<ILoggerFactory>(provider =>
            {
                var logger = provider.GetRequiredService<Serilog.ILogger>();
                return new SerilogLoggerFactory(logger, true);
            });
        }
    }
}

[naishx]

I have the the same problem i can't figure out, how set this up properly (for asp net core and console).