Überwachung von Rust-Anwendungen: Die Bibliothek tracing und Metriken

Überwachung von Rust-Anwendungen: Die Bibliothek tracing und Metrikenerfassung

Überwachung ist ein Schlüsselelement von Produktionssystemen. Für Anwendungen in Rust, die für ihre Leistung und Zuverlässigkeit bekannt sind, ist ein leichtes und effizientes Werkzeug zur Telemetrieerfassung wichtig. Die Bibliothek tracing ist zum De-facto-Standard für Observability im Rust-Ökosystem geworden. Sie bietet strukturiertes Logging, Spans zur Ablaufverfolgung von Anfragen und die Integration mit Metrikenerfassungssystemen.

Was ist tracing?

tracing ist ein Framework zur Instrumentierung von Rust-Programmen. Im Gegensatz zum klassischen Logging basiert es auf Events und Spans. Spans repräsentieren Zeitabschnitte der Codeausführung (z. B. die Verarbeitung einer HTTP-Anfrage), während Events Punkte innerhalb von Spans sind (z. B. „Datenbank hat in 10 ms geantwortet“).

Hauptfunktionen:

• Strukturiertes Logging — jedes Event enthält Felder (Schlüssel-Wert-Paare), nicht nur eine Zeichenkette.
• Spans-Hierarchie — Spans können ineinander verschachtelt werden, um den vollständigen Ausführungspfad zu verfolgen.
• Asynchrone Unterstützung — funktioniert hervorragend mit tokio und async/await.
• Subscriber — verschiedene Backends können angebunden werden: stdout, OpenTelemetry, Prometheus, Dateien.

Installation und grundlegende Verwendung

Fügen Sie in Cargo.toml hinzu:

[dependencies]tracing = "0.1"tracing-subscriber = "0.3"

Ein einfaches Beispiel für strukturiertes Logging:

use tracing::{info, warn, error};use tracing_subscriber;

fn main() {    // Initialisieren des Subscribers für die Ausgabe auf stdout    tracing_subscriber::fmt::init();

    let user_id = 42;    let request_duration_ms = 150;

    info!(user_id, duration = request_duration_ms, "Anfrage verarbeitet");

    // Logging mit Warnstufe    warn!(user_id, "Antwortzeit überschreitet Schwellwert");

    // Logging mit Fehler    error!("Verbindung zur Datenbank fehlgeschlagen");}

Die Ausgabe enthält Felder in einem JSON-ähnlichen Zeichenkettenformat, was das Parsen in Überwachungssystemen vereinfacht.

Spans und Ablaufverfolgung

Spans ermöglichen die Messung der Ausführungszeit von Operationen und die Verkettung von Events:

use tracing::{span, info, Level};use tracing_subscriber;

fn process_request(user_id: u32) {    // Erstellen eines Spans mit Kontext    let span = span!(Level::INFO, "process_request", user_id);    let _guard = span.enter(); // Span aktivieren

    info!("Verarbeitung gestartet");    std::thread::sleep(std::time::Duration::from_millis(50));    info!("Verarbeitung abgeschlossen");}

fn main() {    tracing_subscriber::fmt::init();    process_request(100);}

In der Ausgabe erscheint ein verschachtelter Kontext, der anzeigt, dass die Events zum Span process_request gehören.

Metrikenerfassung mit tracing und Prometheus

Für die Produktionsüberwachung ist oft der Export von Metriken nach Prometheus erforderlich. Verwenden Sie die Crate tracing-appender zum Schreiben in eine Datei oder tracing-opentelemetry für die Integration mit OpenTelemetry. Der direkteste Weg ist jedoch die Verwendung der Bibliothek metrics zusammen mit tracing.

Beispiel für die Integration mit metrics-exporter-prometheus:

[dependencies]metrics = "0.21"metrics-exporter-prometheus = "0.12"tracing = "0.1"tokio = { version = "1", features = ["full"] }

Code zur Metrikenerfassung:

use metrics::{counter, gauge, histogram};use metrics_exporter_prometheus::PrometheusBuilder;use std::net::SocketAddr;

#[tokio::main]async fn main() {    // Starten des HTTP-Servers für Prometheus    let addr: SocketAddr = "0.0.0.0:9090".parse().unwrap();    let builder = PrometheusBuilder::new();    builder        .wit