portail 2.1.0

Unified proxy/gateway: AI Gateway + MCP Gateway + CDN cache
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

//! OpenTelemetry OTLP export — traces to Jaeger/Tempo.
//!
//! v0.2 — gRPC-based OTLP trace export.

use std::time::Duration;

use opentelemetry::KeyValue;
use opentelemetry_otlp::{SpanExporter, WithExportConfig};
use opentelemetry_sdk::Resource;
use serde::{Deserialize, Serialize};
use tracing_subscriber::{EnvFilter, fmt, prelude::*};

/// Initialize production-grade non-blocking JSON logging.
/// Returns a guard that flushes on drop and the log directory path.
/// Uses tracing-appender for async file I/O off the main thread.
pub fn init_logging() -> (tracing_appender::non_blocking::WorkerGuard, String) {
    let log_dir = std::env::var("PORTAIL_LOG_DIR").unwrap_or_else(|_| "/var/log/portail".into());
    let _ = std::fs::create_dir_all(&log_dir);

    let file_appender = tracing_appender::rolling::hourly(&log_dir, "portail.log");
    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);

    let filter = EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into());

    tracing_subscriber::registry()
        .with(filter)
        .with(fmt::layer().json().with_writer(non_blocking))
        .init();

    (guard, log_dir)
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TelemetryConfig {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default = "default_endpoint")]
    pub endpoint: String,
    #[serde(default = "default_service_name")]
    pub service_name: String,
    #[serde(default = "default_sampling")]
    pub sampling_ratio: f64,
}

impl Default for TelemetryConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            endpoint: default_endpoint(),
            service_name: default_service_name(),
            sampling_ratio: default_sampling(),
        }
    }
}

fn default_endpoint() -> String {
    "http://localhost:4317".into()
}
fn default_service_name() -> String {
    "portail".into()
}
fn default_sampling() -> f64 {
    0.1
}

pub struct OtelGuard {
    _provider: Option<opentelemetry_sdk::trace::TracerProvider>,
}

impl OtelGuard {
    pub fn shutdown(self) {
        if let Some(p) = self._provider {
            let _ = p.shutdown();
        }
    }
}

pub fn init(config: &TelemetryConfig) -> Option<OtelGuard> {
    if !config.enabled {
        return None;
    }

    // OTLP endpoint is configured via the exporter builder, not env vars.
    // The env var approach is preferred by opentelemetry but set_var is
    // unsafe in multi-threaded contexts. We pass the endpoint directly.

    let exporter = SpanExporter::builder()
        .with_tonic()
        .with_endpoint(&config.endpoint)
        .with_timeout(Duration::from_secs(10))
        .build()
        .ok()?;

    let sampler = if config.sampling_ratio >= 1.0 {
        opentelemetry_sdk::trace::Sampler::AlwaysOn
    } else {
        opentelemetry_sdk::trace::Sampler::TraceIdRatioBased(config.sampling_ratio)
    };

    let provider = opentelemetry_sdk::trace::TracerProvider::builder()
        .with_batch_exporter(exporter, opentelemetry_sdk::runtime::Tokio)
        .with_resource(Resource::new(vec![KeyValue::new(
            "service.name",
            config.service_name.clone(),
        )]))
        .with_sampler(sampler)
        .build();

    let _ = opentelemetry::global::set_tracer_provider(provider.clone());

    tracing::info!(
        endpoint = %config.endpoint, service = %config.service_name,
        sampling = config.sampling_ratio,
        "OpenTelemetry OTLP export enabled"
    );

    Some(OtelGuard {
        _provider: Some(provider),
    })
}