myko 4.11.1

myko in rust
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

//! Periodic-summary report-cache hit/miss instrumentation.
//!
//! Replaces per-call `log::debug!` lines in `CellServerCtx::report` (which
//! were firing thousands of times per scene load and dominated I/O).
//!
//! The hot path increments per-report-id atomic counters via DashMap entry
//! lookup; a single dedicated thread emits one summary log line every
//! `WINDOW_MS`. Quiet windows emit nothing.

use std::{
    sync::{
        OnceLock,
        atomic::{AtomicU64, Ordering},
    },
    thread,
    time::Duration,
};

use dashmap::DashMap;

const WINDOW_MS: u64 = 1000;

#[derive(Default)]
struct ReportCounts {
    hits: AtomicU64,
    hits_after_gate: AtomicU64,
    misses: AtomicU64,
}

fn counts() -> &'static DashMap<String, ReportCounts> {
    static C: OnceLock<DashMap<String, ReportCounts>> = OnceLock::new();
    C.get_or_init(DashMap::new)
}

#[inline]
pub fn record_hit(report_id: &str) {
    counts()
        .entry(report_id.to_string())
        .or_default()
        .hits
        .fetch_add(1, Ordering::Relaxed);
}

#[inline]
pub fn record_hit_after_gate(report_id: &str) {
    counts()
        .entry(report_id.to_string())
        .or_default()
        .hits_after_gate
        .fetch_add(1, Ordering::Relaxed);
}

#[inline]
pub fn record_miss(report_id: &str) {
    counts()
        .entry(report_id.to_string())
        .or_default()
        .misses
        .fetch_add(1, Ordering::Relaxed);
}

/// Spawn the summary thread. Idempotent.
pub fn start_periodic_logger() {
    static STARTED: OnceLock<()> = OnceLock::new();
    if STARTED.set(()).is_err() {
        return;
    }
    let _ = thread::Builder::new()
        .name("myko-report-cache-stats".to_string())
        .spawn(run_loop)
        .map_err(|e| {
            log::warn!(
                target: "myko::server::report_cache_stats",
                "Failed to spawn report_cache_stats thread: {}", e
            )
        });
}

fn run_loop() {
    loop {
        thread::sleep(Duration::from_millis(WINDOW_MS));
        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(emit_window));
    }
}

fn emit_window() {
    let mut snap: Vec<(String, u64, u64, u64)> = counts()
        .iter()
        .filter_map(|e| {
            let h = e.value().hits.swap(0, Ordering::Relaxed);
            let g = e.value().hits_after_gate.swap(0, Ordering::Relaxed);
            let m = e.value().misses.swap(0, Ordering::Relaxed);
            if h == 0 && g == 0 && m == 0 {
                None
            } else {
                Some((e.key().clone(), h, g, m))
            }
        })
        .collect();
    if snap.is_empty() {
        return;
    }
    snap.sort_by_key(|b| std::cmp::Reverse(b.1 + b.2 + b.3));
    let total_hits: u64 = snap.iter().map(|s| s.1 + s.2).sum();
    let total_misses: u64 = snap.iter().map(|s| s.3).sum();
    let detail = snap
        .iter()
        .map(|(rid, h, g, m)| {
            if *g > 0 {
                format!("{}=H{}/G{}/M{}", rid, h, g, m)
            } else {
                format!("{}=H{}/M{}", rid, h, m)
            }
        })
        .collect::<Vec<_>>()
        .join(", ");
    log::info!(
        target: "myko::server::report_cache_stats",
        "[report_cache window={}ms] hits={} misses={} miss_rate={:.0}% [{}]",
        WINDOW_MS,
        total_hits,
        total_misses,
        if total_hits + total_misses > 0 {
            100.0 * total_misses as f64 / (total_hits + total_misses) as f64
        } else {
            0.0
        },
        detail,
    );
}