La journalisation de .NET Core 2.0 est-elle cassée ?

Question

Je ne parviens pas à obtenir la sortie des informations du journal du niveau Trace après la mise à niveau vers .NET Core 2.0 (+ASP.NET Core 2.0).

En fait, si je fais un dotnet new web et ajoutez le code ci-dessous dans Startup pour Configure, je n'obtiens aucun message de trace ou de débogage, mais je reçois deux fois les messages Information et Erreur. En commentant le code .AddConsole() ne les affichera (Information et Erreur) qu'une seule fois - ce qui suggère qu'il est configuré automatiquement avec un fournisseur de console par défaut. Gardez à l'esprit qu'il s'agit d'une expérience de projet " Fichier -> Nouveau ", il n'y a rien de configuré dans la section Program.cs pour la journalisation ou la configuration du tout pour ceci - sauf pour ce que j'ai ajouté. Quelqu'un a vu des choses ? Ou devrais-je enregistrer un problème GitHub à ce sujet ?

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Microsoft.Extensions.Logging.LogLevel.Trace);

    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.Run(async (context) =>
    {
        var logger = loggerFactory.CreateLogger("Blah");
        logger.LogTrace("Hello world : Trace");
        logger.LogDebug("Hello world : Debug");
        logger.LogInformation("Hello world : Information");
        logger.LogError("Hello world : Error");

        await context.Response.WriteAsync("Hello World!");
    });
}

Answer 1

La façon dont la journalisation est configurée a un peu changé... La méthode recommandée (et assez bien documentée dans le document ce problème/annonce GitHub pour le faire maintenant est de configurer les enregistreurs sur le AddLogging comme

services.AddLogging(builder =>
{
    builder.AddConfiguration(Configuration.GetSection("Logging"))
        .AddConsole()
        .AddDebug();
});

Et avoir un appsettings.json comme

Avis

Il semble que quelques personnes soient confuses, car l'exemple ne montre que la configuration de l'option Console et pas tous les enregistreurs.

Le site LogLevel configure le niveau de journalisation pour tous les espaces de noms ( Default ) ou pour un espace de nom spécifique ( System Remplace la valeur par défaut pour toutes les classes d'enregistrement dont l'espace de nom commence par System.* .

Il s'agit de la classe utilisée dans T en ILogger<T> ). Cela permet de définir un niveau de journalisation supérieur ou inférieur à celui par défaut pour les enregistreurs de cet espace de nom.

{
  "ApplicationInsights": {
    "InstrumentationKey": ""
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Information",
      "System": "Warning",
      "Microsoft": "Information"
    },
    "Console": {
      "LogLevel": {
        "Default": "Warning",
        "System": "Information",
        "Microsoft": "Information"
      }
    }
  }
}

Veuillez noter que la structure du fichier appsettings.json a été modifiée par rapport à ce qu'elle était dans la version 1.x de .NET Core. Logging l'entrée dans la appsettings.json contient désormais les noms des fournisseurs de journaux, ce qui vous permet de configurer les niveaux de journalisation par fournisseur de journaux.

Auparavant, l'entrée dans appsettings.json ne serait applicable qu'au logger de la console.

Il est également possible de déplacer l'enregistrement à l'intérieur de l'espace de travail. WebHostBuilder à la place.

public static void Main()
{
    var host = new WebHostBuilder()
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
            var env = hostingContext.HostingEnvironment;

            config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddJsonFile("hosting.json", optional: false)
                .AddEnvironmentVariables();
        })
        .ConfigureLogging((webhostContext, builder) => {
            builder.AddConfiguration(webhostContext.Configuration.GetSection("Logging"))
            .AddConsole()
            .AddDebug();
        })
        .UseIISIntegration()
        .UseStartup<Startup>()
        .UseApplicationInsights()
        .Build();

    host.Run();
}

Mise à jour

Dans le cas où l'on ne veut pas utiliser l'option appsettings.json On peut aussi enregistrer les filtres dans le code.

services.AddLogging(builder =>
{
    builder.AddConfiguration(Configuration.GetSection("Logging"))
        // filter for all providers
        .AddFilter("System", LogLevel.Debug)
        // Only for Debug logger, using the provider type or it's alias
        .AddFilter("Debug", "System", LogLevel.Information)
        // Only for Console logger by provider type
        .AddFilter<DebugLoggerProvider>("System", LogLevel.Error)
        .AddConsole()
        .AddDebug();
});

Answer 2

J'ai passé presque vingt minutes à réaliser que depuis Configuration.GetSection("Logging") en el Startup.cs lit la section "Logging" à partir de la configuration dans le appsettings.json qui a été configuré comme "Error" . Le changer en "Information" ou quelque chose de plus bas, a résolu le problème.

Voici ce que le appsettinsg.json Le fichier se présente maintenant :

{
  "Logging": {
    "IncludeScopes": true,
    "Debug": {
      "LogLevel": {
        "Default": "Information"
      }
    },
    "Console": {
      "LogLevel": {
        "Default": "Information"
      }
    }
  }
}

Pour en savoir plus sur les niveaux de journalisation (comme dans "Information" ), consultez este qui fournit également des informations générales sur la journalisation d'ASP.NET Core.

Je me contente de poster ici, juste au cas où vous auriez des difficultés à faire fonctionner la journalisation, assurez-vous d'avoir parcouru ce fichier JSON.

Answer 3

Rien de ce qui précède ne fonctionne pour moi Le seul moyen de contourner ce problème était d'écrire une méthode

private void ConfigLogging( ILoggingBuilder builder ) {
    builder.SetMinimumLevel( LogLevel.Trace );
    //... additional configuration...
}

et lorsque vous utilisez la méthode d'extension AddLogging, écrivez-le comme suit

services.AddLogging( ConfigLogging );

Answer 4

La structure suivante de appsettings.json semble fonctionner correctement :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "System": "Information",
      "Microsoft": "Information"
    },
    "Console":
    {
      "IncludeScopes": true
    }
  }
}

Tiré de https://learn.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-2.1

Voyez aussi quels sont vos appels de départ, je trouve que ce qui suit fonctionne pour moi :

public class Startup
{
    public Startup(IHostingEnvironment env)
    {

        var logger = new LoggerConfiguration()
                .MinimumLevel.Information()
                .WriteTo.Sink(jsonSink)
                .Enrich.WithExceptionDetails()
                .CreateLogger();

        Log.Logger = logger;
    }
}