nullnet-liblogging 0.3.0

Logging library for NullNet
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

use crate::datastore::config::DatastoreConfig;
use crate::datastore::generic_log::GenericLog;
use crate::datastore::transmitter::DatastoreTransmitter;
use chrono::Utc;
use tokio::sync::mpsc;
use tokio::sync::mpsc::Sender;

#[derive(Default)]
pub(crate) struct DatastoreLogger {
    logger: Option<Sender<GenericLog>>,
}

impl DatastoreLogger {
    pub(crate) fn new(datastore_config: Option<DatastoreConfig>) -> Self {
        let Some(config) = datastore_config else {
            return Self::default();
        };

        let (sender, receiver) = mpsc::channel(10_000);

        tokio::spawn(async move {
            let transmitter = DatastoreTransmitter::new(config).await;
            transmitter.transmit(receiver).await;
        });

        Self {
            logger: Some(sender),
        }
    }
}

impl log::Log for DatastoreLogger {
    fn enabled(&self, metadata: &log::Metadata) -> bool {
        self.logger.as_ref().is_some_and(|_| {
            metadata.level() <= log::max_level()
                && !metadata.target().starts_with("nullnet_libdatastore")
                && !metadata.target().starts_with("nullnet_libtoken")
        })
    }

    fn log(&self, record: &log::Record) {
        if let Some(logger) = self.logger.as_ref() {
            if self.enabled(record.metadata()) {
                let timestamp = Utc::now().to_rfc3339();
                let level = record.level().to_string();
                let message = record.args().to_string();
                let e = GenericLog {
                    timestamp,
                    level,
                    message,
                };
                // send log entry to transmitter
                let _ = logger.try_send(e);
            }
        }
    }

    fn flush(&self) {}
}