Initial ForgeLM import

crates/metrics/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "metrics"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+serde.workspace = true
+serde_json.workspace = true
+tracing.workspace = true
+chrono.workspace = true
+tokio.workspace = true

crates/metrics/src/counters.rs

@@ -0,0 +1,46 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+
+/// Global atomic performance counters.
+#[derive(Debug, Default)]
+pub struct PerfCounters {
+    pub tokens_generated: AtomicU64,
+    pub requests_completed: AtomicU64,
+    pub requests_failed: AtomicU64,
+    pub total_prompt_tokens: AtomicU64,
+}
+
+impl PerfCounters {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+
+    pub fn inc_tokens(&self, n: u64) {
+        self.tokens_generated.fetch_add(n, Ordering::Relaxed);
+    }
+
+    pub fn inc_completed(&self) {
+        self.requests_completed.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_failed(&self) {
+        self.requests_failed.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn snapshot(&self) -> CountersSnapshot {
+        CountersSnapshot {
+            tokens_generated: self.tokens_generated.load(Ordering::Relaxed),
+            requests_completed: self.requests_completed.load(Ordering::Relaxed),
+            requests_failed: self.requests_failed.load(Ordering::Relaxed),
+            total_prompt_tokens: self.total_prompt_tokens.load(Ordering::Relaxed),
+        }
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct CountersSnapshot {
+    pub tokens_generated: u64,
+    pub requests_completed: u64,
+    pub requests_failed: u64,
+    pub total_prompt_tokens: u64,
+}

crates/metrics/src/lib.rs

@@ -0,0 +1,4 @@
+// metrics: performance counters and structured telemetry
+
+pub mod counters;
+pub mod recorder;

crates/metrics/src/recorder.rs

@@ -0,0 +1,34 @@
+use std::time::Instant;
+
+/// Records a single generation run and computes TPS.
+#[derive(Debug)]
+pub struct GenerationRecord {
+    pub start: Instant,
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+}
+
+impl GenerationRecord {
+    pub fn new(prompt_tokens: u32) -> Self {
+        Self {
+            start: Instant::now(),
+            prompt_tokens,
+            completion_tokens: 0,
+        }
+    }
+
+    pub fn tick(&mut self) {
+        self.completion_tokens += 1;
+    }
+
+    pub fn elapsed_secs(&self) -> f64 {
+        self.start.elapsed().as_secs_f64()
+    }
+
+    pub fn tokens_per_second(&self) -> f64 {
+        if self.completion_tokens == 0 {
+            return 0.0;
+        }
+        self.completion_tokens as f64 / self.elapsed_secs()
+    }
+}