feagi-observability 0.0.1-beta.8

Unified observability infrastructure for FEAGI (logging, telemetry, profiling)
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// Copyright 2025 Neuraville Inc.
// SPDX-License-Identifier: Apache-2.0

//! Observability configuration types

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

/// Unified observability configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObservabilityConfig {
    pub logging: LoggingConfig,
    pub telemetry: TelemetryConfig,
    pub profiling: ProfilingConfig,
}

/// Logging configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoggingConfig {
    /// Log level (trace, debug, info, warn, error)
    pub level: String,

    /// Log format (text or json)
    pub format: LogFormat,

    /// Output destination
    pub output: LogOutput,

    /// File path (if output is file)
    pub file_path: Option<PathBuf>,
}

/// Log format
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogFormat {
    Text,
    Json,
}

/// Log output destination
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogOutput {
    Stdout,
    File(String),
    Syslog,
}

/// Telemetry configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TelemetryConfig {
    /// Enable Prometheus metrics
    pub metrics_enabled: bool,

    /// Enable distributed tracing
    pub tracing_enabled: bool,

    /// Tracing endpoint (Jaeger OTLP)
    pub tracing_endpoint: Option<String>,

    /// Metrics endpoint path
    pub metrics_path: String,

    /// Health check endpoint
    pub health_check_path: String,

    /// System metrics collection interval (seconds)
    pub system_metrics_interval: u64,
}

/// Profiling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProfilingConfig {
    /// Enable CPU profiling
    pub cpu_profiling: bool,

    /// Enable memory profiling
    pub memory_profiling: bool,

    /// Output directory for profiles
    pub output_dir: PathBuf,

    /// Profiling sample rate (0.0-1.0)
    pub sample_rate: f64,

    /// Enable Chrome DevTools tracing
    pub chrome_tracing: bool,

    /// Enable perf profiling (Linux only)
    pub perf_profiling: bool,
}

impl Default for ObservabilityConfig {
    fn default() -> Self {
        ObservabilityConfig {
            logging: LoggingConfig {
                level: "info".to_string(),
                format: LogFormat::Text,
                output: LogOutput::Stdout,
                file_path: None,
            },
            telemetry: TelemetryConfig {
                metrics_enabled: true,
                tracing_enabled: false,
                tracing_endpoint: None,
                metrics_path: "/metrics".to_string(),
                health_check_path: "/health".to_string(),
                system_metrics_interval: 5,
            },
            profiling: ProfilingConfig {
                cpu_profiling: false,
                memory_profiling: false,
                output_dir: PathBuf::from("./profiles"),
                sample_rate: 1.0,
                chrome_tracing: false,
                perf_profiling: false,
            },
        }
    }
}

impl Default for LoggingConfig {
    fn default() -> Self {
        LoggingConfig {
            level: "info".to_string(),
            format: LogFormat::Text,
            output: LogOutput::Stdout,
            file_path: None,
        }
    }
}

impl Default for TelemetryConfig {
    fn default() -> Self {
        TelemetryConfig {
            metrics_enabled: true,
            tracing_enabled: false,
            tracing_endpoint: None,
            metrics_path: "/metrics".to_string(),
            health_check_path: "/health".to_string(),
            system_metrics_interval: 5,
        }
    }
}

impl Default for ProfilingConfig {
    fn default() -> Self {
        ProfilingConfig {
            cpu_profiling: false,
            memory_profiling: false,
            output_dir: PathBuf::from("./profiles"),
            sample_rate: 1.0,
            chrome_tracing: false,
            perf_profiling: false,
        }
    }
}