structured_logging/
error.rs1use thiserror::Error;
4
5pub type Result<T> = std::result::Result<T, StructuredLoggingError>;
7
8#[derive(Error, Debug, Clone)]
10pub enum StructuredLoggingError {
11 #[error("Observability error: {0}")]
13 Observability(#[from] observability_core::ObservabilityError),
14
15 #[error("Performance optimization error: {message}")]
17 Performance { message: String },
18
19 #[error("String interning error: {message}")]
21 StringInterning { message: String },
22
23 #[error("Buffer pool error: {message}")]
25 BufferPool { message: String },
26
27 #[error("Correlation error: {message}")]
29 Correlation { message: String },
30
31 #[error("Baggage error: {message}")]
33 Baggage { message: String },
34
35 #[error("Scoped context error: {message}")]
37 ScopedContext { message: String },
38
39 #[error("Convenience API error: {message}")]
41 Convenience { message: String },
42
43 #[error("Enhanced configuration error: {message}")]
45 EnhancedConfig { message: String },
46
47 #[error("Fast path error: {message}")]
49 FastPath { message: String },
50
51 #[error("Feature not enabled: {feature}. Enable with cargo feature '{feature}'")]
53 FeatureNotEnabled { feature: String },
54}
55
56impl StructuredLoggingError {
57 pub fn performance<T: Into<String>>(message: T) -> Self {
59 Self::Performance {
60 message: message.into(),
61 }
62 }
63
64 pub fn string_interning<T: Into<String>>(message: T) -> Self {
66 Self::StringInterning {
67 message: message.into(),
68 }
69 }
70
71 pub fn buffer_pool<T: Into<String>>(message: T) -> Self {
73 Self::BufferPool {
74 message: message.into(),
75 }
76 }
77
78 pub fn correlation<T: Into<String>>(message: T) -> Self {
80 Self::Correlation {
81 message: message.into(),
82 }
83 }
84
85 pub fn baggage<T: Into<String>>(message: T) -> Self {
87 Self::Baggage {
88 message: message.into(),
89 }
90 }
91
92 pub fn scoped_context<T: Into<String>>(message: T) -> Self {
94 Self::ScopedContext {
95 message: message.into(),
96 }
97 }
98
99 pub fn convenience<T: Into<String>>(message: T) -> Self {
101 Self::Convenience {
102 message: message.into(),
103 }
104 }
105
106 pub fn enhanced_config<T: Into<String>>(message: T) -> Self {
108 Self::EnhancedConfig {
109 message: message.into(),
110 }
111 }
112
113 pub fn fast_path<T: Into<String>>(message: T) -> Self {
115 Self::FastPath {
116 message: message.into(),
117 }
118 }
119
120 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}