inspect_stubs/
stubs.rs

1// Copyright 2023 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 fuchsia_inspect::Inspector;
6use fuchsia_sync::Mutex;
7use futures::future::BoxFuture;
8use std::collections::HashMap;
9use std::num::NonZeroU64;
10use std::panic::Location;
11use std::sync::LazyLock;
12
13static STUB_COUNTS: LazyLock<Mutex<HashMap<Invocation, Counts>>> =
14    LazyLock::new(|| Mutex::new(HashMap::new()));
15
16#[macro_export]
17macro_rules! track_stub {
18    (TODO($bug_url:literal), $message:expr, $flags:expr $(,)?) => {{
19        $crate::__track_stub_inner(
20            $crate::bug_ref!($bug_url),
21            $message,
22            Some($flags.into()),
23            std::panic::Location::caller(),
24        );
25    }};
26    (TODO($bug_url:literal), $message:expr $(,)?) => {{
27        $crate::__track_stub_inner(
28            $crate::bug_ref!($bug_url),
29            $message,
30            None,
31            std::panic::Location::caller(),
32        );
33    }};
34}
35
36#[derive(Debug, Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
37struct Invocation {
38    location: &'static Location<'static>,
39    message: &'static str,
40    bug: BugRef,
41}
42
43#[derive(Default)]
44struct Counts {
45    by_flags: HashMap<Option<u64>, u64>,
46}
47
48#[doc(hidden)]
49#[inline]
50pub fn __track_stub_inner(
51    bug: BugRef,
52    message: &'static str,
53    flags: Option<u64>,
54    location: &'static Location<'static>,
55) -> u64 {
56    let mut counts = STUB_COUNTS.lock();
57    let message_counts = counts.entry(Invocation { location, message, bug }).or_default();
58    let context_count = message_counts.by_flags.entry(flags).or_default();
59
60    // Log the first time we see a particular file/message/context tuple but don't risk spamming.
61    if *context_count == 0 {
62        match flags {
63            Some(flags) => {
64                log::debug!(tag = "track_stub", location:%; "{bug} {message}: 0x{flags:x}");
65            }
66            None => {
67                log::debug!(tag = "track_stub", location:%; "{bug} {message}");
68            }
69        }
70    }
71
72    *context_count += 1;
73    *context_count
74}
75
76pub fn track_stub_lazy_node_callback() -> BoxFuture<'static, Result<Inspector, anyhow::Error>> {
77    Box::pin(async {
78        let inspector = Inspector::default();
79        for (Invocation { location, message, bug }, context_counts) in STUB_COUNTS.lock().iter() {
80            inspector.root().atomic_update(|root| {
81                root.record_child(*message, |message_node| {
82                    message_node.record_string("file", location.file());
83                    message_node.record_uint("line", location.line().into());
84                    message_node.record_string("bug", bug.to_string());
85
86                    // Make a copy of the map so we can mutate it while recording values.
87                    let mut context_counts = context_counts.by_flags.clone();
88
89                    if let Some(no_context_count) = context_counts.remove(&None) {
90                        // If the track_stub callsite doesn't provide any context,
91                        // record the count as a property on the node without an intermediate.
92                        message_node.record_uint("count", no_context_count);
93                    }
94
95                    if !context_counts.is_empty() {
96                        message_node.record_child("counts", |counts_node| {
97                            for (context, count) in context_counts {
98                                if let Some(c) = context {
99                                    counts_node.record_uint(format!("0x{c:x}"), count);
100                                }
101                            }
102                        });
103                    }
104                });
105            });
106        }
107        Ok(inspector)
108    })
109}
110
111#[macro_export]
112macro_rules! bug_ref {
113    ($bug_url:literal) => {{
114        // Assign the value to a const to ensure we get compile-time validation of the URL.
115        const __REF: $crate::BugRef = match $crate::BugRef::from_str($bug_url) {
116            Some(b) => b,
117            None => panic!("bug references must have the form `https://fxbug.dev/123456789`"),
118        };
119        __REF
120    }};
121}
122
123#[derive(Debug, Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
124pub struct BugRef {
125    number: u64,
126}
127
128impl BugRef {
129    #[doc(hidden)] // use bug_ref!() instead
130    pub const fn from_str(url: &'static str) -> Option<Self> {
131        let expected_prefix = b"https://fxbug.dev/";
132        let url = str::as_bytes(url);
133
134        if url.len() < expected_prefix.len() {
135            return None;
136        }
137        let (scheme_and_domain, number_str) = url.split_at(expected_prefix.len());
138        if number_str.is_empty() {
139            return None;
140        }
141
142        // The standard library doesn't seem to have a const string or slice equality function.
143        {
144            let mut i = 0;
145            while i < scheme_and_domain.len() {
146                if scheme_and_domain[i] != expected_prefix[i] {
147                    return None;
148                }
149                i += 1;
150            }
151        }
152
153        // The standard library doesn't seem to have a const base 10 string parser.
154        let mut number = 0;
155        {
156            let mut i = 0;
157            while i < number_str.len() {
158                number *= 10;
159                number += match number_str[i] {
160                    b'0' => 0,
161                    b'1' => 1,
162                    b'2' => 2,
163                    b'3' => 3,
164                    b'4' => 4,
165                    b'5' => 5,
166                    b'6' => 6,
167                    b'7' => 7,
168                    b'8' => 8,
169                    b'9' => 9,
170                    _ => return None,
171                };
172                i += 1;
173            }
174        }
175
176        assert!(number != 0, "Zero does not a valid bug number make.");
177
178        Some(Self { number })
179    }
180}
181
182impl From<NonZeroU64> for BugRef {
183    fn from(value: NonZeroU64) -> Self {
184        Self { number: value.get() }
185    }
186}
187
188impl Into<NonZeroU64> for BugRef {
189    fn into(self) -> NonZeroU64 {
190        NonZeroU64::new(self.number).unwrap()
191    }
192}
193
194impl std::fmt::Display for BugRef {
195    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
196        write!(f, "https://fxbug.dev/{}", self.number)
197    }
198}
199
200#[cfg(test)]
201mod tests {
202    use super::*;
203
204    #[test]
205    fn valid_url_parses() {
206        assert_eq!(BugRef::from_str("https://fxbug.dev/1234567890").unwrap().number, 1234567890);
207    }
208
209    #[test]
210    fn missing_prefix_fails() {
211        assert_eq!(BugRef::from_str("1234567890"), None);
212    }
213
214    #[test]
215    fn missing_number_fails() {
216        assert_eq!(BugRef::from_str("https://fxbug.dev/"), None);
217    }
218
219    #[test]
220    fn short_prefixes_fail() {
221        assert_eq!(BugRef::from_str("b/1234567890"), None);
222        assert_eq!(BugRef::from_str("fxb/1234567890"), None);
223        assert_eq!(BugRef::from_str("fxbug.dev/1234567890"), None);
224    }
225}
inspect_stubs/stubs.rs

inspect_stubs/
stubs.rs
