Monitoring von C++-Anwendungen: Metriken und Alarme für die Produktion

Einleitung: Warum ist das Monitoring von C++-Anwendungen kritisch für die Stabilität?

Moderne C++-Anwendungen laufen in hochbelasteten Umgebungen: Spieleserver, Finanzsysteme, IoT-Geräte und Embedded-Lösungen. Ohne ordnungsgemäßes Monitoring kann selbst perfekt geschriebener Code zu katastrophalen Folgen führen – von Speicherlecks bis zum vollständigen Dienstausfall um 3 Uhr morgens. In diesem Artikel analysieren wir, wie man ein vollwertiges Monitoring für C++-Anwendungen einrichtet: welche Metriken zu sammeln sind, wie man das Logging organisiert und Alarme konfiguriert, um ruhig schlafen zu können.

1. Schlüsselmetriken von C++-Anwendungen

Das Monitoring von C++-Anwendungen beginnt mit der Auswahl der richtigen Metriken. Unterteilen wir sie in drei Gruppen:

1.1. Systemmetriken (OS-level)

• CPU Usage – Prozessorauslastung in Prozent und Zeit im User/Kernel-Modus.
• Memory Usage – RSS (Resident Set Size), Virtual Memory, Anzahl der Page Faults.
• Disk I/O – Lese-/Schreiboperationen auf die Festplatte (besonders wichtig für Datenbanken).
• Network I/O – Anzahl gesendeter/empfangener Bytes, Anzahl der Fehler.

1.2. Anwendungsmetriken (Application-level)

• Request latency – Verarbeitungszeit von Anfragen (p50, p95, p99).
• Throughput – Anzahl verarbeiteter Anfragen pro Sekunde.
• Error rate – Fehlerprozentsatz (Ausnahmen, Timeouts).
• Connection pool – Anzahl aktiver/wartender Verbindungen.

1.3. C++-Runtime-Metriken

• Memory allocation – Anzahl der new/delete-Aufrufe, Heap-Allokationen.
• Thread count – Anzahl aktiver Threads, Deadlock-Erkennung.
• Object pool utilization – Prozentsatz belegter Objekte im Pool.

Beispiel für den Export von Metriken über den Prometheus-Client in C++:

#include <prometheus/exposer.h>#include <prometheus/registry.h>#include <prometheus/counter.h>#include <prometheus/gauge.h>

using namespace prometheus;

int main() {    // Erstellen eines HTTP-Servers für Metriken    Exposer exposer{"0.0.0.0:8080"};    auto registry = std::make_shared<Registry>();

    // Anfragenzähler    auto& request_counter = BuildCounter()        .Name("http_requests_total")        .Help("Total number of HTTP requests")        .Register(*registry);

    // Gauge für die aktuelle Anzahl von Threads    auto& thread_gauge = BuildGauge()        .Name("app_thread_count")        .Help("Current number of active threads")        .Register(*registry);

    // Metriken registrieren    exposer.RegisterCollectable(registry);

    // Simulation des Anwendungsbetriebs    while (true) {        request_counter.Increment();        thread_gauge.Set(5.0); // Beispielwert        std::this_thread::sleep_for(std::chrono::seconds(1));    }}

2. Werkzeuge zur Metrikenerfassung: Prometheus und Grafana

Für die Metrikenerfassung im C++-Ökosystem ist der De-facto-Standard Prometheus in Kombination mit Grafana. Prometheus ist ein Pull-System: Ihre Anwendung gibt Metriken über HTTP aus, und Prometheus holt sie selbstständig in einem festgelegten Intervall ab.

2.1. Einrichtung des Metrikenexports in C++

Beliebte Bibliotheken:

• prometheus-cpp (offizieller C++-Client von Prometheus).
• opentelemetry-cpp – für Tracing und Metriken (moderner).
• NanoMsg + custom exporter – für Embedded-Systeme.

Beispiel für die Integration mit Prometheus-cpp (vollständiger Code oben). Überprüfen Sie nach dem Start den Endpunkt:

curl http://localhost:8080/metrics

# HELP http_requests_total Total number of HTTP requests# TYPE http_requests_total counterhttp_reques