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

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

use crate::backpressure::_reset_backpressure_for_tests;
use crate::cardinality::clear_cardinality_limits;
use crate::classification::clear_classification_rules;
use crate::consent::reset_consent_for_tests;
use crate::context::{reset_context_for_tests, reset_trace_context_for_tests};
use crate::health::_reset_health_for_tests;
use crate::metrics::reset_metrics_for_tests;
use crate::otel::_reset_otel_for_tests;
use crate::pii::{replace_pii_rules, reset_secret_patterns_for_tests};
use crate::receipts::reset_receipts_for_tests;
use crate::resilience::_reset_resilience_for_tests;
use crate::sampling::_reset_sampling_for_tests;
use crate::schema::_reset_schema_for_tests;
use crate::setup::shutdown_telemetry;
use crate::slo::reset_slo_for_tests;
use crate::tracer::set_trace_context;
use std::sync::{Mutex, MutexGuard, OnceLock};

/// Observe this SDK's real config defaults and applicability, variable by
/// variable. Lives here rather than in a probe binary so the executable
/// contract test and the cross-language parity gate measure the same thing.
pub use crate::config::probe::{config_defaults_probe, ProbedConfigEntry};

static TEST_STATE_LOCK: OnceLock<Mutex<()>> = OnceLock::new();

#[cfg_attr(test, mutants::skip)] // Equivalent mutants only swap in Mutex::default().
fn default_test_state_lock_mutex() -> Mutex<()> {
    Mutex::new(())
}

fn test_state_lock() -> &'static Mutex<()> {
    TEST_STATE_LOCK.get_or_init(default_test_state_lock_mutex)
}

/// Serialize tests that mutate process-global telemetry state.
pub fn acquire_test_state_lock() -> MutexGuard<'static, ()> {
    test_state_lock().lock().unwrap_or_else(|e| e.into_inner())
}

/// Reset all telemetry state to keep tests isolated.
pub fn reset_telemetry_state() {
    let _ = shutdown_telemetry(None);
    _reset_otel_for_tests();
    // Restore the stranded-drain-worker budget. Sound even with workers still
    // pending: each decrements with a saturating subtraction on its way out.
    #[cfg(feature = "otel")]
    crate::otel::_reset_abandoned_workers_for_tests();
    _reset_health_for_tests();
    _reset_backpressure_for_tests();
    _reset_sampling_for_tests();
    _reset_resilience_for_tests();
    reset_metrics_for_tests();
    reset_receipts_for_tests();
    reset_consent_for_tests();
    reset_slo_for_tests();
    clear_cardinality_limits();
    clear_classification_rules();
    replace_pii_rules(Vec::new());
    reset_secret_patterns_for_tests();
    _reset_schema_for_tests();
    reset_context_for_tests();
}

/// Clear manual trace context to prevent cross-test leakage.
pub fn reset_trace_context() {
    reset_trace_context_for_tests();
    drop(set_trace_context(None, None));
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn testing_test_acquire_lock_recovers_after_poison() {
        let handle = std::thread::spawn(|| {
            let _guard = test_state_lock()
                .lock()
                .expect("test state lock should acquire before poison");
            panic!("poison test state lock");
        });
        assert!(handle.join().is_err(), "worker must panic to poison lock");

        let _guard = acquire_test_state_lock();
    }
}