Überwachung von C++-Anwendungen: Werkzeuge und Bibliotheken

Überwachung von C++-Anwendungen: Warum und wie man es macht

Überwachung ist ein wesentlicher Bestandteil der Entwicklung und des Betriebs jeder ernsthaften C++-Anwendung. Ohne sie bleiben Sie blind: Sie wissen nicht, wie viel Speicher das Programm verbraucht, welche Funktionen langsam sind oder ob der Server unter Last ausfällt. In diesem Artikel behandeln wir die wichtigsten Bibliotheken und Werkzeuge zur Überwachung von C++-Anwendungen – von der Metriksammlung bis hin zu Profiling und Logging.

1. Sammlung von Systemmetriken: Prometheus Client for C++

Wenn Ihre Anwendung als Mikroservice oder Teil eines verteilten Systems läuft, benötigen Sie eine Infrastruktur zur Metriksammlung. Prometheus ist der De-facto-Standard. Für C++ gibt es den offiziellen Client prometheus-cpp.

Die Bibliothek ermöglicht es Ihnen, Zähler, Histogramme, Zusammenfassungen (Summary) zu erstellen und diese über einen HTTP-Endpunkt bereitzustellen, der vom Prometheus-Server abgefragt wird.

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

int main() {    using namespace prometheus;

    // Erstellen eines HTTP-Servers auf Port 8080    Exposer exposer{"0.0.0.0:8080"};

    // Metriken registrieren    auto registry = std::make_shared<Registry>();    auto& counter_family = BuildCounter()        .Name("http_requests_total")        .Help("Total number of HTTP requests")        .Register(*registry);

    auto& counter = counter_family.Add({{"method", "GET"}, {"endpoint", "/api"}});

    // Metriken bereitstellen    exposer.RegisterCollectable(registry);

    // Simulation von Anfragen    for (int i = 0; i < 100; ++i) {        counter.Increment();        std::this_thread::sleep_for(std::chrono::milliseconds(100));    }

    return 0;}

Vorteile:

• Native Integration in das Prometheus/Grafana-Ökosystem
• Unterstützung für Histogramme und Quantile
• Asynchroner Export ohne Blockierung des Hauptthreads

Nachteile:

• Erfordert die Einrichtung eines Prometheus-Servers und von Grafana zur Visualisierung
• Nicht geeignet für eingebettete Systeme mit begrenztem Speicher

2. Leistungsprofiling: Google Benchmark

Für die genaue Messung der Ausführungszeit einzelner Codeabschnitte (Benchmarks) verwenden Sie Google Benchmark. Dies ist keine Echtzeit-Überwachung, aber ein unverzichtbares Werkzeug für Regressionstests der Leistung.

#include <benchmark/benchmark.h>

static void BM_StringCreation(benchmark::State& state) {    for (auto _ : state) {        std::string empty_string;    }}BENCHMARK(BM_StringCreation);

static void BM_StringCopy(benchmark::State& state) {    std::string x = "hello";    for (auto _ : state) {        std::string copy(x);    }}BENCHMARK(BM_StringCopy);

BENCHMARK_MAIN();

Funktionen:

• Automatische Berechnung von Durchschnitt, Median, Standardabweichung
• Unterstützung für Multithread-Benchmarks
• Generierung von Berichten im JSON-, CSV- und Konsolenformat
• Integration in CI/CD (Ergebnisse können mit Referenzwerten verglichen werden)

3. Logging: spdlog

Logs sind die Grundlage für die Überwachung von Fehlern und Anomalien. spdlog ist die schnellste Logging-Bibliothek für C++ (header-only, asynchroner Modus).

#include <spdlog/spdlog.h>#include <spdlog/sinks/basic_file_sink.h>

int main() {    // Logger mit Dateiausgabe erstellen    auto logger = spdlog::basic_logger_mt("file_logger", "logs/app.log");

    // Logging-Level festlegen    spdlog::set_level(spdlog::level::info);

    // Logs mit verschiedenen Leveln    logger->info("Anwendung gestartet, Version {}", 1.0);    logger->warn("Speicher nahe am Limit: {} MB", 512);    logger-&>