1use 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 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}