Monitoring C++ Applications: Metrics and Alerts for Production

Introduction: Why is monitoring C++ applications critical for stability?

Modern C++ applications operate in high-load environments: game servers, financial systems, IoT devices, and embedded solutions. Without proper monitoring, even perfectly written code can lead to catastrophic consequences — from memory leaks to a complete service crash at 3 AM. In this article, we will analyze how to set up full-fledged monitoring for C++ applications: which metrics to collect, how to organize logging, and how to configure alerts so you can sleep peacefully.

1. Key metrics of C++ applications

Monitoring C++ applications starts with choosing the right metrics. Let's divide them into three groups:

1.1. System metrics (OS-level)

• CPU Usage — processor load in percent and time in user/kernel mode.
• Memory Usage — RSS (Resident Set Size), Virtual Memory, number of page faults.
• Disk I/O — read/write operations to disk (especially important for databases).
• Network I/O — number of bytes sent/received, number of errors.

1.2. Application metrics (Application-level)

• Request latency — request processing time (p50, p95, p99).
• Throughput — number of processed requests per second.
• Error rate — percentage of errors (exceptions, timeouts).
• Connection pool — number of active/pending connections.

1.3. C++ runtime metrics

• Memory allocation — number of new/delete calls, heap allocations.
• Thread count — number of active threads, deadlock detection.
• Object pool utilization — percentage of occupied objects in the pool.

Example of exporting metrics via 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() {    // Create an HTTP server for metrics    Exposer exposer{"0.0.0.0:8080"};    auto registry = std::make_shared<Registry>();

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

    // Gauge for current thread count    auto& thread_gauge = BuildGauge()        .Name("app_thread_count")        .Help("Current number of active threads")        .Register(*registry);

    // Register metrics    exposer.RegisterCollectable(registry);

    // Simulate application work    while (true) {        request_counter.Increment();        thread_gauge.Set(5.0); // Example value        std::this_thread::sleep_for(std::chrono::seconds(1));    }}

2. Metric collection tools: Prometheus and Grafana

For collecting metrics in the C++ ecosystem, the de facto standard is Prometheus combined with Grafana. Prometheus is a pull system: your application exposes metrics via HTTP, and Prometheus itself scrapes them at a configured interval.

2.1. Setting up metric export in C++

Popular libraries:

• prometheus-cpp (official C++ Prometheus client).
• opentelemetry-cpp — for tracing and metrics (more modern).
• NanoMsg + custom exporter — for embedded systems.

Example integration with Prometheus-cpp (full code above). After launching, check the endpoint:

curl http://localhost:8080/metrics

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