use std::collections::HashMap;
use std::io::{self, Write};
use std::sync::{Arc, Mutex, RwLock};
use web_time::{Duration, Instant};
#[cfg(feature = "string-interner")]
use string_interner_crate::StringInterner;
use crate::error::{Result, StructuredLoggingError};
use crate::extension::PerformanceConfig;
use observability_core::domain::TraceContext;
use observability_core::{LogEntry, TransportPort, traits::LogLevel};
use serde_json::Value;
#[derive(Debug, Clone, Default)]
pub struct PerformanceStats {
pub entries_processed: u64,
pub fast_path_time: Duration,
pub standard_path_time: Duration,
pub string_interner_hits: u64,
pub string_interner_misses: u64,
pub buffer_pool_hits: u64,
pub buffer_pool_misses: u64,
pub bytes_written: u64,
pub avg_processing_time_ns: u64,
}
impl PerformanceStats {
pub fn string_interner_hit_ratio(&self) -> f64 {
let total = self.string_interner_hits + self.string_interner_misses;
if total > 0 {
self.string_interner_hits as f64 / total as f64
} else {
0.0
}
}
pub fn buffer_pool_hit_ratio(&self) -> f64 {
let total = self.buffer_pool_hits + self.buffer_pool_misses;
if total > 0 {
self.buffer_pool_hits as f64 / total as f64
} else {
0.0
}
}
pub fn fast_path_ratio(&self) -> f64 {
let total = self.fast_path_time + self.standard_path_time;
if total.as_nanos() > 0 {
self.fast_path_time.as_nanos() as f64 / total.as_nanos() as f64
} else {
0.0
}
}
}
#[cfg(feature = "string-interner")]
pub struct StringInterningProcessor {
interner: Arc<RwLock<StringInterner<string_interner_crate::backend::BucketBackend<usize>>>>,
stats: Arc<Mutex<PerformanceStats>>,
}
#[cfg(feature = "string-interner")]
impl StringInterningProcessor {
pub fn new(capacity: usize) -> Result<Self> {
Ok(Self {
interner: Arc::new(RwLock::new(StringInterner::with_capacity(capacity))),
stats: Arc::new(Mutex::new(PerformanceStats::default())),
})
}
pub fn intern_string(&self, value: &str) -> Result<String> {
if let Ok(interner) = self.interner.read() {
if let Some(sym) = interner.get(value) {
if let Ok(mut stats) = self.stats.lock() {
stats.string_interner_hits += 1;
}
let resolved = interner
.resolve(sym)
.ok_or_else(|| {
StructuredLoggingError::string_interning(
"Failed to resolve interned symbol",
)
})?
.to_string();
return Ok(resolved);
}
}
if let Ok(mut interner) = self.interner.write() {
if let Some(sym) = interner.get(value) {
if let Ok(mut stats) = self.stats.lock() {
stats.string_interner_hits += 1;
}
let resolved = interner
.resolve(sym)
.ok_or_else(|| {
StructuredLoggingError::string_interning(
"Failed to resolve interned symbol",
)
})?
.to_string();
return Ok(resolved);
}
let sym = interner.get_or_intern(value);
if let Ok(mut stats) = self.stats.lock() {
stats.string_interner_misses += 1;
}
let resolved = interner
.resolve(sym)
.ok_or_else(|| {
StructuredLoggingError::string_interning("Failed to resolve interned symbol")
})?
.to_string();
Ok(resolved)
} else {
Err(StructuredLoggingError::string_interning(
"Failed to acquire write lock on string interner",
))
}
}
pub fn process_entry(&self, mut entry: LogEntry) -> Result<LogEntry> {
entry = self.intern_entry_fields(entry)?;
Ok(entry)
}
fn intern_entry_fields(&self, mut entry: LogEntry) -> Result<LogEntry> {
if let serde_json::Value::Object(ref mut fields_map) = entry.fields {
if let Some(Value::String(model)) = fields_map.get("model") {
let interned = self.intern_string(model)?;
fields_map.insert("model".to_string(), Value::String(interned));
}
if let Some(Value::String(status)) = fields_map.get("status") {
let interned = self.intern_string(status)?;
fields_map.insert("status".to_string(), Value::String(interned));
}
if let Some(Value::String(operation)) = fields_map.get("operation") {
let interned = self.intern_string(operation)?;
fields_map.insert("operation".to_string(), Value::String(interned));
}
if let Some(Value::String(component)) = fields_map.get("component") {
let interned = self.intern_string(component)?;
fields_map.insert("component".to_string(), Value::String(interned));
}
}
Ok(entry)
}
}
pub struct BufferPool {
buffers: Arc<Mutex<Vec<Vec<u8>>>>,
capacity: usize,
buffer_size: usize,
stats: Arc<Mutex<PerformanceStats>>,
}
impl BufferPool {
pub fn new(pool_size: usize, buffer_capacity: usize) -> Self {
let mut buffers = Vec::with_capacity(pool_size);
for _ in 0..pool_size {
buffers.push(Vec::with_capacity(buffer_capacity));
}
Self {
buffers: Arc::new(Mutex::new(buffers)),
capacity: pool_size,
buffer_size: buffer_capacity,
stats: Arc::new(Mutex::new(PerformanceStats::default())),
}
}
pub fn get_buffer(&self) -> Result<Vec<u8>> {
if let Ok(mut buffers) = self.buffers.lock() {
if let Some(mut buffer) = buffers.pop() {
buffer.clear();
if let Ok(mut stats) = self.stats.lock() {
stats.buffer_pool_hits += 1;
}
Ok(buffer)
} else {
if let Ok(mut stats) = self.stats.lock() {
stats.buffer_pool_misses += 1;
}
Ok(Vec::with_capacity(self.buffer_size))
}
} else {
Err(StructuredLoggingError::buffer_pool(
"Failed to acquire buffer pool lock",
))
}
}
pub fn return_buffer(&self, buffer: Vec<u8>) -> Result<()> {
if let Ok(mut buffers) = self.buffers.lock() {
if buffers.len() < self.capacity {
buffers.push(buffer);
}
}
Ok(())
}
}
pub struct FastPathLogger {
buffer_pool: BufferPool,
#[cfg(feature = "string-interner")]
string_interner: Option<StringInterningProcessor>,
stats: Arc<Mutex<PerformanceStats>>,
}
impl FastPathLogger {
pub fn new(config: &PerformanceConfig) -> Result<Self> {
let buffer_pool = BufferPool::new(config.buffer_pool_size, config.buffer_capacity);
#[cfg(feature = "string-interner")]
let string_interner = if config.enable_string_interning {
Some(StringInterningProcessor::new(
config.string_interner_capacity,
)?)
} else {
None
};
Ok(Self {
buffer_pool,
#[cfg(feature = "string-interner")]
string_interner,
stats: Arc::new(Mutex::new(PerformanceStats::default())),
})
}
pub fn log_llm_request_fast(
&self,
model: &str,
duration_ms: u64,
tokens: u32,
status: &str,
) -> Result<Vec<u8>> {
let start = Instant::now();
let mut buffer = self.buffer_pool.get_buffer()?;
buffer.extend_from_slice(b"{\"timestamp\":\"");
self.append_timestamp(&mut buffer);
buffer.extend_from_slice(b"\",\"level\":\"INFO\",\"message\":\"LLM request completed\",\"component\":\"openai_client_wasm\",\"model\":\"");
buffer.extend_from_slice(model.as_bytes());
buffer.extend_from_slice(b"\",\"duration_ms\":");
buffer.extend_from_slice(duration_ms.to_string().as_bytes());
buffer.extend_from_slice(b",\"tokens\":");
buffer.extend_from_slice(tokens.to_string().as_bytes());
buffer.extend_from_slice(b",\"status\":\"");
buffer.extend_from_slice(status.as_bytes());
buffer.extend_from_slice(b"\",\"operation\":\"llm_request\"}");
let elapsed = start.elapsed();
if let Ok(mut stats) = self.stats.lock() {
stats.entries_processed += 1;
stats.fast_path_time += elapsed;
stats.bytes_written += buffer.len() as u64;
}
let result = buffer.clone();
self.buffer_pool.return_buffer(buffer)?;
Ok(result)
}
pub fn log_a2a_message_fast(
&self,
message_type: &str,
from_agent: &str,
to_agent: &str,
duration_ms: Option<u64>,
) -> Result<Vec<u8>> {
let start = Instant::now();
let mut buffer = self.buffer_pool.get_buffer()?;
buffer.extend_from_slice(b"{\"timestamp\":\"");
self.append_timestamp(&mut buffer);
buffer.extend_from_slice(b"\",\"level\":\"INFO\",\"message\":\"A2A message processed\",\"component\":\"a2a_jsonrpc_server\",\"message_type\":\"");
buffer.extend_from_slice(message_type.as_bytes());
buffer.extend_from_slice(b"\",\"from_agent\":\"");
buffer.extend_from_slice(from_agent.as_bytes());
buffer.extend_from_slice(b"\",\"to_agent\":\"");
buffer.extend_from_slice(to_agent.as_bytes());
buffer.extend_from_slice(b"\",\"protocol\":\"json-rpc-2.0\"");
if let Some(duration) = duration_ms {
buffer.extend_from_slice(b",\"duration_ms\":");
buffer.extend_from_slice(duration.to_string().as_bytes());
}
buffer.extend_from_slice(b",\"operation\":\"a2a_message\"}");
let elapsed = start.elapsed();
if let Ok(mut stats) = self.stats.lock() {
stats.entries_processed += 1;
stats.fast_path_time += elapsed;
stats.bytes_written += buffer.len() as u64;
}
let result = buffer.clone();
self.buffer_pool.return_buffer(buffer)?;
Ok(result)
}
fn append_timestamp(&self, buffer: &mut Vec<u8>) {
let timestamp = web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
buffer.extend_from_slice(timestamp.to_string().as_bytes());
}
}
pub struct OptimizedWasmStdoutAdapter {
fast_path_logger: FastPathLogger,
config: PerformanceConfig,
stats: Arc<Mutex<PerformanceStats>>,
}
impl OptimizedWasmStdoutAdapter {
pub fn new(config: PerformanceConfig) -> Result<Self> {
let fast_path_logger = FastPathLogger::new(&config)?;
Ok(Self {
fast_path_logger,
config,
stats: Arc::new(Mutex::new(PerformanceStats::default())),
})
}
pub fn write_entry_optimized(&self, entry: &LogEntry) -> Result<()> {
let start = Instant::now();
if self.config.enable_fast_paths {
if let serde_json::Value::Object(ref fields_map) = entry.fields {
if let Some(Value::String(operation)) = fields_map.get("operation") {
match operation.as_str() {
"llm_request" => {
if let Some(json_bytes) = self.try_llm_fast_path(entry)? {
return self.write_bytes(&json_bytes);
}
}
"a2a_message" => {
if let Some(json_bytes) = self.try_a2a_fast_path(entry)? {
return self.write_bytes(&json_bytes);
}
}
_ => {} }
}
}
}
let json_string = serde_json::to_string(entry).map_err(StructuredLoggingError::from)?;
let elapsed = start.elapsed();
if let Ok(mut stats) = self.stats.lock() {
stats.entries_processed += 1;
stats.standard_path_time += elapsed;
stats.bytes_written += json_string.len() as u64;
}
self.write_bytes(json_string.as_bytes())
}
fn try_llm_fast_path(&self, entry: &LogEntry) -> Result<Option<Vec<u8>>> {
let fields = if let serde_json::Value::Object(ref fields_map) = entry.fields {
fields_map
} else {
return Err(StructuredLoggingError::fast_path(
"LLM entry missing fields",
));
};
let model = fields
.get("model")
.and_then(|v| v.as_str())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing model field"))?;
let duration_ms = fields
.get("duration_ms")
.and_then(|v| v.as_u64())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing duration_ms field"))?;
let tokens = fields
.get("tokens")
.and_then(|v| v.as_u64())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing tokens field"))?;
let status = fields
.get("status")
.and_then(|v| v.as_str())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing status field"))?;
let json_bytes = self.fast_path_logger.log_llm_request_fast(
model,
duration_ms,
tokens as u32,
status,
)?;
Ok(Some(json_bytes))
}
fn try_a2a_fast_path(&self, entry: &LogEntry) -> Result<Option<Vec<u8>>> {
let fields = if let serde_json::Value::Object(ref fields_map) = entry.fields {
fields_map
} else {
return Err(StructuredLoggingError::fast_path(
"A2A entry missing fields",
));
};
let message_type = fields
.get("message_type")
.and_then(|v| v.as_str())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing message_type field"))?;
let from_agent = fields
.get("from_agent")
.and_then(|v| v.as_str())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing from_agent field"))?;
let to_agent = fields
.get("to_agent")
.and_then(|v| v.as_str())
.ok_or_else(|| StructuredLoggingError::fast_path("Missing to_agent field"))?;
let duration_ms = fields.get("duration_ms").and_then(|v| v.as_u64());
let json_bytes = self.fast_path_logger.log_a2a_message_fast(
message_type,
from_agent,
to_agent,
duration_ms,
)?;
Ok(Some(json_bytes))
}
fn write_bytes(&self, bytes: &[u8]) -> Result<()> {
io::stdout().write_all(bytes)?;
io::stdout().write_all(b"\n")?;
io::stdout().flush()?;
Ok(())
}
pub fn get_stats(&self) -> Result<PerformanceStats> {
if let Ok(stats) = self.stats.lock() {
Ok(stats.clone())
} else {
Err(StructuredLoggingError::performance(
"Failed to acquire stats lock",
))
}
}
}
impl TransportPort for OptimizedWasmStdoutAdapter {
fn transport(&self, entry: &LogEntry) -> observability_core::ObservabilityResult<()> {
self.write_entry_optimized(entry)
.map_err(|e| observability_core::ObservabilityError::transport(e.to_string()))
}
}
pub struct PerformanceManager {
#[cfg(feature = "string-interner")]
string_interner: Option<StringInterningProcessor>,
optimized_adapter: OptimizedWasmStdoutAdapter,
config: PerformanceConfig,
}
impl PerformanceManager {
pub fn new(config: &PerformanceConfig) -> Result<Self> {
#[cfg(feature = "string-interner")]
let string_interner = if config.enable_string_interning {
Some(StringInterningProcessor::new(
config.string_interner_capacity,
)?)
} else {
None
};
let optimized_adapter = OptimizedWasmStdoutAdapter::new(config.clone())?;
Ok(Self {
#[cfg(feature = "string-interner")]
string_interner,
optimized_adapter,
config: config.clone(),
})
}
pub fn process_entry(&self, mut entry: LogEntry) -> Result<LogEntry> {
#[cfg(feature = "string-interner")]
if let Some(ref interner) = self.string_interner {
entry = interner.process_entry(entry)?;
}
Ok(entry)
}
pub fn get_stats(&self) -> PerformanceStats {
let mut combined_stats = PerformanceStats::default();
if let Ok(adapter_stats) = self.optimized_adapter.get_stats() {
combined_stats.entries_processed += adapter_stats.entries_processed;
combined_stats.fast_path_time += adapter_stats.fast_path_time;
combined_stats.standard_path_time += adapter_stats.standard_path_time;
combined_stats.bytes_written += adapter_stats.bytes_written;
}
#[cfg(feature = "string-interner")]
if let Some(ref interner) = self.string_interner {
if let Ok(interner_stats) = interner.stats.lock() {
combined_stats.string_interner_hits += interner_stats.string_interner_hits;
combined_stats.string_interner_misses += interner_stats.string_interner_misses;
}
}
combined_stats
}
pub fn reset_stats(&self) -> Result<()> {
if let Ok(mut stats) = self.optimized_adapter.stats.lock() {
*stats = PerformanceStats::default();
}
#[cfg(feature = "string-interner")]
if let Some(ref interner) = self.string_interner {
if let Ok(mut stats) = interner.stats.lock() {
*stats = PerformanceStats::default();
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_performance_stats_calculations() {
let mut stats = PerformanceStats::default();
stats.string_interner_hits = 80;
stats.string_interner_misses = 20;
stats.buffer_pool_hits = 90;
stats.buffer_pool_misses = 10;
assert_eq!(stats.string_interner_hit_ratio(), 0.8);
assert_eq!(stats.buffer_pool_hit_ratio(), 0.9);
}
#[test]
fn test_buffer_pool() {
let pool = BufferPool::new(2, 1024);
let buffer1 = pool.get_buffer().unwrap();
let buffer2 = pool.get_buffer().unwrap();
assert_eq!(buffer1.capacity(), 1024);
assert_eq!(buffer2.capacity(), 1024);
pool.return_buffer(buffer1).unwrap();
pool.return_buffer(buffer2).unwrap();
}
#[cfg(feature = "string-interner")]
#[test]
fn test_string_interning() {
let processor = StringInterningProcessor::new(100).unwrap();
let result1 = processor.intern_string("test-value").unwrap();
let result2 = processor.intern_string("test-value").unwrap();
assert_eq!(result1, result2);
assert_eq!(result1, "test-value");
}
#[test]
fn test_fast_path_logger() {
let config = PerformanceConfig::default();
let logger = FastPathLogger::new(&config).unwrap();
let result = logger.log_llm_request_fast("gpt-4", 250, 1500, "success");
assert!(result.is_ok());
let json_bytes = result.unwrap();
let json_str = String::from_utf8(json_bytes).unwrap();
assert!(json_str.contains("gpt-4"));
assert!(json_str.contains("250"));
assert!(json_str.contains("1500"));
assert!(json_str.contains("success"));
}
#[test]
fn test_optimized_adapter_creation() {
let config = PerformanceConfig::default();
let adapter = OptimizedWasmStdoutAdapter::new(config);
assert!(adapter.is_ok());
}
#[test]
fn test_performance_manager_creation() {
let config = PerformanceConfig::default();
let manager = PerformanceManager::new(&config);
assert!(manager.is_ok());
}
#[test]
fn test_stats_zero_denominators() {
let stats = PerformanceStats::default();
assert_eq!(stats.string_interner_hit_ratio(), 0.0);
assert_eq!(stats.buffer_pool_hit_ratio(), 0.0);
assert_eq!(stats.fast_path_ratio(), 0.0);
}
#[test]
fn test_buffer_pool_exhaustion_creates_new() {
let pool = BufferPool::new(1, 512);
let b1 = pool.get_buffer().unwrap();
let b2 = pool.get_buffer().unwrap();
assert_eq!(b1.capacity(), 512);
assert_eq!(b2.capacity(), 512);
pool.return_buffer(b1).unwrap();
pool.return_buffer(b2).unwrap();
let b3 = pool.get_buffer().unwrap();
assert_eq!(b3.len(), 0);
}
#[test]
fn test_fast_path_a2a_message() {
let config = PerformanceConfig::default();
let logger = FastPathLogger::new(&config).unwrap();
let result = logger.log_a2a_message_fast("message/send", "agent-a", "agent-b", Some(100));
assert!(result.is_ok());
let json_str = String::from_utf8(result.unwrap()).unwrap();
assert!(json_str.contains("message/send"));
assert!(json_str.contains("agent-a"));
assert!(json_str.contains("agent-b"));
assert!(json_str.contains("100"));
}
#[test]
fn test_fast_path_a2a_no_duration() {
let config = PerformanceConfig::default();
let logger = FastPathLogger::new(&config).unwrap();
let result = logger.log_a2a_message_fast("message/send", "a", "b", None);
assert!(result.is_ok());
let json_str = String::from_utf8(result.unwrap()).unwrap();
assert!(!json_str.contains("duration_ms"));
}
#[cfg(feature = "string-interner")]
#[test]
fn test_string_interning_hit_miss_stats() {
let processor = StringInterningProcessor::new(100).unwrap();
processor.intern_string("alpha").unwrap();
processor.intern_string("alpha").unwrap();
processor.intern_string("beta").unwrap();
let stats = processor.stats.lock().unwrap();
assert_eq!(stats.string_interner_misses, 2);
assert_eq!(stats.string_interner_hits, 1);
}
#[cfg(feature = "string-interner")]
#[test]
fn test_string_interning_process_entry() {
let processor = StringInterningProcessor::new(100).unwrap();
let entry = observability_core::domain::create_log_entry(
observability_core::traits::LogLevel::Info,
"test",
serde_json::json!({
"model": "gpt-4",
"status": "ok",
"operation": "llm_request",
"component": "sdk"
}),
);
let processed = processor.process_entry(entry).unwrap();
let fields = processed.fields.as_object().unwrap();
assert_eq!(fields["model"], "gpt-4");
assert_eq!(fields["status"], "ok");
assert_eq!(fields["operation"], "llm_request");
assert_eq!(fields["component"], "sdk");
}
#[cfg(feature = "string-interner")]
#[test]
fn test_performance_manager_stats_aggregation() {
let config = PerformanceConfig::default();
let manager = PerformanceManager::new(&config).unwrap();
let entry = observability_core::domain::create_log_entry(
observability_core::traits::LogLevel::Info,
"test",
serde_json::json!({"model": "gpt-4", "status": "ok"}),
);
let _ = manager.process_entry(entry).unwrap();
let stats = manager.get_stats();
assert!(stats.string_interner_misses > 0);
manager.reset_stats().unwrap();
let stats = manager.get_stats();
assert_eq!(stats.string_interner_misses, 0);
assert_eq!(stats.string_interner_hits, 0);
}
}