Method spawn

src/telemetry.rs:32–98

Spawn the background thread and return a handle to send it work.

()

impl TelemetryWorker {
    /// Spawn the background thread and return a handle to send it work.
    fn spawn() -> Self {
        let (sender, receiver) = channel::<WorkerMessage>();
        std::thread::spawn(move || {
            let mut current_path: Option<PathBuf> = None;
            let mut current_file: Option<File> = None;
            let mut consecutive_errors: u32 = 0;
            const MAX_CONSECUTIVE_ERRORS: u32 = 10;

            while let Ok(msg) = receiver.recv() {
                match msg {
                    WorkerMessage::Log(entry) => {
                        // If we've had too many consecutive errors, skip this entry
                        // to avoid spamming the filesystem with failing operations.
                        if consecutive_errors >= MAX_CONSECUTIVE_ERRORS {
                            continue;
                        }

                        let path_display = entry.path.display().to_string();

                        // Open (or re-open) the file if the path has changed.
                        if current_path.as_deref() != Some(entry.path.as_path()) {
                            match open_log_file(&entry.path) {
                                Ok(new_file) => {
                                    current_path = Some(entry.path);
                                    current_file = Some(new_file);
                                    consecutive_errors = 0;
                                }
                                Err(e) => {
                                    consecutive_errors += 1;
                                    current_path = None;
                                    current_file = None;
                                    // Log to stderr as a fallback so the error is visible.
                                    eprintln!(
                                        "telemetry: failed to open {}: {} (consecutive errors: {})",
                                        path_display, e, consecutive_errors
                                    );
                                }
                            }
                        }

                        // Write the entry, with flush to ensure durability.
                        if let Some(file) = current_file.as_mut() {
                            if let Err(e) = write_entry(file, &entry.line) {
                                consecutive_errors += 1;
                                eprintln!(
                                    "telemetry: failed to write to {}: {} (consecutive errors: {})",
                                    path_display, e, consecutive_errors
                                );
                                // Drop the file handle so we re-open on next entry.
                                current_file = None;
                                current_path = None;
                            } else {
                                consecutive_errors = 0;
                            }
                        }
                    }
                    WorkerMessage::Shutdown => break,
                }