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