Logs sammeln: Seq und Application Insights

1. Einführung

Bevor wir in die Praxis eintauchen, lasst uns klären, warum externe Systeme zum Sammeln von Logs überhaupt nötig sind. Stell dir vor, deine Anwendung läuft nicht auf deinem Heim-PC, sondern in Production: Hunderte Server, Microservices, viele Nutzer, jemand beschwert sich, dass die "Anwendung ruckelt". Ein bestimmtes Ereignis in diesem Logstrom zu finden ist wie die Suche nach einer Nadel im Heuhaufen. Ohne zentrales Log-Collection ist Debugging und Betrieb solcher Systeme kaum machbar. Hier kommen Seq und Application Insights ins Spiel.

Seq: schönes UI, schnelle Suche, Echtzeit

Seq ist ein System zum zentralen Sammeln und Analysieren strukturierter Logs, optimiert für .NET und Serilog. Das ist kein bloßer File-Dump-Service, sondern ein mächtiges Tool: in Echtzeit siehst du Logströme, filterst, suchst nach Properties, baust Alerts. Seq kannst du lokal oder in der Cloud betreiben.

Warum wählen Leute Seq?

• Optimiert für .NET und Serilog, funktioniert "out of the box".
• Fantastisch schnelle Suche und Filterung nach beliebigen Message-Eigenschaften.
• Einfaches und angenehmes Web-UI.
• Kann lokal laufen, ohne viel Bürokratie, sogar auf dem Laptop.

Wie sieht eine einfache Architektur aus?

+--------------+        +-------------+         +-------------+
| .NET-app     | --(log)| Serilog     | --(http)|     Seq     |
+--------------+        +-------------+         +-------------+
                                    |            ^ 
                                    |            | 
             (Suche, Filter,         <----[Web UI] 
              Alerts, Integrationen)

Die Anwendung schreibt strukturierte Logs via Serilog, Serilog sendet sie an Seq. Im Web-UI von Seq machst du, was du brauchst.

2. Integration von Serilog mit Seq

Installation von Seq

Seq kannst du schnell lokal ausprobieren, auch für Heimexperimente. Wenn du Windows benutzt, lade Seq von der offiziellen Seite herunter.

1. Lade Seq herunter und installiere es.
2. Nach der Installation öffne das Web-UI (normalerweise http://localhost:5341).
3. Fertig! Jetzt musst du nur noch das Senden von Logs an Seq konfigurieren.

Serilog mit Seq integrieren

NuGet-Paket installieren:

dotnet add package Serilog.Sinks.Seq

Beispiel-Logging-Konfiguration in Program.cs:

using Serilog;

public class Program
{
    public static void Main(string[] args)
    {
        // Serilog konfigurieren, um Logs an Seq zu senden
        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Information()
            .WriteTo.Console()
            .WriteTo.Seq("http://localhost:5341") // URL deines Seq-Servers
            .CreateLogger();

        Log.Information("Die Anwendung startet");
        // ... Rest der Anwendung ...

        Log.CloseAndFlush();
    }
}

Wenn alles richtig konfiguriert ist, fangen deine App-Logs an, in Seq aufzutauchen.

Beispiel für ein strukturiertes Event

Log.Information("Benutzer {User} hat sich eingeloggt um {Time}", userName, DateTime.UtcNow);

In Seq kannst du jetzt alle Logins eines bestimmten Nutzers suchen:

User == 'username'

Filterung und Suche

Seq kann Events nach jedem Feld und Wert filtern. Beispielsweise willst du alle Errors von heute sehen? Einfach Filter setzen:

@Level = 'Error' and @Timestamp > today()

Du kannst Bedingungen kombinieren — super praktisch!

Alerts und Integrationen

Seq kann Alerts erstellen: wenn z.B. die Fehleranzahl einen Threshold übersteigt, bekommst du eine Mail, ein Webhook wird ausgelöst oder du sendest eine Nachricht an Slack.

Welche weiteren Möglichkeiten gibt es?

• Integration in CI/CD-Systeme, um z.B. Test-Logs automatisch zu sammeln.
• Custom Dashboards (gegen Aufpreis).
• Plugins für Log-Analyse, Automatisierung (z.B. Auto-Erstellung von Bugs bei Failures).
• Integration mit Grafana/Prometheus via Plugins.

Typische Fehler bei der Seq-Konfiguration

Ein häufiger Fehler ist, die Seq-URL in Serilog falsch anzugeben oder Seq hört auf einem anderen Port.

Ein weiterer Fehler: der Port für eingehende Verbindungen ist nicht geöffnet, z.B. wenn Seq in Docker oder auf einem Server läuft. Prüfe die Erreichbarkeit des Ports von deiner App aus.

3. Application Insights: Telemetrie für .NET, Cloud und Magic

Application Insights (oder "App Insights") ist Microsoft Azures Cloud-Plattform zum Monitoring und Analysieren von Anwendungen. Das ist nicht nur Log-Sammlung, sondern automatische Anomalie-Erkennung, Nutzungsanalyse, Monitoring von Dependencies, Requests, externen APIs — und natürlich Echtzeit-Visualisierung. Azure Application Insights ist Standard im Enterprise .NET-Umfeld.

Was sind die Vorteile von Application Insights?

• Kein eigener Server nötig: alles in der Cloud.
• Tiefe Integration mit .NET, ASP.NET, Azure, Visual Studio.
• Sammelt automatisch nicht nur deine Logs, sondern auch Metriken, Exceptions, Requests, SQL-Queries.
• Dashboards, SLA-Monitoring, Anomalie-Erkennung, verteiltes Tracing (distributed tracing).

Wie funktioniert Application Insights?

+--------------+        +-------------------+         +---------------------+
| .NET-app     | --(SDK)| AppInsights SDK   | --(https)| Azure Application   |
+--------------+        +-------------------+         | Insights (Cloud)    |
                                                       +---------------------+
                          ^         |
                        (W3C Trace   +----> Analytics, Suche, Dashboards
                         Context)

Die App mit angeschlossenem SDK sendet Telemetrie an Azure, du analysierst und visualisierst sie im Azure-Portal.

Integration von Application Insights in eine .NET-App

Variante 1: Schnell und einfach

Wenn du eine ASP.NET Core-App hast, ist es sehr simpel:

dotnet add package Microsoft.ApplicationInsights.AspNetCore

In Program.cs:

builder.Services.AddApplicationInsightsTelemetry("<dein_instrumentation_key>");

Und wenn du eine Konsole- oder Desktop-App hast:

dotnet add package Microsoft.ApplicationInsights

Initialisierung:

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;

var telemetryConfig = TelemetryConfiguration.CreateDefault();
telemetryConfig.InstrumentationKey = "<dein_instrumentation_key>";
var telemetryClient = new TelemetryClient(telemetryConfig);

telemetryClient.TrackTrace("Hello from Application Insights!");
telemetryClient.TrackException(new Exception("OOPS, es gab einen Fehler!"));

Den Instrumentation Key bekommst du im Azure-Portal, nachdem du eine Application Insights Resource erstellt hast.

Wie sende ich strukturierte Daten?

Du kannst Properties zu jedem Trace hinzufügen:

telemetryClient.TrackTrace("Benutzer hat sich eingeloggt", 
    new Dictionary<string, string> { ["User"] = userName }
);

Beispiel: User-Action-Logging

Angenommen, du willst einen User-Login loggen:

var props = new Dictionary<string, string>
{
    { "User", userName },
    { "Time", DateTime.UtcNow.ToString("o") }
};
telemetryClient.TrackEvent("UserLogin", props);

Jetzt sind sowohl das Event als auch alle Properties im Portal sichtbar.

4. Nützliche Feinheiten

Was siehst du in Application Insights?

• App-Overview: Logins, Errors, Dependencies (z.B. SQL-Queries).
• Log-Suche: beliebige Events, Filter nach Properties.
• Visualisierung: Charts, Dashboards.
• Tracing: Du kannst Call-Chains sehen und wie lange jede Operation gedauert hat.
• Alerting: Alerts nach beliebigen Bedingungen konfigurieren.

Kurz zur Struktur von Application Insights

Beispiel: Fehler suchen in Application Insights

Im Azure-Portal kannst du eine einfache Query (Kusto Query Language — KQL) bauen:

exceptions
| where timestamp > ago(1d)
| where outerMessage contains "Timeout"
| project timestamp, operation_Name, user_Id, outerMessage

Das zeigt dir alle Timeouts der letzten 24 Stunden mit Details.

Limitierungen/Feinheiten von Application Insights

• Du brauchst ein Azure-Konto. Es gibt einen kostenlosen Plan, aber mit Limits.
• Manchmal gibt es eine Verzögerung zwischen Senden der Logs und deren Sichtbarkeit im UI — bis zu ein paar Minuten.
• Für sehr private Projekte ist es eine Cloud-Lösung, keine lokale Installation.
• Wenn du Traces übermäßig nutzt, kannst du schnell dein tägliches Limit verbrauchen.

5. Vergleich: Seq vs Application Insights

Anwenden des Wissens in der Praxis

Das Wissen über Seq und Application Insights hilft dir nicht nur in Production, sondern auch in Entwicklung und Testing (z.B. beim Analysieren von Testläufen), beim Arbeiten mit Microservices, wenn du das große Ganze sehen willst. In Interviews wird oft gefragt: "Wie würdest du Logging so organisieren, dass man in Production schnell Probleme findet?" — jetzt hast du eine gute Antwort!

Außerdem nutzen viele moderne Firmen solche Systeme, um ganze DevOps-Ketten zu bauen: Continuous Delivery, automatische Bug-Erstellung durch Alerts usw. Ein Log-Collection-System ist nicht einfach nur "wohin Console.WriteLine geht", sondern die echte "black box" und der Monitor deiner App.