speechcore 0.1.1

Reusable Rust speech-to-text runtime with audio capture, VAD, backend selection, model provisioning, and transcript streaming.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use parking_lot::Mutex;
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

use crate::transcription_stats::TranscriptionStats;

const STATS_INTERVAL_SECS: u64 = 10;

/// Handles reporting of transcription statistics
pub struct StatsReporter {
    transcription_stats: Arc<Mutex<TranscriptionStats>>,
    running: Arc<AtomicBool>,
    log_stats_enabled: bool,
}

impl StatsReporter {
    /// Creates a new StatsReporter
    pub fn new(
        transcription_stats: Arc<Mutex<TranscriptionStats>>,
        running: Arc<AtomicBool>,
        log_stats_enabled: bool,
    ) -> Self {
        Self {
            transcription_stats,
            running,
            log_stats_enabled,
        }
    }

    /// Start periodic reporting with specified interval
    pub fn start_periodic_reporting(&self) {
        // Exit early if stats logging is not enabled
        if !self.log_stats_enabled {
            tracing::info!("Stats reporting disabled - no statistics will be logged");
            return;
        }

        tracing::info!(
            "Stats reporting enabled - will report every {} seconds",
            STATS_INTERVAL_SECS
        );

        let transcription_stats = self.transcription_stats.clone();
        let running = self.running.clone();

        // Create stats file
        tracing::info!("Stats logging enabled - will write to console and transcription_stats.log");

        // Create or truncate the stats file
        if let Err(e) = File::create("transcription_stats.log") {
            tracing::warn!("Failed to create stats file: {}", e);
        }

        // Spawn an async task to periodically report transcription statistics
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(Duration::from_secs(STATS_INTERVAL_SECS));
            while running.load(Ordering::Relaxed) {
                interval.tick().await;
                if let Some(stats) = transcription_stats.try_lock() {
                    if stats.segments_processed > 0 {
                        let stats_report = stats.report();
                        tracing::info!("\n--- Periodic Transcription Statistics ---");
                        tracing::info!("{}", stats_report);
                        tracing::info!("------------------------------------------\n");
                        let timestamp =
                            chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
                        let file_content = format!("\n--- {} ---\n{}\n", timestamp, stats_report);
                        match std::fs::OpenOptions::new()
                            .append(true)
                            .create(true)
                            .open("transcription_stats.log")
                        {
                            Ok(mut file) => {
                                if let Err(e) = writeln!(file, "{}", file_content) {
                                    tracing::warn!("Failed to write to stats file: {}", e);
                                }
                            }
                            Err(e) => tracing::warn!("Failed to open stats file: {}", e),
                        }
                    }
                }
            }
            tracing::info!("Stats reporting stopped");
        });
    }

    /// Print current statistics on demand
    pub fn print_stats(&self) {
        // Exit early if stats logging is not enabled
        if !self.log_stats_enabled {
            tracing::info!("Stats reporting disabled - no statistics will be logged on demand");
            return;
        }

        if let Some(stats) = self.transcription_stats.try_lock() {
            if stats.segments_processed > 0 {
                let stats_report = stats.report();

                // Log to console
                tracing::info!("\n--- Current Transcription Statistics ---");
                tracing::info!("{}", stats_report);
                tracing::info!("-----------------------------------------\n");

                // Write to file
                let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
                let file_content = format!(
                    "\n--- {} (On-Demand Report) ---\n{}\n",
                    timestamp, stats_report
                );

                match OpenOptions::new()
                    .append(true)
                    .create(true)
                    .open("transcription_stats.log")
                {
                    Ok(mut file) => {
                        if let Err(e) = writeln!(file, "{}", file_content) {
                            tracing::warn!("Failed to write to stats file: {}", e);
                        }
                    }
                    Err(e) => tracing::warn!("Failed to open stats file: {}", e),
                }
            } else {
                tracing::info!("No transcription statistics available yet.");
            }
        } else {
            tracing::info!("Could not access transcription statistics (locked).");
        }
    }
}