provide-telemetry 0.7.0

Cross-language telemetry helpers with privacy, resilience, and OTLP support.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

// SPDX-FileCopyrightText: Copyright (C) 2026 provide.io llc
// SPDX-License-Identifier: Apache-2.0
// SPDX-Comment: Part of provide-telemetry.
//

use std::collections::BTreeMap;

use provide_telemetry::context::get_context;
use provide_telemetry::{
    bind_context, clear_context, counter, event, gauge, get_logger, histogram, setup_telemetry,
    shutdown_telemetry, trace, unbind_context, Logger, TelemetryError,
};
use serde_json::json;

#[derive(Debug, Clone, PartialEq)]
pub struct DemoSummary {
    pub service_name: String,
    pub environment: String,
    pub version: String,
    pub iterations: usize,
    pub logged_events: usize,
    pub counter_total: f64,
    pub gauge_value: f64,
    pub histogram_count: usize,
    pub histogram_total: f64,
    pub context_keys_after_clear: usize,
    pub unbound_key: Option<String>,
}

fn telemetry_error(message: impl Into<String>) -> TelemetryError {
    TelemetryError::new(message)
}

pub fn run_demo() -> Result<DemoSummary, TelemetryError> {
    let _ = shutdown_telemetry(None);
    {
        let _clear = clear_context();
    }
    let _ = Logger::drain_events_for_tests();

    let config = setup_telemetry(None)?;
    let log = get_logger(Some("examples.basic"));
    let requests = counter(
        "example.basic.requests",
        Some("Total request count"),
        Some("request"),
    );
    let active_tasks = gauge(
        "example.basic.active_tasks",
        Some("Active task gauge"),
        Some("1"),
    );
    let latency = histogram(
        "example.basic.latency_ms",
        Some("Simulated latency"),
        Some("ms"),
    );

    let start =
        event(&["example", "basic", "start"]).map_err(|err| telemetry_error(err.message))?;
    let after_unbind =
        event(&["example", "basic", "after_unbind"]).map_err(|err| telemetry_error(err.message))?;
    let after_clear =
        event(&["example", "basic", "after_clear"]).map_err(|err| telemetry_error(err.message))?;

    let _bound = bind_context([
        ("region".to_string(), json!("us-east-1")),
        ("tier".to_string(), json!("premium")),
    ]);
    log.info(&start.event);

    for iteration in 0..3 {
        let iteration_event = event(&["example", "basic", "iteration"])
            .map_err(|err| telemetry_error(err.message))?;
        trace("example.basic.work", || {
            log.info(&iteration_event.event);

            let mut attributes = BTreeMap::new();
            attributes.insert("iteration".to_string(), iteration.to_string());
            requests.add(1.0, Some(attributes.clone()));
            latency.record(iteration as f64 * 12.5, Some(attributes));
            active_tasks.set(1.0, None);
        });
    }

    let _unbind = unbind_context(&["region"]);
    log.info(&after_unbind.event);

    let _clear = clear_context();
    log.info(&after_clear.event);

    let context_keys_after_clear = get_context().len();
    let logged_events = Logger::drain_events_for_tests().len();
    shutdown_telemetry(None)?;

    Ok(DemoSummary {
        service_name: config.service_name,
        environment: config.environment,
        version: config.version,
        iterations: 3,
        logged_events,
        counter_total: requests.value(),
        gauge_value: active_tasks.value(),
        histogram_count: latency.count(),
        histogram_total: latency.total(),
        context_keys_after_clear,
        unbound_key: Some("region".to_string()),
    })
}