Observability

use tracing::{info, warn};

#[derive(Debug)]
enum Plan {
    Free,
    Pro,
}

fn main() {
    tracing_subscriber::fmt().without_time().with_ansi(false).with_target(false).init();

    let user_id = 42;
    let plan = Plan::Pro;
    let email = "ana@example.com";
    info!(user_id, ?plan, "user logged in");
    info!(user_id, plan = ?Plan::Free, %email, "downgraded");
    warn!(user_id, attempts = 3, "password reset rate limit reached");
}

use tracing::{info, info_span, warn};

fn charge_card(amount_cents: u64) -> bool {
    info!(amount_cents, "charging card");
    amount_cents < 10_000
}

fn handle_checkout(request_id: &str, user_id: u64, amount_cents: u64) {
    let span = info_span!("checkout", request_id, user_id);
    let _guard = span.enter();

    info!("checkout started");
    let payment = info_span!("payment", provider = "stripe");
    let ok = payment.in_scope(|| charge_card(amount_cents));
    if !ok {
        warn!(amount_cents, "payment declined");
    }
}

fn main() {
    tracing_subscriber::fmt().without_time().with_ansi(false).with_target(false).init();
    handle_checkout("req-7f3a", 42, 2_500);
    handle_checkout("req-9c1d", 7, 25_000);
}

use tracing::{info, instrument};

#[derive(Debug)]
struct Db;

#[derive(Debug)]
struct Credentials {
    user: String,
    password: String,
}

#[instrument(skip(db, creds), fields(user = %creds.user))]
fn login(db: &Db, creds: &Credentials) -> Result<u64, String> {
    let _ = db;
    info!("checking password");
    if creds.password.len() >= 8 { Ok(42) } else { Err("password too short".to_string()) }
}

#[instrument(err)]
fn load_profile(user_id: u64) -> Result<String, String> {
    if user_id == 42 { Err(format!("profile {user_id} not found")) } else { Ok("profile".into()) }
}

fn main() {
    tracing_subscriber::fmt().without_time().with_ansi(false).with_target(false).init();
    let db = Db;
    let creds = Credentials { user: "ana".into(), password: "correct horse".into() };
    if let Ok(id) = login(&db, &creds) {
        let _ = load_profile(id);
    }
}

use std::time::Duration;
use tracing::{Instrument, info, info_span};

async fn fetch_price(sku: &str) -> u64 {
    tokio::time::sleep(Duration::from_millis(10)).await;
    info!(sku, "price fetched");
    499
}

#[tracing::instrument]
async fn handle(request_id: u32, sku: &'static str) -> u64 {
    info!("start");
    fetch_price(sku).await
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    tracing_subscriber::fmt().without_time().with_ansi(false).with_target(false).init();

    let a = tokio::spawn(handle(1, "apple"));
    let b = tokio::spawn(handle(2, "pear"));
    a.await.unwrap();
    b.await.unwrap();

    // For a future you didn't write, attach the span explicitly:
    let job = async { info!("background job ran") };
    job.instrument(info_span!("nightly_report", day = "2026-09-27")).await;
}

use tracing::{info, info_span, warn};

fn main() {
    tracing_subscriber::fmt().json().without_time().with_target(false).with_current_span(true).with_span_list(false).init();

    let span = info_span!("http_request", method = "POST", route = "/orders", request_id = "req-7f3a");
    let _g = span.enter();
    info!(order_id = 1001, items = 3, "order created");
    warn!(latency_ms = 842, "slow request");
}

use tracing::{debug, info, trace};
use tracing_subscriber::EnvFilter;

// Targets default to the module path (`my_service::db`); they're set explicitly
// here so the example prints the same names wherever it's compiled.
mod db {
    pub fn query() {
        tracing::debug!(target: "app::db", "SELECT * FROM orders");
    }
}

mod http {
    pub fn request() {
        tracing::debug!(target: "app::http", "GET /orders");
        tracing::info!(target: "app::http", "200 OK");
    }
}

fn main() {
    // Usually: EnvFilter::from_default_env(), set with RUST_LOG=...
    let filter = EnvFilter::new("info,app::db=debug");
    tracing_subscriber::fmt().without_time().with_ansi(false).with_env_filter(filter).init();

    info!(target: "app", "service started");
    debug!(target: "app", "hidden: app is at info");
    trace!(target: "app", "hidden too");
    db::query();
    http::request();
}

use tracing::{field, info, info_span};

fn authenticate(token: &str) -> Option<u64> {
    token.strip_prefix("tok-").and_then(|id| id.parse().ok())
}

fn handle(token: &str) {
    let span = info_span!("request", route = "/me", user_id = field::Empty, outcome = field::Empty);
    let _g = span.enter();
    info!("received");
    match authenticate(token) {
        Some(id) => {
            span.record("user_id", id);
            info!("authenticated");
            span.record("outcome", "ok");
        }
        None => {
            span.record("outcome", "unauthorized");
        }
    }
    info!("done");
}

fn main() {
    tracing_subscriber::fmt().without_time().with_ansi(false).with_target(false).init();
    handle("tok-42");
    handle("garbage");
}

use std::sync::atomic::{AtomicU64, Ordering};
use tracing::{Event, Level, Subscriber, error, info, warn};
use tracing_subscriber::layer::{Context, Layer};
use tracing_subscriber::prelude::*;

static WARNINGS: AtomicU64 = AtomicU64::new(0);
static ERRORS: AtomicU64 = AtomicU64::new(0);

struct CountingLayer;

impl<S: Subscriber> Layer<S> for CountingLayer {
    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
        match *event.metadata().level() {
            Level::ERROR => ERRORS.fetch_add(1, Ordering::Relaxed),
            Level::WARN => WARNINGS.fetch_add(1, Ordering::Relaxed),
            _ => 0,
        };
    }
}

fn main() {
    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer().without_time().with_ansi(false).with_target(false))
        .with(CountingLayer)
        .init();

    info!("processing batch");
    warn!(row = 17, "missing optional field");
    error!(row = 42, "invalid date");
    warn!(row = 99, "missing optional field");

    println!("warnings: {}, errors: {}", WARNINGS.load(Ordering::Relaxed), ERRORS.load(Ordering::Relaxed));
}

use metrics::{counter, gauge, histogram};
use metrics_exporter_prometheus::{Matcher, PrometheusBuilder};

fn main() {
    let handle = PrometheusBuilder::new()
        .set_buckets_for_metric(Matcher::Full("http_request_duration_seconds".into()), &[0.01, 0.05, 0.1, 0.5])
        .unwrap()
        .install_recorder()
        .unwrap();

    for (route, status, ms) in [("/orders", 200, 12.0), ("/orders", 200, 30.0), ("/orders", 500, 250.0), ("/health", 200, 1.0)] {
        counter!("http_requests_total", "route" => route, "status" => status.to_string()).increment(1);
        histogram!("http_request_duration_seconds", "route" => route).record(ms / 1000.0);
    }
    gauge!("db_pool_connections_in_use").set(7.0);

    // In a service, a GET /metrics route returns handle.render().
    let text = handle.render();
    let mut lines: Vec<&str> = text.lines().filter(|l| !l.is_empty() && !l.starts_with('#')).collect();
    lines.sort(); // the exporter's order isn't stable; sorted for a reproducible listing
    println!("{}", lines.join("\n"));
}

use metrics::counter;
use metrics_exporter_prometheus::PrometheusBuilder;

fn route_template(path: &str) -> &'static str {
    // Map concrete paths to their route pattern.
    if path.starts_with("/users/") { "/users/{id}" } else if path == "/health" { "/health" } else { "other" }
}

fn main() {
    let handle = PrometheusBuilder::new().install_recorder().unwrap();
    let paths: Vec<String> = (0..1000).map(|i| format!("/users/{i}")).chain(["/health".to_string()]).collect();

    for p in &paths {
        counter!("bad_requests_total", "path" => p.clone()).increment(1); // one series per user!
        counter!("good_requests_total", "route" => route_template(p)).increment(1); // two series
    }

    let text = handle.render();
    let bad = text.lines().filter(|l| l.starts_with("bad_requests_total{")).count();
    let good = text.lines().filter(|l| l.starts_with("good_requests_total{")).count();
    println!("series with the raw path label: {bad}");
    println!("series with the route label:    {good}");
}

use opentelemetry::trace::TracerProvider as _;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::{Resource, trace::SdkTracerProvider};
use tracing_subscriber::{EnvFilter, prelude::*};

fn init_telemetry() -> SdkTracerProvider {
    let exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_tonic()
        .with_endpoint("http://otel-collector:4317")
        .build()
        .expect("OTLP exporter");
    let provider = SdkTracerProvider::builder()
        .with_batch_exporter(exporter) // export in the background, in batches
        .with_resource(Resource::builder().with_service_name("checkout").build())
        .build();

    tracing_subscriber::registry()
        .with(EnvFilter::from_default_env())
        .with(tracing_subscriber::fmt::layer().json())
        .with(tracing_opentelemetry::layer().with_tracer(provider.tracer("checkout")))
        .init();
    provider
}

#[tokio::main]
async fn main() {
    let provider = init_telemetry();
    run_service().await;
    provider.shutdown().expect("flush spans on exit"); // otherwise the last batch is lost
}

use opentelemetry::propagation::TextMapPropagator;
use opentelemetry::trace::TracerProvider as _;
use opentelemetry_sdk::propagation::TraceContextPropagator;
use opentelemetry_sdk::trace::SdkTracerProvider;
use std::collections::HashMap;
use tracing_opentelemetry::OpenTelemetrySpanExt;
use tracing_subscriber::prelude::*;

fn main() {
    let provider = SdkTracerProvider::builder().build();
    tracing_subscriber::registry().with(tracing_opentelemetry::layer().with_tracer(provider.tracer("checkout"))).init();
    let propagator = TraceContextPropagator::new();

    // 1. An incoming HTTP request from the API gateway:
    let incoming = HashMap::from([("traceparent".to_string(), "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01".to_string())]);

    // 2. Continue that trace in this service's span.
    let span = tracing::info_span!("handle_checkout", order_id = 42);
    let _ = span.set_parent(propagator.extract(&incoming));
    let _guard = span.enter();

    // 3. An outgoing call to the pricing service carries the same trace id, with our span as parent.
    let mut outgoing = HashMap::new();
    propagator.inject_context(&tracing::Span::current().context(), &mut outgoing);
    let header = &outgoing["traceparent"];
    let parts: Vec<&str> = header.split('-').collect();
    println!("incoming trace id: 4bf92f3577b34da6a3ce929d0e0e4736");
    println!("outgoing trace id: {}", parts[1]);
    println!("outgoing parent is a new span id: {}", parts[2] != "00f067aa0ba902b7" && parts[2].len() == 16);
    println!("sampled flag kept: {}", parts[3] == "01");
}

use axum::{Router, extract::State, http::StatusCode, routing::get};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use tower::ServiceExt;

#[derive(Clone)]
struct Health {
    db_connected: Arc<AtomicBool>,
    shutting_down: Arc<AtomicBool>,
}

async fn live() -> StatusCode {
    StatusCode::OK // the process runs and the runtime responds
}

async fn ready(State(h): State<Health>) -> (StatusCode, &'static str) {
    if h.shutting_down.load(Ordering::Relaxed) {
        (StatusCode::SERVICE_UNAVAILABLE, "shutting down")
    } else if !h.db_connected.load(Ordering::Relaxed) {
        (StatusCode::SERVICE_UNAVAILABLE, "database unavailable")
    } else {
        (StatusCode::OK, "ready")
    }
}

fn app(h: Health) -> Router {
    Router::new().route("/livez", get(live)).route("/readyz", get(ready)).with_state(h)
}

async fn probe(router: &Router, path: &str) -> u16 {
    let req = axum::http::Request::get(path).body(axum::body::Body::empty()).unwrap();
    router.clone().oneshot(req).await.unwrap().status().as_u16()
}

#[tokio::main]
async fn main() {
    let h = Health { db_connected: Arc::new(AtomicBool::new(true)), shutting_down: Arc::new(AtomicBool::new(false)) };
    let router = app(h.clone());
    println!("healthy:      live {} ready {}", probe(&router, "/livez").await, probe(&router, "/readyz").await);

    h.db_connected.store(false, Ordering::Relaxed);
    println!("db down:      live {} ready {}", probe(&router, "/livez").await, probe(&router, "/readyz").await);

    h.db_connected.store(true, Ordering::Relaxed);
    h.shutting_down.store(true, Ordering::Relaxed); // set on SIGTERM, before draining
    println!("shutting down: live {} ready {}", probe(&router, "/livez").await, probe(&router, "/readyz").await);
}

use tracing::info;

fn main() {
    // Logs go to a background thread; the guard flushes them when main ends.
    let (writer, _guard) = tracing_appender::non_blocking(std::io::stdout());
    tracing_subscriber::fmt().with_writer(writer).without_time().with_ansi(false).with_target(false).init();

    for batch in 1..=3 {
        info!(batch, "processed");
    }
}