vector/enrichment_tables/memory/
internal_events.rs

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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
use metrics::{counter, gauge};
use vector_lib::configurable::configurable_component;
use vector_lib::internal_event::InternalEvent;

/// Configuration of internal metrics for enrichment memory table.
#[configurable_component]
#[derive(Clone, Debug, PartialEq, Eq, Default)]
#[serde(deny_unknown_fields)]
pub struct InternalMetricsConfig {
    /// Determines whether to include the key tag on internal metrics.
    ///
    /// This is useful for distinguishing between different keys while monitoring. However, the tag's
    /// cardinality is unbounded.
    #[serde(default = "crate::serde::default_false")]
    pub include_key_tag: bool,
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableRead<'a> {
    pub key: &'a str,
    pub include_key_metric_tag: bool,
}

impl InternalEvent for MemoryEnrichmentTableRead<'_> {
    fn emit(self) {
        if self.include_key_metric_tag {
            counter!(
                "memory_enrichment_table_reads_total",
                "key" => self.key.to_owned()
            )
            .increment(1);
        } else {
            counter!("memory_enrichment_table_reads_total",).increment(1);
        }
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableRead")
    }
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableInserted<'a> {
    pub key: &'a str,
    pub include_key_metric_tag: bool,
}

impl InternalEvent for MemoryEnrichmentTableInserted<'_> {
    fn emit(self) {
        if self.include_key_metric_tag {
            counter!(
                "memory_enrichment_table_insertions_total",
                "key" => self.key.to_owned()
            )
            .increment(1);
        } else {
            counter!("memory_enrichment_table_insertions_total",).increment(1);
        }
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableInserted")
    }
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableFlushed {
    pub new_objects_count: usize,
    pub new_byte_size: usize,
}

impl InternalEvent for MemoryEnrichmentTableFlushed {
    fn emit(self) {
        counter!("memory_enrichment_table_flushes_total",).increment(1);
        gauge!("memory_enrichment_table_objects_count",).set(self.new_objects_count as f64);
        gauge!("memory_enrichment_table_byte_size",).set(self.new_byte_size as f64);
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableFlushed")
    }
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableTtlExpired<'a> {
    pub key: &'a str,
    pub include_key_metric_tag: bool,
}

impl InternalEvent for MemoryEnrichmentTableTtlExpired<'_> {
    fn emit(self) {
        if self.include_key_metric_tag {
            counter!(
                "memory_enrichment_table_ttl_expirations",
                "key" => self.key.to_owned()
            )
            .increment(1);
        } else {
            counter!("memory_enrichment_table_ttl_expirations",).increment(1);
        }
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableTtlExpired")
    }
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableReadFailed<'a> {
    pub key: &'a str,
    pub include_key_metric_tag: bool,
}

impl InternalEvent for MemoryEnrichmentTableReadFailed<'_> {
    fn emit(self) {
        if self.include_key_metric_tag {
            counter!(
                "memory_enrichment_table_failed_reads",
                "key" => self.key.to_owned()
            )
            .increment(1);
        } else {
            counter!("memory_enrichment_table_failed_reads",).increment(1);
        }
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableReadFailed")
    }
}

#[derive(Debug)]
pub(crate) struct MemoryEnrichmentTableInsertFailed<'a> {
    pub key: &'a str,
    pub include_key_metric_tag: bool,
}

impl InternalEvent for MemoryEnrichmentTableInsertFailed<'_> {
    fn emit(self) {
        if self.include_key_metric_tag {
            counter!(
                "memory_enrichment_table_failed_insertions",
                "key" => self.key.to_owned()
            )
            .increment(1);
        } else {
            counter!("memory_enrichment_table_failed_insertions",).increment(1);
        }
    }

    fn name(&self) -> Option<&'static str> {
        Some("MemoryEnrichmentTableInsertFailed")
    }
}