gitgrip 1.0.0

Multi-repo workflow tool - manage multiple git repositories as one
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

//! Telemetry initialization.
//!
//! Provides configuration and initialization for the tracing subscriber.

use tracing::Level;
use tracing_subscriber::fmt;
use tracing_subscriber::prelude::*;
use tracing_subscriber::EnvFilter;

/// Configuration for telemetry initialization.
#[derive(Debug, Clone)]
pub struct TelemetryConfig {
    /// Default log level
    pub default_level: Level,
    /// Whether to include span enter/exit events
    pub include_span_events: bool,
    /// Whether to include file and line numbers
    pub include_file_line: bool,
    /// Whether to include the target (module path)
    pub include_target: bool,
    /// Whether to use ANSI colors
    pub ansi_colors: bool,
    /// Whether to use compact format
    pub compact: bool,
    /// Custom filter directive (overrides default_level if set)
    pub filter_directive: Option<String>,
}

impl Default for TelemetryConfig {
    fn default() -> Self {
        Self {
            default_level: Level::INFO,
            include_span_events: false,
            include_file_line: false,
            include_target: true,
            ansi_colors: true,
            compact: true,
            filter_directive: None,
        }
    }
}

impl TelemetryConfig {
    /// Create a development configuration (more verbose).
    pub fn development() -> Self {
        Self {
            default_level: Level::DEBUG,
            include_span_events: true,
            include_file_line: true,
            include_target: true,
            ansi_colors: true,
            compact: false,
            filter_directive: None,
        }
    }

    /// Create a production configuration (minimal overhead).
    pub fn production() -> Self {
        Self {
            default_level: Level::WARN,
            include_span_events: false,
            include_file_line: false,
            include_target: false,
            ansi_colors: false,
            compact: true,
            filter_directive: None,
        }
    }
}

/// Guard that keeps the telemetry subscriber active.
///
/// When dropped, the subscriber is deregistered.
pub struct TelemetryGuard {
    #[allow(dead_code)]
    _private: (),
}

/// Initialize telemetry with the given configuration.
///
/// Returns a guard that must be kept alive for the duration of the application.
/// Telemetry is disabled when the guard is dropped.
///
/// # Example
///
/// ```rust,ignore
/// use gitgrip::telemetry::{init_telemetry, TelemetryConfig};
///
/// fn main() -> anyhow::Result<()> {
///     let config = TelemetryConfig::default();
///     let _guard = init_telemetry(&config)?;
///
///     // Application code...
///     Ok(())
/// }
/// ```
pub fn init_telemetry(config: &TelemetryConfig) -> anyhow::Result<TelemetryGuard> {
    let filter = if let Some(ref directive) = config.filter_directive {
        EnvFilter::try_new(directive)?
    } else {
        EnvFilter::from_default_env()
            .add_directive(config.default_level.into())
            .add_directive(format!("gitgrip={}", config.default_level).parse()?)
    };

    let fmt_layer = fmt::layer()
        .with_ansi(config.ansi_colors)
        .with_target(config.include_target)
        .with_file(config.include_file_line)
        .with_line_number(config.include_file_line);

    let fmt_layer = if config.compact {
        fmt_layer.compact().boxed()
    } else {
        fmt_layer.boxed()
    };

    let subscriber = tracing_subscriber::registry().with(filter).with(fmt_layer);

    tracing::subscriber::set_global_default(subscriber)?;

    Ok(TelemetryGuard { _private: () })
}

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

    #[test]
    fn test_config_default() {
        let config = TelemetryConfig::default();
        assert_eq!(config.default_level, Level::INFO);
        assert!(config.compact);
    }

    #[test]
    fn test_config_development() {
        let config = TelemetryConfig::development();
        assert_eq!(config.default_level, Level::DEBUG);
        assert!(config.include_span_events);
    }

    #[test]
    fn test_config_production() {
        let config = TelemetryConfig::production();
        assert_eq!(config.default_level, Level::WARN);
        assert!(!config.include_span_events);
    }
}