autoagents-telemetry 0.3.3

Agent Framework for Building Autonomous Agents
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
110
111
112
113
114
115
116
117
118
119

use autoagents_protocol::RuntimeID;
use std::collections::HashMap;

/// Top-level telemetry configuration applied when a tracer starts.
#[derive(Debug, Clone)]
pub struct TelemetryConfig {
    pub service_name: String,
    pub service_version: Option<String>,
    pub environment: Option<String>,
    pub runtime_id: Option<RuntimeID>,
    pub exporter: ExporterConfig,
    pub span_batch: SpanBatchConfig,
    pub redaction: RedactionConfig,
    pub metrics_enabled: bool,
    pub install_tracing_subscriber: bool,
}

impl TelemetryConfig {
    pub fn new(service_name: impl Into<String>) -> Self {
        Self {
            service_name: service_name.into(),
            service_version: None,
            environment: None,
            runtime_id: None,
            exporter: ExporterConfig::default(),
            span_batch: SpanBatchConfig::default(),
            redaction: RedactionConfig::default(),
            metrics_enabled: true,
            install_tracing_subscriber: true,
        }
    }

    pub fn with_runtime_id(mut self, runtime_id: RuntimeID) -> Self {
        self.runtime_id = Some(runtime_id);
        self
    }
}

impl Default for TelemetryConfig {
    fn default() -> Self {
        Self::new("autoagents")
    }
}

/// Exporter wiring for spans/metrics.
#[derive(Debug, Clone, Default)]
pub struct ExporterConfig {
    pub otlp: Option<OtlpConfig>,
    pub stdout: bool,
}

/// Span batcher configuration to avoid per-span exports.
#[derive(Debug, Clone)]
pub struct SpanBatchConfig {
    pub max_queue_size: usize,
    pub max_export_batch_size: usize,
    pub scheduled_delay: std::time::Duration,
    pub max_export_timeout: std::time::Duration,
    pub max_concurrent_exports: usize,
}

impl Default for SpanBatchConfig {
    fn default() -> Self {
        Self {
            max_queue_size: 2048,
            max_export_batch_size: 512,
            scheduled_delay: std::time::Duration::from_secs(5),
            max_export_timeout: std::time::Duration::from_secs(30),
            max_concurrent_exports: 1,
        }
    }
}

/// OTLP endpoint and transport details.
#[derive(Debug, Clone)]
pub struct OtlpConfig {
    pub endpoint: Option<String>,
    pub protocol: OtlpProtocol,
    pub headers: HashMap<String, String>,
    pub debug_http: bool,
}

impl OtlpConfig {
    pub fn new(endpoint: impl Into<String>) -> Self {
        Self {
            endpoint: Some(endpoint.into()),
            protocol: OtlpProtocol::HttpBinary,
            headers: HashMap::new(),
            debug_http: false,
        }
    }
}

impl Default for OtlpConfig {
    fn default() -> Self {
        Self {
            endpoint: None,
            protocol: OtlpProtocol::HttpBinary,
            headers: HashMap::new(),
            debug_http: false,
        }
    }
}

/// Supported OTLP wire protocols.
#[derive(Debug, Clone, Copy)]
pub enum OtlpProtocol {
    HttpBinary,
    HttpJson,
}

/// Redaction flags for telemetry payloads.
#[derive(Debug, Clone, Default)]
pub struct RedactionConfig {
    pub redact_task_inputs: bool,
    pub redact_task_outputs: bool,
    pub redact_tool_arguments: bool,
    pub redact_tool_results: bool,
}