use thiserror::Error;
pub type Result<T> = std::result::Result<T, StructuredLoggingError>;
#[derive(Error, Debug, Clone)]
pub enum StructuredLoggingError {
#[error("Observability error: {0}")]
Observability(#[from] observability_core::ObservabilityError),
#[error("Performance optimization error: {message}")]
Performance { message: String },
#[error("String interning error: {message}")]
StringInterning { message: String },
#[error("Buffer pool error: {message}")]
BufferPool { message: String },
#[error("Correlation error: {message}")]
Correlation { message: String },
#[error("Baggage error: {message}")]
Baggage { message: String },
#[error("Scoped context error: {message}")]
ScopedContext { message: String },
#[error("Convenience API error: {message}")]
Convenience { message: String },
#[error("Enhanced configuration error: {message}")]
EnhancedConfig { message: String },
#[error("Fast path error: {message}")]
FastPath { message: String },
#[error("Feature not enabled: {feature}. Enable with cargo feature '{feature}'")]
FeatureNotEnabled { feature: String },
}
impl StructuredLoggingError {
pub fn performance<T: Into<String>>(message: T) -> Self {
Self::Performance {
message: message.into(),
}
}
pub fn string_interning<T: Into<String>>(message: T) -> Self {
Self::StringInterning {
message: message.into(),
}
}
pub fn buffer_pool<T: Into<String>>(message: T) -> Self {
Self::BufferPool {
message: message.into(),
}
}
pub fn correlation<T: Into<String>>(message: T) -> Self {
Self::Correlation {
message: message.into(),
}
}
pub fn baggage<T: Into<String>>(message: T) -> Self {
Self::Baggage {
message: message.into(),
}
}
pub fn scoped_context<T: Into<String>>(message: T) -> Self {
Self::ScopedContext {
message: message.into(),
}
}
pub fn convenience<T: Into<String>>(message: T) -> Self {
Self::Convenience {
message: message.into(),
}
}
pub fn enhanced_config<T: Into<String>>(message: T) -> Self {
Self::EnhancedConfig {
message: message.into(),
}
}
pub fn fast_path<T: Into<String>>(message: T) -> Self {
Self::FastPath {
message: message.into(),
}
}
pub fn feature_not_enabled<T: Into<String>>(feature: T) -> Self {
Self::FeatureNotEnabled {
feature: feature.into(),
}
}
}
impl From<serde_json::Error> for StructuredLoggingError {
fn from(err: serde_json::Error) -> Self {
Self::performance(format!("JSON serialization error: {}", err))
}
}
impl From<std::io::Error> for StructuredLoggingError {
fn from(err: std::io::Error) -> Self {
Self::performance(format!("IO error: {}", err))
}
}