Aanmelden bij .NET en ASP.NET Core

In dit artikel wordt beschreven hoe u zich aanmeldt bij ASP.NET Core-apps. Zie Logboekregistratie in C# en .NET voor algemene richtlijnen voor logboekregistratie in .NET. Zie BlazorASP.NET Core-logboekregistratie Blazor voor logboekregistratiehulp, die aan deze richtlijn wordt toegevoegd of vervangen.

Providers voor logboekregistratie

ASP.NET Core ondersteunt hoge prestaties, gestructureerde logboekregistratie via de ILogger API om het gedrag van apps te bewaken en problemen te diagnosticeren. Logboeken worden naar verschillende bestemmingen geschreven door logboekregistratieproviders te configureren. Een set logboekproviders is ingebouwd in het framework en er zijn veel externe providers beschikbaar. Meerdere providers kunnen worden ingeschakeld in een app.

De meeste logboekproviders schrijven logboekberichten naar een gegevensopslagsysteem. De logboekregistratieprovider van Azure Application Insights slaat bijvoorbeeld logboeken op in Azure Application Insights. Eén provider, de Console provider, geeft alleen logboekberichten weer. De Console provider is handig bij het lokaal uitvoeren van een app voor het bewaken en opsporen van fouten in realtime.

var builder = WebApplication.CreateBuilder(args);

var builder = WebApplication.CreateBuilder(args);

builder.Logging.ClearProviders();
builder.Logging.AddConsole();

var builder = WebApplication.CreateBuilder(args);

builder.Host.ConfigureLogging(logging =>
{
    logging.ClearProviders();
    logging.AddConsole();
});

Host.CreateDefaultBuilder(args)

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

Aanvullende providers worden behandeld in de secties ingebouwde logboekregistratieproviders en externe logboekregistratieproviders .

Logboekuitvoer

Logboeken die zijn gemaakt door de standaardproviders voor logboekregistratie , worden weergegeven:

• In Visual Studio
  • In het uitvoervenster Debuggen tijdens het debuggen.
  • In het venster ASP.NET Core Web Server .
• In de opdrachtshell wanneer de app wordt uitgevoerd met de dotnet run opdracht.

.NET in het algemeen en ASP.NET Core gebruiken dezelfde API en providers voor logboekregistratie. Meer informatie vindt u in Logboekregistratie in C# en .NET, waarin algemene logboekregistratiescenario's voor C# en .NET worden beschreven. Dit artikel is gericht op ASP.NET Core-app-logboekregistratie.

Logboekberichten maken

Gebruik een ILogger<TCategoryName> object van afhankelijkheidsinjectie (DI) om logboekberichten te maken.

De volgende voorbeelden:

• Maak een ILoggerlogcategorie op basis van de volledig gekwalificeerde naam van het type. De logboekcategorie is een tekenreeks die is gekoppeld aan elk logboek, wat handig is voor het identificeren, sorteren en filteren van logboekberichten. Verderop in dit artikel vindt u meer informatie over logboekcategorieën .
• Roept LogInformation aan om u aan te melden op Information niveau. Het logboekniveau geeft de ernst van de vastgelegde gebeurtenis aan. Verderop in dit artikel vindt u meer informatie over logboekniveaus .

Op de volgende tellerpagina (CounterRazor onderdeel) in een Blazor app wordt een ILogger<Counter> opgenomen met de @inject instructie. Het logboekexemplaar (Logger) wordt gebruikt om informatie te registreren wanneer de IncrementCount methode wordt aangeroepen.

Pages/Counter.razor:

@page "/counter"
@inject ILogger<Counter> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogInformation("Someone incremented the counter!");

        currentCount++;
    }
}

Logboekbericht:

BlazorSample.Components.Pages.Counter: Information: Someone incremented the counter!

De logboekcategorie is BlazorSample.Components.Pages.Counteren het logboekniveau (ernst) is Information. Het bericht is Someone incremented the counter!.

In het volgende Razor privacypaginaklassebestand wordt een ILogger<PrivacyModel> in de klasseconstructor geïnjecteerd om vast te leggen wanneer de pagina wordt bezocht. In dit voorbeeld is het bericht een sjabloon dat de huidige UTC-datum en -tijd (DateTime.UtcNow) opneemt en in het logbericht schrijft. Sjablonen voor logboekberichten worden behandeld in de sectie Logboekberichtsjabloon verderop in dit artikel.

Pages/Privacy.cshtml.cs:

public class PrivacyModel(ILogger<PrivacyModel> logger) : PageModel
{
    public void OnGet() => logger.LogInformation("Privacy page visited at {DT}", 
        DateTime.UtcNow);
}

Sjabloon voor logboekberichten

De sjabloon voor logboekberichten kan tijdelijke aanduidingen voor opgegeven argumenten bevatten. Gebruik namen voor de tijdelijke aanduidingen, niet voor getallen.

In de volgende voorbeelden zijn {Id} een tijdelijke aanduiding voor een item-ID en id de ID-parameter.

Logger.LogInformation(LogEvent.GetItem, "Getting item {Id}", id);

Logger.LogWarning(LogEvent.GetItemNotFound, "Get({Id}) NOT FOUND", id);

De volgorde van de parameters, niet de namen van de tijdelijke aanduidingen, bepaalt welke parameters worden gebruikt om waarden voor tijdelijke aanduidingen in logboekberichten op te geven. In de volgende code staan de parameternamen in verkeerde volgorde in de tijdelijke aanduidingen van de berichtsjabloon.

var apples = 1;
var pears = 2;
var bananas = 3;

Logger.LogInformation("{Pears}, {Bananas}, {Apples}", apples, pears, bananas);

De parameters worden echter toegewezen aan de tijdelijke aanduidingen in de volgorde: apples, pears, bananas. Het logboekbericht weerspiegelt de volgorde van de parameters:

1, 2, 3

Met deze aanpak kunnen logboekproviders semantische of gestructureerde logboekregistratie implementeren. De argumenten zelf worden doorgegeven aan het logboekregistratiesysteem, niet alleen de opgemaakte berichtsjabloon. Hierdoor kunnen logboekproviders de parameterwaarden opslaan als velden. Denk bijvoorbeeld aan de volgende logmethode:

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

Wanneer u zich aanmeldt bij Azure Table Storage:

• Elke Azure Table-entiteit kan ID- en RequestTime-eigenschappen hebben.
• Tabellen met eigenschappen vereenvoudigen query's op vastgelegde gegevens. Een query kan bijvoorbeeld alle logboeken binnen een bepaald RequestTime bereik vinden zonder de time-out van het tekstbericht te hoeven parseren.

Aanmelden bij het opstarten van de app

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.Logger.LogInformation("Adding Routes");

app.MapGet("/", () => "Hello World!");

app.Logger.LogInformation("Starting the app");

app.Run();

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddConsole();

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.MapGet("/Test", async (ILogger<Program> logger, HttpResponse response) =>
{
    logger.LogInformation("'Test' logging in the Program file");
    await response.WriteAsync("Testing");
});

app.Run();

using Microsoft.Extensions.Logging.Console;

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddSimpleConsole(
    option => option.ColorBehavior = LoggerColorBehavior.Disabled);

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.MapGet("/Test", async (ILogger<Program> logger, HttpResponse response) =>
{
    logger.LogInformation("'Test' logging in the Program file");
    await response.WriteAsync("Testing");
});

app.Run();

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

    var logger = host.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Host created.");

    host.Run();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
{
    logger.LogInformation("'Startup'.Configure' logging");

    ...
}

Logboekregistratie configureren

Wanneer een ILogger object wordt gemaakt, wordt er een categorie opgegeven. Deze categorie is toegevoegd aan elk logboekbericht dat door dat exemplaar van de logger is gemaakt.

Het logboekniveau bepaalt het detailniveau voor logboekberichten op een standaardniveau voor de app als geheel en voor specifieke app-assembly's. Het logboekniveau kan worden ingesteld door een van de configuratieproviders.

App-instellingen

Configuratie van logboekregistratie wordt doorgaans gegeven door het gedeelte Logging van appsettings.{ENVIRONMENT}.json bestanden, waarbij de tijdelijke aanduiding {ENVIRONMENT} de omgeving voorstelt. Het volgende appsettings.Development.json bestand wordt gegenereerd door de ASP.NET Core-web-app-sjablonen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

In de voorgaande JSON:

• De "Default" en "Microsoft.AspNetCore" categorieën worden opgegeven.
• De "Microsoft.AspNetCore" categorie is van toepassing op alle categorieën die beginnen met "Microsoft.AspNetCore". Deze instelling is bijvoorbeeld van toepassing op de "Microsoft.AspNetCore.Routing.EndpointMiddleware" categorie.
• De "Microsoft.AspNetCore" categorie logboekitems worden opgenomen op logboekniveau Warning en hoger (meer ernstig).
• Er is geen specifieke logboekprovider opgegeven, dus LogLevel geldt dit voor alle ingeschakelde logboekregistratieproviders, met uitzondering van Windows EventLog.

De eigenschap Logging kan provider- en logeigenschappen LogLevel hebben. De LogLevel specificeert het minimale niveau dat moet worden vastgelegd voor geselecteerde categorieën. In de voorgaande JSON worden de logniveaus Information en Warning opgegeven. LogLevels geven de ernst van het logboek aan, die worden weergegeven in de volgende tabel met de bijbehorende enum waarden.

Wanneer een LogLevel is opgegeven, wordt logboekregistratie ingeschakeld voor berichten op het opgegeven niveau en hoger (ernstiger). In de voorgaande JSON wordt de Default categorie geregistreerd voor Information en hoger. Bijvoorbeeld, Information, Warningen ErrorCritical berichten worden vastgelegd. Als er geen LogLevel is opgegeven, wordt logboekregistratie standaard ingesteld op het Information niveau. Zie Logboekniveaus voor meer informatie.

Een providereigenschap kan een LogLevel eigenschap opgeven. LogLevel onder een provider geeft de niveaus op die moeten worden vastgelegd voor die provider en overschrijft de logboekinstellingen die niet van de provider zijn. Houd rekening met het volgende appsettings.json bestand:

{
  "Logging": {
    "LogLevel": { // All providers, LogLevel applies to all the enabled providers.
      "Default": "Error", // Default logging, Error and higher.
      "Microsoft": "Warning" // All Microsoft* categories, Warning and higher.
    },
    "Debug": { // Debug provider.
      "LogLevel": {
        "Default": "Information", // Overrides preceding LogLevel:Default setting.
        "Microsoft.Hosting": "Trace" // Debug:Microsoft.Hosting category.
      }
    },
    "EventSource": { // EventSource provider
      "LogLevel": {
        "Default": "Warning" // All categories of EventSource provider.
      }
    }
  }
}

Instellingen in Logging.{PROVIDER NAME}.LogLevel overrulen instellingen in Logging.LogLevel, waarbij de tijdelijke aanduiding {PROVIDER NAME} de naam van de provider is. In de voorgaande JSON is het standaardlogboekniveau van de Debug provider ingesteld op Information:

Logging:Debug:LogLevel:Default:Information

Met de voorgaande instelling wordt het Information logboekniveau voor elke Logging:Debug: categorie opgegeven, behalve Microsoft.Hosting. Wanneer een specifieke categorie wordt weergegeven, overschrijft de specifieke categorie de standaardcategorie. In de voorgaande JSON overschrijven de Logging:Debug:LogLevel categorieën "Microsoft.Hosting" en "Default" de instellingen in Logging:LogLevel.

Het minimale logboekniveau kan worden opgegeven voor een van de volgende:

• Voorbeeld van specifieke providers: Logging:EventSource:LogLevel:Default:Information
• Voorbeeld van specifieke categorieën: Logging:LogLevel:Microsoft:Warning
• Alle aanbieders en alle categorieën: Logging:LogLevel:Default:Warning

Logboeken onder het minimumniveau zijn niet:

• Doorgegeven aan de provider.
• Geregistreerd of weergegeven.

Als u alle logboeken wilt onderdrukken, geeft u op LogLevel.None. LogLevel.None heeft een waarde van 6, die hoger is dan LogLevel.Critical (5).

Als een provider logboekbereiken ondersteunt, IncludeScopes geeft aan of deze zijn ingeschakeld. Zie logboekbereikenvoor meer informatie.

Het volgende appsettings.json bestand bevat standaard alle providers die zijn ingeschakeld:

{
  "Logging": {
    "LogLevel": { // No provider, LogLevel applies to all the enabled providers.
      "Default": "Error",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Warning"
    },
    "Debug": { // Debug provider.
      "LogLevel": {
        "Default": "Information" // Overrides preceding LogLevel:Default setting.
      }
    },
    "Console": {
      "IncludeScopes": true,
      "LogLevel": {
        "Microsoft.AspNetCore.Mvc.Razor.Internal": "Warning",
        "Microsoft.AspNetCore.Mvc.Razor.Razor": "Debug",
        "Microsoft.AspNetCore.Mvc.Razor": "Error",
        "Default": "Information"
      }
    },
    "EventSource": {
      "LogLevel": {
        "Microsoft": "Information"
      }
    },
    "EventLog": {
      "LogLevel": {
        "Microsoft": "Information"
      }
    },
    "AzureAppServicesFile": {
      "IncludeScopes": true,
      "LogLevel": {
        "Default": "Warning"
      }
    },
    "AzureAppServicesBlob": {
      "IncludeScopes": true,
      "LogLevel": {
        "Microsoft": "Information"
      }
    },
    "ApplicationInsights": {
      "LogLevel": {
        "Default": "Information"
      }
    }
  }
}

In het voorgaande voorbeeld:

• De categorieën en niveaus zijn geen voorgestelde waarden. Het voorbeeld wordt gegeven om alle standaardproviders weer te geven.
• Instellingen in Logging.{PROVIDER NAME}.LogLevel overrulen instellingen in Logging.LogLevel, waarbij de tijdelijke aanduiding {PROVIDER NAME} de naam van de provider is. Bijvoorbeeld, het niveau in Debug.LogLevel.Default overschrijdt het niveau in LogLevel.Default.
• Elke alias van een standaardprovider wordt gebruikt. Elke provider definieert een alias die kan worden gebruikt in de configuratie in plaats van de volledig gekwalificeerde typenaam. De ingebouwde providersaliassen zijn:
  • Console
  • Debug
  • EventSource
  • EventLog
  • AzureAppServicesFile
  • AzureAppServicesBlob
  • ApplicationInsights

Opdrachtshell

Omgevingsvariabelen voor logboekregistratieconfiguratie kunnen worden ingesteld via een opdrachtshell.

Het :-scheidingsteken werkt niet met hiërarchische sleutels van omgevingsvariabelen op alle platformen. Het : scheidingsteken wordt bijvoorbeeld niet ondersteund door Bash. Het dubbele onderstrepingsteken, __, wordt door alle platforms ondersteund en wordt automatisch vervangen door een punt, :.

Stel een omgevingsvariabele in met de set opdracht in Windows voor de huidige opdrachtshell. In het volgende voorbeeld wordt de omgevingssleutel Logging:LogLevel:Microsoft ingesteld op een waarde van Information. U kunt de instelling testen met elke app die is gemaakt op basis van een ASP.NET Core-web-app-projectsjabloon.

set Logging__LogLevel__Microsoft=Information

Voer de dotnet run opdracht uit in de projectmap nadat u de voorgaande opdracht hebt set uitgevoerd:

dotnet run

De voorgaande omgevingsvariabele:

• Is alleen ingesteld voor apps die worden gestart vanuit de huidige opdrachtshell.
• Wordt niet gelezen door browsers die door Visual Studio of Visual Studio Code worden gestart.

Gebruik de setx opdracht om de omgevingsvariabele te behouden tussen opdrachtshell-exemplaren. De /M switch stelt de variabele in de systeemomgeving in. Als /M niet wordt gebruikt, wordt een omgevingsvariabele voor de gebruiker ingesteld.

setx Logging__LogLevel__Microsoft Information /M

Azure App Service configureren

Volg in Azure App Service de richtlijnen in Een App Service-app configureren om omgevingsvariabelen voor logboekregistratie in te stellen.

Zie Azure Apps: App-configuratie overschrijven met behulp van Azure Portal voor meer informatie.

Logboekcategorie

Wanneer een ILogger object wordt gemaakt, wordt er een categorie opgegeven. De categorie is opgenomen in elk logbericht dat door die instantie van de logger is gemaakt. De categorietekenreeks is willekeurig, maar de conventie is het gebruik van de volledig gekwalificeerde klassenaam. De ASP.NET Core-web-apps gebruiken ILogger<T> om een logboekregistratie-exemplaar te maken dat gebruikmaakt van de volledig gekwalificeerde typenaam van T als categorie.

Logboekberichten met een categorienaam die begint met 'Microsoft' zijn afkomstig van .NET. Logboekberichten die beginnen met de assemblynaam van de app, zijn doorgaans afkomstig van de app. Pakketten buiten .NET hebben meestal een categorie op basis van een assemblynaam van het pakket. Zie de sectie Algemene logboekcategorieën voor een lijst met algemene logboekcategorieën.

In een Razor component van een Blazor app, waarbij het type TCounter is voor een tellerpagina weergegeven door een Counter component (Pages/Counter.razor):

@inject ILogger<Counter> Logger

In een Razor paginaklassemodel, waarbij het type T voor een privacypagina is PrivacyModel (Pages/Privacy.cshtml.cs):

public class PrivacyModel(ILogger<PrivacyModel> logger) : PageModel

Als verdere categorisatie gewenst is, is het de conventie om een hiërarchische naam te gebruiken door een subcategorie toe te voegen aan de volledig gekwalificeerde klassenaam met behulp van ILoggerFactory.CreateLogger. Deze methode is handig voor het toekennen van een scope aan logboekberichten binnen component- of klassemethoden.

De volgende Counter componentlogs van de IncrementByOne functie met de BlazorSample.Components.Pages.Counter.IncrementByOne categorie en van de IncrementByTen functie met de BlazorSample.Components.Pages.Privacy.IncrementByTen categorie.

Pages/Counter.razor:

@page "/counter"
@inject ILogger<Counter> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementByOne">Click me (+1)</button>
<button class="btn btn-primary" @onclick="IncrementByTen">Click me (+10)</button>

@code {
    private int currentCount = 0;

    private void IncrementByOne()
    {
        var logger = Logger.CreateLogger($"{typeof(Counter)}.IncrementByOne");

        Logger.LogInformation("Someone incremented the counter!");

        currentCount++;
    }

    private void IncrementByTen()
    {
        var logger = Logger.CreateLogger($"{typeof(Counter)}.IncrementByTen");

        Logger.LogInformation("Someone incremented the counter!");

        currentCount += 10;
    }
}

Logboekberichten:

BlazorSample.Components.Pages.Counter.IncrementByOne: Information: Someone incremented the counter!
BlazorSample.Components.Pages.Counter.IncrementByTen: Information: Someone incremented the counter!

In een Razor paginaklassemodel dat gebruikmaakt van een aangepaste categorie ("CustomCategory") voor het hele paginamodel:

public class PrivacyModel(ILoggerFactory logger) : PageModel
{
    private readonly ILogger _logger = 
        logger.CreateLogger($"{typeof(PrivacyModel)}.CustomCategory");

    public void OnGet() =>
        _logger.LogInformation("Privacy page visited");
}

Logboekgebeurtenis-ID

Elk logboekbericht kan een gebeurtenis-id opgeven. In het volgende voorbeeld wordt een set aangepaste gebeurtenis-id's gemaakt voor gebruik door een app. U ziet hoe de id's zich in het bereik van 1000 bevinden voor CRUD-bewerkingen (create, read, update en delete), 3000 voor testlogboekregistratie en in het bereik van 4000 voor niet-gevonden scenario's:

public class LogEvent
{
    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 TestItem           = 3000;

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

Wordt gebruikt in Razor onderdeelcode, waarbij een ILogger<T> exemplaar (Logger) wordt geïnjecteerd:

• De LogEvent.GetItem ID (1002) wordt gebruikt in combinatie met het informatieve logboekbericht om een item op te halen op basis van zijn identificatie-ID (id).
• De LogEvent.GetItemNotFound id (4000) wordt gebruikt met het waarschuwingslogboekbericht als het item niet wordt gevonden.

Logger.LogInformation(LogEvent.GetItem, "Getting item {Id}", id);

var todoItem = await TodoItemService.FindAsync(id);

if (todoItem == null)
{
    Logger.LogWarning(LogEvent.GetItemNotFound, "Get({Id}) NOT FOUND", id);

    return NotFound();
}

De loggingprovider kan de gebeurtenis-ID opslaan in een ID (waardoor er gefilterd kan worden op de ID), in het logbericht of helemaal niet. De Debug provider toont geen gebeurtenis-id's. De consoleprovider toont gebeurtenis-ID's tussen vierkante haken na de categorie:

info: BlazorSample.Components.Pages.Items[1002]
      Getting item 1
warn: BlazorSample.Components.Pages.Items[4000]
      Get(1) NOT FOUND

Logboekniveau

In de volgende tabel worden de logboekniveaus beschreven van laagste tot hoogste ernst, de bijbehorende enum waarden en de methoden voor gemaksuitbreiding.

De eerste parameter van de Log methode, LogLevelgeeft de ernst van het logboek aan. In plaats van Log(LogLevel, ...) aan te roepen, roepen de meeste ontwikkelaars LoggerExtensions-methoden aan. De volgende twee aanroepen voor logboekregistratie zijn bijvoorbeeld functioneel gelijkwaardig en produceren hetzelfde op basis van een geïnjecteerd ILogger<T> exemplaar (Logger) in een Razor onderdeel:

Logger.Log(LogLevel.Information, LogEvent.TestItem, routeInfo);

Logger.LogInformation(LogEvent.TestItem, routeInfo);

Meld u aan op een geschikt niveau om te bepalen hoeveel logboekuitvoer naar een bepaald opslagmedium wordt geschreven:

• In productie:
  • Logboekregistratie op de Trace, Debugof Information niveaus produceert een groot aantal gedetailleerde logboekberichten. Als u de kosten wilt beheren en de limieten voor gegevensopslag niet wilt overschrijden, meldt u zich op deze niveaus aan bij een gegevensarchief met hoge volumes met lage kosten. Overweeg deze niveaus te beperken tot specifieke categorieën.
  • Logboekregistratie op WarningCritical niveaus produceert meestal weinig logboekberichten.
    • Kosten- en opslaglimieten zijn meestal geen probleem.
    • Enkele logboeken bieden meer flexibiliteit in keuzes voor gegevensopslag.
• In ontwikkeling:
  • We raden het Information niveau ("Default": "Information") aan voor standaardlogboekregistratie en het Warning niveau voor Microsoft ASP.NET Core-assembly's ("Microsoft.AspNetCore": "Warning").
  • Toevoegen Trace en Debug, of Information berichten bij het oplossen van problemen. Als u de uitvoer wilt beperken, stelt u deze logboekregistratieniveaus alleen in voor de categorieën die worden onderzocht.

Logboekniveaus wijzigen in een actieve app

De Logboekregistratie-API bevat geen ondersteuning voor het wijzigen van logboekniveaus terwijl een app wordt uitgevoerd. Echter, sommige configuratieproviders kunnen de configuratie opnieuw laden, wat direct van kracht wordt op de logboekconfiguratie. Bijvoorbeeld, de File Configuration Provider laadt standaard de loggingconfiguratie opnieuw. Als de configuratie in de code wordt gewijzigd terwijl een app wordt uitgevoerd, kan de app IConfigurationRoot.Reload aanroepen om de logconfiguratie van de app bij te werken.

Hoe filterregels worden toegepast

Wanneer een ILogger<TCategoryName> object wordt gemaakt, selecteert het ILoggerFactory object één regel per provider die op die logboekregistratie moet worden toegepast. Alle berichten die door een ILogger exemplaar zijn geschreven, worden gefilterd op basis van de geselecteerde regels. De meest specifieke regel voor elk provider- en categoriepaar is geselecteerd op basis van de beschikbare regels.

Het volgende algoritme wordt gebruikt voor elke provider wanneer een ILogger wordt gemaakt voor een bepaalde categorie:

• Selecteer alle regels die overeenkomen met de aanbieder of het alias. Als er geen overeenkomst wordt gevonden, selecteer alle regels met een lege aanbieder.
• Selecteer in het resultaat van de vorige stap regels met het langste overeenkomende categorievoorvoegsel. Als er geen overeenkomst wordt gevonden, selecteert u alle regels die geen categorie opgeven.
• Als er meerdere regels zijn geselecteerd, neemt u de laatste regel.
• Als er geen regels zijn geselecteerd, gebruikt u MinimumLevel.

ILogger en ILoggerFactory

ILogger<TCategoryName> en ILoggerFactory interfaces en implementaties zijn opgenomen in de .NET SDK. Ze zijn ook beschikbaar in de volgende NuGet-pakketten:

• De interfaces bevinden zich in het Microsoft.Extensions.Logging.Abstractions NuGet-pakket.
• De standaard implementaties bevinden zich in het Microsoft.Extensions.Logging NuGet-pakket.

Uitzonderingen in logboeken

De logboekregistratiemethoden hebben overbelastingen die een uitzonderingsparameter gebruiken:

try
{
   ...

   throw new Exception("Test exception");
}
catch (Exception ex)
{
    Logger.LogWarning(LogEvent.GetItemNotFound, ex, "Test exception at {DT}", 
        DateTime.UtcNow);
}

Uitzonderingslogboekregistratie is providerspecifiek.

Standaardlogboekniveau

Als het standaardlogboekniveau niet expliciet is ingesteld, is Informationhet standaardlogboekniveau.

Als het standaardlogboekniveau niet is ingesteld in de configuratie, kan het worden ingesteld met LoggingBuilderExtensions.SetMinimumLevel. In het volgende voorbeeld wordt het Warning niveau ingesteld als het standaardniveau voor logboekregistratie:

var builder = WebApplication.CreateBuilder();

builder.Logging.SetMinimumLevel(LogLevel.Warning);

U wordt aangeraden het minimale standaardlogboekniveau in de configuratie in te stellen, niet in C#-code.

Filterfunctie

Er wordt een filterfunctie aangeroepen voor alle providers en categorieën waaraan geen regels zijn toegewezen door configuratie of code. In het volgende voorbeeld worden consolelogboeken weergegeven wanneer de categorie Page of Microsoft bevat en het logboekniveau Information of hoger is.

var builder = WebApplication.CreateBuilder();

builder.Logging.AddFilter((provider, category, logLevel) =>
{
    if (provider is not null && category is not null)
    {
        return provider.Contains("ConsoleLoggerProvider")
            && (category.Contains("Page") || category.Contains("Microsoft"))
            && logLevel >= LogLevel.Information;
    }

    return false;
});

U wordt aangeraden logboekniveaus op te geven in de configuratie en niet in code met filterfuncties.

ASP.NET Kerncategorieën

De volgende tabel bevat enkele logboekcategorieën die worden gebruikt door ASP.NET Core.

Als u meer categorieën wilt bestuderen met behulp van de Console logger, stelt u appsettings.Development.json deze in een test-app in:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Trace",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }
}

Zie Simple Logging: Message categories (EF Core documentatie) voor een lijst met Entity Framework-categorieën.

Logboekbereiken

Een bereik kan een set logische bewerkingen groeperen. Deze groepering kan worden gebruikt om dezelfde gegevens toe te voegen aan elk logboek dat is gemaakt als onderdeel van een set. Elk logboek dat is gemaakt als onderdeel van het verwerken van een transactie, kan bijvoorbeeld de transactie-id bevatten.

Een bereik:

• Is een IDisposable type dat wordt geretourneerd door de BeginScope methode.
• Duurt totdat het wordt verwijderd.

De volgende providers ondersteunen scopes:

• Console
• AzureAppServicesFile en AzureAppServicesBlob

Gebruik een bereik door logboekoproepen in een using blok te verpakken:

public async Task<TodoItem> GetTodoItem(long id)
{
    TodoItem todoItem;
    var transactionId = Guid.NewGuid().ToString();

    using (Logger.BeginScope(new List<KeyValuePair<string, object>>
    {
        new KeyValuePair<string, object>("TransactionId", transactionId),
    }))
    {
        Logger.LogInformation(LogEvent.GetItem, "Getting item {Id}", id);

        todoItem = await TodoItemsService.FindAsync(id);

        if (todoItem == null)
        {
            Logger.LogWarning(LogEvent.GetItemNotFound, "Get({Id}) NOT FOUND", id);

            return NotFound();
        }
    }

    return todoItem;
}

Ingebouwde providers voor logboekregistratie

ASP.NET Core bevat de volgende logboekregistratieproviders:

• Console
• Debug
• EventSource
• Windows EventLog

De volgende providers voor logboekregistratie worden geleverd door Microsoft, maar niet als onderdeel van het gedeelde .NET-framework. Ze moeten worden geïnstalleerd als een extra NuGet-pakket dat aan de app is toegevoegd.

• AzureAppServicesFile en AzureAppServicesBlob
• ApplicationInsights

ASP.NET Core bevat geen logboekregistratieprovider voor het schrijven van logboeken naar bestanden. Als u logboeken naar bestanden wilt schrijven vanuit een ASP.NET Core-app, kunt u overwegen een externe logboekregistratieprovider te gebruiken.

Zie stdoutASP.NET Core Module (ANCM) voor IIS oplossen voor informatie over logboekregistratie en fouten opsporen in logboekregistratie met de ASP.NET Core-module.

Console

De Console provider registreert uitvoer naar de console. Zie de sectie Console voor meer informatie over het weergeven van logboeken in ontwikkeling.

Debug

De Debug provider schrijft logboekuitvoer met behulp van de System.Diagnostics.Debug klasse. Oproepen aan System.Diagnostics.Debug.WriteLine om te schrijven naar de Debug provider.

In Linux is de locatie van het Debug providerlogboek distributieafhankelijk en kan dit een van de volgende zijn:

• /var/log/message
• /var/log/syslog

EventSource

De EventSource provider schrijft naar een platformoverschrijdende gebeurtenisbron met de naam Microsoft-Extensions-Logging. In Windows gebruikt de provider ETW-.

dotnet-trace-hulpprogramma's

Het dotnet-trace hulpprogramma is een platformoverschrijdend ALGEMEEN CLI-hulpprogramma waarmee u .NET-traceringen van een actief proces kunt verzamelen. Het hulpprogramma verzamelt Microsoft.Extensions.Logging.EventSource providergegevens met behulp van een LoggingEventSource.

Zie voor installatie-instructies dotnet-trace.

Gebruik de dotnet-trace hulpprogramma's om een tracering van een app te verzamelen:

1. Voer de app uit met de dotnet run opdracht.

2. Bepaal de proces-id (PID) van de .NET-app:

   dotnet-trace ps
   

   Zoek de PID voor het proces met dezelfde naam als de assembly van de app.

3. Voer de dotnet-trace opdracht uit.

   Algemene opdrachtsyntaxis:

   • {PID}: Proces-id
   • {KEYWORD}:Trefwoord
   • {PROVIDER LEVEL}: Providerniveau
   • {LOGGER CATEGORY ...}: Logger categorie
   • {CATEGORY LEVEL ...}: Categorieniveau

   dotnet-trace collect -p {PID} 
       --providers Microsoft-Extensions-Logging:{KEYWORD}:{PROVIDER LEVEL}
           :FilterSpecs=\"
               {LOGGER CATEGORY 1}:{CATEGORY LEVEL 1};
               {LOGGER CATEGORY 2}:{CATEGORY LEVEL 2};
               ...
               {LOGGER CATEGORY N}:{CATEGORY LEVEL N}\"
   

   Wanneer u een PowerShell-opdrachtshell gebruikt, plaatst u de --providers waarde tussen enkele aanhalingstekens ('):

   dotnet-trace collect -p {PID} 
       --providers 'Microsoft-Extensions-Logging:{KEYWORD}:{PROVIDER LEVEL}
           :FilterSpecs=\"
               {LOGGER CATEGORY 1}:{CATEGORY LEVEL 1};
               {LOGGER CATEGORY 2}:{CATEGORY LEVEL 2};
               ...
               {LOGGER CATEGORY N}:{CATEGORY LEVEL N}\"'
   

   Voeg op niet-Windows-platforms de -f speedscope optie toe om de indeling van het uitvoertraceringsbestand te wijzigen in speedscope.

   In de volgende tabel wordt het trefwoord ({KEYWORD} tijdelijke aanduiding) gedefinieerd.

   Keyword	Description
   1	Logboekmeta-gebeurtenissen over de LoggingEventSource. Er worden geen gebeurtenissen vastgelegd van ILogger.
   2	Hiermee wordt de Message-gebeurtenis ingeschakeld wanneer ILogger.Log() wordt aangeroepen. Biedt informatie op een programmatische (niet opgemaakte) manier.
   4	Hiermee wordt de FormatMessage-gebeurtenis ingeschakeld wanneer ILogger.Log() wordt aangeroepen. Biedt de opgemaakte tekenreeksversie van de informatie.
   8	Hiermee wordt de MessageJson-gebeurtenis ingeschakeld wanneer ILogger.Log() wordt aangeroepen. Geeft een JSON-weergave van de argumenten.

   In de volgende tabel worden de providerniveaus gedefinieerd.

   Providerniveau	Description
   0	LogAlways
   1	Critical
   2	Error
   3	Warning
   4	Informational
   5	Verbose

   De parsering voor een categorieniveau kan een tekenreeks of een getal zijn, zoals aangegeven in de volgende tabel.

   Categorie benoemde waarde	Numerieke waarde
   Trace	0
   Debug	1
   Information	2
   Warning	3
   Error	4
   Critical	5

   Het niveau van de provider en het categorieniveau:

   • Zijn in omgekeerde volgorde.
   • De tekenreeksconstanten zijn niet allemaal identiek.

   Als er geen FilterSpecs zijn opgegeven, probeert de EventSourceLogger implementatie het providerniveau te converteren naar een categorieniveau en wordt deze toegepast op alle categorieën.

   Providerniveau	Categorieniveau
   Verbose(5)	Debug(1)
   Informational(4)	Information(2)
   Warning(3)	Warning(3)
   Error(2)	Error(4)
   Critical(1)	Critical(5)

   Als FilterSpecs zijn opgegeven, wordt het gecodeerde categorieniveau voor elke categorie in de lijst gebruikt. Alle andere categorieën worden uitgefilterd.

   In de volgende voorbeelden wordt ervan uitgegaan:

   • Een app is actief en voert een oproep naar Logger.LogDebug("12345") uit.
   • De proces-id (PID) wordt ingesteld via set PID=12345, waar 12345 is de werkelijke PID.

   Kijk eens naar de volgende opdracht:

   dotnet-trace collect -p %PID% --providers Microsoft-Extensions-Logging:4:5
   

   De bovenstaande opdracht:

   • Registreert foutopsporingsberichten.
   • Past geen FilterSpecs.
   • Specificeert niveau 5 dat overeenkomt met categorie Debug.

   Kijk eens naar de volgende opdracht:

   dotnet-trace collect -p %PID%  --providers Microsoft-Extensions-Logging:4:5:\"FilterSpecs=*:5\"
   

   De bovenstaande opdracht:

   • Registreert geen foutopsporingsberichten omdat categorieniveau 5 is Critical.
   • Biedt een FilterSpecs.

   Met de volgende opdracht worden foutopsporingsberichten vastgelegd omdat categorieniveau 1 aangeeft Debug:

   dotnet-trace collect -p %PID%  --providers Microsoft-Extensions-Logging:4:5:\"FilterSpecs=*:1\"
   

   Met de volgende opdracht worden foutopsporingsberichten vastgelegd omdat de categorie aangeeft Debug:

   dotnet-trace collect -p %PID%  --providers Microsoft-Extensions-Logging:4:5:\"FilterSpecs=*:Debug\"
   

   FilterSpecs vermeldingen voor de logboekcategorie en het categorieniveau vertegenwoordigen aanvullende voorwaarden voor logboekfiltering. Scheid FilterSpecs vermeldingen met het ; puntkommateken.

   Voorbeeld van een Windows-opdrachtprompt:

   dotnet-trace collect -p %PID% --providers Microsoft-Extensions-Logging:4:2:FilterSpecs=\"Microsoft.AspNetCore.Hosting*:4\"
   

   Met de voorgaande opdracht wordt het volgende geactiveerd:

   • De EventSource provider om opgemaakte tekenreeksen (4) voor foutmeldingen (2) te produceren.
   • Microsoft.AspNetCore.Hosting logboekregistratie op logboekregistratieniveau Information (4).

4. Stop de dotnet-trace hulpmiddelen door op Enter of Ctrl+C te drukken.

   De tracering wordt opgeslagen met de naam trace.nettrace in de map waarin de dotnet-trace opdracht wordt uitgevoerd.

5. Open de trace met Perfview. Open het trace.nettrace bestand en verken de traceringsevenementen.

Als de app de host niet bouwt metWebApplication.CreateBuilder, voeg dan de EventSource provider toe aan de logboekconfiguratie van de app.

Voor meer informatie, zie:

• Tracering voor hulpprogramma voor prestatieanalyse (dotnet-trace) (.NET-documentatie)
• Tracering voor prestatieanalysehulpprogramma (dotnet-trace) (dotnet/diagnostics GitHub-repositorydocumentatie)
• LoggingEventSource
• EventLevel
• Perfview voor het weergeven van EventSource traceringen

Perfview

Gebruik het hulpprogramma PerfView om logboeken te verzamelen en weer te geven. Er zijn andere hulpprogramma's voor het weergeven van ETW-logboeken, maar PerfView biedt de beste ervaring voor het werken met de ETW-gebeurtenissen die worden verzonden door ASP.NET Core.

Als u PerfView wilt configureren voor het verzamelen van gebeurtenissen die door deze provider zijn geregistreerd, voegt u de tekenreeks *Microsoft-Extensions-Logging toe aan de lijst Aanvullende providers . Mis het * aan het begin van de tekenreeks niet.

Windows Logboek

De Windows-provider EventLog verzendt logboekuitvoer naar het Windows-gebeurtenislogboek. In tegenstelling tot de andere providers neemt de EventLog provider de standaardinstellingen voor niet-providers niet over. Als EventLog logboekinstellingen niet zijn opgegeven, worden ze standaard ingesteld op LogLevel.Warning.

Als u gebeurtenissen wilt vastleggen die lager zijn dan LogLevel.Warning, stelt u het logboekniveau expliciet in. In het volgende voorbeeld wordt het standaardlogboekniveau van het gebeurtenislogboek ingesteld op LogLevel.Information:

"Logging": {
  "EventLog": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

AddEventLog overbelastingen kunnen worden EventLogSettingsdoorgegeven. Als null niet is opgegeven, worden de volgende standaardinstellingen gebruikt:

• LogName: "Application"
• SourceName: ".NET Runtime"
• MachineName: de naam van de lokale computer wordt gebruikt.

Met de volgende code verandert de SourceName van de standaardwaarde ".NET Runtime" naar "CustomLogs".

var builder = WebApplication.CreateBuilder();

builder.Logging.AddEventLog(eventLogSettings =>
{
    eventLogSettings.SourceName = "CustomLogs";
});

Wanneer de app de AddEventLog overbelasting aanroept EventLogSettings, wordt er een nieuw exemplaar gemaakt EventLogLoggerProvider met de opgegeven instellingen. Als er al een EventLogLoggerProvider exemplaar is geregistreerd, wat het geval is als de app niet aanroept ClearProviders om alle ILoggerProvider exemplaren te verwijderen, worden de bestaande instellingen niet vervangen door de nieuwe instellingen. Als u ervoor wilt zorgen dat de EventLogSettings worden gebruikt, moet u ClearProviders aanroepen voordat u AddEventLog aanroept.

Azure App Service

Het Microsoft.Extensions.Logging.AzureAppServices NuGet-providerpakket schrijft logboeken naar tekstbestanden in het bestandssysteem van een Azure App Service-app en naar blobopslag in een Azure Storage-account. De provider registreert alleen wanneer het project wordt uitgevoerd in de Azure-omgeving.

Het providerpakket is niet opgenomen in het gedeelde framework. Als u de provider wilt gebruiken, voegt u het providerpakket toe aan het project.

Als u providerinstellingen wilt configureren, gebruikt u AzureFileLoggerOptions en AzureBlobLoggerOptions, zoals wordt weergegeven in het volgende voorbeeld:

using Microsoft.Extensions.Logging.AzureAppServices;

var builder = WebApplication.CreateBuilder();

builder.Logging.AddAzureWebAppDiagnostics();

builder.Services.Configure<AzureFileLoggerOptions>(options =>
{
    options.FileName = "azure-diagnostics-";
    options.FileSizeLimit = 50 * 1024;
    options.RetainedFileCountLimit = 5;
});

builder.Services.Configure<AzureBlobLoggerOptions>(options =>
{
    options.BlobName = "log.txt";
});

public class Scopes
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().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>();
                });
    }
}

Wanneer de app is geïmplementeerd in Azure App Service, worden de instellingen in de App Service-logboeken sectie van de pagina App Service van Azure Portal gebruikt. Wanneer de volgende instellingen worden bijgewerkt, worden de wijzigingen onmiddellijk van kracht zonder dat de app opnieuw hoeft te worden opgestart of opnieuw hoeft te worden geïmplementeerd.

• Toepassingslogboekregistratie (bestandssysteem)
• Logboekregistratie van toepassingen (blob)

De standaardlocatie voor logboekbestanden is D:\home\LogFiles\Application. De standaardlimiet voor de bestandsgrootte is 10 MB en het maximum aantal bestanden dat wordt bewaard, is twee bestanden.

Azure-logboekstreaming

Azure-logboekstreaming biedt ondersteuning voor het weergeven van logboekactiviteiten in realtime vanuit:

• De app-server
• De webserver
• Tracering van mislukte aanvragen

Om Azure-logstreaming te configureren:

• Navigeer naar de App Service-logboeken pagina vanaf de portalpagina van de app.
• Stel application logging (bestandssysteem) in op On.
• Kies het logboek niveau. Deze instelling is alleen van toepassing op Azure-logboekstreaming.

Navigeer naar de pagina Logstream om logs weer te geven. De vastgelegde berichten worden vastgelegd met de ILogger interface.

Azure Application Insights

Application Insights is een service die een web-app bewaakt en hulpprogramma's biedt voor het opvragen en analyseren van de telemetriegegevens. Als u deze provider gebruikt, kunt u uw logboeken opvragen en analyseren met behulp van de Application Insights-hulpprogramma's.

Het NuGet-pakket van deMicrosoft.Extensions.Logging.ApplicationInsights provider schrijft logboeken naar Azure Application Insights. De logboekregistratieprovider is opgenomen als een afhankelijkheid van het Microsoft.ApplicationInsights.AspNetCore NuGet-pakket. Dit is het pakket dat alle beschikbare telemetrie biedt voor ASP.NET Core. Als u het Microsoft.ApplicationInsights.AspNetCore NuGet-pakket gebruikt, hoeft u het Microsoft.Extensions.Logging.ApplicationInsights providerpakket niet te installeren.

Zie de volgende bronnen voor meer informatie:

• Overzicht van Application Insights
• Application Insights voor ASP.NET Core-toepassingen: begin hier als u het volledige scala aan Application Insights-telemetrie wilt implementeren, samen met logboekregistratie.
• ApplicationInsightsLoggerProvider voor .NET ILogger-logboeken: begin hier als u de logboekregistratieprovider wilt implementeren zonder de rest van Application Insights-telemetrie.
• Application Insights-logboekregistratieadapters
• Installeer, configureer en initialiseer de interactieve zelfstudie over de Application Insights SDK .

Externe logboekregistratieproviders

Frameworks voor logboekregistratie van derden die werken met ASP.NET Core:

• elmah.io (GitHub-opslagplaats)
• Gelf (GitHub-opslagplaats)
• JSNLog (GitHub-opslagplaats)
• KissLog.net (GitHub-opslagplaats)
• Log4Net (GitHub-opslagplaats)
• NLog (GitHub-opslagplaats)
• PLogger (GitHub-opslagplaats)
• Sentry (GitHub-opslagplaats)
• Serilog (GitHub-opslagplaats)
• Stackdriver (GitHub-opslagplaats)

Sommige frameworks van derden kunnen semantische logboekregistratie uitvoeren, ook wel gestructureerde logboekregistratie genoemd.

Het gebruik van een framework van derden is vergelijkbaar met het gebruik van een van de ingebouwde providers:

1. Voeg het NuGet-pakket van de provider toe aan het project.
2. Roep een ILoggerFactory extensiemethode aan die wordt geleverd door het logboekregistratieframework.

Zie de documentatie van de provider voor meer informatie. Externe logboekregistratieproviders worden niet eigendom van, onderhouden of ondersteund door Microsoft.

Logboekregistratie van niet-hostconsole-apps

Zie Logboekregistratie in C# en .NET voor logboekregistratie in een console-app zonder de Generic Host. Zie voor een extra voorbeeld de voorbeeld-app Achtergrondtaken, die wordt gedekt door achtergrondtaken met gehoste services in ASP.NET Core.

Geen asynchrone logboekregistratiemethoden

Logboekregistratie moet zo snel zijn dat het de prestatiekosten van asynchrone code niet waard is. Als een logboekgegevensarchief traag is, moet u er niet rechtstreeks naar schrijven. Overweeg eerst de logboekberichten naar een snelle opslag te schrijven en de logboeken later naar het tragere gegevensarchief te verplaatsen. Schrijf bijvoorbeeld geen logboekberichten rechtstreeks naar een SQL Server-gegevensarchief in een Log methode omdat Log methoden synchroon zijn. Voeg in plaats daarvan synchroon logboekberichten toe aan een wachtrij in het geheugen en laat een achtergrondmedewerker de berichten uit de wachtrij halen om de gegevens asynchroon naar SQL Server te pushen. Zie Richtlijnen voor het aanmelden bij een berichtenwachtrij voor trage gegevensarchieven (dotnet/AspNetCore.Docs #11801) voor meer informatie.

Regels voor logboekfilters toepassen in code

De voorkeursmethode voor het instellen van logboekfilterregels is op basis van app-configuratie.

In het volgende voorbeeld ziet u hoe u filterregels in code registreert door aan te roepen AddFilterWebApplicationBuilder.Logging:

using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Logging.Debug;

var builder = WebApplication.CreateBuilder();

builder.Logging.AddFilter("System", LogLevel.Debug);
builder.Logging.AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information);
builder.Logging.AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace);

In het voorgaande voorbeeld:

• Het eerste filter geeft het volgende op:

  • Regels voor logboekfilters voor alle providers omdat een specifieke provider niet is geconfigureerd.
  • Alle categorieën beginnen met 'System'.
  • Logboekniveau Debug en hoger.

• De Debug provider (DebugLoggerProvider) geeft het volgende op:

  • Alle categorieën beginnen met 'Microsoft'.
  • Logboekniveau Information en hoger.

• De Console provider (ConsoleLoggerProvider) geeft het volgende op:

  • Alle categorieën beginnen met 'Microsoft'.
  • Logboekniveau Trace en hoger.

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddSimpleConsole(options =>
{
    options.IncludeScopes = true;
});

builder.Logging.Configure(options =>
{
    options.ActivityTrackingOptions = 
        ActivityTrackingOptions.SpanId | ActivityTrackingOptions.TraceId;
});

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

var loggerFactory = LoggerFactory.Create(logging =>
{
    logging.Configure(options =>
    {
        options.ActivityTrackingOptions = 
            ActivityTrackingOptions.SpanId | ActivityTrackingOptions.TraceId;
    }).AddSimpleConsole(options =>
    {
        options.IncludeScopes = true;
    });
});

Maak een aangepaste logger

Zie Een aangepaste logboekregistratieprovider implementeren in .NET om een aangepaste logboekregistratie te maken.

var builtConfig = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddCommandLine(args)
    .Build();

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File(builtConfig["Logging:FilePath"])
    .CreateLogger();

try
{
    return Host.CreateDefaultBuilder(args)
        .ConfigureServices((context, services) =>
        {
            services.AddRazorPages();
        })
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
            config.AddConfiguration(builtConfig);
        })
        .ConfigureLogging(logging =>
        {   
            logging.AddSerilog();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host builder error");

    throw;
}
finally
{
    Log.CloseAndFlush();
}

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

Bugrapporten loggen

Dien een foutenrapport voor logboekregistratie in in de Problemen met de dotnet/runtime GitHub-opslagplaats.

Algemene logboekcategorieën

In deze sectie worden algemene logboekcategorieën beschreven die worden weergegeven in ASP.NET Core-app-logboeken. Hier volgt geen uitgebreide lijst.

Microsoft.AspNetCore: Logboeken van de ASP.NET Core framework-onderdelen, zoals hosting, routering en middleware.

Authenticatie

• Microsoft.AspNetCore.Authentication: Logboeken van de verificatie-middleware en -services, inclusief verwerking van verificatieschema's.
• Microsoft.AspNetCore.Authentication.Cookies: Logboeken specifiek voor op cookie-gebaseerde authenticatie.
• Microsoft.AspNetCore.Authentication.JwtBearer: Logboeken met betrekking tot JWT Bearer-tokenverificatie.
• Microsoft.AspNetCore.Authentication.OpenIdConnect: Logboeken met betrekking tot OpenID Connect-verificatieprocessen.
• Microsoft.AspNetCore.Authentication.OAuth: Logboeken met betrekking tot OAuth-verificatie- en autorisatiestromen.

Authorization

• Microsoft.AspNetCore.Authorization: Logboeken met betrekking tot autorisatiebewerkingen, waaronder beleidsevaluatie en besluitvorming.
• Microsoft.AspNetCore.Authorization.DefaultAuthorizationService: Logs met betrekking tot de standaardinstelling.

Configuratie

• Microsoft.Extensions.Configuration.Json: Logboeken van klassen die configuratiegegevens ophalen uit JSON-bestanden.
• Microsoft.Extensions.Configuration.UserSecrets: Logboeken met betrekking tot het laden van configuratiegegevens van gebruikersgeheimen.

CORS (Cross-Origin Resource Sharing)

• Microsoft.AspNetCore.Cors: Logboeken met betrekking tot CORS-middleware (Cross-Origin Resource Sharing) en beleidsevaluatie.
• Microsoft.AspNetCore.Cors.Infrastructure: Logboeken met betrekking tot configuratie en afdwinging van CORS-beleid.

Gegevensbescherming:

• Microsoft.AspNetCore.DataProtection: Logboeken van het systeem voor gegevensbeveiliging, waaronder sleutelbeheer, versleutelingsbewerkingen en welke sleutels werden overwogen, gevonden en gebruikt.
• Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager: Logboeken die specifiek zijn voor xml-sleutelbeheer, inclusief sleutelopslag en ophalen.

Diagnostics

• Microsoft.AspNetCore.Diagnostics: Logboeken over diagnostische gegevens en middleware voor foutafhandeling, waaronder uitzonderingsafhandeling en statuscodepagina's.
• Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware: Logboeken die specifiek zijn voor de verwerking van middleware voor ontwikkelaars-uitzonderingspagina's.
• Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware: Logboeken met betrekking tot het verwerken van uitzonderingen en het genereren van foutenreacties.
• Microsoft.AspNetCore.Diagnostics.StatusCodePageMiddleware: Logboeken met betrekking tot middleware en antwoordafhandeling van statuscodepagina's.

Hostfiltering

• Microsoft.AspNetCore.HostFiltering: Hosts die zijn toegestaan en geweigerd door de hostfiltering middleware.
• Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware: Logboeken met betrekking tot de middleware voor hostfilters, inclusief toegestane en geweigerde hosts.
• Microsoft.AspNetCore.HostFiltering.HostFilteringOptions: Logboeken met betrekking tot opties voor de HostFiltering-middleware.

Hosten

• Microsoft.AspNetCore.Hosting.Lifetime: Logboeken met betrekking tot de levenscyclus van de webhost, inclusief het starten en stoppen van gebeurtenissen.
• Microsoft.AspNetCore.Hosting.Diagnostics: registreert diagnostische gegevens, zoals het opstarten en afsluiten van toepassingen.
• Microsoft.AspNetCore.Hosting.RequestDelegate: Logboeken met betrekking tot de verwerking van HTTP-aanvragen door de toepassingspijplijn.
• Microsoft.AspNetCore.Hosting.Internal.WebHost: Interne logboeken van de webhost, handig voor het opsporen van problemen met de host.
• Microsoft.AspNetCore.Hosting.Internal.HostedServiceExecutor: Logboeken met betrekking tot de uitvoering van gehoste services door de webhost.

HTTP

• Microsoft.AspNetCore.Http.ConnectionLogging: Gerelateerd aan HTTP-verbindingen, waaronder het tot stand maken en beëindigen van verbindingen.
• Microsoft.AspNetCore.Http.DefaultHttpContext: Logboeken met betrekking tot het maken en gebruiken van HttpContext-exemplaren.
• Microsoft.AspNetCore.Http.Endpoints.EndpointMiddleware: Logboeken over eindpuntroutering en middleware-uitvoering.
• Microsoft.AspNetCore.Http.Response: Logboeken met betrekking tot http-antwoordverwerking.

HTTPS

• Microsoft.AspNetCore.HttpsPolicy: Logboeken van HTTPS-omleidingsmiddleware, beleidshandhaving en HTTP Strict-Transport-Security (HSTS).
• Microsoft.AspNetCore.HttpsPolicy.HstsMiddleware: Logboeken die specifiek zijn voor HTTP Strict-Transport-Security (HSTS) middlewareverwerking.
• Microsoft.AspNetCore.HttpsPolicy.HttpsRedirectionMiddleware: Logboeken met betrekking tot de uitvoering van HTTPS-omleidings-middleware.
• Microsoft.AspNetCore.HttpsPolicy.HstsOptions: Logboeken met betrekking tot configuratie en afdwinging van HSTS-beleid.

Identity

• Microsoft.AspNetCore.Identity: Logboeken van het ASP.NET Core-framework Identity , met inbegrip van gebruikersbeheer- en identiteitsbewerkingen.
• Microsoft.AspNetCore.Identity.RoleManager: Logboeken met betrekking tot bewerkingen voor rolbeheer.
• Microsoft.AspNetCore.Identity.UserManager: Logboeken met betrekking tot activiteiten van gebruikersbeheer en levenscyclus-gebeurtenissen.

Kestrel

• Microsoft.AspNetCore.Server.Kestrel: Logboeken van de Kestrel webserver, met betrekking tot de verwerking van verbindingen en aanvraagverwerking.
• Microsoft.AspNetCore.Server.Kestrel.Core: Logboeken met betrekking tot kernbewerkingen Kestrel , zoals configuratie en resourcebeheer.
• Microsoft.AspNetCore.Server.Kestrel.Transport: Logboeken die specifiek zijn voor netwerktransportlagen die worden gebruikt door Kestrel.

Loggen

• Microsoft.Extensions.Logging: Logboeken van de logging-extensies API.
• Microsoft.Extensions.Logging.Console: Logs die specifiek zijn voor de Console-log.

MVC

• Microsoft.AspNetCore.Mvc: Algemene logboeken van MVC-frameworkonderdelen, waaronder controller- en actie-uitvoering.
• Microsoft.AspNetCore.Mvc.Infrastructure: Logboeken met betrekking tot de infrastructuur en ondersteuningsservices voor MVC, zoals modelbinding en actiefilters.
• Microsoft.AspNetCore.Mvc.ModelBinding: Logboeken met betrekking tot modelbindingsbewerkingen en gegevensvalidatie.
• Microsoft.AspNetCore.Mvc.Filters: Logbestanden over de uitvoering van actiefilters en filterpijplijnen.
• Microsoft.AspNetCore.Mvc.Razor: Logboeken die specifiek zijn voor Razor weergave en compilatie.
• Microsoft.AspNetCore.Mvc.ViewFeatures: Logboeken met betrekking tot weergaverendering en gerelateerde functies, zoals weergavecomponenten en taghelpers.

Routebepaling

• Microsoft.AspNetCore.Routing.EndpointMiddleware: Logboeken met betrekking tot de routering van HTTP-aanvragen naar eindpunten.
• Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware: Logboeken over de middleware voor aanvraagverwerking met betrekking tot eindpuntroutering.
• Microsoft.AspNetCore.Routing.Matching.DataSourceDependentMatcher: Logboeken met betrekking tot routekoppeling en selectie van eindpunten.
• Microsoft.AspNetCore.Routing.Matching.DfaMatcher: Logs specifiek voor de DFA-routeringsmatcher (Deterministische Eindige Automaat).

SignalR

• Microsoft.AspNetCore.SignalR: Logboeken van het SignalR framework, inclusief hubverbindingen en berichtafhandeling.
• Microsoft.AspNetCore.SignalR.Hub: Logboeken die specifiek zijn voor het aanroepen van hubs en het verzenden van berichten.
• Microsoft.AspNetCore.SignalR.Transports: Logboeken met betrekking tot transportmechanismen die worden gebruikt door SignalR.

Statische bestanden

• Microsoft.AspNetCore.StaticFiles: Logboeken van de middleware voor statische bestanden, waaronder bewerkingen voor bestandslevering en cachebewerkingen.
• Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware: Logboeken met betrekking tot uitvoering van statische bestands-middleware en verwerking van bestandsreacties.

Aanvullende bronnen

• ASP.NET Core Blazor logboekregistratie
• Prestaties van logboekregistratie verbeteren met brongeneratoren
• Achter [LogProperties] en de nieuwe brongenerator voor telemetrieregistratie
• Microsoft.Extensions.Logging referentiebron (dotnet/runtime) GitHub-opslagplaats
• Logboekregistratie met hoge prestaties
• Voorbeeldcode bekijken of downloaden (hoe download je)