Skip to main content

archivist_lib/logs/
mod.rs

1// Copyright 2018 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
5pub mod container;
6pub mod debuglog;
7pub mod error;
8pub mod listener;
9pub mod repository;
10pub mod serial;
11pub mod servers;
12pub mod shared_buffer;
13pub mod stats;
14pub mod stored_message;
15#[cfg(test)]
16pub mod testing;
17
18#[cfg(test)]
19mod tests {
20    use crate::identity::ComponentIdentity;
21    use crate::logs::testing::*;
22    use diagnostics_assertions::{AnyProperty, assert_data_tree};
23    use diagnostics_log_encoding::{Argument, Record};
24    use diagnostics_log_types::Severity;
25    use fidl_fuchsia_logger::{LogFilterOptions, LogLevelFilter, LogMessage};
26    use fuchsia_async as fasync;
27    use moniker::ExtendedMoniker;
28    use std::sync::Arc;
29
30    #[fuchsia::test]
31    async fn test_log_manager() {
32        Box::pin(TestHarness::default().manager_test()).await;
33    }
34
35    #[fuchsia::test]
36    async fn unfiltered_stats() {
37        let first_message = LogMessage {
38            pid: 1,
39            tid: 2,
40            time: zx::BootInstant::get(),
41            dropped_logs: 3,
42            severity: Severity::Warn as i32,
43            msg: String::from("BBBBB"),
44            tags: vec![String::from("AAAAA")],
45        };
46        let first_packet = to_record(&first_message);
47
48        let mut second_message = first_message.clone();
49        second_message.pid = 0;
50        let second_packet = to_record(&second_message);
51
52        let mut third_message = second_message.clone();
53        third_message.severity = Severity::Info as i32;
54        let third_packet = to_record(&third_message);
55
56        let (fourth_packet, fourth_message) = (third_packet.clone(), third_message.clone());
57
58        let mut fifth_message = fourth_message.clone();
59        fifth_message.severity = Severity::Error as i32;
60        let fifth_packet = to_record(&fifth_message);
61
62        let mut harness = TestHarness::default();
63        let mut stream =
64            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
65        stream.write_packets(vec![
66            first_packet,
67            second_packet,
68            third_packet,
69            fourth_packet,
70            fifth_packet,
71        ]);
72        drop(stream);
73
74        let log_stats_tree = harness
75            .filter_test(
76                vec![first_message, second_message, third_message, fourth_message, fifth_message],
77                None,
78            )
79            .await;
80
81        assert_data_tree!(
82            log_stats_tree,
83            root: contains {
84                log_sources: {
85                    "UNKNOWN": {
86                        url: "fuchsia-pkg://UNKNOWN",
87                        last_timestamp: AnyProperty,
88                        sockets_closed: 0u64,
89                        sockets_opened: 0u64,
90                        invalid: {
91                            number: 0u64,
92                            bytes: 0u64,
93                        },
94                        total: {
95                            number: 5u64,
96                            bytes: AnyProperty,
97                        },
98                        trace: {
99                            number: 0u64,
100                            bytes: 0u64,
101                        },
102                        debug: {
103                            number: 0u64,
104                            bytes: 0u64,
105                        },
106                        info: {
107                            number: 2u64,
108                            bytes: AnyProperty,
109                        },
110                        warn: {
111                            number: 2u64,
112                            bytes: AnyProperty,
113                        },
114                        error: {
115                            number: 1u64,
116                            bytes: AnyProperty,
117                        },
118                        fatal: {
119                            number: 0u64,
120                            bytes: 0u64,
121                        },
122                    },
123                }
124            }
125        );
126    }
127
128    macro_rules! attributed_inspect_two_streams_different_identities_by_reader {
129        (
130            $harness:ident,
131            $log_reader1:ident @ $foo_moniker:literal,
132            $log_reader2:ident @ $bar_moniker:literal,
133        ) => {{
134            let message = LogMessage {
135                pid: 1,
136                tid: 2,
137                time: zx::BootInstant::get(),
138                dropped_logs: 3,
139                severity: Severity::Warn as i32,
140                msg: String::from("BBBBB"),
141                tags: vec![String::from("AAAAA")],
142            };
143            let packet = to_record(&message);
144
145            let mut message2 = message.clone();
146            message2.severity = Severity::Error as i32;
147            let packet2 = to_record(&message2);
148
149            let mut foo_stream = $harness.create_stream_from_log_reader($log_reader1).await;
150            foo_stream.write_packet(packet);
151
152            let mut bar_stream = $harness.create_stream_from_log_reader($log_reader2).await;
153            bar_stream.write_packet(packet2);
154            drop((foo_stream, bar_stream));
155
156            let log_stats_tree = $harness.filter_test(vec![message, message2], None).await;
157
158            assert_data_tree!(
159                log_stats_tree,
160                root: contains {
161                    log_sources: {
162                        $foo_moniker: {
163                            url: "http://foo.com",
164                            last_timestamp: AnyProperty,
165                            sockets_closed: 0u64,
166                            sockets_opened: 0u64,
167                            invalid: {
168                                number: 0u64,
169                                bytes: 0u64,
170                            },
171                            total: {
172                                number: 1u64,
173                                bytes: AnyProperty,
174                            },
175                            trace: {
176                                number: 0u64,
177                                bytes: 0u64,
178                            },
179                            debug: {
180                                number: 0u64,
181                                bytes: 0u64,
182                            },
183                            info: {
184                                number: 0u64,
185                                bytes: 0u64,
186                            },
187                            warn: {
188                                number: 1u64,
189                                bytes: AnyProperty,
190                            },
191                            error: {
192                                number: 0u64,
193                                bytes: 0u64,
194                            },
195                            fatal: {
196                                number: 0u64,
197                                bytes: 0u64,
198                            },
199                        },
200                        $bar_moniker: {
201                            url: "http://bar.com",
202                            last_timestamp: AnyProperty,
203                            sockets_closed: 0u64,
204                            sockets_opened: 0u64,
205                            invalid: {
206                                number: 0u64,
207                                bytes: 0u64,
208                            },
209                            total: {
210                                number: 1u64,
211                                bytes: AnyProperty,
212                            },
213                            trace: {
214                                number: 0u64,
215                                bytes: 0u64,
216                            },
217                            debug: {
218                                number: 0u64,
219                                bytes: 0u64,
220                            },
221                            info: {
222                                number: 0u64,
223                                bytes: 0u64,
224                            },
225                            warn: {
226                                number: 0u64,
227                                bytes: 0u64,
228                            },
229                            error: {
230                                number: 1u64,
231                                bytes: AnyProperty,
232                            },
233                            fatal: {
234                                number: 0u64,
235                                bytes: 0u64,
236                            },
237                        },
238                    },
239                }
240            );
241        }}
242    }
243
244    #[fuchsia::test]
245    async fn attributed_inspect_two_streams_different_identities() {
246        let mut harness = TestHarness::with_retained_sinks();
247
248        let log_reader1 = harness.create_default_reader(ComponentIdentity::new(
249            ExtendedMoniker::parse_str("./foo").unwrap(),
250            "http://foo.com",
251        ));
252
253        let log_reader2 = harness.create_default_reader(ComponentIdentity::new(
254            ExtendedMoniker::parse_str("./bar").unwrap(),
255            "http://bar.com",
256        ));
257
258        attributed_inspect_two_streams_different_identities_by_reader!(
259            harness,
260            log_reader1 @ "foo",
261            log_reader2 @ "bar",
262        );
263    }
264
265    #[fuchsia::test]
266    async fn attributed_inspect_two_v2_streams_different_identities() {
267        let mut harness = TestHarness::with_retained_sinks();
268        let log_reader1 = harness.create_event_stream_reader("./foo", "http://foo.com");
269        let log_reader2 = harness.create_event_stream_reader("./bar", "http://bar.com");
270
271        attributed_inspect_two_streams_different_identities_by_reader!(
272            harness,
273            log_reader1 @ "foo",
274            log_reader2 @ "bar",
275        );
276    }
277
278    #[fuchsia::test]
279    async fn attributed_inspect_two_mixed_streams_different_identities() {
280        let mut harness = TestHarness::with_retained_sinks();
281        let log_reader1 = harness.create_event_stream_reader("./foo", "http://foo.com");
282        let log_reader2 = harness.create_default_reader(ComponentIdentity::new(
283            ExtendedMoniker::parse_str("./bar").unwrap(),
284            "http://bar.com",
285        ));
286
287        attributed_inspect_two_streams_different_identities_by_reader!(
288            harness,
289            log_reader1 @ "foo",
290            log_reader2 @ "bar",
291        );
292    }
293
294    #[fuchsia::test]
295    async fn test_filter_by_pid() {
296        let lm = LogMessage {
297            pid: 1,
298            tid: 2,
299            time: zx::BootInstant::get(),
300            dropped_logs: 3,
301            severity: Severity::Info as i32,
302            msg: String::from("BBBBB"),
303            tags: vec![String::from("AAAAA")],
304        };
305        let p = to_record(&lm);
306        let lm2 = LogMessage { pid: 11, ..lm.clone() };
307        let p2 = to_record(&lm2);
308        let options = LogFilterOptions {
309            filter_by_pid: true,
310            pid: 1,
311            filter_by_tid: false,
312            tid: 0,
313            min_severity: LogLevelFilter::None,
314            verbosity: 0,
315            tags: vec![],
316        };
317
318        let mut harness = TestHarness::default();
319        let mut stream =
320            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
321        stream.write_packets(vec![p, p2]);
322        drop(stream);
323        harness.filter_test(vec![lm], Some(options)).await;
324    }
325
326    #[fuchsia::test]
327    async fn test_filter_by_tid() {
328        let lm = LogMessage {
329            pid: 1,
330            tid: 2,
331            time: zx::BootInstant::get(),
332            dropped_logs: 3,
333            severity: Severity::Info as i32,
334            msg: String::from("BBBBB"),
335            tags: vec![String::from("AAAAA")],
336        };
337        let p = to_record(&lm);
338        let lm2 = LogMessage { tid: 12, ..lm.clone() };
339        let p2 = to_record(&lm2);
340        let options = LogFilterOptions {
341            filter_by_pid: false,
342            pid: 1,
343            filter_by_tid: true,
344            tid: 2,
345            min_severity: LogLevelFilter::None,
346            verbosity: 0,
347            tags: vec![],
348        };
349
350        let mut harness = TestHarness::default();
351        let mut stream =
352            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
353        stream.write_packets(vec![p, p2]);
354        drop(stream);
355        harness.filter_test(vec![lm], Some(options)).await;
356    }
357
358    #[fuchsia::test]
359    async fn test_filter_by_min_severity() {
360        let lm = LogMessage {
361            pid: 0,
362            tid: 0,
363            time: zx::BootInstant::get(),
364            dropped_logs: 2,
365            severity: Severity::Error as i32,
366            msg: String::from("BBBBB"),
367            tags: vec![String::from("AAAAA")],
368        };
369        let p = to_record(&LogMessage { severity: Severity::Warn as i32, ..lm.clone() });
370        let p2 = to_record(&lm);
371        let p3 = to_record(&LogMessage { severity: Severity::Info as i32, ..lm.clone() });
372        let p4 = to_record(&LogMessage { severity: 0x70, ..lm.clone() });
373        let p5 = to_record(&LogMessage { severity: Severity::Fatal as i32, ..lm.clone() });
374
375        let options = LogFilterOptions {
376            filter_by_pid: false,
377            pid: 1,
378            filter_by_tid: false,
379            tid: 1,
380            min_severity: LogLevelFilter::Error,
381            verbosity: 0,
382            tags: vec![],
383        };
384
385        let mut harness = TestHarness::default();
386        let mut stream =
387            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
388        stream.write_packets(vec![p, p2, p3, p4, p5]);
389        drop(stream);
390        harness.filter_test(vec![lm], Some(options)).await;
391    }
392
393    #[fuchsia::test]
394    async fn test_filter_by_combination() {
395        let lm = LogMessage {
396            pid: 0,
397            tid: 0,
398            time: zx::BootInstant::get(),
399            dropped_logs: 2,
400            severity: Severity::Error as i32,
401            msg: String::from("BBBBB"),
402            tags: vec![String::from("AAAAA")],
403        };
404        let p = to_record(&LogMessage { severity: Severity::Warn as i32, ..lm.clone() });
405        let p2 = to_record(&lm);
406        let p3 = to_record(&LogMessage { pid: 1, ..lm.clone() });
407        let options = LogFilterOptions {
408            filter_by_pid: true,
409            pid: 0,
410            filter_by_tid: false,
411            tid: 1,
412            min_severity: LogLevelFilter::Error,
413            verbosity: 0,
414            tags: vec![],
415        };
416
417        let mut harness = TestHarness::default();
418        let mut stream =
419            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
420        stream.write_packets(vec![p, p2, p3]);
421        drop(stream);
422        harness.filter_test(vec![lm], Some(options)).await;
423    }
424
425    #[fuchsia::test]
426    async fn test_filter_by_tags() {
427        let lm1 = LogMessage {
428            pid: 1,
429            tid: 1,
430            time: zx::BootInstant::get(),
431            dropped_logs: 2,
432            severity: Severity::Warn as i32,
433            msg: String::from("BBBBB"),
434            tags: vec![String::from("DDDDD")],
435        };
436        let p = to_record(&lm1);
437
438        let lm2 = LogMessage {
439            pid: 0,
440            tid: 0,
441            time: zx::BootInstant::get(),
442            dropped_logs: 2,
443            severity: Severity::Warn as i32,
444            msg: String::from("CCCCC"),
445            tags: vec![String::from("AAAAA"), String::from("BBBBB")],
446        };
447        let p2 = to_record(&lm2);
448
449        let options = LogFilterOptions {
450            filter_by_pid: false,
451            pid: 1,
452            filter_by_tid: false,
453            tid: 1,
454            min_severity: LogLevelFilter::None,
455            verbosity: 0,
456            tags: vec![String::from("BBBBB"), String::from("DDDDD")],
457        };
458
459        let mut harness = TestHarness::default();
460        let mut stream =
461            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
462        stream.write_packets(vec![p, p2]);
463        drop(stream);
464        harness.filter_test(vec![lm1, lm2], Some(options)).await;
465    }
466
467    #[fuchsia::test]
468    async fn test_structured_log() {
469        let logs = vec![
470            Record {
471                timestamp: zx::BootInstant::from_nanos(6),
472                severity: Severity::Info as u8,
473                arguments: vec![Argument::message("hi")],
474            },
475            Record {
476                timestamp: zx::BootInstant::from_nanos(13),
477                severity: Severity::Error as u8,
478                arguments: vec![],
479            },
480            Record {
481                timestamp: zx::BootInstant::from_nanos(19),
482                severity: Severity::Warn as u8,
483                arguments: vec![
484                    Argument::pid(zx::Koid::from_raw(0x1d1)),
485                    Argument::tid(zx::Koid::from_raw(0x1d2)),
486                    Argument::dropped(23),
487                    Argument::tag("tag"),
488                    Argument::message("message"),
489                ],
490            },
491            Record {
492                timestamp: zx::BootInstant::from_nanos(21),
493                severity: Severity::Warn as u8,
494                arguments: vec![Argument::tag("tag-1"), Argument::tag("tag-2")],
495            },
496        ];
497
498        let expected_logs = vec![
499            LogMessage {
500                pid: zx::sys::ZX_KOID_INVALID,
501                tid: zx::sys::ZX_KOID_INVALID,
502                time: zx::BootInstant::from_nanos(6),
503                severity: LogLevelFilter::Info as i32,
504                dropped_logs: 0,
505                msg: String::from("hi"),
506                tags: vec!["UNKNOWN".to_owned()],
507            },
508            LogMessage {
509                pid: zx::sys::ZX_KOID_INVALID,
510                tid: zx::sys::ZX_KOID_INVALID,
511                time: zx::BootInstant::from_nanos(14),
512                severity: LogLevelFilter::Error as i32,
513                dropped_logs: 0,
514                msg: String::from(""),
515                tags: vec!["UNKNOWN".to_owned()],
516            },
517            LogMessage {
518                pid: 0x1d1,
519                tid: 0x1d2,
520                time: zx::BootInstant::from_nanos(19),
521                severity: LogLevelFilter::Warn as i32,
522                dropped_logs: 23,
523                msg: String::from("message"),
524                tags: vec![String::from("tag")],
525            },
526            LogMessage {
527                pid: zx::sys::ZX_KOID_INVALID,
528                tid: zx::sys::ZX_KOID_INVALID,
529                time: zx::BootInstant::from_nanos(21),
530                severity: LogLevelFilter::Warn as i32,
531                dropped_logs: 0,
532                msg: String::from(""),
533                tags: vec![String::from("tag-1"), String::from("tag-2")],
534            },
535        ];
536        let mut harness = TestHarness::default();
537        let mut stream =
538            harness.create_structured_stream(Arc::new(ComponentIdentity::unknown())).await;
539        stream.write_packets(logs);
540        drop(stream);
541        harness.filter_test(expected_logs, None).await;
542    }
543
544    #[fuchsia::test]
545    async fn test_debuglog_drainer() {
546        let log1 = TestDebugEntry::new("log1".as_bytes());
547        let log2 = TestDebugEntry::new("log2".as_bytes());
548        let log3 = TestDebugEntry::new("log3".as_bytes());
549
550        let klog_reader = TestDebugLog::default();
551        klog_reader.enqueue_read_entry(&log1);
552        klog_reader.enqueue_read_entry(&log2);
553        // logs received after kernel indicates no logs should be read
554        klog_reader.enqueue_read_fail(zx::Status::SHOULD_WAIT);
555        klog_reader.enqueue_read_entry(&log3);
556        klog_reader.enqueue_read_fail(zx::Status::SHOULD_WAIT);
557
558        let expected_logs = vec![
559            LogMessage {
560                pid: log1.record.pid.raw_koid(),
561                tid: log1.record.tid.raw_koid(),
562                time: log1.record.timestamp,
563                dropped_logs: 0,
564                severity: LogLevelFilter::Info as i32,
565                msg: String::from("log1"),
566                tags: vec![String::from("klog")],
567            },
568            LogMessage {
569                pid: log2.record.pid.raw_koid(),
570                tid: log2.record.tid.raw_koid(),
571                time: log2.record.timestamp,
572                dropped_logs: 0,
573                severity: LogLevelFilter::Info as i32,
574                msg: String::from("log2"),
575                tags: vec![String::from("klog")],
576            },
577            LogMessage {
578                pid: log3.record.pid.raw_koid(),
579                tid: log3.record.tid.raw_koid(),
580                time: log3.record.timestamp,
581                dropped_logs: 0,
582                severity: LogLevelFilter::Info as i32,
583                msg: String::from("log3"),
584                tags: vec![String::from("klog")],
585            },
586        ];
587
588        let scope = fasync::Scope::new();
589        let klog_stats_tree = debuglog_test(expected_logs, klog_reader, scope.new_child()).await;
590        assert_data_tree!(
591            klog_stats_tree,
592            root: contains {
593                log_sources: {
594                    "klog": {
595                        url: "fuchsia-boot://kernel",
596                        last_timestamp: AnyProperty,
597                        sockets_closed: 0u64,
598                        sockets_opened: 0u64,
599                        invalid: {
600                            number: 0u64,
601                            bytes: 0u64,
602                        },
603                        total: {
604                            number: 3u64,
605                            bytes: AnyProperty,
606                        },
607                        trace: {
608                            number: 0u64,
609                            bytes: 0u64,
610                        },
611                        debug: {
612                            number: 0u64,
613                            bytes: 0u64,
614                        },
615                        info: {
616                            number: 3u64,
617                            bytes: AnyProperty,
618                        },
619                        warn: {
620                            number: 0u64,
621                            bytes: 0u64,
622                        },
623                        error: {
624                            number: 0u64,
625                            bytes: 0u64,
626                        },
627                        fatal: {
628                            number: 0u64,
629                            bytes: 0u64,
630                        },
631                    },
632                }
633            }
634        );
635    }
636}