grafatui 0.1.12

A Grafana-like TUI for Prometheus
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

use std::collections::BTreeSet;
use std::fmt;

use super::{AnnotationSnapshot, AnnotationTarget};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum AnnotationTargetWarning {
    MissingPanel { title: String },
    AmbiguousPanel { title: String, matches: usize },
}

impl fmt::Display for AnnotationTargetWarning {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingPanel { title } => {
                write!(
                    formatter,
                    "target \"{title}\" matches no graph/timeseries panel"
                )
            }
            Self::AmbiguousPanel { title, matches } => write!(
                formatter,
                "target \"{title}\" matches {matches} graph/timeseries panels; applied to all"
            ),
        }
    }
}

pub(crate) fn target_warnings(
    snapshot: &AnnotationSnapshot,
    eligible_panel_titles: &[String],
) -> Vec<AnnotationTargetWarning> {
    let requested = snapshot
        .events()
        .iter()
        .filter_map(|event| match &event.target {
            AnnotationTarget::All => None,
            AnnotationTarget::PanelTitles(titles) => Some(titles.iter()),
        })
        .flatten()
        .cloned()
        .collect::<BTreeSet<_>>();

    requested
        .into_iter()
        .filter_map(|title| {
            let matches = eligible_panel_titles
                .iter()
                .filter(|candidate| candidate.as_str() == title.as_str())
                .count();
            match matches {
                0 => Some(AnnotationTargetWarning::MissingPanel { title }),
                1 => None,
                matches => Some(AnnotationTargetWarning::AmbiguousPanel { title, matches }),
            }
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use crate::annotations::{
        AnnotationSnapshot, AnnotationTarget, AnnotationTargetWarning, target_warnings,
    };

    fn targeted_event(text: &str, titles: &[&str]) -> crate::annotations::AnnotationEvent {
        let mut event = crate::annotations::test_event_at(10.0, text);
        event.target = AnnotationTarget::PanelTitles(
            titles.iter().map(|title| (*title).to_string()).collect(),
        );
        event
    }

    #[test]
    fn warns_once_for_missing_and_ambiguous_titles() {
        let snapshot = AnnotationSnapshot::new(vec![
            targeted_event("first", &["CPU", "Missing"]),
            targeted_event("second", &["CPU", "Missing"]),
        ]);
        let panels = vec!["CPU".to_string(), "CPU".to_string(), "Memory".to_string()];

        assert_eq!(
            target_warnings(&snapshot, &panels),
            vec![
                AnnotationTargetWarning::AmbiguousPanel {
                    title: "CPU".to_string(),
                    matches: 2,
                },
                AnnotationTargetWarning::MissingPanel {
                    title: "Missing".to_string(),
                },
            ]
        );
    }

    #[test]
    fn all_targets_do_not_produce_warnings() {
        let snapshot =
            AnnotationSnapshot::new(vec![crate::annotations::test_event_at(10.0, "all")]);

        assert!(target_warnings(&snapshot, &["CPU".to_string()]).is_empty());
    }

    #[test]
    fn formats_target_warnings_for_the_footer() {
        assert_eq!(
            AnnotationTargetWarning::AmbiguousPanel {
                title: "CPU".to_string(),
                matches: 2,
            }
            .to_string(),
            "target \"CPU\" matches 2 graph/timeseries panels; applied to all"
        );
        assert_eq!(
            AnnotationTargetWarning::MissingPanel {
                title: "Missing".to_string(),
            }
            .to_string(),
            "target \"Missing\" matches no graph/timeseries panel"
        );
    }
}