auditor 0.11.0

AccoUnting Data handlIng Toolbox for Opportunistic Resources
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

// Copyright 2021-2022 AUDITOR developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.

use rolling_file::*;
use serde::{Deserialize, de};
use std::str::FromStr;
use tracing::{Subscriber, subscriber::set_global_default};
use tracing_appender::non_blocking::WorkerGuard;
use tracing_bunyan_formatter::{BunyanFormattingLayer, JsonStorageLayer};
use tracing_log::LogTracer;
use tracing_subscriber::{
    EnvFilter, Registry, filter::LevelFilter, fmt::MakeWriter, layer::SubscriberExt,
};

/// Compose multiple layers into a `tracing`'s subscriber.
pub fn get_subscriber<Sink>(
    name: String,
    env_filter: LevelFilter,
    sink: Sink,
    file_config: Option<(impl AsRef<std::path::Path>, &str, u64, usize)>,
) -> (Box<dyn Subscriber + Send + Sync>, Vec<WorkerGuard>)
where
    Sink: for<'a> MakeWriter<'a> + Send + Sync + 'static,
{
    //let env_filter =
    //    EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(env_filter));
    let env_filter = EnvFilter::from_default_env().add_directive(env_filter.into());
    let stdout_formatting_layer = BunyanFormattingLayer::new(name.clone(), sink);

    let base = Registry::default()
        .with(env_filter)
        .with(JsonStorageLayer)
        .with(stdout_formatting_layer);

    match file_config {
        Some((log_dir, log_file_prefix, log_file_size, number_of_rotated_backups)) => {
            std::fs::create_dir_all(&log_dir).expect("Failed to create log directory");

            let log_path = log_dir.as_ref().join(log_file_prefix);

            let file_appender = BasicRollingFileAppender::new(
                log_path,
                RollingConditionBasic::new().max_size(10 * 1024 * 1024 * log_file_size),
                number_of_rotated_backups, // rotated backups
            )
            .expect("Failed to create rolling file appender");
            let (non_blocking_file, file_guard) = tracing_appender::non_blocking(file_appender);
            let file_formatting_layer = BunyanFormattingLayer::new(name, non_blocking_file);

            let subscriber = base.with(file_formatting_layer);
            (Box::new(subscriber), vec![file_guard])
        }
        None => (Box::new(base), vec![]),
    }
}

/// Register a subscriber as global default for processing span data.
pub fn init_subscriber(subscriber: impl Subscriber + Send + Sync) {
    LogTracer::init().expect("Failed to set logger");
    set_global_default(subscriber).expect("Failed to set subscriber");
}

pub fn deserialize_log_level<'de, D>(deserializer: D) -> Result<LevelFilter, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    LevelFilter::from_str(&s.to_lowercase()).map_err(de::Error::custom)
}