moniof 1.0.1

Actix middleware to monitor over-fetching and detect N+1 / overfetch database patterns (Mongo + SQL-agnostic)
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

//! Unit tests for `core::stats` — counters, latency accumulation, SQL normalization.

use moniof::core::stats::{normalize_sql, QueryStats};

#[test]
fn record_counts_total_and_per_key() {
    let mut s = QueryStats::new();
    s.record("mongo/users/find");
    s.record("mongo/users/find");
    s.record("sql/select 1");

    assert_eq!(s.total, 3);
    assert_eq!(s.per_key["mongo/users/find"], 2);
    assert_eq!(s.per_key["sql/select 1"], 1);
}

#[test]
fn record_latency_accumulates_total_and_per_key() {
    let mut s = QueryStats::new();
    s.record_latency("sql/a", 10);
    s.record_latency("sql/a", 5);
    s.record_latency("sql/b", 7);

    assert_eq!(s.total_db_latency_ms, 22);
    assert_eq!(s.per_key_latency_ms["sql/a"], 15);
    assert_eq!(s.per_key_latency_ms["sql/b"], 7);
}

#[test]
fn record_latency_tracks_max_not_last() {
    let mut s = QueryStats::new();
    s.record_latency("sql/a", 10);
    s.record_latency("sql/a", 3); // smaller — must not overwrite the max
    s.record_latency("sql/a", 25);
    s.record_latency("sql/a", 1);

    assert_eq!(s.per_key_max_latency_ms["sql/a"], 25);
}

#[test]
fn record_and_record_latency_are_independent() {
    // `record` is called on command-start, `record_latency` on completion.
    // A started-but-never-finished command must count, yet contribute no latency.
    let mut s = QueryStats::new();
    s.record("mongo/users/find");

    assert_eq!(s.total, 1);
    assert_eq!(s.total_db_latency_ms, 0);
    assert!(!s.per_key_latency_ms.contains_key("mongo/users/find"));
}

#[test]
fn elapsed_is_non_negative() {
    let s = QueryStats::new();
    assert!(s.elapsed().whole_milliseconds() >= 0);
}

// ---------------------------------------------------------------------------
// normalize_sql
// ---------------------------------------------------------------------------

#[test]
fn normalize_sql_collapses_whitespace_and_lowercases() {
    let key = normalize_sql("SELECT   id,\n\tname\n  FROM Users");
    assert_eq!(key, "select id, name from users");
}

#[test]
fn normalize_sql_is_stable_across_formatting() {
    // The whole point of a "key" is that two spellings of one query collide.
    let a = normalize_sql("SELECT id FROM users WHERE tenant = $1");
    let b = normalize_sql("select   id\nfrom USERS\n  where tenant = $1");
    assert_eq!(a, b);
}

#[test]
fn normalize_sql_truncates_long_queries() {
    let long = format!("SELECT {}", "x".repeat(500));
    let key = normalize_sql(&long);
    assert_eq!(key.len(), 200);
}

#[test]
fn normalize_sql_leaves_short_queries_untruncated() {
    let key = normalize_sql("SELECT 1");
    assert_eq!(key, "select 1");
}

/// BUG: `normalize_sql` calls `String::truncate(200)`, which panics when byte
/// 200 lands inside a multi-byte character. sqlx itself appends a `…` (U+2026)
/// to long query summaries, so this is reachable from real traffic: any query
/// over 200 bytes with a non-ASCII character straddling the cut point takes the
/// whole request thread down.
///
/// Fix: cut on a char boundary, e.g.
///     let cut = reduced.char_indices().map(|(i, _)| i)
///         .take_while(|i| *i <= 200).last().unwrap_or(0);
///     reduced.truncate(cut);
#[test]
#[ignore = "known bug: normalize_sql panics on multi-byte char at the 200-byte cut"]
fn normalize_sql_should_not_panic_on_multibyte_boundary() {
    // 199 ASCII bytes, then 'é' occupying bytes 199..201 => len 201, cut at 200.
    let sql = format!("{}é", "a".repeat(199));
    assert_eq!(sql.len(), 201, "test fixture must straddle the 200-byte cut");

    let key = normalize_sql(&sql); // currently panics here
    assert!(key.len() <= 200);
}