Registrazione in .NET Core e ASP.NET CoreLogging in .NET Core and ASP.NET Core

Di Tom Dykstra e Steve SmithBy Tom Dykstra and Steve Smith

.NET Core supporta un'API di registrazione che funziona con un'ampia gamma di provider di registrazione predefiniti e di terze parti..NET Core supports a logging API that works with a variety of built-in and third-party logging providers. Questo articolo illustra come usare l'API di registrazione con i provider predefiniti.This article shows how to use the logging API with built-in providers.

La maggior parte degli esempi di codice illustrati in questo articolo proviene da app ASP.NET Core.Most of the code examples shown in this article are from ASP.NET Core apps. Le parti specifiche per la registrazione di questi frammenti di codice si applicano a qualsiasi app .NET Core che usa l' host generico.The logging-specific parts of these code snippets apply to any .NET Core app that uses the Generic Host. Per informazioni su come usare l'host generico nelle app console non Web, vedere Servizi ospitati.For information about how to use the Generic Host in non-web console apps, see Hosted services.

Il codice di registrazione per le app senza host generico differisce per il modo in cui vengono aggiunti i provider e creati i logger.Logging code for apps without Generic Host differs in the way providers are added and loggers are created. Gli esempi di codice non host sono illustrati nelle sezioni dell'articolo in cui sono riportate queste procedure.Non-host code examples are shown in those sections of the article.

Visualizzare o scaricare il codice di esempio (procedura per il download)View or download sample code (how to download)

Aggiungere providerAdd providers

Un provider di registrazione visualizza o archivia i log.A logging provider displays or stores logs. Il provider Console, ad esempio, visualizza i log nella console, mentre il provider Azure Application Insights li archivia in Azure Application Insights.For example, the Console provider displays logs on the console, and the Azure Application Insights provider stores them in Azure Application Insights. I log possono essere inviati a più destinazioni aggiungendo più provider.Logs can be sent to multiple destinations by adding multiple providers.

Per aggiungere un provider in un'app che usa l'host generico, chiamare il metodo di estensione Add{provider name} del provider in Program.cs:To add a provider in an app that uses Generic Host, call the provider's Add{provider name} extension method in Program.cs:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.AddConsole();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

In un'app console non host chiamare il metodo di estensione Add{provider name} del provider durante la creazione di un oggetto LoggerFactory:In a non-host console app, call the provider's Add{provider name} extension method while creating a LoggerFactory:

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddFilter("Microsoft", LogLevel.Warning)
        .AddFilter("System", LogLevel.Warning)
        .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
        .AddConsole()
        .AddEventLog();
});
ILogger logger = loggerFactory.CreateLogger<Program>();
logger.LogInformation("Example log message");

LoggerFactory e AddConsole richiedono un'istruzione using per Microsoft.Extensions.Logging.LoggerFactory and AddConsole require a using statement for Microsoft.Extensions.Logging.

I modelli di progetto ASP.NET Core predefiniti chiamano CreateDefaultBuilder, che aggiunge i provider di registrazione seguenti:The default ASP.NET Core project templates call CreateDefaultBuilder, which adds the following logging providers:

  • ConsoleConsole
  • DebugDebug
  • EventSourceEventSource
  • EventLog (solo quando è in esecuzione su Windows)EventLog (only when running on Windows)

È possibile sostituire i provider predefiniti con quelli di propria scelta.You can replace the default providers with your own choices. Chiamare ClearProviders e aggiungere i provider desiderati.Call ClearProviders, and add the providers you want.

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.AddConsole();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Per aggiungere un provider, chiamare il metodo di estensione Add{provider name} del provider in Program.cs:To add a provider, call the provider's Add{provider name} extension method in Program.cs:

public static void Main(string[] args)
{
    var webHost = 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, reloadOnChange: true);
            config.AddEnvironmentVariables();
        })
        .ConfigureLogging((hostingContext, logging) =>
        {
            // Requires `using Microsoft.Extensions.Logging;`
            logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
            logging.AddConsole();
            logging.AddDebug();
            logging.AddEventSourceLogger();
        })
        .UseStartup<Startup>()
        .Build();

    webHost.Run();
}

Il codice precedente richiede riferimenti a Microsoft.Extensions.Logging e Microsoft.Extensions.Configuration.The preceding code requires references to Microsoft.Extensions.Logging and Microsoft.Extensions.Configuration.

Il modello di progetto predefinito chiama CreateDefaultBuilder, che aggiunge i provider di registrazione seguenti:The default project template calls CreateDefaultBuilder, which adds the following logging providers:

  • ConsoleConsole
  • DebugDebug
  • EventSource (a partire da ASP.NET Core 2.2)EventSource (starting in ASP.NET Core 2.2)
public static void Main(string[] args)
{
    CreateWebHostBuilder(args).Build().Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>();

Se si usa CreateDefaultBuilder, è possibile sostituire i provider predefiniti con quelli di propria scelta.If you use CreateDefaultBuilder, you can replace the default providers with your own choices. Chiamare ClearProviders e aggiungere i provider desiderati.Call ClearProviders, and add the providers you want.

public static void Main(string[] args)
{
    var host = CreateWebHostBuilder(args).Build();

    var todoRepository = host.Services.GetRequiredService<ITodoRepository>();
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Feed the dog" });
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Walk the dog" });

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Seeded the database.");

    host.Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.AddConsole();
        });

Altre informazioni sui provider di registrazione predefiniti e sui provider di registrazione di terze parti vengono fornite più avanti in questo articolo.Learn more about built-in logging providers and third-party logging providers later in the article.

Creare logCreate logs

Per creare i log, usare un oggetto ILogger<TCategoryName>.To create logs, use an ILogger<TCategoryName> object. In un'app Web o in un servizio ospitato, ottenere un oggetto ILogger da un inserimento delle dipendenze.In a web app or hosted service, get an ILogger from dependency injection (DI). Nelle app console non host, usare LoggerFactory per creare un oggetto ILogger.In non-host console apps, use the LoggerFactory to create an ILogger.

L'esempio seguente di ASP.NET Core crea un logger con TodoApiSample.Pages.AboutModel come categoria.The following ASP.NET Core example creates a logger with TodoApiSample.Pages.AboutModel as the category. La categoria del log è una stringa associata a ogni log.The log category is a string that is associated with each log. L'istanza di ILogger<T> fornita dall'inserimento delle dipendenze crea log con nome completo di tipo T come categoria.The ILogger<T> instance provided by DI creates logs that have the fully qualified name of type T as the category.

public class AboutModel : PageModel
{
    private readonly ILogger _logger;

    public AboutModel(ILogger<AboutModel> logger)
    {
        _logger = logger;
    }

L'esempio seguente di app console non host crea un logger con LoggingConsoleApp.Program come categoria.The following non-host console app example creates a logger with LoggingConsoleApp.Program as the category.

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddFilter("Microsoft", LogLevel.Warning)
        .AddFilter("System", LogLevel.Warning)
        .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
        .AddConsole()
        .AddEventLog();
});
ILogger logger = loggerFactory.CreateLogger<Program>();
logger.LogInformation("Example log message");
public class AboutModel : PageModel
{
    private readonly ILogger _logger;

    public AboutModel(ILogger<AboutModel> logger)
    {
        _logger = logger;
    }

Negli esempi seguenti di ASP.NET Core e app console, il logger viene usato per creare log con Information come livello.In the following ASP.NET Core and console app examples, the logger is used to create logs with Information as the level. Il livello del log indica la gravità dell'evento registrato.The Log level indicates the severity of the logged event.

public void OnGet()
{
    Message = $"About page visited at {DateTime.UtcNow.ToLongTimeString()}";
    _logger.LogInformation("Message displayed: {Message}", Message);
}
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddFilter("Microsoft", LogLevel.Warning)
        .AddFilter("System", LogLevel.Warning)
        .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
        .AddConsole()
        .AddEventLog();
});
ILogger logger = loggerFactory.CreateLogger<Program>();
logger.LogInformation("Example log message");
public void OnGet()
{
    Message = $"About page visited at {DateTime.UtcNow.ToLongTimeString()}";
    _logger.LogInformation("Message displayed: {Message}", Message);
}

Livelli e categorie vengono illustrati in modo dettagliato più avanti in questo articolo.Levels and categories are explained in more detail later in this article.

Creare log nella classe ProgramCreate logs in the Program class

Per scrivere log nella classe Program di un'app ASP.NET Core, ottenere un'istanza di ILogger dall'inserimento delle dipendenze dopo aver creato l'host:To write logs in the Program class of an ASP.NET Core app, get an ILogger instance from DI after building the host:

public static void Main(string[] args)
{
    var host = CreateHostBuilder(args).Build();

    var todoRepository = host.Services.GetRequiredService<ITodoRepository>();
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Feed the dog" });
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Walk the dog" });

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Seeded the database.");

    IMyService myService = host.Services.GetRequiredService<IMyService>();
    myService.WriteLog("Logged from MyService.");

    host.Run();
}

Creare log nella classe StartupCreate logs in the Startup class

Per scrivere log nel metodo Startup.Configure di un'app ASP.NET Core, includere un parametro ILogger nella firma del metodo:To write logs in the Startup.Configure method of an ASP.NET Core app, include an ILogger parameter in the method signature:

public void Configure(IApplicationBuilder app, IHostEnvironment env, ILogger<Startup> logger)
{
    if (env.IsDevelopment())
    {
        logger.LogInformation("In Development environment");
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
        endpoints.MapRazorPages();
    });
}

La scrittura di log prima del completamento della configurazione del contenitore di inserimento delle dipendenze nel metodo Startup.ConfigureServices non è supportata:Writing logs before completion of the DI container setup in the Startup.ConfigureServices method is not supported:

  • L'inserimento del logger nel costruttore Startup non è supportato.Logger injection into the Startup constructor is not supported.
  • L'inserimento del logger nella firma del metodo Startup.ConfigureServices non è supportatoLogger injection into the Startup.ConfigureServices method signature is not supported

Questa restrizione è dovuta al fatto che la registrazione dipende dall'inserimento delle dipendenze e dalla configurazione, che a sua volta dipende dall'inserimento delle dipendenze.The reason for this restriction is that logging depends on DI and on configuration, which in turns depends on DI. Il contenitore di inserimento delle dipendenze non viene configurato finché il metodo ConfigureServices non è completato.The DI container isn't set up until ConfigureServices finishes.

L'inserimento di un logger nel costruttore Startup è possibile nelle versioni precedenti di ASP.NET Core perché viene creato un contenitore di inserimento delle dipendenze separato per l'host Web.Constructor injection of a logger into Startup works in earlier versions of ASP.NET Core because a separate DI container is created for the Web Host. Per informazioni sul motivo per cui viene creato un solo contenitore per l'host generico, vedere l'annuncio relativo alle modifiche di rilievo.For information about why only one container is created for the Generic Host, see the breaking change announcement.

Se è necessario configurare un servizio che dipende da ILogger<T>, è comunque possibile eseguire questa operazione usando l'inserimento nel costruttore o specificando un metodo factory.If you need to configure a service that depends on ILogger<T>, you can still do that by using constructor injection or by providing a factory method. L'approccio con il metodo factory è consigliato solo se non sono disponibili altre opzioni.The factory method approach is recommended only if there is no other option. Si supponga, ad esempio, di dover specificare una proprietà con un servizio ottenuto dall'inserimento delle dipendenze:For example, suppose you need to fill a property with a service from DI:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddRazorPages();

    services.AddSingleton<IMyService>((container) =>
    {
        var logger = container.GetRequiredService<ILogger<MyService>>();
        return new MyService() { Logger = logger };
    });

    services.AddSingleton<ITodoRepository, TodoRepository>();
}

Il precedente codice evidenziato è un oggetto Func che viene eseguito la prima volta che il contenitore di inserimento delle dipendenze deve creare un'istanza di MyService.The preceding highlighted code is a Func that runs the first time the DI container needs to construct an instance of MyService. È possibile accedere a uno dei servizi registrati in questo modo.You can access any of the registered services in this way.

Creare log nella classe StartupCreate logs in Startup

Per scrivere log nella classe Startup, includere un parametro ILogger nella firma del costruttore:To write logs in the Startup class, include an ILogger parameter in the constructor signature:

public class Startup
{
    private readonly ILogger _logger;

    public Startup(IConfiguration configuration, ILogger<Startup> logger)
    {
        Configuration = configuration;
        _logger = logger;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

        // Add our repository type
        services.AddSingleton<ITodoRepository, TodoRepository>();
        _logger.LogInformation("Added TodoRepository to services");
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            _logger.LogInformation("In Development environment");
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseCookiePolicy();

        app.UseMvc();
    }
}

Creare log nella classe ProgramCreate logs in the Program class

Per scrivere log nella classe Program, ottenere un'istanza di ILogger dall'inserimento delle dipendenze:To write logs in the Program class, get an ILogger instance from DI:

public static void Main(string[] args)
{
    var host = CreateWebHostBuilder(args).Build();

    var todoRepository = host.Services.GetRequiredService<ITodoRepository>();
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Feed the dog" });
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Walk the dog" });

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Seeded the database.");

    host.Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.AddConsole();
        });

Evitare l'uso di metodi logger asincroniNo asynchronous logger methods

La registrazione deve essere così rapida da non giustificare l'impatto sulle prestazioni del codice asincrono.Logging should be so fast that it isn't worth the performance cost of asynchronous code. Se l'archivio dati di registrazione è lento, non scrivere direttamente al suo interno.If your logging data store is slow, don't write to it directly. Scrivere invece i messaggi di log prima in un archivio veloce e quindi spostarli nell'archivio lento in un secondo momento.Consider writing the log messages to a fast store initially, then move them to the slow store later. Ad esempio, se la registrazione viene eseguita in SQL Server, è preferibile non farlo direttamente in un metodo Log, poiché i metodi Log sono sincroni.For example, if you're logging to SQL Server, you don't want to do that directly in a Log method, since the Log methods are synchronous. Al contrario, aggiungere i messaggi di log in modo sincrono a una coda in memoria e usare un ruolo di lavoro in background per eseguire il pull dei messaggi dalla coda per eseguire le operazioni asincrone di push dei dati in SQL Server.Instead, synchronously add log messages to an in-memory queue and have a background worker pull the messages out of the queue to do the asynchronous work of pushing data to SQL Server.

ConfigurazioneConfiguration

La configurazione dei provider di registrazione viene fornita da uno o più provider di configurazione:Logging provider configuration is provided by one or more configuration providers:

  • Formati di file (INI, JSON e XML).File formats (INI, JSON, and XML).
  • Argomenti della riga di comando.Command-line arguments.
  • Variabili di ambiente.Environment variables.
  • Oggetti .NET in memoria.In-memory .NET objects.
  • Archiviazione con Secret Manager senza crittografia.The unencrypted Secret Manager storage.
  • Un archivio utente non crittografato, come Azure Key Vault.An encrypted user store, such as Azure Key Vault.
  • Provider personalizzati (installati o creati).Custom providers (installed or created).

Ad esempio, la configurazione di registrazione viene comunemente fornita dalla sezione Logging del file di impostazioni dell'app.For example, logging configuration is commonly provided by the Logging section of app settings files. L'esempio seguente mostra il contenuto di un file appsettings.Development.json tipico:The following example shows the contents of a typical appsettings.Development.json file:

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

La proprietà Logging può avere le proprietà LogLevel e quella del provider di log (nell'esempio, Console).The Logging property can have LogLevel and log provider properties (Console is shown).

La proprietà LogLevel in Logging specifica il livello minimo per la registrazione per determinate categorie.The LogLevel property under Logging specifies the minimum level to log for selected categories. Nell'esempio, le categorie System e Microsoft eseguono la registrazione al livello Information, mentre tutte le altre la eseguono al livello Debug.In the example, System and Microsoft categories log at Information level, and all others log at Debug level.

Altre proprietà in Logging specificano i provider di registrazione.Other properties under Logging specify logging providers. L'esempio si riferisce al provider Console.The example is for the Console provider. Se un provider supporta gli ambiti di log, IncludeScopes indica se tali ambiti sono abilitati.If a provider supports log scopes, IncludeScopes indicates whether they're enabled. Una proprietà del provider (ad esempio Console nell'esempio) può specificare anche una proprietà LogLevel.A provider property (such as Console in the example) may also specify a LogLevel property. LogLevel in un provider specifica i livelli di registrazione per tale provider.LogLevel under a provider specifies levels to log for that provider.

Se i livelli sono specificati in Logging.{providername}.LogLevel, eseguono l'override di eventuali valori impostati in Logging.LogLevel.If levels are specified in Logging.{providername}.LogLevel, they override anything set in Logging.LogLevel.

Per informazioni sull'implementazione dei provider di configurazione, vedere Configurazione in ASP.NET Core.For information on implementing configuration providers, see Configurazione in ASP.NET Core.

Esempio di output di registrazioneSample logging output

Con il codice di esempio illustrato nella sezione precedente i log vengono visualizzati nella console quando l'app viene eseguita dalla riga di comando.With the sample code shown in the preceding section, logs appear in the console when the app is run from the command line. Ecco un esempio di output della console:Here's an example of console output:

info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
      Request starting HTTP/1.1 GET http://localhost:5000/api/todo/0
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
      Request finished in 84.26180000000001ms 307
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
      Request starting HTTP/2 GET https://localhost:5001/api/todo/0
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
      Executing endpoint 'TodoApiSample.Controllers.TodoController.GetById (TodoApiSample)'
info: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[3]
      Route matched with {action = "GetById", controller = "Todo", page = ""}. Executing controller action with signature Microsoft.AspNetCore.Mvc.IActionResult GetById(System.String) on controller TodoApiSample.Controllers.TodoController (TodoApiSample).
info: TodoApiSample.Controllers.TodoController[1002]
      Getting item 0
warn: TodoApiSample.Controllers.TodoController[4000]
      GetById(0) NOT FOUND
info: Microsoft.AspNetCore.Mvc.StatusCodeResult[1]
      Executing HttpStatusCodeResult, setting HTTP status code 404
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[1]
      Request starting HTTP/1.1 GET http://localhost:5000/api/todo/0
info: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[1]
      Executing action method TodoApi.Controllers.TodoController.GetById (TodoApi) with arguments (0) - ModelState is Valid
info: TodoApi.Controllers.TodoController[1002]
      Getting item 0
warn: TodoApi.Controllers.TodoController[4000]
      GetById(0) NOT FOUND
info: Microsoft.AspNetCore.Mvc.StatusCodeResult[1]
      Executing HttpStatusCodeResult, setting HTTP status code 404
info: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[2]
      Executed action TodoApi.Controllers.TodoController.GetById (TodoApi) in 42.9286ms
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
      Request finished in 148.889ms 404

I log precedenti sono stati generati inviando una richiesta HTTP Get all'app di esempio all'indirizzo http://localhost:5000/api/todo/0.The preceding logs were generated by making an HTTP Get request to the sample app at http://localhost:5000/api/todo/0.

Ecco un esempio degli stessi log visualizzati nella finestra Debug quando si esegue l'app di esempio in Visual Studio:Here's an example of the same logs as they appear in the Debug window when you run the sample app in Visual Studio:

Microsoft.AspNetCore.Hosting.Diagnostics: Information: Request starting HTTP/2.0 GET https://localhost:44328/api/todo/0  
Microsoft.AspNetCore.Routing.EndpointMiddleware: Information: Executing endpoint 'TodoApiSample.Controllers.TodoController.GetById (TodoApiSample)'
Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker: Information: Route matched with {action = "GetById", controller = "Todo", page = ""}. Executing controller action with signature Microsoft.AspNetCore.Mvc.IActionResult GetById(System.String) on controller TodoApiSample.Controllers.TodoController (TodoApiSample).
TodoApiSample.Controllers.TodoController: Information: Getting item 0
TodoApiSample.Controllers.TodoController: Warning: GetById(0) NOT FOUND
Microsoft.AspNetCore.Mvc.StatusCodeResult: Information: Executing HttpStatusCodeResult, setting HTTP status code 404
Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker: Information: Executed action TodoApiSample.Controllers.TodoController.GetById (TodoApiSample) in 34.167ms
Microsoft.AspNetCore.Routing.EndpointMiddleware: Information: Executed endpoint 'TodoApiSample.Controllers.TodoController.GetById (TodoApiSample)'
Microsoft.AspNetCore.Hosting.Diagnostics: Information: Request finished in 98.41300000000001ms 404

I log creati dalle chiamate a ILogger illustrate nella sezione precedente iniziano con "TodoApiSample".The logs that are created by the ILogger calls shown in the preceding section begin with "TodoApiSample". I log che iniziano con le categorie "Microsoft" provengono dal codice del framework ASP.NET Core.The logs that begin with "Microsoft" categories are from ASP.NET Core framework code. ASP.NET Core e il codice dell'applicazione usano la stessa API di registrazione e gli stessi provider.ASP.NET Core and application code are using the same logging API and providers.

Microsoft.AspNetCore.Hosting.Internal.WebHost:Information: Request starting HTTP/1.1 GET http://localhost:53104/api/todo/0  
Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker:Information: Executing action method TodoApi.Controllers.TodoController.GetById (TodoApi) with arguments (0) - ModelState is Valid
TodoApi.Controllers.TodoController:Information: Getting item 0
TodoApi.Controllers.TodoController:Warning: GetById(0) NOT FOUND
Microsoft.AspNetCore.Mvc.StatusCodeResult:Information: Executing HttpStatusCodeResult, setting HTTP status code 404
Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker:Information: Executed action TodoApi.Controllers.TodoController.GetById (TodoApi) in 152.5657ms
Microsoft.AspNetCore.Hosting.Internal.WebHost:Information: Request finished in 316.3195ms 404

I log creati dalle chiamate a ILogger illustrate nella sezione precedente iniziano con "TodoApi".The logs that are created by the ILogger calls shown in the preceding section begin with "TodoApi". I log che iniziano con le categorie "Microsoft" provengono dal codice del framework ASP.NET Core.The logs that begin with "Microsoft" categories are from ASP.NET Core framework code. ASP.NET Core e il codice dell'applicazione usano la stessa API di registrazione e gli stessi provider.ASP.NET Core and application code are using the same logging API and providers.

Il resto di questo articolo spiega alcuni dettagli e le opzioni per la registrazione.The remainder of this article explains some details and options for logging.

Pacchetti NuGetNuGet packages

Le interfacce ILogger e ILoggerFactory si trovano in Microsoft.Extensions.Logging.Abstractions e le loro implementazioni predefinite si trovano in Microsoft.Extensions.Logging.The ILogger and ILoggerFactory interfaces are in Microsoft.Extensions.Logging.Abstractions, and default implementations for them are in Microsoft.Extensions.Logging.

Categoria dei logLog category

Quando viene creato un oggetto ILogger, viene specificata la relativa categoria.When an ILogger object is created, a category is specified for it. La categoria è inclusa in ogni messaggio di log creato da tale istanza di ILogger.That category is included with each log message created by that instance of ILogger. La categoria può essere qualsiasi stringa, ma per convenzione si usa il nome della classe, ad esempio "TodoApi.Controllers.TodoController".The category may be any string, but the convention is to use the class name, such as "TodoApi.Controllers.TodoController".

Usare ILogger<T> per ottenere un'istanza di ILogger che usa il nome completo di tipo T come categoria:Use ILogger<T> to get an ILogger instance that uses the fully qualified type name of T as the category:

public class TodoController : Controller
{
    private readonly ITodoRepository _todoRepository;
    private readonly ILogger _logger;

    public TodoController(ITodoRepository todoRepository,
        ILogger<TodoController> logger)
    {
        _todoRepository = todoRepository;
        _logger = logger;
    }
public class TodoController : Controller
{
    private readonly ITodoRepository _todoRepository;
    private readonly ILogger _logger;

    public TodoController(ITodoRepository todoRepository,
        ILogger<TodoController> logger)
    {
        _todoRepository = todoRepository;
        _logger = logger;
    }

Per specificare in modo esplicito la categoria, chiamare ILoggerFactory.CreateLogger:To explicitly specify the category, call ILoggerFactory.CreateLogger:

public class TodoController : Controller
{
    private readonly ITodoRepository _todoRepository;
    private readonly ILogger _logger;

    public TodoController(ITodoRepository todoRepository,
        ILoggerFactory logger)
    {
        _todoRepository = todoRepository;
        _logger = logger.CreateLogger("TodoApiSample.Controllers.TodoController");
    }
public class TodoController : Controller
{
    private readonly ITodoRepository _todoRepository;
    private readonly ILogger _logger;

    public TodoController(ITodoRepository todoRepository,
        ILoggerFactory logger)
    {
        _todoRepository = todoRepository;
        _logger = logger.CreateLogger("TodoApiSample.Controllers.TodoController");
    }

L'uso di ILogger<T> equivale a chiamare CreateLogger con il nome completo di tipo T.ILogger<T> is equivalent to calling CreateLogger with the fully qualified type name of T.

Livello di registrazioneLog level

Ogni log specifica un valore LogLevel.Every log specifies a LogLevel value. Il livello di registrazione indica la gravità o l'importanza.The log level indicates the severity or importance. È ad esempio possibile scrivere un log Information quando un metodo termina normalmente e un log Warning quando un metodo restituisce un codice di stato 404 Non trovato.For example, you might write an Information log when a method ends normally and a Warning log when a method returns a 404 Not Found status code.

Il codice seguente crea i log Information e Warning:The following code creates Information and Warning logs:

public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}
public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}

Nel codice precedente il primo parametro è l'ID dell'evento di log.In the preceding code, the first parameter is the Log event ID. Il secondo parametro è un modello di messaggio con segnaposto per i valori degli argomenti forniti dai parametri dei metodi rimanenti.The second parameter is a message template with placeholders for argument values provided by the remaining method parameters. I parametri dei metodi sono descritti nella sezione relativa al modello di messaggio più avanti in questo articolo.The method parameters are explained in the message template section later in this article.

I metodi di registrazione che includono il livello nel nome del metodo (ad esempio LogInformation e LogWarning) sono metodi di estensione per ILogger.Log methods that include the level in the method name (for example, LogInformation and LogWarning) are extension methods for ILogger. Questi metodi chiamano un metodo Log che accetta un parametro LogLevel.These methods call a Log method that takes a LogLevel parameter. È possibile chiamare il metodo Log direttamente anziché chiamare uno di questi metodi di estensione, ma la sintassi è relativamente complessa.You can call the Log method directly rather than one of these extension methods, but the syntax is relatively complicated. Per altre informazioni, vedere ILogger e il codice sorgente delle estensioni del logger.For more information, see ILogger and the logger extensions source code.

ASP.NET Core definisce i livelli di registrazione seguenti, ordinati dal meno grave al più grave.ASP.NET Core defines the following log levels, ordered here from lowest to highest severity.

  • Trace = 0Trace = 0

    Per informazioni in genere utili solo per il debug.For information that's typically valuable only for debugging. Questi messaggi possono contenere dati sensibili dell'applicazione e pertanto non devono essere abilitati in un ambiente di produzione.These messages may contain sensitive application data and so shouldn't be enabled in a production environment. Disattivato per impostazione predefinita.Disabled by default.

  • Debug = 1Debug = 1

    Per informazioni che possono essere utili per lo sviluppo e il debug.For information that may be useful in development and debugging. Esempio: Entering method Configure with flag set to true. Abilitare i livelli di registrazione Debug nell'ambiente di produzione solo in fase di risoluzione dei problemi, per non fare aumentare eccessivamente il volume dei log.Example: Entering method Configure with flag set to true. Enable Debug level logs in production only when troubleshooting, due to the high volume of logs.

  • Information = 2Information = 2

    Per tenere traccia del flusso generale dell'app.For tracking the general flow of the app. Queste registrazioni hanno in genere un valore a lungo termine.These logs typically have some long-term value. Esempio: Request received for path /api/todoExample: Request received for path /api/todo

  • Warning = 3Warning = 3

    Per gli eventi imprevisti o anomali nel flusso dell'app.For abnormal or unexpected events in the app flow. Tali eventi potrebbero includere errori o altre condizioni che non provocano l'arresto dell'app, ma che potrebbe essere necessario analizzare.These may include errors or other conditions that don't cause the app to stop but might need to be investigated. Le eccezioni gestite sono una situazione comune in cui usare il livello di registrazione Warning.Handled exceptions are a common place to use the Warning log level. Esempio: FileNotFoundException for file quotes.txt.Example: FileNotFoundException for file quotes.txt.

  • Error = 4Error = 4

    Per errori ed eccezioni che non possono essere gestiti.For errors and exceptions that cannot be handled. Questi messaggi indicano un errore nell'operazione o nell'attività in corso (ad esempio la richiesta HTTP corrente), non un errore a livello di app.These messages indicate a failure in the current activity or operation (such as the current HTTP request), not an app-wide failure. Messaggio di registrazione di esempio:Cannot insert record due to duplicate key violation.Example log message: Cannot insert record due to duplicate key violation.

  • Critical = 5Critical = 5

    Per gli errori che richiedono attenzione immediata.For failures that require immediate attention. Esempi: scenari di perdita di dati, spazio su disco insufficiente.Examples: data loss scenarios, out of disk space.

Usare il livello di registrazione per controllare la quantità di output di log scritto in un supporto di archiviazione specifico o in una finestra.Use the log level to control how much log output is written to a particular storage medium or display window. Esempio:For example:

  • In produzione:In production:
    • La registrazione al @no__t da 0 a livelli Information genera un volume elevato di messaggi di log dettagliati.Logging at the Trace through Information levels produces a high-volume of detailed log messages. Per controllare i costi e non superare i limiti di archiviazione dei dati, registrare Trace tramite messaggi di livello Information in un archivio dati a volume elevato e a basso costo.To control costs and not exceed data storage limits, log Trace through Information level messages to a high-volume, low-cost data store.
    • La registrazione da Warning a livelli Critical in genere produce un minor numero di messaggi di log più piccoli.Logging at Warning through Critical levels typically produces fewer, smaller log messages. Pertanto, i costi e i limiti di archiviazione in genere non rappresentano un problema, il che comporta una maggiore flessibilità di scelta dell'archivio dati.Therefore, costs and storage limits usually aren't a concern, which results in greater flexibility of data store choice.
  • Durante lo sviluppo:During development:
    • Registra Warning tramite messaggi Critical alla console.Log Warning through Critical messages to the console.
    • Quando si esegue la risoluzione dei problemi, aggiungere Trace a messaggi Information.Add Trace through Information messages when troubleshooting.

La sezione Filtro dei log più avanti in questo articolo descrive come controllare quali livelli di registrazione gestisce un provider.The Log filtering section later in this article explains how to control which log levels a provider handles.

ASP.NET Core scrive log per gli eventi del framework.ASP.NET Core writes logs for framework events. Gli esempi di log illustrati in precedenza in questo articolo escludono i log al di sotto del livello Information, quindi non vengono creati log di livello Debug o Trace.The log examples earlier in this article excluded logs below Information level, so no Debug or Trace level logs were created. Ecco un esempio di log della console prodotti eseguendo l'app di esempio configurata in modo da mostrare i log di livello Debug:Here's an example of console logs produced by running the sample app configured to show Debug logs:

info: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[3]
      Route matched with {action = "GetById", controller = "Todo", page = ""}. Executing controller action with signature Microsoft.AspNetCore.Mvc.IActionResult GetById(System.String) on controller TodoApiSample.Controllers.TodoController (TodoApiSample).
dbug: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[1]
      Execution plan of authorization filters (in the following order): None
dbug: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[1]
      Execution plan of resource filters (in the following order): Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter
dbug: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[1]
      Execution plan of action filters (in the following order): Microsoft.AspNetCore.Mvc.Filters.ControllerActionFilter (Order: -2147483648), Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter (Order: -3000)
dbug: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[1]
      Execution plan of exception filters (in the following order): None
dbug: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[1]
      Execution plan of result filters (in the following order): Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.ParameterBinder[22]
      Attempting to bind parameter 'id' of type 'System.String' ...
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.Binders.SimpleTypeModelBinder[44]
      Attempting to bind parameter 'id' of type 'System.String' using the name 'id' in request data ...
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.Binders.SimpleTypeModelBinder[45]
      Done attempting to bind parameter 'id' of type 'System.String'.
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.ParameterBinder[23]
      Done attempting to bind parameter 'id' of type 'System.String'.
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.ParameterBinder[26]
      Attempting to validate the bound parameter 'id' of type 'System.String' ...
dbug: Microsoft.AspNetCore.Mvc.ModelBinding.ParameterBinder[27]
      Done attempting to validate the bound parameter 'id' of type 'System.String'.
info: TodoApiSample.Controllers.TodoController[1002]
      Getting item 0
warn: TodoApiSample.Controllers.TodoController[4000]
      GetById(0) NOT FOUND
info: Microsoft.AspNetCore.Mvc.StatusCodeResult[1]
      Executing HttpStatusCodeResult, setting HTTP status code 404
info: Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker[2]
      Executed action TodoApiSample.Controllers.TodoController.GetById (TodoApiSample) in 32.690400000000004ms
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
      Executed endpoint 'TodoApiSample.Controllers.TodoController.GetById (TodoApiSample)'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
      Request finished in 176.9103ms 404
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[1]
      Request starting HTTP/1.1 GET http://localhost:62555/api/todo/0
dbug: Microsoft.AspNetCore.Routing.Tree.TreeRouter[1]
      Request successfully matched the route with name 'GetTodo' and template 'api/Todo/{id}'.
dbug: Microsoft.AspNetCore.Mvc.Internal.ActionSelector[2]
      Action 'TodoApi.Controllers.TodoController.Update (TodoApi)' with id '089d59b6-92ec-472d-b552-cc613dfd625d' did not match the constraint 'Microsoft.AspNetCore.Mvc.Internal.HttpMethodActionConstraint'
dbug: Microsoft.AspNetCore.Mvc.Internal.ActionSelector[2]
      Action 'TodoApi.Controllers.TodoController.Delete (TodoApi)' with id 'f3476abe-4bd9-4ad3-9261-3ead09607366' did not match the constraint 'Microsoft.AspNetCore.Mvc.Internal.HttpMethodActionConstraint'
dbug: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[1]
      Executing action TodoApi.Controllers.TodoController.GetById (TodoApi)
info: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[1]
      Executing action method TodoApi.Controllers.TodoController.GetById (TodoApi) with arguments (0) - ModelState is Valid
info: TodoApi.Controllers.TodoController[1002]
      Getting item 0
warn: TodoApi.Controllers.TodoController[4000]
      GetById(0) NOT FOUND
dbug: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[2]
      Executed action method TodoApi.Controllers.TodoController.GetById (TodoApi), returned result Microsoft.AspNetCore.Mvc.NotFoundResult.
info: Microsoft.AspNetCore.Mvc.StatusCodeResult[1]
      Executing HttpStatusCodeResult, setting HTTP status code 404
info: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[2]
      Executed action TodoApi.Controllers.TodoController.GetById (TodoApi) in 0.8788ms
dbug: Microsoft.AspNetCore.Server.Kestrel[9]
      Connection id "0HL6L7NEFF2QD" completed keep alive response.
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
      Request finished in 2.7286ms 404

ID evento di registrazioneLog event ID

Ogni log può specificare un ID evento.Each log can specify an event ID. A tale scopo, l'app di esempio usa una classe LoggingEvents definita a livello locale:The sample app does this by using a locally defined LoggingEvents class:

public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}
public class LoggingEvents
{
    public const int GenerateItems = 1000;
    public const int ListItems = 1001;
    public const int GetItem = 1002;
    public const int InsertItem = 1003;
    public const int UpdateItem = 1004;
    public const int DeleteItem = 1005;

    public const int GetItemNotFound = 4000;
    public const int UpdateItemNotFound = 4001;
}
public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}
public class LoggingEvents
{
    public const int GenerateItems = 1000;
    public const int ListItems = 1001;
    public const int GetItem = 1002;
    public const int InsertItem = 1003;
    public const int UpdateItem = 1004;
    public const int DeleteItem = 1005;

    public const int GetItemNotFound = 4000;
    public const int UpdateItemNotFound = 4001;
}

Un ID evento associa un set di eventi.An event ID associates a set of events. Ad esempio, tutti i log correlati alla visualizzazione di un elenco di elementi in una pagina potrebbero essere indicati con 1001.For example, all logs related to displaying a list of items on a page might be 1001.

Il provider di log può archiviare l'ID evento in un campo ID o nel messaggio di registrazione oppure non archiviarlo.The logging provider may store the event ID in an ID field, in the logging message, or not at all. Il provider Debug non visualizza gli ID evento.The Debug provider doesn't show event IDs. Il provider Console visualizza gli ID evento tra parentesi quadre dopo la categoria:The console provider shows event IDs in brackets after the category:

info: TodoApi.Controllers.TodoController[1002]
      Getting item invalidid
warn: TodoApi.Controllers.TodoController[4000]
      GetById(invalidid) NOT FOUND

Modello di messaggio di registrazioneLog message template

Ogni log specifica un modello di messaggio.Each log specifies a message template. Il modello di messaggio può contenere segnaposto per i quali vengono forniti argomenti.The message template can contain placeholders for which arguments are provided. Usare nomi per i segnaposto, non numeri.Use names for the placeholders, not numbers.

public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}
public IActionResult GetById(string id)
{
    _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
    var item = _todoRepository.Find(id);
    if (item == null)
    {
        _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
        return NotFound();
    }
    return new ObjectResult(item);
}

L'ordine dei segnaposto, non il loro nome, determina i parametri da usare per fornire i valori corrispondenti.The order of placeholders, not their names, determines which parameters are used to provide their values. Nel codice seguente, si noti che i nomi dei parametri non sono in sequenza nel modello di messaggio:In the following code, notice that the parameter names are out of sequence in the message template:

string p1 = "parm1";
string p2 = "parm2";
_logger.LogInformation("Parameter values: {p2}, {p1}", p1, p2);

Questo codice crea un messaggio di log con i valori dei parametri in sequenza:This code creates a log message with the parameter values in sequence:

Parameter values: parm1, parm2

Il framework di registrazione funziona in questo modo per consentire ai provider di registrazione di implementare la registrazione semantica, nota anche come registrazione strutturata.The logging framework works this way so that logging providers can implement semantic logging, also known as structured logging. Al sistema di registrazione vengono passati gli argomenti e non solo il modello di messaggio formattato.The arguments themselves are passed to the logging system, not just the formatted message template. Queste informazioni consentono ai provider di registrazione di archiviare i valori dei parametri come campi.This information enables logging providers to store the parameter values as fields. Si supponga, ad esempio, che il metodo logger esegua chiamate simili alla seguente:For example, suppose logger method calls look like this:

_logger.LogInformation("Getting item {Id} at {RequestTime}", id, DateTime.Now);

Se si inviano i log all'archiviazione tabelle di Azure, ogni entità tabella di Azure può avere le proprietà ID e RequestTime, il che semplifica le query sui dati dei log.If you're sending the logs to Azure Table Storage, each Azure Table entity can have ID and RequestTime properties, which simplifies queries on log data. Una query può trovare tutti i log entro un determinato intervallo RequestTime senza che sia necessario analizzare il messaggio di testo per determinare l'intervallo di tempo.A query can find all logs within a particular RequestTime range without parsing the time out of the text message.

Registrazione delle eccezioniLogging exceptions

I metodi logger dispongono di overload che consentono di passare un'eccezione, come nell'esempio seguente:The logger methods have overloads that let you pass in an exception, as in the following example:

catch (Exception ex)
{
    _logger.LogWarning(LoggingEvents.GetItemNotFound, ex, "GetById({Id}) NOT FOUND", id);
    return NotFound();
}
return new ObjectResult(item);
catch (Exception ex)
{
    _logger.LogWarning(LoggingEvents.GetItemNotFound, ex, "GetById({Id}) NOT FOUND", id);
    return NotFound();
}
return new ObjectResult(item);

Provider diversi gestiscono le informazioni sulle eccezioni in modi diversi.Different providers handle the exception information in different ways. Ecco un esempio di output del provider Debug dal codice sopra riportato.Here's an example of Debug provider output from the code shown above.

TodoApiSample.Controllers.TodoController: Warning: GetById(55) NOT FOUND

System.Exception: Item not found exception.
   at TodoApiSample.Controllers.TodoController.GetById(String id) in C:\TodoApiSample\Controllers\TodoController.cs:line 226

Filtro dei logLog filtering

È possibile specificare un livello di registrazione minimo per un provider e una categoria specifici oppure per tutti i provider o tutte le categorie.You can specify a minimum log level for a specific provider and category or for all providers or all categories. Tutti i log sotto il livello minimo non sono passati al provider, quindi non vengono visualizzati o archiviati.Any logs below the minimum level aren't passed to that provider, so they don't get displayed or stored.

Per eliminare tutti i log, specificare LogLevel.None come livello di registrazione minimo.To suppress all logs, specify LogLevel.None as the minimum log level. Il valore intero di LogLevel.None è 6, maggiore di LogLevel.Critical (5).The integer value of LogLevel.None is 6, which is higher than LogLevel.Critical (5).

Creare regole di filtro nella configurazioneCreate filter rules in configuration

Il codice del modello di progetto chiama CreateDefaultBuilder per configurare la registrazione per i provider Console e Debug.The project template code calls CreateDefaultBuilder to set up logging for the Console and Debug providers. Il metodo CreateDefaultBuilder imposta inoltre la registrazione per la ricerca della configurazione in una sezione Logging, come illustrato in precedenza in questo articolo.The CreateDefaultBuilder method sets up logging to look for configuration in a Logging section, as explained earlier in this article.

I dati di configurazione specificano i livelli di registrazione minimi in base al provider e alla categoria, come nell'esempio seguente:The configuration data specifies minimum log levels by provider and category, as in the following example:

{
  "Logging": {
    "Debug": {
      "LogLevel": {
        "Default": "Information"
      }
    },
    "Console": {
      "IncludeScopes": false,
      "LogLevel": {
        "Microsoft.AspNetCore.Mvc.Razor.Internal": "Warning",
        "Microsoft.AspNetCore.Mvc.Razor.Razor": "Debug",
        "Microsoft.AspNetCore.Mvc.Razor": "Error",
        "Default": "Information"
      }
    },
    "LogLevel": {
      "Default": "Debug"
    }
  }
}
{
  "Logging": {
    "Debug": {
      "LogLevel": {
        "Default": "Information"
      }
    },
    "Console": {
      "IncludeScopes": false,
      "LogLevel": {
        "Microsoft.AspNetCore.Mvc.Razor.Internal": "Warning",
        "Microsoft.AspNetCore.Mvc.Razor.Razor": "Debug",
        "Microsoft.AspNetCore.Mvc.Razor": "Error",
        "Default": "Information"
      }
    },
    "LogLevel": {
      "Default": "Debug"
    }
  }
}

Questo codice JSON crea sei regole di filtro, una per il provider Debug, quattro per il provider Console e una per tutti i provider.This JSON creates six filter rules: one for the Debug provider, four for the Console provider, and one for all providers. Quando viene creato un oggetto ILogger, viene scelta una singola regola per ogni provider.A single rule is chosen for each provider when an ILogger object is created.

Regole di filtro nel codiceFilter rules in code

L'esempio seguente illustra come registrare le regole di filtro nel codice:The following example shows how to register filter rules in code:

.ConfigureLogging(logging =>
    logging.AddFilter("System", LogLevel.Debug)
           .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Trace))
WebHost.CreateDefaultBuilder(args)
    .UseStartup<Startup>()
    .ConfigureLogging(logging =>
        logging.AddFilter("System", LogLevel.Debug)
               .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Trace));

Il secondo AddFilter specifica il provider Debug tramite il nome del tipo.The second AddFilter specifies the Debug provider by using its type name. Il primo AddFilter si applica a tutti i provider in quanto non consente di specificare un tipo di provider.The first AddFilter applies to all providers because it doesn't specify a provider type.

Applicazione delle regole di filtroHow filtering rules are applied

I dati di configurazione e il codice AddFilter illustrato negli esempi precedenti creano le regole indicate nella tabella seguente.The configuration data and the AddFilter code shown in the preceding examples create the rules shown in the following table. I primi sei provengono dall'esempio di configurazione e gli ultimi due dall'esempio di codice.The first six come from the configuration example and the last two come from the code example.

NUMBERNumber ProviderProvider Categorie che iniziano con...Categories that begin with ... Livello di registrazione minimoMinimum log level
11 DebugDebug Tutte le categorieAll categories InformazioniInformation
22 ConsoleConsole Microsoft.AspNetCore.Mvc.Razor.InternalMicrosoft.AspNetCore.Mvc.Razor.Internal AvvisoWarning
33 ConsoleConsole Microsoft.AspNetCore.Mvc.Razor.RazorMicrosoft.AspNetCore.Mvc.Razor.Razor DebugDebug
44 ConsoleConsole Microsoft.AspNetCore.Mvc.RazorMicrosoft.AspNetCore.Mvc.Razor ErroreError
55 ConsoleConsole Tutte le categorieAll categories InformazioniInformation
66 Tutti i providerAll providers Tutte le categorieAll categories DebugDebug
77 Tutti i providerAll providers SystemSystem DebugDebug
88 DebugDebug MicrosoftMicrosoft TraceTrace

Quando viene creato un oggetto ILogger, l'oggetto ILoggerFactory seleziona una singola regola per ogni provider da applicare al logger.When an ILogger object is created, the ILoggerFactory object selects a single rule per provider to apply to that logger. Tutti i messaggi scritti da un'istanza di ILogger vengono filtrati in base alle regole selezionate.All messages written by an ILogger instance are filtered based on the selected rules. Tra le regole disponibili viene selezionata la regola più specifica possibile per ogni coppia di categoria e provider.The most specific rule possible for each provider and category pair is selected from the available rules.

L'algoritmo seguente viene usato per ogni provider quando viene creato un ILogger per una determinata categoria:The following algorithm is used for each provider when an ILogger is created for a given category:

  • Selezionare tutte le regole corrispondenti al provider o al relativo alias.Select all rules that match the provider or its alias. Se non viene trovata alcuna corrispondenza, selezionare tutte le regole con un provider vuoto.If no match is found, select all rules with an empty provider.
  • Dal risultato del passaggio precedente, selezionare le regole con il prefisso di categoria corrispondente più lungo.From the result of the preceding step, select rules with longest matching category prefix. Se non viene trovata alcuna corrispondenza, selezionare tutte le regole che non specificano una categoria.If no match is found, select all rules that don't specify a category.
  • Se sono selezionate più regole, scegliere l'ultima.If multiple rules are selected, take the last one.
  • Se non è selezionata alcuna regola, usare MinimumLevel.If no rules are selected, use MinimumLevel.

Con l'elenco di regole precedente, si supponga di creare un oggetto ILogger per la categoria "Microsoft.AspNetCore.Mvc.Razor.RazorViewEngine":With the preceding list of rules, suppose you create an ILogger object for category "Microsoft.AspNetCore.Mvc.Razor.RazorViewEngine":

  • Per il provider Debug si applicano le regole 1, 6 e 8.For the Debug provider, rules 1, 6, and 8 apply. La regola 8 è più specifica, così sarà quella selezionata.Rule 8 is most specific, so that's the one selected.
  • Per il provider Console si applicano le regole 3, 4, 5 e 6.For the Console provider, rules 3, 4, 5, and 6 apply. La regola 3 è la più specifica.Rule 3 is most specific.

L'istanza di ILogger risultante invia i log di livello Trace o superiore al provider Debug.The resulting ILogger instance sends logs of Trace level and above to the Debug provider. I log di livello Debug o superiore vengono inviati al provider Console.Logs of Debug level and above are sent to the Console provider.

Alias dei providerProvider aliases

Ogni provider definisce un alias che può essere utilizzato nella configurazione al posto del nome completo di tipo.Each provider defines an alias that can be used in configuration in place of the fully qualified type name. Per i provider predefiniti, usare gli alias seguenti:For the built-in providers, use the following aliases:

  • ConsoleConsole
  • DebugDebug
  • EventSourceEventSource
  • EventLogEventLog
  • TraceSourceTraceSource
  • AzureAppServicesFileAzureAppServicesFile
  • AzureAppServicesBlobAzureAppServicesBlob
  • ApplicationInsightsApplicationInsights

Livello minimo predefinitoDefault minimum level

Esiste un'impostazione del livello minimo che diventa effettiva solo se non si applica alcuna regola di configurazione o codice per un provider e una categoria specifici.There's a minimum level setting that takes effect only if no rules from configuration or code apply for a given provider and category. L'esempio seguente illustra come impostare il livello minimo:The following example shows how to set the minimum level:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging => logging.SetMinimumLevel(LogLevel.Warning))
WebHost.CreateDefaultBuilder(args)
    .UseStartup<Startup>()
    .ConfigureLogging(logging => logging.SetMinimumLevel(LogLevel.Warning));

Se non si imposta in modo esplicito il livello minimo, il valore predefinito è Information, che indica che i log Trace e Debug vengono ignorati.If you don't explicitly set the minimum level, the default value is Information, which means that Trace and Debug logs are ignored.

Funzioni di filtroFilter functions

Una funzione di filtro viene richiamata per tutti i provider e le categorie a cui non sono assegnate regole tramite la configurazione o il codice.A filter function is invoked for all providers and categories that don't have rules assigned to them by configuration or code. Il codice della funzione ha accesso al tipo di provider, alla categoria e al livello di registrazione.Code in the function has access to the provider type, category, and log level. Esempio:For example:

.ConfigureLogging(logBuilder =>
{
    logBuilder.AddFilter((provider, category, logLevel) =>
    {
        if (provider == "Microsoft.Extensions.Logging.Console.ConsoleLoggerProvider" &&
            category == "TodoApiSample.Controllers.TodoController")
        {
            return false;
        }
        return true;
    });
})
WebHost.CreateDefaultBuilder(args)
    .UseStartup<Startup>()
    .ConfigureLogging(logBuilder =>
    {
        logBuilder.AddFilter((provider, category, logLevel) =>
        {
            if (provider == "Microsoft.Extensions.Logging.Console.ConsoleLoggerProvider" &&
                category == "TodoApiSample.Controllers.TodoController")
            {
                return false;
            }
            return true;
        });
    });

Livelli e categorie di sistemaSystem categories and levels

Di seguito sono elencate alcune categorie usate da ASP.NET Core ed Entity Framework Core, con note sui log previsti per ognuna:Here are some categories used by ASP.NET Core and Entity Framework Core, with notes about what logs to expect from them:

CategoryCategory NoteNotes
Microsoft.AspNetCoreMicrosoft.AspNetCore Diagnostica generale di ASP.NET Core.General ASP.NET Core diagnostics.
Microsoft.AspNetCore.DataProtectionMicrosoft.AspNetCore.DataProtection Chiavi considerate, trovate e usate.Which keys were considered, found, and used.
Microsoft.AspNetCore.HostFilteringMicrosoft.AspNetCore.HostFiltering Host consentiti.Hosts allowed.
Microsoft.AspNetCore.HostingMicrosoft.AspNetCore.Hosting Tempo impiegato per il completamento delle richieste HTTP e ora di inizio delle richieste.How long HTTP requests took to complete and what time they started. Assembly di avvio dell'hosting caricati.Which hosting startup assemblies were loaded.
Microsoft.AspNetCore.MvcMicrosoft.AspNetCore.Mvc Diagnostica di MVC e Razor.MVC and Razor diagnostics. Associazione di modelli, esecuzione di filtri, compilazione di viste, selezione di azioni.Model binding, filter execution, view compilation, action selection.
Microsoft.AspNetCore.RoutingMicrosoft.AspNetCore.Routing Informazioni sulla corrispondenza di route.Route matching information.
Microsoft.AspNetCore.ServerMicrosoft.AspNetCore.Server Risposte di avvio, arresto e keep-alive per la connessione.Connection start, stop, and keep alive responses. Informazioni sui certificati HTTPS.HTTPS certificate information.
Microsoft.AspNetCore.StaticFilesMicrosoft.AspNetCore.StaticFiles File forniti.Files served.
Microsoft.EntityFrameworkCoreMicrosoft.EntityFrameworkCore Diagnostica generale di Entity Framework Core.General Entity Framework Core diagnostics. Attività e configurazione del database, rilevamento delle modifiche, migrazioni.Database activity and configuration, change detection, migrations.

Ambiti dei logLog scopes

Un ambito può raggruppare un set di operazioni logiche.A scope can group a set of logical operations. Questo raggruppamento può essere usato per collegare gli stessi dati a ogni log creato come parte di un set.This grouping can be used to attach the same data to each log that's created as part of a set. Ad esempio, ogni log creato come parte dell'elaborazione di una transazione può includere l'ID transazione.For example, every log created as part of processing a transaction can include the transaction ID.

Un ambito è un tipo IDisposable restituito dal metodo BeginScope e viene mantenuto fino all'eliminazione.A scope is an IDisposable type that's returned by the BeginScope method and lasts until it's disposed. Un ambito si usa mediante il wrapping delle chiamate del logger in un blocco using:Use a scope by wrapping logger calls in a using block:

public IActionResult GetById(string id)
{
    TodoItem item;
    using (_logger.BeginScope("Message attached to logs created in the using block"))
    {
        _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
        item = _todoRepository.Find(id);
        if (item == null)
        {
            _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
            return NotFound();
        }
    }
    return new ObjectResult(item);
}
public IActionResult GetById(string id)
{
    TodoItem item;
    using (_logger.BeginScope("Message attached to logs created in the using block"))
    {
        _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
        item = _todoRepository.Find(id);
        if (item == null)
        {
            _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
            return NotFound();
        }
    }
    return new ObjectResult(item);
}

Il codice seguente abilita gli ambiti per il provider Console:The following code enables scopes for the console provider:

Program.cs:Program.cs:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging((hostingContext, logging) =>
        {
            logging.ClearProviders();
            logging.AddConsole(options => options.IncludeScopes = true);
            logging.AddDebug();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });
.ConfigureLogging((hostingContext, logging) =>
{
    logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
    logging.AddConsole(options => options.IncludeScopes = true);
    logging.AddDebug();
})

Nota

La configurazione dell'opzione del logger della console IncludeScopes è necessaria per abilitare la registrazione basata sull'ambito.Configuring the IncludeScopes console logger option is required to enable scope-based logging.

Per informazioni sulla configurazione, vedere la sezione Configurazione.For information on configuration, see the Configuration section.

Ogni messaggio di registrazione include le informazioni sull'ambito:Each log message includes the scoped information:

info: TodoApiSample.Controllers.TodoController[1002]
      => RequestId:0HKV9C49II9CK RequestPath:/api/todo/0 => TodoApiSample.Controllers.TodoController.GetById (TodoApi) => Message attached to logs created in the using block
      Getting item 0
warn: TodoApiSample.Controllers.TodoController[4000]
      => RequestId:0HKV9C49II9CK RequestPath:/api/todo/0 => TodoApiSample.Controllers.TodoController.GetById (TodoApi) => Message attached to logs created in the using block
      GetById(0) NOT FOUND

Provider di registrazione predefinitiBuilt-in logging providers

ASP.NET Core include i provider seguenti:ASP.NET Core ships the following providers:

Per informazioni su StdOut e la registrazione debug con il modulo ASP.NET Core, vedere Risolvere i problemi relativi a ASP.NET Core in app Azure servizio e IIS e Modulo ASP.NET Core.For information on stdout and debug logging with the ASP.NET Core Module, see Risolvere i problemi relativi a ASP.NET Core in app Azure servizio e IIS and Modulo ASP.NET Core.

Provider ConsoleConsole provider

Il pacchetto del provider Microsoft.Extensions.Logging.Console invia l'output della registrazione alla console.The Microsoft.Extensions.Logging.Console provider package sends log output to the console.

logging.AddConsole();

Per visualizzare l'output di registrazione del provider Console, aprire un prompt dei comandi nella cartella del progetto ed eseguire il comando seguente:To see console logging output, open a command prompt in the project folder and run the following command:

dotnet run

Provider DebugDebug provider

Il pacchetto del provider Microsoft.Extensions.Logging.Debug scrive l'output della registrazione usando la classe System.Diagnostics.Debug (chiamate del metodo Debug.WriteLine).The Microsoft.Extensions.Logging.Debug provider package writes log output by using the System.Diagnostics.Debug class (Debug.WriteLine method calls).

In Linux, questo provider scrive i log in /var/log/message.On Linux, this provider writes logs to /var/log/message.

logging.AddDebug();

Provider EventSourceEventSource provider

Per le app destinate a ASP.NET Core 1.1.0 o versione successiva, il pacchetto di provider Microsoft.Extensions.Logging.EventSource può implementare la traccia degli eventi.For apps that target ASP.NET Core 1.1.0 or later, the Microsoft.Extensions.Logging.EventSource provider package can implement event tracing. In Windows, usa ETW.On Windows, it uses ETW. Il provider è multipiattaforma, ma non sono ancora disponibili gli strumenti di raccolta e visualizzazione degli eventi per Linux o macOS.The provider is cross-platform, but there are no event collection and display tools yet for Linux or macOS.

logging.AddEventSourceLogger();

Un buon metodo per raccogliere e visualizzare i log consiste nell'usare l'utilità PerfView.A good way to collect and view logs is to use the PerfView utility. Sono disponibili altri strumenti per la visualizzazione dei log ETW, ma PerfView fornisce un'esperienza ottimale per l'uso con gli eventi ETW generati da ASP.NET Core.There are other tools for viewing ETW logs, but PerfView provides the best experience for working with the ETW events emitted by ASP.NET Core.

Per configurare PerfView per la raccolta degli eventi registrati da questo provider, aggiungere la stringa *Microsoft-Extensions-Logging nell'elenco Provider aggiuntiviTo configure PerfView for collecting events logged by this provider, add the string *Microsoft-Extensions-Logging to the Additional Providers list. (non dimenticare l'asterisco all'inizio della stringa).(Don't miss the asterisk at the start of the string.)

Provider aggiuntivi di PerfView

Provider EventLog di WindowsWindows EventLog provider

Il pacchetto di provider Microsoft.Extensions.Logging.AventLog invia l'output del log al registro eventi di Windows.The Microsoft.Extensions.Logging.EventLog provider package sends log output to the Windows Event Log.

logging.AddEventLog();

Gli overload di AddEventLog consentono di passare EventLogSettings.AddEventLog overloads let you pass in EventLogSettings.

Provider TraceSourceTraceSource provider

Il pacchetto di provider Microsoft.Extensions.Logging.TraceSource usa le librerie e i provider TraceSource.The Microsoft.Extensions.Logging.TraceSource provider package uses the TraceSource libraries and providers.

logging.AddTraceSource(sourceSwitchName);

Gli overload di AddTraceSource consentono di passare un cambio di origine e un listener di traccia.AddTraceSource overloads let you pass in a source switch and a trace listener.

Per usare questo provider, un'app deve essere in esecuzione in .NET Framework (invece che in .NET Core).To use this provider, an app has to run on the .NET Framework (rather than .NET Core). Il provider può instradare i messaggi a diversi listener, come TextWriterTraceListener, usato nell'app di esempio.The provider can route messages to a variety of listeners, such as the TextWriterTraceListener used in the sample app.

Provider del Servizio app di AzureAzure App Service provider

Il pacchetto di provider Microsoft.Extensions.Logging.AzureAppServices scrive i log in file di testo nel file system di un'app del Servizio app di Azure e nell'archivio di BLOB in un account di archiviazione di Azure.The Microsoft.Extensions.Logging.AzureAppServices provider package writes logs to text files in an Azure App Service app's file system and to blob storage in an Azure Storage account.

logging.AddAzureWebAppDiagnostics();

Il pacchetto del provider non è incluso nel framework condiviso.The provider package isn't included in the shared framework. Per usare il provider, aggiungere il relativo pacchetto al progetto.To use the provider, add the provider package to the project.

Il pacchetto del provider non è incluso nel metapacchetto Microsoft.AspNetCore.App.The provider package isn't included in the Microsoft.AspNetCore.App metapackage. Quando la destinazione è .NET Framework o il riferimento è il metapacchetto Microsoft.AspNetCore.App, aggiungere il pacchetto del provider al progetto.When targeting .NET Framework or referencing the Microsoft.AspNetCore.App metapackage, add the provider package to the project.

Per configurare le impostazioni del provider, usare AzureFileLoggerOptions e AzureBlobLoggerOptions, come illustrato nell'esempio seguente:To configure provider settings, use AzureFileLoggerOptions and AzureBlobLoggerOptions, as shown in the following example:

public static void Main(string[] args)
{
    var host = CreateHostBuilder(args).Build();

    var todoRepository = host.Services.GetRequiredService<ITodoRepository>();
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Feed the dog" });
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Walk the dog" });

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Seeded the database.");

    host.Run();
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging => logging.AddAzureWebAppDiagnostics())
            .ConfigureServices(serviceCollection => serviceCollection
                .Configure<AzureFileLoggerOptions>(options =>
                {
                    options.FileName = "azure-diagnostics-";
                    options.FileSizeLimit = 50 * 1024;
                    options.RetainedFileCountLimit = 5;
                }).Configure<AzureBlobLoggerOptions>(options =>
                {
                    options.BlobName = "log.txt";
                })
            )
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Per configurare le impostazioni del provider, usare AzureFileLoggerOptions e AzureBlobLoggerOptions, come illustrato nell'esempio seguente:To configure provider settings, use AzureFileLoggerOptions and AzureBlobLoggerOptions, as shown in the following example:

public static void Main(string[] args)
{
    var host = CreateWebHostBuilder(args).Build();

    var todoRepository = host.Services.GetRequiredService<ITodoRepository>();
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Feed the dog" });
    todoRepository.Add(new Core.Model.TodoItem() { Name = "Walk the dog" });

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Seeded the database.");

    host.Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .ConfigureLogging(logging => logging.AddAzureWebAppDiagnostics())
        .ConfigureServices(serviceCollection => serviceCollection
                .Configure<AzureFileLoggerOptions>(options =>
                {
                    options.FileName = "azure-diagnostics-";
                    options.FileSizeLimit = 50 * 1024;
                    options.RetainedFileCountLimit = 5;
                }).Configure<AzureBlobLoggerOptions>(options =>
                {
                    options.BlobName = "log.txt";
                }))
        .UseStartup<Startup>();

Un overload di AddAzureWebAppDiagnostics consente di passare AzureAppServicesDiagnosticsSettings.An AddAzureWebAppDiagnostics overload lets you pass in AzureAppServicesDiagnosticsSettings. L'oggetto impostazioni può eseguire l'override delle impostazioni predefinite, ad esempio il modello di output di registrazione, il nome di BLOB e il limite di dimensioni di file.The settings object can override default settings, such as the logging output template, blob name, and file size limit. Il modello di output è un modello di messaggio che viene applicato a tutti i log in aggiunta a quanto specificato quando si chiama un metodo ILogger.(Output template is a message template that's applied to all logs in addition to what's provided with an ILogger method call.)

Quando si distribuisce un'app del servizio app, l'applicazione applica le impostazioni della sezione Log del servizio app della pagina Servizio app del portale di Azure.When you deploy to an App Service app, the application honors the settings in the App Service logs section of the App Service page of the Azure portal. Quando le impostazioni seguenti vengono aggiornate, le modifiche hanno effetto immediatamente senza richiedere un riavvio o la ridistribuzione dell'app.When the following settings are updated, the changes take effect immediately without requiring a restart or redeployment of the app.

  • Registrazione applicazioni (file system)Application Logging (Filesystem)
  • Registrazione applicazione (BLOB)Application Logging (Blob)

Il percorso predefinito per i file di log è nella cartella D:\home\LogFiles\Application e il nome di file predefinito è diagnostics-aaaammgg.txt.The default location for log files is in the D:\home\LogFiles\Application folder, and the default file name is diagnostics-yyyymmdd.txt. Il limite predefinito per le dimensioni del file è 10 MB e il numero massimo predefinito di file conservati è 2.The default file size limit is 10 MB, and the default maximum number of files retained is 2. Il nome BLOB predefinito è {nome-app}{timestamp}/aaaa/mm/gg/hh/{guid}-applicationLog.txt.The default blob name is {app-name}{timestamp}/yyyy/mm/dd/hh/{guid}-applicationLog.txt.

Il provider funziona solo quando il progetto viene eseguito nell'ambiente di Azure.The provider only works when the project runs in the Azure environment. Non ha alcun effetto quando il progetto viene eseguito localmente, in quanto non scrive nulla in file locali o in archivi di sviluppo locali per i BLOB.It has no effect when the project is run locally—it doesn't write to local files or local development storage for blobs.

Flusso di registrazione di AzureAzure log streaming

Il flusso di registrazione di Azure consente di visualizzare l'attività di registrazione in tempo reale da:Azure log streaming lets you view log activity in real time from:

  • Server applicazioniThe app server
  • Server WebThe web server
  • Traccia delle richieste non riusciteFailed request tracing

Per configurare il flusso di registrazione di Azure:To configure Azure log streaming:

  • Passare alla pagina Log del servizio app dalla pagina del portale dell'app.Navigate to the App Service logs page from your app's portal page.
  • Impostare Registrazione applicazioni (file system) su .Set Application Logging (Filesystem) to On.
  • Scegliere il livello di registrazione in Livello.Choose the log Level.

Passare alla pagina Flusso di registrazione per visualizzare i messaggi dell'app.Navigate to the Log Stream page to view app messages. I messaggi vengono registrati dall'app tramite l'interfaccia ILogger.They're logged by the app through the ILogger interface.

Registrazione di traccia di Azure Application InsightsAzure Application Insights trace logging

Il pacchetto di provider Microsoft.Extensions.Logging.ApplicationInsights scrive log in Azure Application Insights.The Microsoft.Extensions.Logging.ApplicationInsights provider package writes logs to Azure Application Insights. Application Insights è un servizio che monitora un'app Web e fornisce gli strumenti per l'esecuzione di query sui dati di telemetria e la loro analisi.Application Insights is a service that monitors a web app and provides tools for querying and analyzing the telemetry data. Se si usa questo provider, è possibile eseguire query sui log e analizzarli usando gli strumenti di Application Insights.If you use this provider, you can query and analyze your logs by using the Application Insights tools.

Il provider di registrazione è incluso come dipendenza di Microsoft.ApplicationInsights.AspNetCore, ovvero il pacchetto che fornisce tutti i dati di telemetria disponibili per ASP.NET Core.The logging provider is included as a dependency of Microsoft.ApplicationInsights.AspNetCore, which is the package that provides all available telemetry for ASP.NET Core. Se si usa questo pacchetto, non è necessario installare il pacchetto di provider.If you use this package, you don't have to install the provider package.

Non usare il pacchetto Microsoft.ApplicationInsights.Web, che è per ASP.NET 4.x.Don't use the Microsoft.ApplicationInsights.Web package—that's for ASP.NET 4.x.

Per altre informazioni, vedere le seguenti risorse:For more information, see the following resources:

Provider di registrazione di terze partiThird-party logging providers

Framework di registrazione di terze parti che usano ASP.NET Core:Third-party logging frameworks that work with ASP.NET Core:

Alcuni framework di terze parti possono eseguire la registrazione semantica, nota anche come registrazione strutturata.Some third-party frameworks can perform semantic logging, also known as structured logging.

L'uso di un framework di terze parti è simile a quello di uno dei provider predefiniti:Using a third-party framework is similar to using one of the built-in providers:

  1. Aggiungere un pacchetto NuGet al progetto.Add a NuGet package to your project.
  2. Chiamare un metodo di estensione @no__t 0 fornito dal framework di registrazione.Call an ILoggerFactory extension method provided by the logging framework.

Per altre informazioni, vedere la documentazione di ogni provider.For more information, see each provider's documentation. I provider di registrazione di terze parti non sono supportati da Microsoft.Third-party logging providers aren't supported by Microsoft.

Risorse aggiuntiveAdditional resources