bindizr-core 0.1.0-beta.4

Core models, configuration, DNS record types, and logging utilities for bindizr
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

use std::io::{self, Write};

use log::{Level, Metadata, Record};

use crate::config;

#[macro_export]
macro_rules! log_error {
    ($($arg:tt)*) => {
        log::error!($($arg)*)
    };
}

#[macro_export]
macro_rules! log_warn {
    ($($arg:tt)*) => {
        log::warn!($($arg)*)
    };
}

#[macro_export]
macro_rules! log_info {
    ($($arg:tt)*) => {
        log::info!($($arg)*)
    };
}

#[macro_export]
macro_rules! log_debug {
    ($($arg:tt)*) => {
        log::debug!($($arg)*)
    };
}

#[macro_export]
macro_rules! log_trace {
    ($($arg:tt)*) => {
        log::trace!($($arg)*)
    };
}

pub struct Logger {
    log_level: Level,
}

impl log::Log for Logger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= self.log_level
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            let log_message = if self.log_level == Level::Debug {
                // Include target in debug logs
                format!(
                    "{} - {}: {}\n",
                    record.level(),
                    record.target(),
                    record.args()
                )
            } else {
                // Exclude target for other log levels
                format!("{}: {}\n", record.level(), record.args())
            };

            // Use stderr for logging to avoid interfering with stdout
            eprint!("{}", log_message);
        }
    }

    fn flush(&self) {
        let _ = io::stderr().flush();
    }
}

pub fn initialize() {
    let log_level = match config::get_bindizr_config().logging.log_level {
        config::LogLevel::Error => Level::Error,
        config::LogLevel::Warn => Level::Warn,
        config::LogLevel::Debug => Level::Debug,
        config::LogLevel::Trace => Level::Trace,
        config::LogLevel::Info => Level::Info,
    };

    let logger = Logger { log_level };

    if let Err(e) = log::set_boxed_logger(Box::new(logger)) {
        eprintln!("Failed to set logger: {}", e);
        return;
    }
    log::set_max_level(log_level.to_level_filter());

    println!("Console logging level: {}", log_level);
}