Skip to main content

archivist_lib/logs/
stats.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::identity::ComponentIdentity;
6use diagnostics_data::Severity;
7use flyweights::FlyStr;
8use fuchsia_inspect::{
9    ArrayProperty, Inspector, IntArrayProperty, LazyNode, Node, UintArrayProperty,
10};
11use fuchsia_sync::Mutex;
12use futures::FutureExt;
13use std::sync::Arc;
14use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
15
16#[derive(Debug, Default)]
17struct LogCounter {
18    number: AtomicU64,
19    bytes: AtomicU64,
20}
21
22impl LogCounter {
23    fn count(&self, bytes: usize) {
24        self.number.fetch_add(1, Ordering::Relaxed);
25        self.bytes.fetch_add(bytes as u64, Ordering::Relaxed);
26    }
27
28    fn increment_bytes(&self, bytes: usize) {
29        self.number.fetch_add(1, Ordering::Relaxed);
30        self.bytes.fetch_add(bytes as u64, Ordering::Relaxed);
31    }
32}
33
34#[derive(Debug, Default)]
35struct InnerStats {
36    sockets_opened: AtomicU64,
37    sockets_closed: AtomicU64,
38    last_timestamp: AtomicI64,
39    total: LogCounter,
40    fatal: LogCounter,
41    error: LogCounter,
42    warn: LogCounter,
43    info: LogCounter,
44    debug: LogCounter,
45    trace: LogCounter,
46    url: FlyStr,
47    invalid: LogCounter,
48}
49
50#[derive(Debug)]
51pub struct LogStreamStats {
52    inner: Arc<InnerStats>,
53    _lazy_node: LazyNode,
54}
55
56impl LogStreamStats {
57    pub fn new(parent: &Node, identity: &ComponentIdentity) -> Self {
58        let inner = Arc::new(InnerStats { url: identity.url.clone(), ..Default::default() });
59        let inner_clone = Arc::clone(&inner);
60        let lazy_node = parent.create_lazy_child(identity.moniker.to_string(), move || {
61            let inner = Arc::clone(&inner_clone);
62            async move {
63                let inspector = Inspector::default();
64                let root = inspector.root();
65                root.record_uint("sockets_opened", inner.sockets_opened.load(Ordering::Relaxed));
66                root.record_uint("sockets_closed", inner.sockets_closed.load(Ordering::Relaxed));
67                root.record_int("last_timestamp", inner.last_timestamp.load(Ordering::Relaxed));
68                root.record_string("url", inner.url.as_str());
69
70                let record_counter = |name: &str, counter: &LogCounter| {
71                    let child = root.create_child(name);
72                    child.record_uint("number", counter.number.load(Ordering::Relaxed));
73                    child.record_uint("bytes", counter.bytes.load(Ordering::Relaxed));
74                    root.record(child);
75                };
76
77                record_counter("total", &inner.total);
78                record_counter("fatal", &inner.fatal);
79                record_counter("error", &inner.error);
80                record_counter("warn", &inner.warn);
81                record_counter("info", &inner.info);
82                record_counter("debug", &inner.debug);
83                record_counter("trace", &inner.trace);
84                record_counter("invalid", &inner.invalid);
85
86                Ok(inspector)
87            }
88            .boxed()
89        });
90        Self { inner, _lazy_node: lazy_node }
91    }
92
93    pub fn open_socket(&self) {
94        self.inner.sockets_opened.fetch_add(1, Ordering::Relaxed);
95    }
96
97    pub fn close_socket(&self) {
98        self.inner.sockets_closed.fetch_add(1, Ordering::Relaxed);
99    }
100
101    pub fn increment_invalid(&self, bytes: usize) {
102        self.inner.invalid.increment_bytes(bytes);
103    }
104
105    pub fn ingest_message(&self, bytes: usize, severity: Severity) {
106        self.inner.total.count(bytes);
107        match severity {
108            Severity::Trace => self.inner.trace.count(bytes),
109            Severity::Debug => self.inner.debug.count(bytes),
110            Severity::Info => self.inner.info.count(bytes),
111            Severity::Warn => self.inner.warn.count(bytes),
112            Severity::Error => self.inner.error.count(bytes),
113            Severity::Fatal => self.inner.fatal.count(bytes),
114        }
115    }
116}
117
118pub struct GlobalAnalytics {
119    _node: Node,
120    logs_node: Node,
121}
122
123impl GlobalAnalytics {
124    pub fn new(parent: &Node) -> Self {
125        let node = parent.create_child("global_analytics");
126        let logs_node = node.create_child("logs");
127        Self { _node: node, logs_node }
128    }
129
130    pub fn logs_node(&self) -> &Node {
131        &self.logs_node
132    }
133}
134
135pub struct SaturationCurve {
136    boot_times: IntArrayProperty,
137    message_counts: UintArrayProperty,
138    cursor: Mutex<usize>,
139    size: usize,
140    _node: Node,
141}
142
143impl SaturationCurve {
144    pub fn new(parent: &Node, size: usize) -> Self {
145        let node = parent.create_child("saturation_curve");
146        let boot_times = node.create_int_array("boot_times", size);
147        let message_counts = node.create_uint_array("message_counts", size);
148        Self { boot_times, message_counts, cursor: Mutex::new(0), size, _node: node }
149    }
150
151    pub fn record(&self, boot_time: i64, message_count: u64) {
152        let mut cursor = self.cursor.lock();
153        self.boot_times.set(*cursor, boot_time);
154        self.message_counts.set(*cursor, message_count);
155        *cursor = (*cursor + 1) % self.size;
156    }
157}
158
159#[cfg(test)]
160mod tests {
161    use super::*;
162    use diagnostics_assertions::assert_data_tree;
163    use fuchsia_inspect::Inspector;
164
165    #[fuchsia::test]
166    async fn saturation_curve_circular() {
167        let inspector = Inspector::default();
168        let curve = SaturationCurve::new(inspector.root(), 3);
169
170        curve.record(1, 10);
171        curve.record(2, 20);
172        curve.record(3, 30);
173
174        assert_data_tree!(inspector,
175        root: {
176            saturation_curve: {
177                boot_times: vec![1i64, 2, 3],
178                message_counts: vec![10u64, 20, 30],
179            }
180        });
181
182        // Should wrap around
183        curve.record(4, 40);
184
185        assert_data_tree!(inspector,
186        root: {
187            saturation_curve: {
188                boot_times: vec![4i64, 2, 3],
189                message_counts: vec![40u64, 20, 30],
190            }
191        });
192    }
193}