tklog 0.3.0

Lightweight and efficient rust structured log library with support for log level, file shred, compressed archive
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
119
120

// Copyright (c) 2024, donnie4w <donnie4w@gmail.com>
// All rights reserved.
// https://github.com/donnie4w/tklog
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Trace log macros, call secondary macro processing logic
#[macro_export]
macro_rules! async_traces {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Trace, $($arg),*);
    };
    () => {};
}

//Debug log macro, call secondary macro processing logic
#[macro_export]
macro_rules! async_debugs {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Debug, $($arg),*);
    };
    () => {};
}

//Info log macro, call secondary macro processing logic
#[macro_export]
macro_rules! async_infos {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Info, $($arg),*);
    };
    () => {};
}

// warn log macro, call secondary macro processing logic
#[macro_export]
macro_rules! async_warns {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Warn, $($arg),*);
    };
    () => {};
}

// Error log macro, call secondary macro processing logic
#[macro_export]
macro_rules! async_errors {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Error, $($arg),*);
    };
    () => {};
}

// Fatal log macros, call secondary macro processing logic
#[macro_export]
macro_rules! async_fatals {
    ($logger:expr, $($arg:expr),+) => {
        $crate::async_logs_common!($logger, $crate::LEVEL::Fatal, $($arg),*);
    };
    () => {};
}

#[macro_export]
macro_rules! async_formats {
    ($logger:expr, $level:expr, $($arg:expr),*) => {
        unsafe {
            let logger_lock:&mut Arc<tokio::sync::Mutex<tklog::Async::Logger>> = $logger;
            let mut logger = logger_lock.as_ref().lock().await;
            let level:$crate::LEVEL = $level;
            let module = module_path!();
            if logger.get_level(module) <= level {
                let mut file = "";
                let mut line = 0;
                if logger.is_file_line($level,module) {
                    file = file!();
                    line = line!();
                }
                let ss = logger.fmt(module,$level, file, line, format!($($arg),*));
                if !ss.is_empty(){
                    logger.print($level,module,ss.as_str()).await;
                }
            }
        }
    };
    () => {};
}

#[macro_export]
macro_rules! async_logs_common {
    ($logger:expr, $level:expr, $($arg:expr),*) => {
        unsafe {
            let logger_lock:&mut Arc<tokio::sync::Mutex<tklog::Async::Logger>> = $logger;
            let mut logger = logger_lock.as_ref().lock().await;
            let module = module_path!();
            if logger.get_level(module) <= $level {
                let formatted_args: Vec<String> = vec![$(format!("{}", $arg)),*];
                let mut file = "";
                let mut line = 0;
                if logger.is_file_line($level,module) {
                    file = file!();
                    line = line!();
                }
                let msg: String = formatted_args.join(logger.get_separator().as_str());
                let ss = logger.fmt(module,$level, file, line, msg);
                if !ss.is_empty(){
                    logger.print($level,module,ss.as_str()).await;
                }
            }
        }
    };
    () => {};
}