1use std::fmt;
23use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
24use std::time::{SystemTime, UNIX_EPOCH};
25
26pub use tracing::Level;
27
28pub const fn trace_level_of(level: Level) -> u32 {
31 match level {
32 Level::ERROR | Level::WARN => 1,
33 Level::INFO => 5,
34 Level::DEBUG => 10,
35 Level::TRACE => 25,
36 }
37}
38
39static LEVEL: AtomicU32 = AtomicU32::new(1);
40static TIME: AtomicBool = AtomicBool::new(false);
41
42pub fn set_trace_level(level: u32) {
48 LEVEL.store(level, Ordering::Relaxed);
49}
50
51pub fn trace_level() -> u32 {
53 LEVEL.load(Ordering::Relaxed)
54}
55
56pub fn set_trace_time(on: bool) {
59 TIME.store(on, Ordering::Relaxed);
60}
61
62pub fn selects(level: Level) -> bool {
64 trace_level() >= trace_level_of(level)
65}
66
67#[inline]
70pub(crate) fn to_stderr(level: Level) -> bool {
71 selects(level) && !tracing::dispatcher::has_been_set()
72}
73
74#[cold]
76pub(crate) fn write_stderr(level: Level, args: fmt::Arguments<'_>) {
77 eprintln!("{}", line(level, args, TIME.load(Ordering::Relaxed)));
78}
79
80pub fn stderr_line(level: Level, message: &str) -> String {
84 line(
85 level,
86 format_args!("{message}"),
87 TIME.load(Ordering::Relaxed),
88 )
89}
90
91fn line(level: Level, args: fmt::Arguments<'_>, time: bool) -> String {
94 let name = level_name(level);
95 if time {
96 format!("{} rustorb: {name}: {args}", utc_now())
97 } else {
98 format!("rustorb: {name}: {args}")
99 }
100}
101
102pub fn level_name(level: Level) -> &'static str {
104 match level {
105 Level::ERROR => "error",
106 Level::WARN => "warning",
107 Level::INFO => "info",
108 Level::DEBUG => "debug",
109 Level::TRACE => "trace",
110 }
111}
112
113fn utc_now() -> String {
115 let now = SystemTime::now()
116 .duration_since(UNIX_EPOCH)
117 .unwrap_or_default();
118 format_utc(now.as_secs(), now.subsec_micros())
119}
120
121fn format_utc(secs: u64, micros: u32) -> String {
122 let days = (secs / 86_400) as i64;
123 let rem = secs % 86_400;
124 let (y, m, d) = civil_from_days(days);
125 format!(
126 "{y:04}-{m:02}-{d:02} {:02}:{:02}:{:02}.{micros:06}",
127 rem / 3600,
128 rem / 60 % 60,
129 rem % 60
130 )
131}
132
133fn civil_from_days(z: i64) -> (i64, u32, u32) {
135 let z = z + 719_468;
136 let era = z.div_euclid(146_097);
137 let doe = z.rem_euclid(146_097);
138 let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
139 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
140 let mp = (5 * doy + 2) / 153;
141 let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
142 let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
143 let y = yoe + era * 400 + i64::from(m <= 2);
144 (y, m, d)
145}
146
147macro_rules! event {
151 ($level:ident, $($arg:tt)+) => {
152 if $crate::trace::to_stderr(::tracing::Level::$level) {
153 $crate::trace::write_stderr(::tracing::Level::$level, format_args!($($arg)+));
154 } else {
155 ::tracing::event!(::tracing::Level::$level, $($arg)+);
156 }
157 };
158}
159
160macro_rules! warning {
161 ($($arg:tt)+) => { $crate::trace::event!(WARN, $($arg)+) };
162}
163
164macro_rules! info {
165 ($($arg:tt)+) => { $crate::trace::event!(INFO, $($arg)+) };
166}
167
168macro_rules! debug {
169 ($($arg:tt)+) => { $crate::trace::event!(DEBUG, $($arg)+) };
170}
171
172macro_rules! trace {
173 ($($arg:tt)+) => { $crate::trace::event!(TRACE, $($arg)+) };
174}
175
176pub(crate) use {debug, event, info, trace, warning};
177
178pub(crate) fn message_type_name(octet: u8) -> &'static str {
181 match octet {
182 0 => "Request",
183 1 => "Reply",
184 2 => "CancelRequest",
185 3 => "LocateRequest",
186 4 => "LocateReply",
187 5 => "CloseConnection",
188 6 => "MessageError",
189 7 => "Fragment",
190 _ => "unknown",
191 }
192}
193
194pub(crate) struct MessageSummary<'a>(pub(crate) &'a [u8], pub(crate) usize);
197
198impl fmt::Display for MessageSummary<'_> {
199 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
200 let MessageSummary(head, len) = *self;
201 match head {
202 [b'G', b'I', b'O', b'P', major, minor, _, kind, ..] => write!(
203 f,
204 "{} (GIOP {major}.{minor}, {len} bytes)",
205 message_type_name(*kind)
206 ),
207 _ => write!(f, "a message of {len} bytes"),
208 }
209 }
210}
211
212pub(crate) struct IorSummary<'a>(pub(crate) &'a rustorb_giop::Ior);
215
216impl fmt::Display for IorSummary<'_> {
217 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
218 let ior = self.0;
219 if ior.is_nil() {
220 return f.write_str("a nil reference");
221 }
222 let id = if ior.type_id.is_empty() {
223 "an object"
224 } else {
225 &ior.type_id
226 };
227 let first = ior
228 .profiles
229 .iter()
230 .filter(|p| p.tag == rustorb_giop::TAG_INTERNET_IOP)
231 .find_map(|p| p.iiop().ok());
232 match first {
233 Some(iiop) => write!(f, "{id} at {}:{}", iiop.host, iiop.port),
234 None => write!(f, "{id} (no IIOP profile)"),
235 }
236 }
237}
238
239pub(crate) struct IdSummary<'a>(pub(crate) &'a [u8]);
242
243impl fmt::Display for IdSummary<'_> {
244 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
245 let id = self.0;
246 if !id.is_empty() && id.iter().all(|b| b.is_ascii_graphic() || *b == b' ') {
247 write!(f, "{:?}", String::from_utf8_lossy(id))
248 } else {
249 f.write_str("0x")?;
250 id.iter().try_for_each(|b| write!(f, "{b:02x}"))
251 }
252 }
253}
254
255#[cfg(test)]
256mod tests {
257 use super::*;
258
259 #[test]
260 fn utc_dates() {
261 assert_eq!(format_utc(0, 0), "1970-01-01 00:00:00.000000");
262 assert_eq!(format_utc(951_782_400, 5), "2000-02-29 00:00:00.000005");
263 assert_eq!(
264 format_utc(1_793_569_356, 123_456),
265 "2026-11-01 21:42:36.123456"
266 );
267 }
268
269 #[test]
270 fn lines() {
271 assert_eq!(
272 line(Level::WARN, format_args!("x {}", 1), false),
273 "rustorb: warning: x 1"
274 );
275 assert!(line(Level::INFO, format_args!("y"), true).ends_with(" rustorb: info: y"));
276 }
277
278 #[test]
279 fn levels() {
280 assert_eq!(trace_level_of(Level::WARN), 1);
281 assert_eq!(trace_level_of(Level::TRACE), 25);
282 let msg = b"GIOP\x01\x02\x01\x00\x00\x00\x00\x00";
283 assert_eq!(IdSummary(b"Echo").to_string(), "\"Echo\"");
284 assert_eq!(IdSummary(&[0, 0xab]).to_string(), "0x00ab");
285 assert_eq!(
286 MessageSummary(msg, 12).to_string(),
287 "Request (GIOP 1.2, 12 bytes)"
288 );
289 }
290}