autolog 0.1.0

A mini Rust library for logging when a function is called
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

// NOTE: Unfortunately when using tracing, the tests must be run with `-- --test-threads=1` in order for the tracing messages to show up. Otherwise only the first one will

use autolog::autolog;

#[cfg(feature = "tracing")]
use parking_lot::Mutex;

#[cfg(feature = "tracing")]
static TRACING_ENABLED: Mutex<bool> = Mutex::new(false);

fn init_sub() {
    #[cfg(feature = "tracing")]
    {
        if !*TRACING_ENABLED.lock() {
            *TRACING_ENABLED.lock() = true;

            use tracing::Level;
            use tracing_subscriber::*;

            // a builder for `FmtSubscriber`.
            let subscriber = FmtSubscriber::builder()
                // all spans/events with a level higher than TRACE (e.g, debug, info, warn, etc.)
                // will be written to stdout.
                .with_max_level(Level::TRACE)
                // completes the builder.
                .finish();

            tracing::subscriber::set_global_default(subscriber)
                .expect("setting default subscriber failed");
        }
    }
}

#[test]
fn test_with_args() {
    init_sub();

    #[autolog("\"{fn_name}\" was called with variable \"arg1 = {arg1}\"")]
    fn with_args(arg1: &str) {}

    with_args("first arg");
}

#[test]
fn test_no_fn_name() {
    init_sub();

    #[autolog("Function was called without fn name as an arg")]
    fn no_fn_name() {}

    no_fn_name();
}

#[test]
fn test_no_fn_name_args() {
    init_sub();

    #[autolog("Function was called without fn name as an arg, but with args: {arg1}, {arg2}")]
    fn no_fn_name_args(arg1: &str, arg2: &str) {}

    no_fn_name_args("first arg", "second arg");
}

#[test]
fn test_fn_name_no_args() {
    init_sub();

    #[autolog("\"{fn_name}\" was called without args")]
    fn fn_name_no_args() {}

    fn_name_no_args();
}

#[test]
fn test_default_message() {
    init_sub();

    #[autolog]
    fn default_message() {}

    default_message();
}

#[test]
fn test_async() {
    init_sub();

    #[autolog("\"async\" fn was called with variable \"arg1 = {arg1}\"")]
    async fn with_args(arg1: &str) {}

    smol::block_on(with_args("first arg"));
}