session_log 0.1.3

A simple session log library for Rust.
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

# `Session_log` crate


This crate tries to provide a easy to use logging system that can group / nest logs in a session like
manner. This is useful for systems that having multiple threads and you want to group logs by session.

## Usage


For most basic usage, you just need to import everything from `session_log::prelude` and you're good
to go.

```rust
use session_log::prelude::*;

fn main() {
    // Create a new logging entry point with default settings
    let logger = Logger::new("main");

    // Log a message directly to the logger
    log_info!(logger, "Hello, world!");

    // Create a new session
    {
        let session = logger.session();

        // Log some messages in the session
        log_info!(session, "Hello, session!");

        // Create a new session in the session
        {
            let session = session.session();

            // Log some messages in the session
            log_info!(session, "Hello, nested session!");
        }

        // Log some messages in the session
        log_info!(session, "Goodbye, session!");
    }
}
```

The creation of a logger is very cheap, essentially it's just a wrapper around `String` as the key
to a global map of loggers.

```rust
use session_log::prelude::*;

fn main() {
    // Create a new logging entry point with default settings
    let logger1 = Logger::new("main");
    logger1.set_level(Level::Verbose);

    // Create a new logger with the same name
    let logger2 = Logger::new("main");

    // They are the same logger
    assert_eq!(
        logger1.get_level(),
        logger2.get_level());
}

```

Each entry point have their own logging level and output directory can be set either at initialization
or at runtime.

```rust
use session_log::{
    prelude::*,
    Level,
};

fn main() {
    { // Create a new logger with custom settings
        let logger1 = Logger::with_options("1",
            Level::Verbose, "logs/1").unwrap();

        // If you try to use `with_options` to create a logger with the same name
        // but different settings, it will return an error
        assert_eq!(
            Logger::with_options("1",
                Level::Info, "logs/1").is_err(),
            true);

        // Same options will not return an error
        assert_eq!(
            Logger::with_options("1",
                Level::Verbose, "logs/1").is_err(),
            false);
    }

    { // Create a new logger with custom settings that may be omitted
        // If "2" is never been created before, it will use the given options
        let logger2 = Logger::try_with_options("2",
            Level::Verbose, "logs/2");

        // If "2" is already created, it will omit the given options
        let logger2 = Logger::try_with_options("2",
            Level::Verbose, "logs/2");
    }

    { // Do the setting after initialization
        // This will create a new logger with default settings or retrieve the existing one
        // regardless of the settings. Default setting: (Level::Info, "logs")
        let logger2 = Logger::new("3");

        // Configure the logger afterward
        logger2.set_level(Level::Verbose);
        logger2.set_directory("logs/3");
    }
}
```