718 lines
21 KiB
Rust
718 lines
21 KiB
Rust
|
//! Logging structuré avec tracing pour le serveur de streaming
|
||
|
|
//!
|
||
|
|
//! Ce module fournit un système de logging avancé avec:
|
||
|
|
//! - Logs structurés avec champs contextuels
|
||
|
|
//! - Rotation des logs
|
||
|
|
//! - Filtrage par niveau et module
|
||
|
|
//! - Export vers différents formats (JSON, Pretty, Compact)
|
||
|
|
//! - Intégration avec les métriques
|
||
|
|
|
||
|
|
use crate::config::LogFormat;
|
||
|
|
use crate::error::{AppError, Result};
|
||
|
|
use serde::{Deserialize, Serialize};
|
||
|
|
use std::collections::HashMap;
|
||
|
|
use std::path::PathBuf;
|
||
|
|
use std::time::Duration;
|
||
|
|
// Note: Use tracing::info! macro directly instead of importing
|
||
|
|
use tracing_appender::{
|
||
|
|
non_blocking::{NonBlocking, WorkerGuard},
|
||
|
|
rolling::{RollingFileAppender, Rotation},
|
||
|
|
};
|
||
|
|
use tracing_subscriber::{
|
||
|
|
fmt::{self, format::Writer, time::ChronoUtc},
|
||
|
|
layer::SubscriberExt,
|
||
|
|
util::SubscriberInitExt,
|
||
|
|
EnvFilter, Layer, Registry,
|
||
|
|
};
|
||
|
|
|
||
|
|
/// Configuration du logging
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub struct LoggingConfig {
|
||
|
|
pub level: String,
|
||
|
|
pub format: LogFormat,
|
||
|
|
pub file: Option<PathBuf>,
|
||
|
|
pub rotation: Option<LogRotation>,
|
||
|
|
pub filters: Vec<String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Configuration de la rotation des logs
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub struct LogRotation {
|
||
|
|
pub max_size: u64,
|
||
|
|
pub max_files: usize,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Configuration du logging structuré
|
||
|
|
#[derive(Debug)]
|
||
|
|
pub struct StructuredLogging {
|
||
|
|
config: LoggingConfig,
|
||
|
|
_guard: Option<WorkerGuard>,
|
||
|
|
appender: Option<NonBlocking>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl StructuredLogging {
|
||
|
|
/// Initialise le système de logging structuré
|
||
|
|
pub fn new(config: LoggingConfig) -> Result<Self> {
|
||
|
|
let (appender, guard) = if let Some(file_path) = &config.file {
|
||
|
|
// Configuration de la rotation des logs
|
||
|
|
let rotation = match &config.rotation {
|
||
|
|
Some(LogRotation { max_size, .. }) => {
|
||
|
|
if *max_size > 100 * 1024 * 1024 {
|
||
|
|
// > 100MB -> rotation quotidienne
|
||
|
|
Rotation::DAILY
|
||
|
|
} else {
|
||
|
|
// <= 100MB -> rotation horaire
|
||
|
|
Rotation::HOURLY
|
||
|
|
}
|
||
|
|
}
|
||
|
|
None => Rotation::DAILY,
|
||
|
|
};
|
||
|
|
|
||
|
|
let file_appender =
|
||
|
|
RollingFileAppender::new(rotation, file_path.parent().unwrap(), "stream-server");
|
||
|
|
let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
|
||
|
|
(Some(non_blocking), Some(guard))
|
||
|
|
} else {
|
||
|
|
(None, None)
|
||
|
|
};
|
||
|
|
|
||
|
|
Ok(Self {
|
||
|
|
config,
|
||
|
|
_guard: guard,
|
||
|
|
appender,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Configure et initialise le subscriber tracing
|
||
|
|
pub fn setup(&self) -> Result<()> {
|
||
|
|
// Filtre d'environnement
|
||
|
|
let env_filter = EnvFilter::try_from_default_env()
|
||
|
|
.or_else(|_| EnvFilter::try_new(&self.config.level))
|
||
|
|
.map_err(|e| AppError::ConfigError {
|
||
|
|
message: format!("Erreur configuration filtre: {e}"),
|
||
|
|
})?;
|
||
|
|
|
||
|
|
// Configuration du format
|
||
|
|
let format_layer = match self.config.format {
|
||
|
|
LogFormat::Json => fmt::layer()
|
||
|
|
.json()
|
||
|
|
.with_timer(ChronoUtc::rfc_3339())
|
||
|
|
.with_target(true)
|
||
|
|
.with_file(true)
|
||
|
|
.with_line_number(true)
|
||
|
|
.boxed(),
|
||
|
|
LogFormat::Pretty => fmt::layer()
|
||
|
|
.pretty()
|
||
|
|
.with_timer(ChronoUtc::rfc_3339())
|
||
|
|
.with_target(true)
|
||
|
|
.with_file(true)
|
||
|
|
.with_line_number(true)
|
||
|
|
.boxed(),
|
||
|
|
LogFormat::Compact => fmt::layer()
|
||
|
|
.compact()
|
||
|
|
.with_timer(ChronoUtc::rfc_3339())
|
||
|
|
.with_target(true)
|
||
|
|
.boxed(),
|
||
|
|
};
|
||
|
|
|
||
|
|
// Configuration de la sortie
|
||
|
|
let registry = Registry::default().with(env_filter).with(format_layer);
|
||
|
|
|
||
|
|
if let Some(appender) = &self.appender {
|
||
|
|
let file_layer = fmt::layer()
|
||
|
|
.json()
|
||
|
|
.with_writer(appender.clone())
|
||
|
|
.with_timer(ChronoUtc::rfc_3339())
|
||
|
|
.with_target(true)
|
||
|
|
.with_file(true)
|
||
|
|
.with_line_number(true)
|
||
|
|
.boxed();
|
||
|
|
|
||
|
|
registry.with(file_layer).init();
|
||
|
|
} else {
|
||
|
|
registry.init();
|
||
|
|
}
|
||
|
|
|
||
|
|
tracing::info!(
|
||
|
|
level = %self.config.level,
|
||
|
|
format = ?self.config.format,
|
||
|
|
file = ?self.config.file,
|
||
|
|
"🔧 Système de logging structuré initialisé"
|
||
|
|
);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'une requête de streaming
|
||
|
|
pub fn log_stream_request(
|
||
|
|
track_id: &str,
|
||
|
|
user_id: &str,
|
||
|
|
bitrate: u32,
|
||
|
|
metadata: HashMap<String, String>,
|
||
|
|
) {
|
||
|
|
tracing::info!(
|
||
|
|
track_id = track_id,
|
||
|
|
user_id = user_id,
|
||
|
|
bitrate = bitrate,
|
||
|
|
metadata = ?metadata,
|
||
|
|
"Stream request initiated"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Trace d'un chunk audio traité
|
||
|
|
pub fn trace_audio_chunk(chunk_id: usize, size: usize) {
|
||
|
|
tracing::trace!(chunk_id = chunk_id, size = size, "Audio chunk processed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'erreur avec contexte
|
||
|
|
pub fn log_error(error: &str, context: HashMap<String, String>) {
|
||
|
|
tracing::error!(
|
||
|
|
error = error,
|
||
|
|
context = ?context,
|
||
|
|
"Error occurred in stream server"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Macros de logging contextuel pour le streaming
|
||
|
|
pub mod stream_logs {
|
||
|
|
use super::*;
|
||
|
|
use std::collections::HashMap;
|
||
|
|
// Note: Use tracing::info! macro directly instead of importing
|
||
|
|
use uuid::Uuid;
|
||
|
|
|
||
|
|
/// Log de connexion de streaming
|
||
|
|
pub fn stream_connected(stream_id: &str, client_ip: &str, user_agent: &str, codec: &str) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "stream_connected",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
client_ip = %client_ip,
|
||
|
|
user_agent = %user_agent,
|
||
|
|
codec = %codec,
|
||
|
|
"🎵 Connexion de streaming établie"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de déconnexion de streaming
|
||
|
|
pub fn stream_disconnected(
|
||
|
|
stream_id: &str,
|
||
|
|
client_ip: &str,
|
||
|
|
duration_seconds: u64,
|
||
|
|
reason: &str,
|
||
|
|
) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "stream_disconnected",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
client_ip = %client_ip,
|
||
|
|
duration_seconds = %duration_seconds,
|
||
|
|
reason = %reason,
|
||
|
|
"🎵 Connexion de streaming fermée"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de début de lecture
|
||
|
|
pub fn playback_started(stream_id: &str, track_id: &str, codec: &str, bitrate: u32) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "playback_started",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
track_id = %track_id,
|
||
|
|
codec = %codec,
|
||
|
|
bitrate = %bitrate,
|
||
|
|
"▶️ Lecture démarrée"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de pause de lecture
|
||
|
|
pub fn playback_paused(stream_id: &str, track_id: &str, position_seconds: f64) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "playback_paused",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
track_id = %track_id,
|
||
|
|
position_seconds = %position_seconds,
|
||
|
|
"⏸️ Lecture en pause"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de reprise de lecture
|
||
|
|
pub fn playback_resumed(stream_id: &str, track_id: &str, position_seconds: f64) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "playback_resumed",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
track_id = %track_id,
|
||
|
|
position_seconds = %position_seconds,
|
||
|
|
"▶️ Lecture reprise"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de fin de lecture
|
||
|
|
pub fn playback_finished(stream_id: &str, track_id: &str, duration_seconds: f64) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "playback_finished",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
track_id = %track_id,
|
||
|
|
duration_seconds = %duration_seconds,
|
||
|
|
"🏁 Lecture terminée"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de changement de qualité
|
||
|
|
pub fn quality_changed(stream_id: &str, old_quality: &str, new_quality: &str, reason: &str) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "quality_changed",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
old_quality = %old_quality,
|
||
|
|
new_quality = %new_quality,
|
||
|
|
reason = %reason,
|
||
|
|
"📊 Qualité changée"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'encodage audio
|
||
|
|
pub fn audio_encoded(
|
||
|
|
stream_id: &str,
|
||
|
|
codec: &str,
|
||
|
|
input_samples: usize,
|
||
|
|
output_bytes: usize,
|
||
|
|
encoding_time_ms: u64,
|
||
|
|
) {
|
||
|
|
tracing::debug!(
|
||
|
|
event = "audio_encoded",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
codec = %codec,
|
||
|
|
input_samples = %input_samples,
|
||
|
|
output_bytes = %output_bytes,
|
||
|
|
encoding_time_ms = %encoding_time_ms,
|
||
|
|
"🎼 Audio encodé"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de décodage audio
|
||
|
|
pub fn audio_decoded(
|
||
|
|
stream_id: &str,
|
||
|
|
codec: &str,
|
||
|
|
input_bytes: usize,
|
||
|
|
output_samples: usize,
|
||
|
|
decoding_time_ms: u64,
|
||
|
|
) {
|
||
|
|
tracing::debug!(
|
||
|
|
event = "audio_decoded",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
codec = %codec,
|
||
|
|
input_bytes = %input_bytes,
|
||
|
|
output_samples = %output_samples,
|
||
|
|
decoding_time_ms = %decoding_time_ms,
|
||
|
|
"🎼 Audio décodé"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'upload de fichier
|
||
|
|
pub fn file_uploaded(
|
||
|
|
file_id: &str,
|
||
|
|
filename: &str,
|
||
|
|
file_size: u64,
|
||
|
|
codec: &str,
|
||
|
|
duration_seconds: f64,
|
||
|
|
) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "file_uploaded",
|
||
|
|
file_id = %file_id,
|
||
|
|
filename = %filename,
|
||
|
|
file_size = %file_size,
|
||
|
|
codec = %codec,
|
||
|
|
duration_seconds = %duration_seconds,
|
||
|
|
"📁 Fichier uploadé"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de suppression de fichier
|
||
|
|
pub fn file_deleted(file_id: &str, filename: &str, reason: &str) {
|
||
|
|
tracing::warn!(
|
||
|
|
event = "file_deleted",
|
||
|
|
file_id = %file_id,
|
||
|
|
filename = %filename,
|
||
|
|
reason = %reason,
|
||
|
|
"🗑️ Fichier supprimé"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de transcodage
|
||
|
|
pub fn transcoding_started(
|
||
|
|
file_id: &str,
|
||
|
|
input_codec: &str,
|
||
|
|
output_codec: &str,
|
||
|
|
quality: &str,
|
||
|
|
) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "transcoding_started",
|
||
|
|
file_id = %file_id,
|
||
|
|
input_codec = %input_codec,
|
||
|
|
output_codec = %output_codec,
|
||
|
|
quality = %quality,
|
||
|
|
"🔄 Transcodage démarré"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de fin de transcodage
|
||
|
|
pub fn transcoding_finished(
|
||
|
|
file_id: &str,
|
||
|
|
input_codec: &str,
|
||
|
|
output_codec: &str,
|
||
|
|
duration_seconds: f64,
|
||
|
|
success: bool,
|
||
|
|
) {
|
||
|
|
let level = if success { "info" } else { "error" };
|
||
|
|
let message = if success {
|
||
|
|
"✅ Transcodage terminé"
|
||
|
|
} else {
|
||
|
|
"❌ Transcodage échoué"
|
||
|
|
};
|
||
|
|
|
||
|
|
match level {
|
||
|
|
"info" => {
|
||
|
|
tracing::info!(
|
||
|
|
event = "transcoding_finished",
|
||
|
|
file_id = %file_id,
|
||
|
|
input_codec = %input_codec,
|
||
|
|
output_codec = %output_codec,
|
||
|
|
duration_seconds = %duration_seconds,
|
||
|
|
success = %success,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
tracing::error!(
|
||
|
|
event = "transcoding_finished",
|
||
|
|
file_id = %file_id,
|
||
|
|
input_codec = %input_codec,
|
||
|
|
output_codec = %output_codec,
|
||
|
|
duration_seconds = %duration_seconds,
|
||
|
|
success = %success,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'erreur de streaming
|
||
|
|
pub fn stream_error(stream_id: &str, error_type: &str, error_message: &str, context: &str) {
|
||
|
|
tracing::error!(
|
||
|
|
event = "stream_error",
|
||
|
|
stream_id = %stream_id,
|
||
|
|
error_type = %error_type,
|
||
|
|
error_message = %error_message,
|
||
|
|
context = %context,
|
||
|
|
"💥 Erreur de streaming"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'erreur de codec
|
||
|
|
pub fn codec_error(codec: &str, operation: &str, error_message: &str) {
|
||
|
|
tracing::error!(
|
||
|
|
event = "codec_error",
|
||
|
|
codec = %codec,
|
||
|
|
operation = %operation,
|
||
|
|
error_message = %error_message,
|
||
|
|
"🎼 Erreur de codec"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'erreur de fichier
|
||
|
|
pub fn file_error(file_id: &str, operation: &str, error_message: &str) {
|
||
|
|
tracing::error!(
|
||
|
|
event = "file_error",
|
||
|
|
file_id = %file_id,
|
||
|
|
operation = %operation,
|
||
|
|
error_message = %error_message,
|
||
|
|
"📁 Erreur de fichier"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de performance
|
||
|
|
pub fn performance_measurement(
|
||
|
|
operation: &str,
|
||
|
|
duration_ms: f64,
|
||
|
|
success: bool,
|
||
|
|
additional_data: Option<&HashMap<String, String>>,
|
||
|
|
) {
|
||
|
|
let level = if success { "debug" } else { "warn" };
|
||
|
|
let message = if success {
|
||
|
|
"⚡ Opération terminée"
|
||
|
|
} else {
|
||
|
|
"🐌 Opération lente"
|
||
|
|
};
|
||
|
|
|
||
|
|
match level {
|
||
|
|
"debug" => {
|
||
|
|
tracing::debug!(
|
||
|
|
event = "performance_measurement",
|
||
|
|
operation = %operation,
|
||
|
|
duration_ms = %duration_ms,
|
||
|
|
success = %success,
|
||
|
|
additional_data = ?additional_data,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
tracing::warn!(
|
||
|
|
event = "performance_measurement",
|
||
|
|
operation = %operation,
|
||
|
|
duration_ms = %duration_ms,
|
||
|
|
success = %success,
|
||
|
|
additional_data = ?additional_data,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de démarrage du serveur
|
||
|
|
pub fn server_started(bind_addr: &str, environment: &str, version: &str) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "server_started",
|
||
|
|
bind_addr = %bind_addr,
|
||
|
|
environment = %environment,
|
||
|
|
version = %version,
|
||
|
|
"🚀 Serveur de streaming démarré"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log d'arrêt du serveur
|
||
|
|
pub fn server_stopped(reason: &str, uptime_seconds: u64) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "server_stopped",
|
||
|
|
reason = %reason,
|
||
|
|
uptime_seconds = %uptime_seconds,
|
||
|
|
"🛑 Serveur de streaming arrêté"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de configuration
|
||
|
|
pub fn config_loaded(config_source: &str, config_path: Option<&str>) {
|
||
|
|
tracing::info!(
|
||
|
|
event = "config_loaded",
|
||
|
|
config_source = %config_source,
|
||
|
|
config_path = ?config_path,
|
||
|
|
"⚙️ Configuration chargée"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de base de données
|
||
|
|
pub fn database_operation(operation: &str, table: &str, duration_ms: f64, success: bool) {
|
||
|
|
let level = if success { "debug" } else { "error" };
|
||
|
|
let message = if success {
|
||
|
|
"🗄️ Opération DB réussie"
|
||
|
|
} else {
|
||
|
|
"💥 Erreur DB"
|
||
|
|
};
|
||
|
|
|
||
|
|
match level {
|
||
|
|
"debug" => {
|
||
|
|
tracing::debug!(
|
||
|
|
event = "database_operation",
|
||
|
|
operation = %operation,
|
||
|
|
table = %table,
|
||
|
|
duration_ms = %duration_ms,
|
||
|
|
success = %success,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
tracing::error!(
|
||
|
|
event = "database_operation",
|
||
|
|
operation = %operation,
|
||
|
|
table = %table,
|
||
|
|
duration_ms = %duration_ms,
|
||
|
|
success = %success,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de cache
|
||
|
|
pub fn cache_operation(operation: &str, key: &str, hit: bool, duration_ms: f64) {
|
||
|
|
tracing::debug!(
|
||
|
|
event = "cache_operation",
|
||
|
|
operation = %operation,
|
||
|
|
key = %key,
|
||
|
|
hit = %hit,
|
||
|
|
duration_ms = %duration_ms,
|
||
|
|
"💾 Opération de cache"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de sécurité
|
||
|
|
pub fn security_event(event_type: &str, client_ip: &str, details: &str) {
|
||
|
|
tracing::warn!(
|
||
|
|
event = "security_event",
|
||
|
|
event_type = %event_type,
|
||
|
|
client_ip = %client_ip,
|
||
|
|
details = %details,
|
||
|
|
"🔒 Événement de sécurité"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Log de métriques
|
||
|
|
pub fn metrics_updated(metric_name: &str, value: f64, labels: &HashMap<String, String>) {
|
||
|
|
tracing::trace!(
|
||
|
|
event = "metrics_updated",
|
||
|
|
metric_name = %metric_name,
|
||
|
|
value = %value,
|
||
|
|
labels = ?labels,
|
||
|
|
"📊 Métrique mise à jour"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Wrapper pour les logs avec contexte de streaming
|
||
|
|
pub struct StreamContextLogger {
|
||
|
|
stream_id: String,
|
||
|
|
client_ip: String,
|
||
|
|
user_agent: Option<String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl StreamContextLogger {
|
||
|
|
pub fn new(stream_id: String, client_ip: String, user_agent: Option<String>) -> Self {
|
||
|
|
Self {
|
||
|
|
stream_id,
|
||
|
|
client_ip,
|
||
|
|
user_agent,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn info(&self, message: &str, fields: Option<&HashMap<String, String>>) {
|
||
|
|
tracing::info!(
|
||
|
|
stream_id = %self.stream_id,
|
||
|
|
client_ip = %self.client_ip,
|
||
|
|
user_agent = ?self.user_agent,
|
||
|
|
additional_fields = ?fields,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn warn(&self, message: &str, fields: Option<&HashMap<String, String>>) {
|
||
|
|
tracing::warn!(
|
||
|
|
stream_id = %self.stream_id,
|
||
|
|
client_ip = %self.client_ip,
|
||
|
|
user_agent = ?self.user_agent,
|
||
|
|
additional_fields = ?fields,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn error(&self, message: &str, fields: Option<&HashMap<String, String>>) {
|
||
|
|
tracing::error!(
|
||
|
|
stream_id = %self.stream_id,
|
||
|
|
client_ip = %self.client_ip,
|
||
|
|
user_agent = ?self.user_agent,
|
||
|
|
additional_fields = ?fields,
|
||
|
|
"{}", message
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Initialise le système de logging depuis la configuration du serveur
|
||
|
|
pub fn init_logging_from_config(config: &crate::config::Config) -> Result<StructuredLogging> {
|
||
|
|
let logging_config = LoggingConfig {
|
||
|
|
level: config.monitoring.log_level.clone(),
|
||
|
|
format: config.monitoring.log_format.clone(),
|
||
|
|
file: None, // TODO: Ajouter configuration de fichier si nécessaire
|
||
|
|
rotation: None,
|
||
|
|
filters: vec![],
|
||
|
|
};
|
||
|
|
let structured_logging = StructuredLogging::new(logging_config)?;
|
||
|
|
structured_logging.setup()?;
|
||
|
|
|
||
|
|
stream_logs::config_loaded("server_config", None);
|
||
|
|
stream_logs::server_started(
|
||
|
|
&format!("0.0.0.0:{}", config.port),
|
||
|
|
&format!("{:?}", config.environment),
|
||
|
|
env!("CARGO_PKG_VERSION"),
|
||
|
|
);
|
||
|
|
|
||
|
|
Ok(structured_logging)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Configuration par défaut pour les tests
|
||
|
|
pub fn init_test_logging() -> Result<()> {
|
||
|
|
let config = LoggingConfig {
|
||
|
|
level: "debug".to_string(),
|
||
|
|
format: LogFormat::Compact,
|
||
|
|
file: None,
|
||
|
|
rotation: None,
|
||
|
|
filters: vec!["stream_server=debug".to_string()],
|
||
|
|
};
|
||
|
|
|
||
|
|
let structured_logging = StructuredLogging::new(config)?;
|
||
|
|
structured_logging.setup()?;
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
use std::collections::HashMap;
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_stream_context_logger() {
|
||
|
|
let logger = StreamContextLogger::new(
|
||
|
|
"test_stream".to_string(),
|
||
|
|
"127.0.0.1".to_string(),
|
||
|
|
Some("TestAgent".to_string()),
|
||
|
|
);
|
||
|
|
|
||
|
|
// Test que le logger peut être créé sans erreur
|
||
|
|
assert_eq!(logger.stream_id, "test_stream");
|
||
|
|
assert_eq!(logger.client_ip, "127.0.0.1");
|
||
|
|
assert_eq!(logger.user_agent, Some("TestAgent".to_string()));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_stream_logs_macros() {
|
||
|
|
// Test que les macros de logging peuvent être appelées
|
||
|
|
// (elles ne feront rien en mode test sans subscriber)
|
||
|
|
stream_logs::stream_connected("test", "127.0.0.1", "TestAgent", "mp3");
|
||
|
|
stream_logs::playback_started("test", "track1", "mp3", 128000);
|
||
|
|
stream_logs::stream_error("test", "codec", "Test error", "encoding");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_structured_logging_creation() {
|
||
|
|
let config = LoggingConfig {
|
||
|
|
level: "info".to_string(),
|
||
|
|
format: LogFormat::Pretty,
|
||
|
|
file: None,
|
||
|
|
rotation: None,
|
||
|
|
filters: vec![],
|
||
|
|
};
|
||
|
|
|
||
|
|
let result = StructuredLogging::new(config);
|
||
|
|
assert!(result.is_ok());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_log_stream_request() {
|
||
|
|
let mut metadata = HashMap::new();
|
||
|
|
metadata.insert("ip".to_string(), "192.168.1.1".to_string());
|
||
|
|
|
||
|
|
// Should not panic
|
||
|
|
log_stream_request("track-123", "user-456", 320, metadata);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_trace_audio_chunk() {
|
||
|
|
// Should not panic
|
||
|
|
trace_audio_chunk(1, 1024);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_log_error() {
|
||
|
|
let mut context = HashMap::new();
|
||
|
|
context.insert("operation".to_string(), "encoding".to_string());
|
||
|
|
|
||
|
|
// Should not panic
|
||
|
|
log_error("Test error message", context);
|
||
|
|
}
|
||
|
|
}
|