ma-core 0.10.0

DIDComm service library: inboxes, outboxes, DID document publishing, and transport abstraction
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

//! Logging initialisation for ma-core-based daemons.
//!
//! [`Config::init_logging`] sets up a two-layer [`tracing_subscriber`]
//! registry:
//! - A **file layer** that writes structured log lines at `config.log_level`
//!   to `config.effective_log_file()`.
//! - A **stdout layer** that writes human-readable log lines at
//!   `config.log_level_stdout`.
//!
//! Call this once, early in `main`, before spawning any tasks.

use tracing_subscriber::{
    filter::LevelFilter, fmt, layer::SubscriberExt, prelude::*, util::SubscriberInitExt,
};

use crate::error::{Error, Result};

use super::Config;

impl Config {
    /// Initialise the global `tracing` subscriber.
    ///
    /// Sets up:
    /// - A file appender writing at `self.log_level` to
    ///   `self.effective_log_file()`.
    /// - A stdout writer writing at `self.log_level_stdout`.
    ///
    /// Uses [`try_init`](tracing_subscriber::util::SubscriberInitExt::try_init)
    /// so that calling this more than once (e.g. in tests) does not panic.
    pub fn init_logging(&self) -> Result<()> {
        let file_level: LevelFilter = self
            .log_level
            .parse()
            .map_err(|_| Error::Config(format!("invalid log_level: {}", self.log_level)))?;

        let stdout_level: LevelFilter = self.log_level_stdout.parse().map_err(|_| {
            Error::Config(format!(
                "invalid log_level_stdout: {}",
                self.log_level_stdout
            ))
        })?;

        let log_path = self.effective_log_file()?;

        // Ensure the log directory exists.
        if let Some(parent) = log_path.parent() {
            std::fs::create_dir_all(parent).map_err(|e| {
                Error::Config(format!(
                    "failed to create log directory {}: {e}",
                    parent.display()
                ))
            })?;
        }

        let log_file = std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(&log_path)
            .map_err(|e| {
                Error::Config(format!(
                    "failed to open log file {}: {e}",
                    log_path.display()
                ))
            })?;

        let file_layer = fmt::layer()
            .with_writer(std::sync::Mutex::new(log_file))
            .with_ansi(false)
            .with_filter(file_level);

        let stdout_layer = fmt::layer()
            .with_writer(std::io::stdout)
            .with_filter(stdout_level);

        tracing_subscriber::registry()
            .with(file_layer)
            .with(stdout_layer)
            .try_init()
            .map_err(|e| Error::Config(format!("failed to initialise logging: {e}")))?;

        Ok(())
    }
}