Skip to main content

archivist_lib/logs/
repository.rs

1// Copyright 2019 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::events::router::EventConsumer;
6use crate::events::types::{Event, EventPayload, LogSinkRequestedPayload};
7use crate::identity::ComponentIdentity;
8use crate::logs::container::LogsArtifactsContainer;
9use crate::logs::debuglog::{DebugLog, DebugLogBridge, KERNEL_IDENTITY};
10use crate::logs::shared_buffer::{Buffer, FilterCursor, FilterCursorStream, SharedBuffer};
11use crate::logs::stats::{GlobalAnalytics, LogStreamStats};
12use anyhow::format_err;
13use diagnostics_data::{LogsData, Severity};
14use diagnostics_log_encoding::ARCHIVIST_URL;
15use fidl_fuchsia_diagnostics::{
16    ComponentSelector, LogInterestSelector, StreamMode, StringSelector,
17};
18use fidl_fuchsia_diagnostics_types::Severity as FidlSeverity;
19use flyweights::FlyStr;
20use fuchsia_async as fasync;
21use fuchsia_inspect as inspect;
22use fuchsia_sync::Mutex;
23use futures::prelude::*;
24use log::{LevelFilter, debug, error};
25use moniker::{ExtendedMoniker, Moniker};
26use selectors::SelectorExt;
27use std::collections::{BTreeMap, HashMap};
28use std::str::FromStr;
29use std::sync::atomic::{AtomicUsize, Ordering};
30use std::sync::{Arc, OnceLock, Weak};
31
32// LINT.IfChange
33#[derive(Ord, PartialOrd, Eq, PartialEq)]
34pub struct ComponentInitialInterest {
35    /// The URL or moniker for the component which should receive the initial interest.
36    component: UrlOrMoniker,
37    /// The log severity the initial interest should specify.
38    log_severity: Severity,
39}
40// LINT.ThenChange(/src/lib/assembly/config_schema/src/platform_config/diagnostics_config.rs)
41
42impl FromStr for ComponentInitialInterest {
43    type Err = anyhow::Error;
44    fn from_str(s: &str) -> Result<Self, Self::Err> {
45        let mut split = s.rsplitn(2, ":");
46        match (split.next(), split.next()) {
47            (Some(severity), Some(url_or_moniker)) => {
48                let Ok(url_or_moniker) = UrlOrMoniker::from_str(url_or_moniker) else {
49                    return Err(format_err!("invalid url or moniker"));
50                };
51                let Ok(severity) = Severity::from_str(severity) else {
52                    return Err(format_err!("invalid severity"));
53                };
54                Ok(ComponentInitialInterest { log_severity: severity, component: url_or_moniker })
55            }
56            _ => Err(format_err!("invalid interest")),
57        }
58    }
59}
60
61#[derive(Debug, PartialEq, Eq, Ord, PartialOrd)]
62pub enum UrlOrMoniker {
63    /// An absolute fuchsia url to a component.
64    Url(FlyStr),
65    /// The absolute moniker for a component.
66    Moniker(ExtendedMoniker),
67    /// A partial string to match against url or moniker.
68    Partial(FlyStr),
69}
70
71impl FromStr for UrlOrMoniker {
72    type Err = ();
73    fn from_str(s: &str) -> Result<Self, Self::Err> {
74        if fuchsia_url::fuchsia_pkg::AbsoluteComponentUrl::from_str(s).is_ok()
75            || fuchsia_url::boot::AbsoluteComponentUrl::parse(s).is_ok()
76        {
77            Ok(UrlOrMoniker::Url(s.into()))
78        } else if s.starts_with("/") {
79            if let Ok(moniker) = Moniker::from_str(s) {
80                Ok(UrlOrMoniker::Moniker(ExtendedMoniker::ComponentInstance(moniker)))
81            } else {
82                Err(())
83            }
84        } else {
85            Ok(UrlOrMoniker::Partial(s.into()))
86        }
87    }
88}
89
90/// Static ID, used for persistent changes to interest settings.
91pub const STATIC_CONNECTION_ID: usize = 0;
92static INTEREST_CONNECTION_ID: AtomicUsize = AtomicUsize::new(STATIC_CONNECTION_ID + 1);
93
94/// This is set when Archivist first starts. This might not be set for unit tests.
95pub static ARCHIVIST_MONIKER: OnceLock<Moniker> = OnceLock::new();
96
97/// The IOBuffer writer tag used for Archivist logs. We rely on the first container we create having
98/// this tag, so the Archivist container must be the first container created after creating the
99/// shared buffer. This tag is used before we create the container because we want to set up logging
100/// at the earliest possible moment after a binary starts.
101pub const ARCHIVIST_TAG: u64 = 0;
102
103/// LogsRepository holds all diagnostics data and is a singleton wrapped by multiple
104/// [`pipeline::Pipeline`]s in a given Archivist instance.
105pub struct LogsRepository {
106    mutable_state: Mutex<LogsRepositoryState>,
107    shared_buffer: Arc<SharedBuffer>,
108    scope_handle: fasync::ScopeHandle,
109}
110
111impl LogsRepository {
112    pub fn new(
113        ring_buffer: Buffer,
114        initial_interests: impl Iterator<Item = ComponentInitialInterest>,
115        parent: &fuchsia_inspect::Node,
116        scope: fasync::Scope,
117    ) -> Arc<Self> {
118        let scope_handle = scope.to_handle();
119        Arc::new_cyclic(|me: &Weak<LogsRepository>| {
120            let mut mutable_state = LogsRepositoryState::new(parent, initial_interests, scope);
121            let me_clone = Weak::clone(me);
122            let shared_buffer = SharedBuffer::new(
123                ring_buffer,
124                Box::new(move |identity| {
125                    if let Some(this) = me_clone.upgrade() {
126                        this.on_container_inactive(&identity);
127                    }
128                }),
129                Default::default(),
130                mutable_state.global_analytics.logs_node(),
131            );
132            if let Some(m) = ARCHIVIST_MONIKER.get() {
133                let archivist_container = mutable_state.create_log_container(
134                    Arc::new(ComponentIdentity::new(
135                        ExtendedMoniker::ComponentInstance(m.clone()),
136                        ARCHIVIST_URL,
137                    )),
138                    &shared_buffer,
139                    Weak::clone(me),
140                );
141                // We rely on the first container we create ending up with the correct tag.
142                assert_eq!(archivist_container.buffer().iob_tag(), ARCHIVIST_TAG);
143            }
144            LogsRepository { scope_handle, mutable_state: Mutex::new(mutable_state), shared_buffer }
145        })
146    }
147
148    pub async fn flush(&self) {
149        self.shared_buffer.flush().await;
150    }
151
152    /// Drain the kernel's debug log. The returned future completes once
153    /// existing messages have been ingested.
154    pub fn drain_debuglog<K>(self: &Arc<Self>, klog_reader: K)
155    where
156        K: DebugLog + Send + Sync + 'static,
157    {
158        let mut mutable_state = self.mutable_state.lock();
159
160        // We can only have one klog reader, if this is already set, it means we are already
161        // draining klog.
162        if mutable_state.draining_klog {
163            return;
164        }
165        mutable_state.draining_klog = true;
166
167        let container =
168            mutable_state.get_log_container(KERNEL_IDENTITY.clone(), &self.shared_buffer, self);
169        let Some(ref scope) = mutable_state.scope else {
170            return;
171        };
172        scope.spawn(async move {
173            debug!("Draining debuglog.");
174            let mut kernel_logger = DebugLogBridge::create(klog_reader);
175            let mut messages = match kernel_logger.existing_logs() {
176                Ok(messages) => messages,
177                Err(e) => {
178                    error!(e:%; "failed to read from kernel log, important logs may be missing");
179                    return;
180                }
181            };
182            messages.sort_by_key(|m| m.timestamp());
183            for message in messages {
184                container.ingest_message(message);
185            }
186
187            let res = kernel_logger
188                .listen()
189                .try_for_each(|message| async {
190                    container.ingest_message(message);
191                    Ok(())
192                })
193                .await;
194            if let Err(e) = res {
195                error!(e:%; "failed to drain kernel log, important logs may be missing");
196            }
197        });
198    }
199
200    pub fn logs_cursor_raw(
201        &self,
202        mode: StreamMode,
203        selectors: Vec<ComponentSelector>,
204    ) -> FilterCursor {
205        self.shared_buffer.cursor(mode, selectors)
206    }
207
208    /// Returns a log stream filtered to the specified selectors. If `selectors` is empty, all logs
209    /// are returned.
210    pub fn logs_cursor(
211        &self,
212        mode: StreamMode,
213        selectors: Vec<ComponentSelector>,
214    ) -> FilterCursorStream<LogsData> {
215        self.shared_buffer.cursor(mode, selectors).into()
216    }
217
218    /// Returns a log container.
219    ///
220    /// NOTE: This function does nothing to stop the container from being removed, so this is
221    /// currently only suitable for test code.
222    #[cfg(test)]
223    pub fn get_log_container(
224        self: &Arc<Self>,
225        identity: Arc<ComponentIdentity>,
226    ) -> Arc<LogsArtifactsContainer> {
227        self.mutable_state.lock().get_log_container(identity, &self.shared_buffer, self)
228    }
229
230    /// Waits until `stop_accepting_new_log_sinks` is called and all log sink tasks have completed.
231    /// After that, any pending Cursors will return Poll::Ready(None).
232    pub async fn wait_for_termination(&self) {
233        let Some(scope) = self.mutable_state.lock().scope.take() else {
234            error!("Attempted to terminate twice");
235            return;
236        };
237        scope.join().await;
238        // Process messages from log sink.
239        debug!("Log ingestion stopped.");
240        // Terminate the shared buffer first so that pending messages are processed before we
241        // terminate all the containers.
242        self.shared_buffer.terminate().await;
243
244        // Avoid holding `mutable_state` across `container.terminate()`, which drains the ring
245        // buffer and can trigger `on_container_inactive`.
246        let containers: Vec<_> =
247            self.mutable_state.lock().logs_data_store.values().cloned().collect();
248        for container in containers {
249            container.terminate();
250        }
251    }
252
253    /// Closes the connection in which new logger draining tasks are sent. No more logger tasks
254    /// will be accepted when this is called and we'll proceed to terminate logs.
255    pub fn stop_accepting_new_log_sinks(&self) {
256        self.scope_handle.close();
257    }
258
259    /// Returns an id to use for a new interest connection. Used by both LogSettings and Log, to
260    /// ensure shared uniqueness of their connections.
261    pub fn new_interest_connection(&self) -> usize {
262        INTEREST_CONNECTION_ID.fetch_add(1, Ordering::Relaxed)
263    }
264
265    /// Updates log selectors associated with an interest connection.
266    pub fn update_logs_interest(&self, connection_id: usize, selectors: Vec<LogInterestSelector>) {
267        self.mutable_state.lock().update_logs_interest(connection_id, selectors);
268    }
269
270    /// Indicates that the connection associated with the given ID is now done.
271    pub fn finish_interest_connection(&self, connection_id: usize) {
272        self.mutable_state.lock().finish_interest_connection(connection_id);
273    }
274
275    fn on_container_inactive(&self, identity: &ComponentIdentity) {
276        let mut repo = self.mutable_state.lock();
277        if !repo.is_live(identity) {
278            let container = repo.remove(identity);
279
280            // Drop the lock before dropping `container`, since `ContainerBuffer::drop` drains the
281            // ring buffer and may re-entrantly invoke `on_container_inactive` for other containers.
282            drop(repo);
283            drop(container);
284        }
285    }
286}
287
288#[cfg(test)]
289impl LogsRepository {
290    pub fn for_test(scope: fasync::Scope) -> Arc<Self> {
291        use crate::logs::shared_buffer::create_ring_buffer;
292
293        LogsRepository::new(
294            create_ring_buffer(crate::constants::LEGACY_DEFAULT_MAXIMUM_CACHED_LOGS_BYTES as usize),
295            std::iter::empty(),
296            &Default::default(),
297            scope,
298        )
299    }
300}
301
302impl EventConsumer for LogsRepository {
303    fn handle(self: Arc<Self>, event: Event) {
304        match event.payload {
305            EventPayload::LogSinkRequested(LogSinkRequestedPayload {
306                component,
307                request_stream,
308            }) => {
309                debug!(identity:% = component; "LogSink requested.");
310                // NOTE: It is important that we hold the lock whilst we call
311                // `Container::handle_log_sink` because otherwise the container could be removed by
312                // `on_container_inactive`.  After calling `handle_log_sink`, the container cannot
313                // be removed until after the `LogSink` channel is closed.
314                let mut mutable_state = self.mutable_state.lock();
315                let container =
316                    mutable_state.get_log_container(component, &self.shared_buffer, &self);
317                container.handle_log_sink(request_stream, self.scope_handle.clone());
318            }
319            _ => unreachable!("Archivist state just subscribes to log sink requested"),
320        }
321    }
322}
323
324pub struct LogsRepositoryState {
325    logs_data_store: HashMap<Arc<ComponentIdentity>, Arc<LogsArtifactsContainer>>,
326    inspect_node: inspect::Node,
327    global_analytics: GlobalAnalytics,
328
329    /// Interest registrations that we have received through fuchsia.logger.Log/ListWithSelectors
330    /// or through fuchsia.logger.LogSettings/SetInterest.
331    interest_registrations: BTreeMap<usize, Vec<LogInterestSelector>>,
332
333    /// Whether or not we are draining the kernel log.
334    draining_klog: bool,
335
336    /// Scope where log ingestion tasks are running.
337    scope: Option<fasync::Scope>,
338
339    /// The initial log interests with which archivist was configured.
340    initial_interests: BTreeMap<UrlOrMoniker, Severity>,
341}
342
343impl LogsRepositoryState {
344    fn new(
345        parent: &fuchsia_inspect::Node,
346        initial_interests: impl Iterator<Item = ComponentInitialInterest>,
347        scope: fasync::Scope,
348    ) -> Self {
349        Self {
350            inspect_node: parent.create_child("log_sources"),
351            logs_data_store: HashMap::new(),
352            interest_registrations: BTreeMap::new(),
353            draining_klog: false,
354            initial_interests: initial_interests
355                .map(|ComponentInitialInterest { component, log_severity }| {
356                    (component, log_severity)
357                })
358                .collect(),
359            scope: Some(scope),
360            global_analytics: GlobalAnalytics::new(parent),
361        }
362    }
363
364    /// Returns a container for logs artifacts, constructing one and adding it to the trie if
365    /// necessary.
366    pub fn get_log_container(
367        &mut self,
368        identity: Arc<ComponentIdentity>,
369        shared_buffer: &Arc<SharedBuffer>,
370        repo: &Arc<LogsRepository>,
371    ) -> Arc<LogsArtifactsContainer> {
372        match self.logs_data_store.get(&identity) {
373            None => self.create_log_container(identity, shared_buffer, Arc::downgrade(repo)),
374            Some(existing) => Arc::clone(existing),
375        }
376    }
377
378    fn create_log_container(
379        &mut self,
380        identity: Arc<ComponentIdentity>,
381        shared_buffer: &Arc<SharedBuffer>,
382        repo: Weak<LogsRepository>,
383    ) -> Arc<LogsArtifactsContainer> {
384        let initial_interest = self.get_initial_interest(identity.as_ref());
385        let stats = Arc::new(LogStreamStats::new(&self.inspect_node, &identity));
386        let buffer = shared_buffer.new_container_buffer(Arc::clone(&identity), Arc::clone(&stats));
387        let container = Arc::new(LogsArtifactsContainer::new(
388            Arc::clone(&identity),
389            self.interest_registrations.values().flat_map(|s| s.iter()),
390            initial_interest,
391            stats,
392            buffer,
393            Some(Box::new(move |c| {
394                if let Some(repo) = repo.upgrade() {
395                    repo.on_container_inactive(&c.identity)
396                }
397            })),
398        ));
399        self.logs_data_store.insert(Arc::clone(&identity), Arc::clone(&container));
400        container
401    }
402
403    fn get_initial_interest(&self, identity: &ComponentIdentity) -> Option<FidlSeverity> {
404        let exact_url_severity =
405            self.initial_interests.get(&UrlOrMoniker::Url(identity.url.clone())).copied();
406        let exact_moniker_severity =
407            self.initial_interests.get(&UrlOrMoniker::Moniker(identity.moniker.clone())).copied();
408
409        let partial_severity = self
410            .initial_interests
411            .iter()
412            .filter_map(|(uom, severity)| match uom {
413                UrlOrMoniker::Partial(p) => {
414                    if identity.url.contains(p.as_str())
415                        || identity.moniker.to_string().contains(p.as_str())
416                    {
417                        Some(*severity)
418                    } else {
419                        None
420                    }
421                }
422                _ => None,
423            })
424            .min();
425
426        [exact_url_severity, exact_moniker_severity, partial_severity]
427            .into_iter()
428            .flatten()
429            .min()
430            .map(FidlSeverity::from)
431    }
432
433    fn is_live(&self, identity: &ComponentIdentity) -> bool {
434        match self.logs_data_store.get(identity) {
435            Some(container) => container.is_active(),
436            None => false,
437        }
438    }
439
440    /// Updates our own log interest if we are the root Archivist and logging
441    /// to klog.
442    fn maybe_update_own_logs_interest(
443        &mut self,
444        selectors: &[LogInterestSelector],
445        clear_interest: bool,
446    ) {
447        let Some(moniker) = ARCHIVIST_MONIKER.get() else { return };
448        let lowest_selector = selectors
449            .iter()
450            .filter(|selector| {
451                // If this is an embedded archivist, the wildcard selector "**" is used (in
452                // tests at least) to change the interest level on all components. Since
453                // archivist logs to itself, this creates a situation where archivist logs can
454                // get included which is undesirable in the vast majority of cases. To address
455                // this, we prevent the global wildcard pattern "**" and "*" from matching
456                // archivist. This is clearly a bit of a hack, but it is balanced by it being
457                // the behavior that the vast majority of users will want. It is still possible
458                // to change the interest level for archivist by using an exact match. Note that
459                // this will apply to both the embedded and system archivist to keep things
460                // consistent.
461                if selector.selector.moniker_segments.as_ref().is_some_and(|s| {
462                    matches!(
463                        &s[..],
464                        [StringSelector::StringPattern(s)] if s == "**" || s == "*"
465                    )
466                }) {
467                    return false;
468                }
469
470                moniker.matches_component_selector(&selector.selector).unwrap_or(false)
471            })
472            .min_by_key(|selector| selector.interest.min_severity.unwrap_or(FidlSeverity::Info));
473        if let Some(selector) = lowest_selector {
474            if clear_interest {
475                log::set_max_level(LevelFilter::Info);
476            } else {
477                log::set_max_level(
478                    match selector.interest.min_severity.unwrap_or(FidlSeverity::Info) {
479                        FidlSeverity::Trace => LevelFilter::Trace,
480                        FidlSeverity::Debug => LevelFilter::Debug,
481                        FidlSeverity::Info => LevelFilter::Info,
482                        FidlSeverity::Warn => LevelFilter::Warn,
483                        FidlSeverity::Error => LevelFilter::Error,
484                        // Log has no "Fatal" level, so set it to Error
485                        // instead.
486                        FidlSeverity::Fatal => LevelFilter::Error,
487                        FidlSeverity::__SourceBreaking { .. } => return,
488                    },
489                );
490            }
491        }
492    }
493
494    fn update_logs_interest(&mut self, connection_id: usize, selectors: Vec<LogInterestSelector>) {
495        self.maybe_update_own_logs_interest(&selectors, false);
496        let previous_selectors =
497            self.interest_registrations.insert(connection_id, selectors).unwrap_or_default();
498        // unwrap safe, we just inserted.
499        let new_selectors = self.interest_registrations.get(&connection_id).unwrap();
500        for logs_data in self.logs_data_store.values() {
501            logs_data.update_interest(new_selectors.iter(), &previous_selectors);
502        }
503    }
504
505    pub fn finish_interest_connection(&mut self, connection_id: usize) {
506        let selectors = self.interest_registrations.remove(&connection_id);
507        if let Some(selectors) = selectors {
508            self.maybe_update_own_logs_interest(&selectors, true);
509            for logs_data in self.logs_data_store.values() {
510                logs_data.reset_interest(&selectors);
511            }
512        }
513    }
514
515    #[must_use]
516    pub fn remove(&mut self, identity: &ComponentIdentity) -> Option<Arc<LogsArtifactsContainer>> {
517        self.logs_data_store.remove(identity)
518    }
519}
520
521#[cfg(test)]
522mod tests {
523    use super::*;
524    use crate::logs::shared_buffer::create_ring_buffer;
525    use crate::logs::testing::make_message;
526    use fidl_fuchsia_diagnostics::StreamMode;
527    use fidl_fuchsia_logger::LogSinkMarker;
528    use fuchsia_inspect::Inspector;
529    use moniker::ExtendedMoniker;
530    use ring_buffer::MAX_MESSAGE_SIZE;
531    use selectors::{FastError, SelectorExt};
532    use std::time::Duration;
533
534    #[fuchsia::test]
535    async fn data_repo_filters_logs_by_selectors() {
536        let repo = LogsRepository::for_test(fasync::Scope::new());
537        let foo_container = repo.get_log_container(Arc::new(ComponentIdentity::new(
538            ExtendedMoniker::parse_str("./foo").unwrap(),
539            "fuchsia-pkg://foo",
540        )));
541        let bar_container = repo.get_log_container(Arc::new(ComponentIdentity::new(
542            ExtendedMoniker::parse_str("./bar").unwrap(),
543            "fuchsia-pkg://bar",
544        )));
545
546        foo_container.ingest_message(make_message("a", None, zx::BootInstant::from_nanos(1)));
547        bar_container.ingest_message(make_message("b", None, zx::BootInstant::from_nanos(2)));
548        foo_container.ingest_message(make_message("c", None, zx::BootInstant::from_nanos(3)));
549
550        let stream = repo.logs_cursor(StreamMode::Snapshot, Vec::new());
551
552        let results =
553            stream.map(|value| value.msg().unwrap().to_string()).collect::<Vec<_>>().await;
554        assert_eq!(results, vec!["a".to_string(), "b".to_string(), "c".to_string()]);
555
556        let filtered_stream = repo.logs_cursor(
557            StreamMode::Snapshot,
558            vec![selectors::parse_component_selector::<FastError>("foo").unwrap()],
559        );
560
561        let results =
562            filtered_stream.map(|value| value.msg().unwrap().to_string()).collect::<Vec<_>>().await;
563        assert_eq!(results, vec!["a".to_string(), "c".to_string()]);
564    }
565
566    #[fuchsia::test]
567    async fn data_repo_correctly_sets_initial_interests() {
568        let repo = LogsRepository::new(
569            create_ring_buffer(100000),
570            [
571                ComponentInitialInterest {
572                    component: UrlOrMoniker::Url("fuchsia-pkg://bar".into()),
573                    log_severity: Severity::Info,
574                },
575                ComponentInitialInterest {
576                    component: UrlOrMoniker::Url("fuchsia-pkg://baz".into()),
577                    log_severity: Severity::Warn,
578                },
579                ComponentInitialInterest {
580                    component: UrlOrMoniker::Moniker("/core/bar".try_into().unwrap()),
581                    log_severity: Severity::Error,
582                },
583                ComponentInitialInterest {
584                    component: UrlOrMoniker::Moniker("/core/foo".try_into().unwrap()),
585                    log_severity: Severity::Debug,
586                },
587            ]
588            .into_iter(),
589            &fuchsia_inspect::Node::default(),
590            fasync::Scope::new(),
591        );
592
593        // We have the moniker configured, use the associated severity.
594        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
595            ExtendedMoniker::parse_str("core/foo").unwrap(),
596            "fuchsia-pkg://foo",
597        )));
598        expect_initial_interest(Some(FidlSeverity::Debug), container, repo.scope_handle.clone())
599            .await;
600
601        // We have the URL configure, use the associated severity.
602        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
603            ExtendedMoniker::parse_str("core/baz").unwrap(),
604            "fuchsia-pkg://baz",
605        )));
606        expect_initial_interest(Some(FidlSeverity::Warn), container, repo.scope_handle.clone())
607            .await;
608
609        // We have both a URL and a moniker in the config. Pick the minimium one, in this case Info
610        // for the URL over Error for the moniker.
611        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
612            ExtendedMoniker::parse_str("core/bar").unwrap(),
613            "fuchsia-pkg://bar",
614        )));
615        expect_initial_interest(Some(FidlSeverity::Info), container, repo.scope_handle.clone())
616            .await;
617
618        // Neither the moniker nor the URL have an associated severity, therefore, the minimum
619        // severity isn't set.
620        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
621            ExtendedMoniker::parse_str("core/quux").unwrap(),
622            "fuchsia-pkg://quux",
623        )));
624        expect_initial_interest(None, container, repo.scope_handle.clone()).await;
625    }
626
627    #[fuchsia::test]
628    async fn data_repo_correctly_handles_partial_matching() {
629        let repo = LogsRepository::new(
630            create_ring_buffer(100000),
631            [
632                "fuchsia-pkg://fuchsia.com/bar#meta/bar.cm:INFO".parse(),
633                "fuchsia-pkg://fuchsia.com/baz#meta/baz.cm:WARN".parse(),
634                "/core/bust:DEBUG".parse(),
635                "core/bar:ERROR".parse(),
636                "foo:DEBUG".parse(),
637                "both:TRACE".parse(),
638            ]
639            .into_iter()
640            .map(Result::unwrap),
641            &fuchsia_inspect::Node::default(),
642            fasync::Scope::new(),
643        );
644
645        // We have a partial moniker configured, use the associated severity.
646        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
647            ExtendedMoniker::parse_str("core/foo").unwrap(),
648            "fuchsia-pkg://fuchsia.com/not-foo#meta/not-foo.cm",
649        )));
650        expect_initial_interest(Some(FidlSeverity::Debug), container, repo.scope_handle.clone())
651            .await;
652
653        // We have a partial url configured, use the associated severity.
654        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
655            ExtendedMoniker::parse_str("core/not-foo").unwrap(),
656            "fuchsia-pkg://fuchsia.com/foo#meta/foo.cm",
657        )));
658        expect_initial_interest(Some(FidlSeverity::Debug), container, repo.scope_handle.clone())
659            .await;
660
661        // We have the URL configure, use the associated severity.
662        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
663            ExtendedMoniker::parse_str("core/baz").unwrap(),
664            "fuchsia-pkg://fuchsia.com/baz#meta/baz.cm",
665        )));
666        expect_initial_interest(Some(FidlSeverity::Warn), container, repo.scope_handle.clone())
667            .await;
668
669        // We have both a URL and a moniker in the config. Pick the minimum one, in this case Info
670        // for the URL over Error for the moniker.
671        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
672            ExtendedMoniker::parse_str("core/bar").unwrap(),
673            "fuchsia-pkg://fuchsia.com/bar#meta/bar.cm",
674        )));
675        expect_initial_interest(Some(FidlSeverity::Info), container, repo.scope_handle.clone())
676            .await;
677
678        // Neither the moniker nor the URL have an associated severity, therefore, the minimum
679        // severity isn't set.
680        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
681            ExtendedMoniker::parse_str("core/quux").unwrap(),
682            "fuchsia-pkg://fuchsia.com/quux#meta/quux.cm",
683        )));
684        expect_initial_interest(None, container, repo.scope_handle.clone()).await;
685
686        // We have a partial match for both moniker and url, should still work.
687        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
688            ExtendedMoniker::parse_str("core/both").unwrap(),
689            "fuchsia-pkg://fuchsia.com/both#meta/both.cm",
690        )));
691        expect_initial_interest(Some(FidlSeverity::Trace), container, repo.scope_handle.clone())
692            .await;
693
694        // Exact moniker match should not match sub-monikers.
695        let container = repo.get_log_container(Arc::new(ComponentIdentity::new(
696            ExtendedMoniker::parse_str("core/bust/testing").unwrap(),
697            "fuchsia-pkg://fuchsia.com/busted#meta/busted.cm",
698        )));
699        expect_initial_interest(None, container, repo.scope_handle.clone()).await;
700    }
701
702    async fn expect_initial_interest(
703        expected_severity: Option<FidlSeverity>,
704        container: Arc<LogsArtifactsContainer>,
705        scope: fasync::ScopeHandle,
706    ) {
707        let (log_sink, stream) = fidl::endpoints::create_proxy_and_stream::<LogSinkMarker>();
708        container.handle_log_sink(stream, scope);
709        let initial_interest = log_sink.wait_for_interest_change().await.unwrap().unwrap();
710        assert_eq!(initial_interest.min_severity, expected_severity);
711    }
712
713    #[fuchsia::test]
714    async fn inspect_node_cleaned_up_on_roll_out() {
715        let inspector = Inspector::default();
716        let repo = LogsRepository::new(
717            create_ring_buffer(MAX_MESSAGE_SIZE),
718            std::iter::empty(),
719            inspector.root(),
720            fasync::Scope::new(),
721        );
722
723        let identity_foo = Arc::new(ComponentIdentity::new(
724            ExtendedMoniker::parse_str("./foo").unwrap(),
725            "fuchsia-pkg://foo",
726        ));
727
728        // Create container A
729        let container_foo = repo.get_log_container(Arc::clone(&identity_foo));
730        container_foo.ingest_message(make_message("a", None, zx::BootInstant::from_nanos(1)));
731
732        // Force SharedBuffer to drain messages and update last_msg_id.
733        // Without this, ContainerInfo::is_active() evaluates to false immediately after
734        // mark_stopped(), causing repo.is_live() to return false before rollout happens.
735        let _cursor = repo.logs_cursor(
736            StreamMode::Subscribe,
737            vec![identity_foo.moniker.clone().into_component_selector()],
738        );
739
740        container_foo.mark_stopped();
741        drop(container_foo);
742
743        // Verify stats exist
744        let hierarchy = fuchsia_inspect::reader::read(&inspector).await.unwrap();
745        assert!(
746            hierarchy.get_child_by_path(&["log_sources", "foo"]).is_some(),
747            "foo stats must exist initially"
748        );
749
750        // Ingest messages for another component until foo is rolled out
751        let container_bar = repo.get_log_container(Arc::new(ComponentIdentity::new(
752            ExtendedMoniker::parse_str("./bar").unwrap(),
753            "fuchsia-pkg://bar",
754        )));
755
756        let large_str = "b".repeat(1000);
757        for i in 2..1000 {
758            container_bar.ingest_message(make_message(
759                &large_str,
760                None,
761                zx::BootInstant::from_nanos(i),
762            ));
763            fasync::Timer::new(Duration::from_millis(10)).await;
764            if !repo.mutable_state.lock().is_live(&identity_foo) {
765                break;
766            }
767        }
768
769        assert!(
770            !repo.mutable_state.lock().is_live(&identity_foo),
771            "foo container must be inactive after rollout"
772        );
773
774        // Verify stats are cleaned up
775        let hierarchy = fuchsia_inspect::reader::read(&inspector).await.unwrap();
776        assert!(
777            hierarchy.get_child_by_path(&["log_sources", "foo"]).is_none(),
778            "foo stats must be cleaned up after rollout"
779        );
780    }
781
782    #[fuchsia::test]
783    async fn reentrant_on_container_inactive_during_drop() {
784        const CAPACITY: usize = 65536;
785        let inspector = Inspector::default();
786        let repo = LogsRepository::new(
787            create_ring_buffer(CAPACITY),
788            std::iter::empty(),
789            inspector.root(),
790            fasync::Scope::new(),
791        );
792
793        let identity_c1 = Arc::new(ComponentIdentity::new(
794            ExtendedMoniker::parse_str("./c1").unwrap(),
795            "fuchsia-pkg://c1",
796        ));
797        let identity_c2 = Arc::new(ComponentIdentity::new(
798            ExtendedMoniker::parse_str("./c2").unwrap(),
799            "fuchsia-pkg://c2",
800        ));
801        let identity_c3 = Arc::new(ComponentIdentity::new(
802            ExtendedMoniker::parse_str("./c3").unwrap(),
803            "fuchsia-pkg://c3",
804        ));
805
806        // Seed `c2` with a single message in the first chunk, then mark it stopped and drop our
807        // handle so `logs_data_store` holds the sole `Arc<LogsArtifactsContainer>` for `c2`.
808        let c2 = repo.get_log_container(Arc::clone(&identity_c2));
809        let c2_msg = make_message("c2", None, zx::BootInstant::from_nanos(1));
810        let mut active_len = 8 + c2_msg.bytes().len();
811        c2.ingest_message(c2_msg);
812        c2.mark_stopped();
813        drop(c2);
814
815        // Generate incompressible pseudo-random ASCII messages for `c3`.
816        let mut rng_state = 0x1234_5678_9abc_def0u64;
817        let mut next_incompressible_msg = |ts: i64| {
818            let text: String = (0..1000)
819                .map(|_| {
820                    rng_state = rng_state.wrapping_mul(6364136223846793005).wrapping_add(1);
821                    (b'!' + ((rng_state >> 32) % 94) as u8) as char
822                })
823                .collect();
824            make_message(&text, None, zx::BootInstant::from_nanos(ts))
825        };
826
827        let c3 = repo.get_log_container(Arc::clone(&identity_c3));
828        let mut ts = 2;
829
830        // Seal the first chunk (containing `c2`'s message) without evicting it yet.
831        loop {
832            let msg = next_incompressible_msg(ts);
833            ts += 1;
834            let record_bytes = 8 + msg.bytes().len();
835            c3.ingest_message(msg);
836            if active_len + record_bytes > CAPACITY {
837                active_len = record_bytes;
838                break;
839            }
840            active_len += record_bytes;
841        }
842        assert!(repo.mutable_state.lock().is_live(&identity_c2));
843
844        // Fill `active_chunk` right up to the 64 KiB boundary without sealing a second chunk yet.
845        loop {
846            let msg = next_incompressible_msg(ts);
847            let record_bytes = 8 + msg.bytes().len();
848            if active_len + record_bytes > CAPACITY {
849                // Stage one more message in `c3`'s IOBuffer ring buffer without draining it yet, so
850                // the next `drain_ring_buffer` call (inside `c1`'s `ContainerBuffer::terminate`)
851                // will seal `active_chunk`, evict `c2`'s chunk, and trigger `on_container_inactive`
852                // for `c2`.
853                let iob_c3 = c3.buffer().iob();
854                iob_c3.write(Default::default(), 0, msg.bytes()).unwrap();
855                break;
856            }
857            ts += 1;
858            c3.ingest_message(msg);
859            active_len += record_bytes;
860        }
861        assert!(repo.mutable_state.lock().is_live(&identity_c2));
862
863        // Place an inactive `c1` container in `logs_data_store` with `strong_count == 1`.
864        let c1 = repo.get_log_container(Arc::clone(&identity_c1));
865        c1.mark_stopped();
866        repo.mutable_state.lock().logs_data_store.insert(Arc::clone(&identity_c1), c1);
867
868        // Removing and dropping `c1` drains `c3`'s ring buffer write, evicting `c2` and
869        // re-entrantly invoking `on_container_inactive(&identity_c2)`.
870        repo.on_container_inactive(&identity_c1);
871
872        assert!(!repo.mutable_state.lock().logs_data_store.contains_key(&identity_c1));
873        assert!(!repo.mutable_state.lock().logs_data_store.contains_key(&identity_c2));
874
875        let hierarchy = fuchsia_inspect::reader::read(&inspector).await.unwrap();
876        assert!(hierarchy.get_child_by_path(&["log_sources", "c1"]).is_none());
877        assert!(hierarchy.get_child_by_path(&["log_sources", "c2"]).is_none());
878    }
879}