codewhale_runtime/
logging.rs1use std::sync::atomic::{AtomicBool, Ordering};
4
5use colored::Colorize;
6
7use codewhale_palette as palette;
8static VERBOSE: AtomicBool = AtomicBool::new(false);
9#[cfg(windows)]
10static VERBOSE_SNAPSHOT: AtomicBool = AtomicBool::new(false);
11
12pub struct PhaseTimer {
13 phase: &'static str,
14 started: std::time::Instant,
15}
16
17impl PhaseTimer {
18 pub fn start(phase: &'static str) -> Option<Self> {
19 static ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
20 ENABLED
21 .get_or_init(|| std::env::var("CODEWHALE_TIMING").is_ok_and(|value| value == "1"))
22 .then(|| Self {
23 phase,
24 started: std::time::Instant::now(),
25 })
26 }
27}
28
29impl Drop for PhaseTimer {
30 fn drop(&mut self) {
31 use std::io::Write;
32 let receipt = serde_json::json!({
33 "type": "execution_timing",
34 "phase": self.phase,
35 "pid": std::process::id(),
36 "elapsed_us": self.started.elapsed().as_micros(),
37 "ended_unix_us": std::time::SystemTime::now()
38 .duration_since(std::time::UNIX_EPOCH)
39 .ok()
40 .map(|elapsed| elapsed.as_micros()),
41 });
42 let _ = writeln!(std::io::stderr().lock(), "{receipt}");
43 }
44}
45
46pub fn set_verbose(enabled: bool) {
48 VERBOSE.store(enabled, Ordering::SeqCst);
49}
50
51#[cfg(windows)]
54pub fn snapshot_verbose_state() {
55 VERBOSE_SNAPSHOT.store(is_verbose(), Ordering::SeqCst);
56}
57
58#[cfg(windows)]
60pub fn restore_verbose_state() {
61 set_verbose(VERBOSE_SNAPSHOT.load(Ordering::SeqCst));
62}
63
64#[must_use]
73pub fn env_requests_verbose_logging() -> bool {
74 std::env::var("CODEWHALE_LOG_LEVEL")
75 .or_else(|_| std::env::var("DEEPSEEK_LOG_LEVEL"))
76 .ok()
77 .is_some_and(|value| log_value_enables_verbose(&value))
78}
79
80fn log_value_enables_verbose(value: &str) -> bool {
81 value.split(',').any(|directive| {
82 let level = directive
83 .rsplit('=')
84 .next()
85 .unwrap_or(directive)
86 .trim()
87 .to_ascii_lowercase();
88 matches!(level.as_str(), "trace" | "debug" | "info")
89 })
90}
91
92#[must_use]
94pub fn is_verbose() -> bool {
95 VERBOSE.load(Ordering::SeqCst)
96}
97
98pub fn info(message: impl AsRef<str>) {
100 if is_verbose() {
101 let (r, g, b) = palette::WHALE_ACTION_RGB;
102 eprintln!("{} {}", "info".truecolor(r, g, b).bold(), message.as_ref());
103 }
104}
105
106pub fn warn(message: impl AsRef<str>) {
108 if is_verbose() {
109 let (r, g, b) = palette::WHALE_ACTION_RGB;
110 eprintln!("{} {}", "warn".truecolor(r, g, b).bold(), message.as_ref());
111 }
112}
113
114#[cfg(test)]
115#[cfg(windows)]
116mod tests {
117 use super::*;
118 use std::sync::Mutex;
119
120 static TEST_GUARD: Mutex<()> = Mutex::new(());
121
122 #[test]
123 fn log_value_parser_accepts_common_rust_log_directives() {
124 assert!(log_value_enables_verbose("debug"));
125 assert!(log_value_enables_verbose("codewhale_cli=debug"));
126 assert!(log_value_enables_verbose(
127 "warn,codewhale_runtime::client=trace"
128 ));
129 assert!(!log_value_enables_verbose("warn"));
130 assert!(!log_value_enables_verbose("codewhale_runtime=off"));
131 }
132
133 #[test]
134 fn snapshot_and_restore_verbose_state_round_trip() {
135 let _guard = TEST_GUARD.lock().unwrap_or_else(|err| err.into_inner());
136
137 set_verbose(false);
138 snapshot_verbose_state();
139 set_verbose(true);
140 restore_verbose_state();
141 assert!(!is_verbose());
142
143 set_verbose(true);
144 snapshot_verbose_state();
145 set_verbose(false);
146 restore_verbose_state();
147 assert!(is_verbose());
148
149 set_verbose(false);
150 }
151
152 #[test]
153 fn restore_keeps_cli_verbose_state_even_when_env_is_not_verbose() {
154 let _guard = TEST_GUARD.lock().unwrap_or_else(|err| err.into_inner());
155
156 set_verbose(true);
157 snapshot_verbose_state();
158
159 set_verbose(false);
163 restore_verbose_state();
164
165 assert!(is_verbose());
166 set_verbose(false);
167 }
168}