Přihlášení v .NET

Rozhraní .NET podporuje protokolovací rozhraní API, které funguje s celou řadou integrovaných zprostředkovatelů protokolování a jiných výrobců. V tomto článku se dozvíte, jak používat rozhraní API protokolování s integrovanými poskytovateli. Většina příkladů kódu uvedených v tomto článku se týká libovolné aplikace .NET, která používá obecného hostitele. Pro aplikace, které nepoužívají obecného hostitele, se podívejte na nehostitelskou konzolovou aplikaci.

Vytvořit protokoly

Chcete-li vytvořit protokoly, použijte ILogger<TCategoryName> objekt z Injektáže závislosti (di).

Následující příklad:

  • Vytvoří protokolovací nástroj, ILogger<Worker> který používá kategorii protokolu plně kvalifikovaného názvu typu Worker . Kategorie protokolu je řetězec, který je spojený s každým protokolem.
  • Volání LogInformation do protokolu na Information úrovni. Úroveň protokolu označuje závažnost protokolované události.
public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger) =>
        _logger = logger;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.UtcNow);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

Úrovně a kategorie jsou podrobněji vysvětleny dále v tomto článku.

Konfigurovat protokolování

Konfigurace protokolování je běžně poskytována Logging oddílem appSettings. {Environment} soubory . JSON . Následující appsettings.Development.jsv souboru vygeneruje šablony služby .NET Worker:

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

V předchozím fragmentu kódu JSON:

  • "Default" "Microsoft" "Microsoft.Hosting.Lifetime" Jsou určeny kategorie, a.
  • "Microsoft"Kategorie se vztahuje na všechny kategorie, které začínají na "Microsoft" .
  • "Microsoft"Protokol kategorie na úrovni protokolu Warning a vyšším.
  • "Microsoft.Hosting.Lifetime"Kategorie je konkrétnější než "Microsoft" kategorie, takže se v "Microsoft.Hosting.Lifetime" kategorii protokoluje na úrovni protokolu "informace" a vyšší.
  • konkrétního poskytovatele protokolu není zadaný, takže LogLevel se použije na všechny povolené zprostředkovatele protokolování s výjimkou Windows protokolu událostí.

LoggingVlastnost může mít LogLevel vlastnosti a log Provider. LogLevelUrčuje minimální úroveň protokolu pro vybrané kategorie. V předchozím kódu JSON Information Warning jsou zadány úrovně protokolu. LogLevel označuje závažnost protokolu a rozsahů od 0 do 6:

Trace = 0, Debug = 1, Information = 2, Warning = 3, = Error 4, Critical = 5 a None = 6.

Je-li LogLevel zadán parametr, je protokolování povoleno pro zprávy na zadané úrovni a vyšší. V předchozím formátu JSON Default kategorie je protokolována Information a vyšší. Například zprávy, Information , Warning Error a Critical jsou protokolovány. Pokud LogLevel není zadaný, použije se jako výchozí Information úroveň protokolování. Další informace najdete v tématu úrovně protokolu.

Vlastnost zprostředkovatele může určovat LogLevel vlastnost. LogLevel v části poskytovatel Určuje úrovně, které se mají protokolovat pro daného zprostředkovatele, a přepíše nastavení protokolu bez poskytovatele. V souboru zvažte následující appsettings.js :

{
    "Logging": {
        "LogLevel": {
            "Default": "Error",
            "Microsoft": "Warning"
        },
        "Debug": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft.Hosting": "Trace"
            }
        },
        "EventSource": {
            "LogLevel": {
                "Default": "Warning"
            }
        }
    }
}

Nastavení v Logging.{ProviderName}.LogLevel nastavení přepsání v Logging.LogLevel . V předchozím formátu JSON Debug je výchozí úroveň protokolu poskytovatele nastavená na Information :

Logging:Debug:LogLevel:Default:Information

Předchozí nastavení určuje Information úroveň protokolu pro každou Logging:Debug: kategorii s výjimkou Microsoft.Hosting . Když je uvedena konkrétní kategorie, konkrétní kategorie přepíše výchozí kategorii. V předchozím formátu JSON Logging:Debug:LogLevel Kategorie "Microsoft.Hosting" a "Default" přepisují nastavení v Logging:LogLevel

Minimální úroveň protokolu může být zadána pro některý z těchto:

  • Konkrétní poskytovatelé: například Logging:EventSource:LogLevel:Default:Information
  • Konkrétní kategorie: například Logging:LogLevel:Microsoft:Warning
  • Všichni zprostředkovatelé a všechny kategorie: Logging:LogLevel:Default:Warning

Všechny protokoly pod minimální úrovní nejsou:

  • Předáno poskytovateli.
  • Protokolováno nebo zobrazeno.

Pokud chcete potlačit všechny protokoly, zadejte LogLevel. None. LogLevel.None má hodnotu 6, která je vyšší než LogLevel.Critical (5).

Pokud zprostředkovatel podporuje obory protokolů, IncludeScopes označuje, zda jsou povoleny. Další informace najdete v tématu rozsahy protokolů .

Následující appsettings.js souboru obsahuje nastavení pro všechny předdefinované zprostředkovatele:

{
    "Logging": {
        "LogLevel": {
            "Default": "Error",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Warning"
        },
        "Debug": {
            "LogLevel": {
                "Default": "Information"
            }
        },
        "Console": {
            "IncludeScopes": true,
            "LogLevel": {
                "Microsoft.Extensions.Hosting": "Warning",
                "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"
            }
        }
    }
}

V předchozí ukázce:

  • Kategorie a úrovně nejsou navrhovanými hodnotami. Ukázka je k dispozici pro zobrazení všech výchozích zprostředkovatelů.
  • Nastavení v Logging.{ProviderName}.LogLevel nastavení přepsání v Logging.LogLevel . Například úroveň v Debug.LogLevel.Default Přepisuje úroveň v LogLevel.Default .
  • Použije se alias každého poskytovatele. Každý zprostředkovatel definuje alias , který lze použít v konfiguraci místo plně kvalifikovaného názvu typu. Mezi předdefinované aliasy zprostředkovatelů patří:
    • Konzola
    • Ladění
    • EventSource
    • EventLog
    • AzureAppServicesFile
    • AzureAppServicesBlob
    • ApplicationInsights

Nastavení úrovně protokolu podle příkazového řádku, proměnných prostředí a jiné konfigurace

Úroveň protokolu může být nastavena libovolnými poskytovateli konfigurace. Můžete například vytvořit trvalou proměnnou prostředí s názvem Logging:LogLevel:Microsoft s hodnotou Information .

Vytvořte a přiřaďte proměnnou trvalého prostředí s ohledem na hodnotu úrovně protokolu.

:: Assigns the env var to the value
setx "Logging__LogLevel__Microsoft" "Information" /M

V nové instanci příkazového řádku si přečtěte proměnnou prostředí.

:: Prints the env var value
echo %Logging__LogLevel__Microsoft%

Předchozí nastavení prostředí je v prostředí trvalé. Chcete-li otestovat nastavení při použití aplikace vytvořené pomocí šablon služby .NET Worker, použijte dotnet run příkaz v adresáři projektu po přiřazení proměnné prostředí.

dotnet run

Tip

Po nastavení proměnné prostředí restartujte integrované vývojové prostředí (IDE), aby bylo zajištěno, že nově přidané proměnné prostředí budou k dispozici.

v Azure App Servicena stránce konfigurace > Nastavení vyberte nové nastavení aplikace . Azure App Service nastavení aplikace:

  • Šifrované v klidovém stavu a přenášené přes zašifrovaný kanál.
  • Vystaveno jako proměnné prostředí.

Další informace o nastavení hodnot konfigurace .NET pomocí proměnných prostředí naleznete v tématu proměnné prostředí.

Jak se používají pravidla filtrování

Při ILogger<TCategoryName> vytvoření objektu ILoggerFactory vybere objekt jedno pravidlo pro každého poskytovatele, které se použije pro tento protokolovací nástroj. Všechny zprávy napsané ILogger instancí jsou filtrovány podle vybraných pravidel. Z dostupných pravidel je vybráno pravidlo s nejpřesnější pro každou dvojici zprostředkovatelů a kategorií.

Následující algoritmus se používá pro každého poskytovatele při ILogger vytvoření pro danou kategorii:

  • Vyberte všechna pravidla, která se shodují se zprostředkovatelem nebo jeho aliasem. Pokud se nenajde žádná shoda, vyberte všechna pravidla s prázdným zprostředkovatelem.
  • Z výsledku předchozího kroku vyberte pravidla s nejdelší vyhovující předponou kategorie. Pokud se nenajde žádná shoda, vyberte všechna pravidla, která neurčují kategorii.
  • Pokud je vybráno více pravidel, vezměte Poslední z nich.
  • Pokud nejsou vybrána žádná pravidla, použijte LoggingBuilderExtensions.SetMinimumLevel(ILoggingBuilder, LogLevel) k určení minimální úrovně protokolování.

Kategorie protokolu

Při ILogger vytvoření objektu je zadána kategorie . Tato kategorie je součástí každé zprávy protokolu vytvořené pomocí této instance ILogger . Řetězec kategorie je libovolný, ale konvence používá název třídy. Například v aplikaci, která je definována jako následující objekt, může být kategorie "Example.DefaultService" :

namespace Example
{
    public class DefaultService : IService
    {
        private readonly ILogger<DefaultService> _logger;

        public DefaultService(ILogger<DefaultService> logger) =>
            _logger = logger;

        // ...
    }
}

Chcete-li explicitně zadat kategorii, zavolejte LoggerFactory.CreateLogger :

namespace Example
{
    public class DefaultService : IService
    {
        private readonly ILogger _logger;

        public DefaultService(ILoggerFactory loggerFactory) =>
            _logger = loggerFactory.CreateLogger("CustomCategory");

        // ...
    }
}

Volání CreateLogger s pevným názvem může být užitečné při použití v několika třídách/typech, aby mohly být události uspořádány podle kategorie.

ILogger<T> je ekvivalentní volání CreateLogger s plně kvalifikovaným názvem typu T .

Úroveň protokolování

Následující tabulka uvádí LogLevel hodnoty, Log{LogLevel} způsob rozšíření pohodlí a navrhované použití:

LogLevel Hodnota Metoda Popis
Trasování 0 LogTrace Obsahuje nejpodrobnější zprávy. Tyto zprávy mohou obsahovat citlivá data aplikací. Tyto zprávy jsou ve výchozím nastavení zakázané a neměly by být povolené v produkčním prostředí.
Ladění 1 LogDebug Pro ladění a vývoj. Používejte s opatrností v produkčním prostředí kvůli vysokému objemu.
Informace 2 LogInformation Sleduje obecný tok aplikace. Může mít dlouhodobou hodnotu.
Upozornění 3 LogWarning Pro neobvyklé nebo neočekávané události. Obvykle obsahuje chyby nebo podmínky, které nezpůsobí selhání aplikace.
Chyba 4 LogError Pro chyby a výjimky, které nelze zpracovat. Tyto zprávy označují selhání aktuální operace nebo žádosti, ne selhání celé aplikace.
Kritické 5 LogCritical Chyby, které vyžadují okamžitou pozornost. Příklady: scénáře ztráty dat, nedostatek místa na disku.
Žádný 6 Určuje, že se nemají zapisovat žádné zprávy.

V předchozí tabulce LogLevel je uveden od nejnižší k nejvyšší závažnosti.

První parametr metody protokolu , LogLevel , označuje závažnost protokolu. Místo volání Log(LogLevel, ...) by většina vývojářů volala metody rozšíření log {LogLevel} . Log{LogLevel}Rozšiřující metody volají metodu protokolu a určují rozsah LogLevel. Například následující dvě volání protokolování jsou funkčně ekvivalentní a tvoří stejný protokol:

public void LogDetails()
{
    var logMessage = "Details for log.";

    _logger.Log(LogLevel.Information, AppLogEvents.Details, logMessage);
    _logger.LogInformation(AppLogEvents.Details, logMessage);
}

AppLogEvents.Details je ID události a implicitně je reprezentovaná konstantní Int32 hodnotou. AppLogEvents je třída, která zpřístupňuje různé pojmenované konstanty identifikátorů a je zobrazena v části ID události protokolu .

Následující kód vytváří Information a Warning protokoluje:

public async Task<T> GetAsync<T>(string id)
{
    _logger.LogInformation(AppLogEvents.Read, "Reading value for {Id}", id);

    var result = await _repository.GetAsync(id);
    if (result is null)
    {
        _logger.LogWarning(AppLogEvents.ReadNotFound, "GetAsync({Id}) not found", id);
    }

    return result;
}

V předchozím kódu Log{LogLevel} je prvním parametrem AppLogEvents.Read ID události protokolu. Druhý parametr je šablona zprávy se zástupnými symboly pro hodnoty argumentů poskytované zbývajícími parametry metody. Parametry metody jsou vysvětleny v části Šablona zprávy dále v tomto článku.

Nakonfigurujte příslušnou úroveň protokolu a zavolejte správné Log{LogLevel} metody, abyste mohli řídit, kolik výstupu protokolu se zapisuje na konkrétní paměťové médium. Příklad:

  • V produkčním prostředí:
    • Protokolování na úrovni Trace nebo Information vytváří velké množství podrobných zpráv protokolu. Abyste mohli řídit náklady a nepřekračuje limity úložiště dat, protokolovat a vyhodnotit Trace Information zprávy na úrovni cloudového úložiště s nízkými náklady na velké objemy dat. Zvažte omezení Trace a Information konkrétní kategorie.
    • Přihlášení Warning prostřednictvím Critical úrovní by mělo mít za následek několik zpráv protokolu.
      • Náklady a limity úložiště většinou nejsou obavy.
      • Několik protokolů umožňuje větší flexibilitu v možnostech úložiště dat.
  • Ve vývoji:
    • Nastavte na Warning.
    • Přidání Trace Information zpráv při řešení potíží. Pro omezení výstupu, nastavení Trace nebo Information pouze pro kategorie v rámci šetření.

Následující sady JSON Logging:Console:LogLevel:Microsoft:Information :

{
    "Logging": {
        "LogLevel": {
            "Microsoft": "Warning"
        },
        "Console": {
            "LogLevel": {
                "Microsoft": "Information"
            }
        }
    }
}

ID události protokolu

Každý protokol může určovat identifikátorem události, EventId je strukturou s Id volitelnými Name vlastnostmi ReadOnly. Vzorový zdrojový kód používá AppLogEvents třídu k definování ID událostí:

internal static class AppLogEvents
{
    internal const int Create = 1000;
    internal const int Read = 1001;
    internal const int Update = 1002;
    internal const int Delete = 1003;

    internal const int Details = 3000;
    internal const int Error = 3001;

    internal const int ReadNotFound = 4000;
    internal const int UpdateNotFound = 4001;

    // ...
}

ID události přidružuje sadu událostí. Například všechny protokoly týkající se čtení hodnot z úložiště mohou být 1001 .

Zprostředkovatel protokolování může protokolovat ID události v poli ID, ve zprávě protokolování nebo vůbec ne. Zprostředkovatel ladění nezobrazuje ID událostí. Poskytovatel konzoly zobrazuje ID událostí v závorkách za kategorií:

info: Example.DefaultService.GetAsync[1001]
      Reading value for a1b2c3
warn: Example.DefaultService.GetAsync[4000]
      GetAsync(a1b2c3) not found

Někteří zprostředkovatelé protokolování ukládají ID události do pole, které umožňuje filtrování podle ID.

Šablona zprávy protokolu

Každé rozhraní API protokolu používá šablonu zprávy. Šablona zprávy může obsahovat zástupné symboly, pro které jsou k dispozici argumenty. Použijte názvy zástupných symbolů, nikoli čísla. Pořadí zástupných symbolů, nikoli jejich názvů, určuje, které parametry slouží k zadání jejich hodnot. V následujícím kódu jsou názvy parametrů mimo pořadí v šabloně zprávy:

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

Předchozí kód vytvoří zprávu protokolu s hodnotami parametrů v pořadí:

Parameter values: param1, param2

Tento přístup umožňuje zprostředkovatelům protokolování implementovat sémantické nebo strukturované protokolování. Samotné argumenty jsou předány do protokolovacího systému, nikoli pouze ze šablony formátované zprávy. To umožňuje zprostředkovatelům protokolování ukládat hodnoty parametrů jako pole. Vezměte v úvahu následující metodu protokolovacího nástroje:

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

Například při protokolování do Azure Table Storage:

  • Každá entita tabulky Azure může mít ID RunTime vlastnosti a.
  • Tabulky s vlastnostmi zjednodušují dotazy na data protokolu. Dotaz může například najít všechny protokoly v rámci určitého RunTime rozsahu bez nutnosti analyzovat časový limit textové zprávy.

Protokolování výjimek

Metody protokolovacího nástroje mají přetížení, která přijímají parametr výjimky:

public void Test(string id)
{
    try
    {
        if (id == "none")
        {
            throw new Exception("Default Id detected.");
        }
    }
    catch (Exception ex)
    {
        _logger.LogWarning(
            AppLogEvents.Error, ex,
            "Failed to process iteration: {Id}", id);
    }
}

Protokolování výjimek je specifické pro konkrétního zprostředkovatele.

Výchozí úroveň protokolování

Pokud není nastavená výchozí úroveň protokolování, je výchozí hodnota úrovně protokolu Information .

Zvažte například následující aplikaci služby pracovního procesu:

  • Vytvořeno pomocí šablon pracovních procesů .NET.
  • appsettings.js a appsettings.Development.jspři odstranění nebo přejmenování.

Při předchozí instalaci se při přechodu na stránku ochrany osobních údajů nebo domovská stránka vyprodukuje mnoho zpráv , a s v Trace Debug názvu Information Microsoft kategorie.

Následující kód nastaví výchozí úroveň protokolu, pokud není v konfiguraci nastavená výchozí úroveň protokolu:

class Program
{
    static Task Main(string[] args) =>
        CreateHostBuilder(args).Build().RunAsync();

    static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging => logging.SetMinimumLevel(LogLevel.Warning));
}

Funkce Filter

Funkce filtru je vyvolána pro všechny zprostředkovatele a kategorie, které nemají přiřazená pravidla podle konfigurace nebo kódu:

class Program
{
    static Task Main(string[] args) =>
        CreateHostBuilder(args).Build().RunAsync();

    static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
                logging.AddFilter((provider, category, logLevel) =>
                {
                    return provider.Contains("ConsoleLoggerProvider")
                        && (category.Contains("Example") || category.Contains("Microsoft"))
                        && logLevel >= LogLevel.Information;
                }));
}

Předchozí kód zobrazí protokoly konzoly, když kategorie obsahuje nebo a Example úroveň protokolu je nebo Microsoft Information vyšší.

Obory protokolů

Obor může seskupit sadu logických operací. Toto seskupení lze použít k připojení stejných dat ke každému protokolu vytvořeném jako součást sady. Například každý protokol vytvořený jako součást zpracování transakce může zahrnovat ID transakce.

Obor:

Obory podporují následující poskytovatelé:

Použití oboru zabalením volání protokolovacího nástroje do using bloku:

public async Task<T> GetAsync<T>(string id)
{
    T result;

    using (_logger.BeginScope("using block message"))
    {
        _logger.LogInformation(
            AppLogEvents.Read, "Reading value for {Id}", id);

        var result = await _repository.GetAsync(id);
        if (result is null)
        {
            _logger.LogWarning(
                AppLogEvents.ReadNotFound, "GetAsync({Id}) not found", id);
        }
    }

    return result;
}

Následující kód JSON povoluje obory pro zprostředkovatele konzoly:

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

Následující kód povolí obory pro zprostředkovatele konzoly:

class Program
{
    static Task Main(string[] args) =>
        CreateHostBuilder(args).Build().RunAsync();

    static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureLogging((_, logging) =>
                logging.ClearProviders()
                    .AddConsole(options => options.IncludeScopes = true));
}

Aplikace konzoly bez hostitele

Protokolovací kód pro aplikace bez obecného hostitele se liší v způsobu, jakým se přidávají zprostředkovatelé a vytvářejí protokolovací nástroje. V aplikaci konzoly mimo hostitele volejte rozšiřující metodu zprostředkovatele při Add{provider name} vytváření LoggerFactory :

class Program
{
    static void Main(string[] args)
    {
        using var loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddFilter("Microsoft", LogLevel.Warning)
                .AddFilter("System", LogLevel.Warning)
                .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
                .AddConsole();
        });

        ILogger logger = loggerFactory.CreateLogger<Program>();
        logger.LogInformation("Example log message");
    }
}

Objekt loggerFactory se používá k vytvoření ILogger instance.

Vytváření protokolů v hlavní části

Následující kód se Main zahlásí ILogger získáním instance z induitátoru po sestavení hostitele:

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

class Program
{
    static Task Main(string[] args)
    {
        IHost host = Host.CreateDefaultBuilder(args).Build();

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

        return host.RunAsync();
    }
}

Žádné asynchronní protokolovací metody

Protokolování by mělo být tak rychlé, že za výkon asynchronního kódu nemá cenu. Pokud je úložiště dat protokolování pomalé, nezapisujte do něj přímo. Na začátku zvažte zápis zpráv protokolu do rychlého úložiště a jejich pozdější přesun do pomalého úložiště. Například při protokolování SQL Server, nepoužívejte to přímo v metodě, protože metody Log Log jsou synchronní. Místo toho synchronně přidávat zprávy protokolu do fronty v paměti a mít pracovní proces na pozadí, který zprávy vytahuje z fronty, aby se asynchronně nasazoval data do SQL Server.

Změna úrovní protokolu ve spuštěné aplikaci

Rozhraní API pro protokolování nezahrnuje scénář pro změnu úrovní protokolu, když je aplikace spuštěná. Někteří poskytovatelé konfigurace jsou ale schopni konfiguraci znovu načíst, což okamžitě projeví konfiguraci protokolování. Například poskytovatel konfigurace souborů ve výchozím nastavení znovu načítá konfiguraci protokolování. Pokud se konfigurace v kódu změní, když je aplikace spuštěná, může aplikace zavolat IConfigurationRoot.Reload a aktualizovat konfiguraci protokolování aplikace.

Balíčky NuGet

Rozhraní ILogger<TCategoryName> ILoggerFactory a a jsou zahrnuty v .NET Core SDK. Jsou k dispozici také v následujících balíčcích NuGet:

Použití pravidel filtru protokolů v kódu

Upřednostňovaným přístupem k nastavení pravidel filtru protokolů je použití konfigurace.

Následující příklad ukazuje, jak zaregistrovat pravidla filtru v kódu:

class Program
{
    static Task Main(string[] args) =>
        CreateHostBuilder(args).Build().RunAsync();

    static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
               logging.AddFilter("System", LogLevel.Debug)
                  .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information)
                  .AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace));
}

logging.AddFilter("System", LogLevel.Debug) určuje System kategorii a úroveň protokolu Debug . Filtr se použije u všech zprostředkovatelů, protože konkrétní poskytovatel nebyl nakonfigurován.

AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information) Určuje:

  • Zprostředkovatel Debug protokolování.
  • Úroveň protokolu Information a vyšší.
  • Všechny kategorie začínající na "Microsoft" .

Viz také