1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
//! Kernel logging subsystem.
//!
//! Linux equivalent: `kernel/printk/`
//!
//! This module provides the kernel's logging mechanism following Linux's printk design.
//! The kernel defines the logging interface (`Logger` trait), while drivers implement
//! the actual output policy (where logs go, formatting, buffering, etc.).
//!
//! # Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────────┐
//! │ User Code │
//! │ │
//! │ pr_err!("failed: {}", err); │
//! │ pr_info!("buffer {} opened", id); │
//! │ │
//! └─────────────────────────────────────────────────────────────────┘
//! │
//! ▼
//! ┌─────────────────────────────────────────────────────────────────┐
//! │ Kernel (printk/) │
//! │ │
//! │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
//! │ │ Level │ │ Record │ │ Logger │ │
//! │ │ (severity) │ │ (message + │ │ (trait) │ │
//! │ │ │ │ metadata) │ │ │ │
//! │ └──────────────┘ └──────────────┘ └──────────────┘ │
//! │ │ │
//! │ ┌──────────────────┘ │
//! │ │ │
//! │ ┌──────────┴──────────┐ │
//! │ │ Global Logger │ │
//! │ │ (OnceLock) │ │
//! │ └──────────┬──────────┘ │
//! │ │ │
//! └──────────────────────────────┼───────────────────────────────────┘
//! │
//! ┌─────────────────┴─────────────────┐
//! │ │
//! ▼ ▼
//! ┌────────────────────────┐ ┌────────────────────────┐
//! │ NopLogger (default) │ │ Driver Logger │
//! │ - No output │ │ (e.g., TracingLogger)│
//! │ - Zero overhead │ │ - Actual output │
//! └────────────────────────┘ └────────────────────────┘
//! ```
//!
//! # Design Philosophy
//!
//! Following Linux kernel "mechanism, not policy":
//!
//! - **Kernel provides mechanism**: `Logger` trait, `Level` enum, `Record` struct
//! - **Drivers provide policy**: Where logs go, formatting, filtering, buffering
//! - **Zero external dependencies**: Pure Rust, std only
//! - **Performance first**: Level check before formatting to avoid allocations
//!
//! # Usage
//!
//! ## Basic Logging
//!
//! ```
//! use reovim_kernel::{pr_err, pr_warn, pr_info, pr_debug, pr_trace};
//!
//! // Log at different levels
//! pr_err!("critical error: buffer not found");
//! pr_warn!("deprecated API used");
//! pr_info!("editor started with {} buffers", 3);
//! pr_debug!("cursor at position {:?}", (10, 5));
//! pr_trace!("entering function");
//! ```
//!
//! ## Setting a Logger (Driver Layer)
//!
//! ```
//! use reovim_kernel::api::v1::*;
//!
//! struct StderrLogger;
//!
//! impl Logger for StderrLogger {
//! fn log(&self, record: &Record) {
//! eprintln!("[{}] {}:{} - {}",
//! record.level(),
//! record.file(),
//! record.line(),
//! record.message());
//! }
//!
//! fn flush(&self) {}
//!
//! fn enabled(&self, level: Level) -> bool {
//! level <= Level::Info // Log Error, Warn, Info
//! }
//! }
//!
//! // Set once at startup (typically in server/lib/server/)
//! // static LOGGER: StderrLogger = StderrLogger;
//! // set_logger(&LOGGER).expect("logger already set");
//! ```
//!
//! # Performance
//!
//! The logging macros are designed for minimal overhead when logging is disabled:
//!
//! ```text
//! pr_info!("message: {}", expensive_computation());
//! │
//! ▼
//! if logger().enabled(Level::Info) { ◄── Fast check (no allocation)
//! // Only format if enabled
//! __log(..., format_args!(...)); ◄── Allocation happens here
//! }
//! ```
//!
//! When the level is disabled, `enabled()` returns `false` and the format
//! string is never evaluated, avoiding the cost of string formatting.
//!
//! # Thread Safety
//!
//! All logging operations are thread-safe:
//!
//! - `set_logger()` uses `OnceLock` for safe one-time initialization
//! - `Logger` implementations must be `Send + Sync`
//! - Multiple threads can log concurrently without blocking
// Re-export level types
pub use ;
// Re-export record types
pub use ;
// Re-export logger types and functions
pub use ;