Webframeworkk/ASP.NET Core/Protokollierung und Serilog

Logging ist ein unverzichtbares Werkzeug zur Überwachung, Fehlerbehebung und Gewinnung von Einblicken in das Verhalten deiner ASP.NET Core-Anwendung. Es dient als Fenster zu den Laufzeitereignissen deiner Anwendung und ermöglicht es dir, alles von Routineoperationen bis hin zu kritischen Fehlern zu verfolgen.

1. Das ILogger-Interface

Das Herzstück der Logging-Infrastruktur von ASP.NET Core ist das ILogger-Interface. Es bietet eine standardisierte Möglichkeit, Log-Meldungen, Warnungen, Fehler und andere Diagnoseinformationen auszugeben.

Kernaspekte:

• Abstraktion: ILogger ist ein Interface. Das bedeutet, du kannst verschiedene Logging-Provider (Konsole, Datei, Datenbank, Cloud) einbinden, ohne deinen Anwendungscode ändern zu müssen.
• Anpassungsfähigkeit: Du kannst Provider wechseln oder Konfigurationen nahtlos ändern, um sie an unterschiedliche Umgebungen anzupassen.

Log-Level (Schweregrade): Die Log-Level geben an, wie kritisch ein Ereignis ist:

1. Trace: Sehr detailliert, meist nur für die Fehlersuche in der Entwicklung.
2. Debug: Informationen für das Debugging, weniger ausführlich als Trace.
3. Information: Nachrichten über den normalen Geschäftsverlauf.
4. Warning: Ereignisse, die auf Probleme hinweisen könnten, aber die Anwendung nicht stoppen.
5. Error: Ausnahmen oder Fehler, die die Benutzererfahrung beeinträchtigen könnten.
6. Critical: Kritische Systemfehler, die sofortiges Handeln erfordern.

Strukturiertes Logging: Anstatt nur einfachen Text zu loggen ("User 'John' logged in"), nutzt ASP.NET Core Key-Value-Paare.

• Vorteil: Erleichtert das Filtern und Analysieren in Tools wie Seq oder Elasticsearch erheblich.
• Beispiel: _logger.LogInformation("User {UserName} logged in", user.UserName);

2. Dependency Injection & Controller

In ASP.NET Core erhältst du eine ILogger-Instanz normalerweise über Dependency Injection (DI).

public class PersonsController : Controller
{
    private readonly ILogger<PersonsController> _logger;

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

    public IActionResult Index()
    {
        _logger.LogInformation("Die Index-Seite wurde aufgerufen.");
        return View();
    }
}

Der generische Typ ILogger<T> legt den Kategorienamen fest (meist der Klassenname), was eine gezielte Filterung ermöglicht.

3. Logging-Konfiguration (appsettings.json)

Die Steuerung der Logs erfolgt zentral in der appsettings.json. Hier legst du fest, ab welchem Schweregrad geloggt werden soll.

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

• Default: Gilt für fast alle Kategorien.
• Microsoft.AspNetCore: Speziell für Framework-Logs (hier werden nur Warnungen oder Höherwertiges angezeigt).

4. Logging-Provider

Ein Provider bestimmt, wohin die Logs geschrieben werden.

Integrierte Provider:

• Console: Ausgabe im Konsolenfenster.
• Debug: Ausgabe im Visual Studio Debug-Fenster.
• EventLog: Schreibt in das Windows-Ereignisprotokoll (nur Windows).

Drittanbieter (Empfohlen):

• Serilog: Ein Kraftpaket für strukturiertes Logging mit vielen Zielorten ("Sinks").
• NLog / log4net: Etablierte Frameworks mit langer Historie.

5. HTTP-Logging

ASP.NET Core bietet Middleware, um HTTP-Requests und -Responses automatisch zu erfassen. Dies ist ideal für Performance-Analysen und Sicherheitsaudits.

Aktivierung in Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Konfiguration der Felder
builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
});

var app = builder.Build();

app.UseHttpLogging(); // Middleware hinzufügen

Wichtige HttpLoggingFields:

• RequestMethod, RequestPath, RequestProtocol.
• ResponseStatusCode.
• RequestBody / ResponseBody (Achtung: Hoher Performance-Impact!).

6. Serilog: Profi-Logging

Serilog ist die bevorzugte Wahl für moderne .NET-Anwendungen.

Vorteile & Sinks: Serilog nutzt sogenannte Sinks, um Logs an verschiedene Ziele zu senden:

• File Sink: Schreibt in Textdateien (unterstützt "Rolling Files" nach Zeit oder Größe).
• MSSqlServer Sink: Speichert Logs direkt in einer SQL-Datenbank.
• Seq Sink: Sendet Logs an Seq für Echtzeit-Suche und -Analyse.

Erweiterte Funktionen:

• Enrichers: Fügt jedem Log-Eintrag Kontext hinzu (z.B. MachineName oder eine eindeutige RequestId).
• IDiagnosticContext: Ermöglicht es, zusätzliche Eigenschaften während eines Requests zu sammeln und sie gesammelt am Ende zu loggen.
• Serilog Timings: Misst die Ausführungszeit von Codeblöcken.

Konfiguration (Beispiel für Program.cs):

builder.Host.UseSerilog((ctx, services, config) => config
    .ReadFrom.Configuration(ctx.Configuration)
    .ReadFrom.Services(services));

7. Best Practices & Interview-Tipps

Best Practices:

1. Sorgfältige Auswahl: Wähle den Provider passend zum Projekt (Serilog ist meist die beste Wahl).
2. Strukturiertes Logging nutzen: Nutze Platzhalter wie {UserName} statt String-Interpolation.
3. Keine sensiblen Daten: Logge niemals Passwörter, Kreditkartennummern oder personenbezogene Daten direkt.
4. Umgebungsanpassung: Nutze in der Produktion höhere Log-Level (z.B. Warning), um die Performance nicht zu beeinträchtigen.

Interview-Fragen:

• Warum strukturiertes Logging? Es macht Logs maschinenlesbar, was die Auswertung durch Tools (wie SQL-Abfragen in Seq) erst ermöglicht.
• Was ist der ILogger-Abstraktionsvorteil? Loose Coupling – die Geschäftslogik muss nicht wissen, ob die Logs in einer Datei, einer DB oder in der Cloud landen.
• Was ist ein Sink in Serilog? Ein Zielort für Log-Ereignisse.

Erstellt für Thorsten am 27. Februar 2026