1use 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#[derive(Ord, PartialOrd, Eq, PartialEq)]
34pub struct ComponentInitialInterest {
35 component: UrlOrMoniker,
37 log_severity: Severity,
39}
40impl 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 Url(FlyStr),
65 Moniker(ExtendedMoniker),
67 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
90pub const STATIC_CONNECTION_ID: usize = 0;
92static INTEREST_CONNECTION_ID: AtomicUsize = AtomicUsize::new(STATIC_CONNECTION_ID + 1);
93
94pub static ARCHIVIST_MONIKER: OnceLock<Moniker> = OnceLock::new();
96
97pub const ARCHIVIST_TAG: u64 = 0;
102
103pub 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 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 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 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 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 #[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 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 debug!("Log ingestion stopped.");
240 self.shared_buffer.terminate().await;
243
244 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 pub fn stop_accepting_new_log_sinks(&self) {
256 self.scope_handle.close();
257 }
258
259 pub fn new_interest_connection(&self) -> usize {
262 INTEREST_CONNECTION_ID.fetch_add(1, Ordering::Relaxed)
263 }
264
265 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 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(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 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: BTreeMap<usize, Vec<LogInterestSelector>>,
332
333 draining_klog: bool,
335
336 scope: Option<fasync::Scope>,
338
339 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 loop {
846 let msg = next_incompressible_msg(ts);
847 let record_bytes = 8 + msg.bytes().len();
848 if active_len + record_bytes > CAPACITY {
849 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 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 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}