17501935621

Committed 05 Sep 2025 06:52PM UTC coverage: 31.645% (-0.3%) from 31.982%

Build # 17501935621

Build Type

push

github

Committed by

Xevion

Commit Message

feat: special formatting with game tick counter, remove date from tracing formatter

Run Details

0 of 36 new or added lines in 3 files covered. (0.0%)

1081 of 3416 relevant lines covered (31.65%)

796.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/platform/tracing_buffer.rs

#![allow(dead_code)]

//! Buffered tracing setup for handling logs before console attachment.

use crate::formatter::CustomFormatter;
use crate::platform::buffered_writer::BufferedWriter;
use std::io;
use tracing::{debug, Level};
use tracing_error::ErrorLayer;
use tracing_subscriber::fmt::MakeWriter;
use tracing_subscriber::layer::SubscriberExt;

/// A writer that can switch between buffering and direct output.
#[derive(Clone, Default)]
pub struct SwitchableWriter {
    buffered_writer: BufferedWriter,
    direct_mode: std::sync::Arc<parking_lot::Mutex<bool>>,
}

impl SwitchableWriter {
    pub fn switch_to_direct_mode(&self) -> io::Result<()> {
        let buffer_size = {
            // Acquire the lock
            let mut mode = self.direct_mode.lock();

            // Get buffer size before flushing for debug logging
            let buffer_size = self.buffered_writer.buffer_size();

            // Flush any buffered content
            self.buffered_writer.flush_to(io::stdout())?;

            // Switch to direct mode (and drop the lock)
            *mode = true;

            buffer_size
        };

        // Log how much was buffered (this will now go directly to stdout)
        debug!("Flushed {buffer_size:?} bytes of buffered logs to console");

        Ok(())
    }
}

impl io::Write for SwitchableWriter {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        if *self.direct_mode.lock() {
            io::stdout().write(buf)
        } else {
            self.buffered_writer.clone().write(buf)
        }
    }

    fn flush(&mut self) -> io::Result<()> {
        if *self.direct_mode.lock() {
            io::stdout().flush()
        } else {
            // For buffered mode, flush is a no-op
            Ok(())
        }
    }
}

/// A make writer that uses the switchable writer.
#[derive(Clone)]
pub struct SwitchableMakeWriter {
    writer: SwitchableWriter,
}

impl SwitchableMakeWriter {
    pub fn new(writer: SwitchableWriter) -> Self {
        Self { writer }
    }
}

impl<'a> MakeWriter<'a> for SwitchableMakeWriter {
    type Writer = SwitchableWriter;

    fn make_writer(&'a self) -> Self::Writer {
        self.writer.clone()
    }
}

/// Sets up a switchable tracing subscriber that can transition from buffered to direct output.
///
/// Returns the switchable writer that can be used to control the behavior.
pub fn setup_switchable_subscriber() -> SwitchableWriter {
    let switchable_writer = SwitchableWriter::default();
    let make_writer = SwitchableMakeWriter::new(switchable_writer.clone());

    let _subscriber = tracing_subscriber::fmt()
        .with_ansi(cfg!(not(target_os = "emscripten")))
        .with_max_level(Level::DEBUG)
        .event_format(CustomFormatter)
        .with_writer(make_writer)
        .finish()
        .with(ErrorLayer::default());

    tracing::subscriber::set_global_default(_subscriber).expect("Could not set global default switchable subscriber");

    switchable_writer
}

1	#![allow(dead_code)]
2
3	//! Buffered tracing setup for handling logs before console attachment.
4
5	use crate::formatter::CustomFormatter;
6	use crate::platform::buffered_writer::BufferedWriter;
7	use std::io;
8	use tracing::{debug, Level};
9	use tracing_error::ErrorLayer;
10	use tracing_subscriber::fmt::MakeWriter;
11	use tracing_subscriber::layer::SubscriberExt;
12
13	/// A writer that can switch between buffering and direct output.
14	#[derive(Clone, Default)]
15	pub struct SwitchableWriter {
16	buffered_writer: BufferedWriter,
17	direct_mode: std::sync::Arc<parking_lot::Mutex<bool>>,
18	}
19
20	impl SwitchableWriter {
21	pub fn switch_to_direct_mode(&self) -> io::Result<()> {	×
22	let buffer_size = {	×
23	// Acquire the lock
24	let mut mode = self.direct_mode.lock();	×
25		×
26	// Get buffer size before flushing for debug logging	×
27	let buffer_size = self.buffered_writer.buffer_size();	×
28		×
29	// Flush any buffered content	×
30	self.buffered_writer.flush_to(io::stdout())?;	×
31
32	// Switch to direct mode (and drop the lock)
33	*mode = true;	×
34		×
35	buffer_size	×
36	};	×
37		×
38	// Log how much was buffered (this will now go directly to stdout)	×
39	debug!("Flushed {buffer_size:?} bytes of buffered logs to console");	×
40
41	Ok(())	×
42	}	×
43	}
44
45	impl io::Write for SwitchableWriter {
46	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {	×
47	if *self.direct_mode.lock() {	×
48	io::stdout().write(buf)	×
49	} else {
50	self.buffered_writer.clone().write(buf)	×
51	}
52	}	×
53
54	fn flush(&mut self) -> io::Result<()> {	×
55	if *self.direct_mode.lock() {	×
56	io::stdout().flush()	×
57	} else {
58	// For buffered mode, flush is a no-op
59	Ok(())	×
60	}
61	}	×
62	}
63
64	/// A make writer that uses the switchable writer.
65	#[derive(Clone)]
66	pub struct SwitchableMakeWriter {
67	writer: SwitchableWriter,
68	}
69
70	impl SwitchableMakeWriter {
71	pub fn new(writer: SwitchableWriter) -> Self {	×
72	Self { writer }	×
73	}	×
74	}
75
76	impl<'a> MakeWriter<'a> for SwitchableMakeWriter {
77	type Writer = SwitchableWriter;
78
79	fn make_writer(&'a self) -> Self::Writer {	×
80	self.writer.clone()	×
81	}	×
82	}
83
84	/// Sets up a switchable tracing subscriber that can transition from buffered to direct output.
85	///
86	/// Returns the switchable writer that can be used to control the behavior.
87	pub fn setup_switchable_subscriber() -> SwitchableWriter {	×
88	let switchable_writer = SwitchableWriter::default();	×
89	let make_writer = SwitchableMakeWriter::new(switchable_writer.clone());	×
90		×
91	let _subscriber = tracing_subscriber::fmt()	×
92	.with_ansi(cfg!(not(target_os = "emscripten")))	×
93	.with_max_level(Level::DEBUG)	×
NEW 94	.event_format(CustomFormatter)	×
95	.with_writer(make_writer)	×
96	.finish()	×
97	.with(ErrorLayer::default());	×
98		×
99	tracing::subscriber::set_global_default(_subscriber).expect("Could not set global default switchable subscriber");	×
100		×
101	switchable_writer	×
102	}	×

Xevion / Pac-Man / 17501935621

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous