Skip to main content

structured_logging/
error.rs

1//! Error types for enhanced structured logging
2
3use thiserror::Error;
4
5/// Result type for structured logging operations
6pub type Result<T> = std::result::Result<T, StructuredLoggingError>;
7
8/// Enhanced error types for structured logging operations
9#[derive(Error, Debug, Clone)]
10pub enum StructuredLoggingError {
11    /// Wraps observability_core errors
12    #[error("Observability error: {0}")]
13    Observability(#[from] observability_core::ObservabilityError),
14
15    /// Performance optimization errors
16    #[error("Performance optimization error: {message}")]
17    Performance { message: String },
18
19    /// String interning errors
20    #[error("String interning error: {message}")]
21    StringInterning { message: String },
22
23    /// Buffer pool errors
24    #[error("Buffer pool error: {message}")]
25    BufferPool { message: String },
26
27    /// Correlation enhancement errors
28    #[error("Correlation error: {message}")]
29    Correlation { message: String },
30
31    /// Baggage management errors
32    #[error("Baggage error: {message}")]
33    Baggage { message: String },
34
35    /// Scoped context errors
36    #[error("Scoped context error: {message}")]
37    ScopedContext { message: String },
38
39    /// Convenience API errors
40    #[error("Convenience API error: {message}")]
41    Convenience { message: String },
42
43    /// Configuration errors specific to enhanced features
44    #[error("Enhanced configuration error: {message}")]
45    EnhancedConfig { message: String },
46
47    /// Fast path errors
48    #[error("Fast path error: {message}")]
49    FastPath { message: String },
50
51    /// Feature not enabled
52    #[error("Feature not enabled: {feature}. Enable with cargo feature '{feature}'")]
53    FeatureNotEnabled { feature: String },
54}
55
56impl StructuredLoggingError {
57    /// Create a performance error
58    pub fn performance<T: Into<String>>(message: T) -> Self {
59        Self::Performance {
60            message: message.into(),
61        }
62    }
63
64    /// Create a string interning error
65    pub fn string_interning<T: Into<String>>(message: T) -> Self {
66        Self::StringInterning {
67            message: message.into(),
68        }
69    }
70
71    /// Create a buffer pool error
72    pub fn buffer_pool<T: Into<String>>(message: T) -> Self {
73        Self::BufferPool {
74            message: message.into(),
75        }
76    }
77
78    /// Create a correlation error
79    pub fn correlation<T: Into<String>>(message: T) -> Self {
80        Self::Correlation {
81            message: message.into(),
82        }
83    }
84
85    /// Create a baggage error
86    pub fn baggage<T: Into<String>>(message: T) -> Self {
87        Self::Baggage {
88            message: message.into(),
89        }
90    }
91
92    /// Create a scoped context error
93    pub fn scoped_context<T: Into<String>>(message: T) -> Self {
94        Self::ScopedContext {
95            message: message.into(),
96        }
97    }
98
99    /// Create a convenience API error
100    pub fn convenience<T: Into<String>>(message: T) -> Self {
101        Self::Convenience {
102            message: message.into(),
103        }
104    }
105
106    /// Create an enhanced configuration error
107    pub fn enhanced_config<T: Into<String>>(message: T) -> Self {
108        Self::EnhancedConfig {
109            message: message.into(),
110        }
111    }
112
113    /// Create a fast path error
114    pub fn fast_path<T: Into<String>>(message: T) -> Self {
115        Self::FastPath {
116            message: message.into(),
117        }
118    }
119
120    /// Create a feature not enabled error
121    pub fn feature_not_enabled<T: Into<String>>(feature: T) -> Self {
122        Self::FeatureNotEnabled {
123            feature: feature.into(),
124        }
125    }
126}
127
128impl From<serde_json::Error> for StructuredLoggingError {
129    fn from(err: serde_json::Error) -> Self {
130        Self::performance(format!("JSON serialization error: {}", err))
131    }
132}
133
134impl From<std::io::Error> for StructuredLoggingError {
135    fn from(err: std::io::Error) -> Self {
136        Self::performance(format!("IO error: {}", err))
137    }
138}