cs-trace 0.14.0

Tracing utilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use tracing::{Level, Subscriber};
use std::{io::{stdout, Write}};
use tracing_subscriber::{self, EnvFilter};

use crate::writers::{FileWriter, MakeCompositeWriter};

pub struct TraceListenerOptions {
    level: Level,
    is_stdout: bool,
    cleanup_file: bool,
    include_thread_ids: bool,
    include_thread_names: bool,
    file_path: String,
    filter: EnvFilter,
}

impl Default for TraceListenerOptions {
    fn default() -> Self {
        return TraceListenerOptions {
            level: Level::TRACE,
            is_stdout: true,
            cleanup_file: false,
            include_thread_ids: false,
            include_thread_names: false,
            file_path: String::new(),
            filter: EnvFilter::default(),
        };
    }
}

impl TraceListenerOptions {
    pub fn new() -> Self {
        return TraceListenerOptions::default();
    }

    pub fn with_stdout(self, is_stdout: bool) -> Self {
        return TraceListenerOptions { is_stdout, ..self };
    }

    pub fn with_level(self, level: Level) -> Self {
        return TraceListenerOptions { level, ..self };
    }

    pub fn with_file_path<S: AsRef<str> + ToString>(self, file_path: S, cleanup_file: bool) -> Self {
        let file_path = file_path.to_string();

        return TraceListenerOptions { file_path, cleanup_file: cleanup_file, ..self };
    }

    pub fn with_thread_names(self, include_thread_names: bool) -> Self {
        return TraceListenerOptions { include_thread_names, ..self };
    }

    pub fn with_thread_ids(self, include_thread_ids: bool) -> Self {
        return TraceListenerOptions { include_thread_ids, ..self };
    }

    pub fn with_env_filter(self, filter: impl Into<EnvFilter>) -> Self {
        let filter = filter.into();

        return TraceListenerOptions { filter, ..self };
    }
}

pub fn create_trace_listener(
    options: TraceListenerOptions,
) -> Box<dyn Subscriber + Send + Sync> {
    // get the file path and stdout options
    let TraceListenerOptions {
        file_path,
        is_stdout,
        cleanup_file,
        include_thread_names,
        include_thread_ids,
        filter,
        ..
    } = options;

    let file_writer = FileWriter::new(&file_path, cleanup_file);
    let stdout_writer: Box<dyn Write + Send + Sync> = Box::new(stdout());
    let mut writers: Vec<Box<dyn Write + Send + Sync>> = vec![];

    // if file path is set, use the file writer
    if file_path.len() > 0 {
        writers.push(file_writer);
    }

    // is stdout set, write to console
    if is_stdout {
        writers.push(stdout_writer);
    }

    let make_composite_writer = MakeCompositeWriter::new(writers);
    let collector = tracing_subscriber::fmt()
        // make sure the tracing level filtering is respected
        .with_max_level(options.level)
        // otherwise the log line will always contain trace::trace
        // since we wrap the tracing functionality and the macros
        // are called from within the trace create
        .with_target(false)
        // include thread name
        .with_thread_ids(include_thread_ids)
        .with_thread_names(include_thread_names)
        // setup writers based on options
        .with_writer(make_composite_writer)
        .with_env_filter(filter)
        .finish();

    return Box::new(collector);
}

// pub use spin;

// static START: spin::Once<()> = spin::Once::new();

// START.call_once(|| {
//     // run initialization here
// });