17471041457

Committed 04 Sep 2025 04:53PM UTC coverage: 32.327% (-1.7%) from 33.977%

Build # 17471041457

Build Type

push

github

Committed by

Xevion

Commit Message

refactor(test): remove dead code and consolidate test utilities

Run Details

1081 of 3344 relevant lines covered (32.33%)

813.28 hits per line

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

0.0

/src/platform/tracing_buffer.rs

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

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

Xevion / Pac-Man / 17471041457

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