daimon 0.16.0

A Rust-native AI agent framework
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! OpenTelemetry integration for exporting `tracing` spans to OTLP collectors.
//!
//! Since Daimon already instruments the entire agent pipeline with the `tracing`
//! crate, enabling OpenTelemetry export is a matter of installing the right
//! subscriber layer. This module provides [`init_otel_tracing`] to set up the
//! pipeline and [`OtelGuard::shutdown`] for graceful shutdown.
//!
//! # Feature Flag
//!
//! Requires the `otel` feature to be enabled.
//!
//! # Example
//!
//! ```ignore
//! use daimon::telemetry::{OtelConfig, init_otel_tracing};
//!
//! #[tokio::main]
//! async fn main() {
//!     let guard = init_otel_tracing(OtelConfig::default()).expect("otel init");
//!
//!     // ... run your agent ...
//!
//!     guard.shutdown();
//! }
//! ```

use opentelemetry::trace::TracerProvider;
use opentelemetry_otlp::SpanExporter;
use opentelemetry_sdk::trace::SdkTracerProvider;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::EnvFilter;

/// Configuration for the OpenTelemetry OTLP pipeline.
#[derive(Debug, Clone)]
pub struct OtelConfig {
    /// OTLP endpoint URL (default: `http://localhost:4318` for HTTP).
    pub endpoint: String,
    /// Service name reported in traces.
    pub service_name: String,
    /// Whether to also install a `tracing_subscriber::fmt` layer for
    /// local console output alongside OTLP export.
    pub with_fmt_layer: bool,
}

impl Default for OtelConfig {
    fn default() -> Self {
        Self {
            endpoint: "http://localhost:4318".to_string(),
            service_name: "daimon-agent".to_string(),
            with_fmt_layer: true,
        }
    }
}

impl OtelConfig {
    /// Sets the OTLP endpoint.
    pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
        self.endpoint = endpoint.into();
        self
    }

    /// Sets the service name.
    pub fn service_name(mut self, name: impl Into<String>) -> Self {
        self.service_name = name.into();
        self
    }

    /// Enables or disables the local fmt layer.
    pub fn with_fmt_layer(mut self, enabled: bool) -> Self {
        self.with_fmt_layer = enabled;
        self
    }
}

/// Guard returned by [`init_otel_tracing`]. Holds the tracer provider
/// for graceful shutdown.
pub struct OtelGuard {
    provider: SdkTracerProvider,
}

impl OtelGuard {
    /// Shuts down the OpenTelemetry pipeline, flushing any pending spans.
    pub fn shutdown(self) {
        if let Err(e) = self.provider.shutdown() {
            eprintln!("OpenTelemetry shutdown error: {e}");
        }
    }
}

/// Initializes the `tracing` subscriber with an OpenTelemetry OTLP layer.
///
/// This wires up `tracing` spans → OpenTelemetry → OTLP exporter so all
/// existing `#[instrument]` annotations on agent, model, tool, and
/// orchestration code automatically appear in your observability backend
/// (Jaeger, Tempo, Datadog, etc.).
///
/// Returns an [`OtelGuard`] that should be kept alive for the duration of
/// the application. Call [`OtelGuard::shutdown`] before exit for clean
/// flush.
pub fn init_otel_tracing(config: OtelConfig) -> Result<OtelGuard, Box<dyn std::error::Error>> {
    let exporter = SpanExporter::builder()
        .with_http()
        .build()?;

    let resource = opentelemetry_sdk::Resource::builder()
        .with_service_name(config.service_name)
        .build();

    let provider = SdkTracerProvider::builder()
        .with_batch_exporter(exporter)
        .with_resource(resource)
        .build();

    let tracer = provider.tracer("daimon");
    let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));

    if config.with_fmt_layer {
        let fmt_layer = tracing_subscriber::fmt::layer().compact();
        tracing_subscriber::registry()
            .with(otel_layer)
            .with(fmt_layer)
            .with(filter)
            .init();
    } else {
        tracing_subscriber::registry()
            .with(otel_layer)
            .with(filter)
            .init();
    }

    Ok(OtelGuard { provider })
}