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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use tracing::{info, trace, debug, warn, error};
use crate::Tracer;

#[derive(Debug)]
pub struct Trace {
    name: String,
    is_silent: bool,
}

impl Default for Trace {
    fn default() -> Trace {
        return Trace::from("default");
    }
}

impl Tracer for Trace {
    fn name(&self) -> &str {
        return &self.name;
    }

    fn child(&self, child_name: &str) -> Box<dyn Tracer> {
        let parent_name = format!("{}:{}", self.name, child_name);

        return Box::new(
            Trace::from(parent_name)
                .as_silent(self.is_silent),
        );
    }

    fn trace(&self, message: &str) -> &dyn Tracer {
        if self.is_silent {
            return self;
        }

        trace!("{}", self.get_log_message(message));

        return self;
    }

    fn debug(&self, message: &str) -> &dyn Tracer {
        if self.is_silent {
            return self;
        }

        debug!("{}", self.get_log_message(message));

        return self;
    }

    fn info(&self, message: &str) -> &dyn Tracer {
        if self.is_silent {
            return self;
        }

        info!("{}", self.get_log_message(message));

        return self;
    }

    fn warn(&self, message: &str) -> &dyn Tracer {
        if self.is_silent {
            return self;
        }

        warn!("{}", self.get_log_message(message));

        return self;
    }

    fn error(&self, message: &str) -> &dyn Tracer {
        if self.is_silent {
            return self;
        }

        error!("{}", self.get_log_message(message));

        return self;
    }
}

impl Trace {
    fn get_log_message(&self, message: &str) -> String {
        if message.trim().len() == 0 {
            return format!("{}", self.name);
        }

        return format!("{} -> {}", self.name, message);
    }

    pub fn as_silent(mut self, is_silent: bool) -> Self {
        self.is_silent = is_silent;

        return self;
    }

    pub fn name(&self) -> &str {
        return Tracer::name(self);
    }

    pub fn child(&self, child_name: &str) -> Box<dyn Tracer> {
        return Tracer::child(self, child_name);
    }

    pub fn trace(&self, message: &str) -> &dyn Tracer {
        return Tracer::trace(self, message);

    }

    pub fn debug(&self, message: &str) -> &dyn Tracer {
        return Tracer::debug(self, message);
    }

    pub fn info(&self, message: &str) -> &dyn Tracer {
        return Tracer::info(self, message);

    }

    pub fn warn(&self, message: &str) -> &dyn Tracer {
        return Tracer::warn(self, message);

    }

    pub fn error(&self, message: &str) -> &dyn Tracer {
        return Tracer::error(self, message);

    }
}

impl<T: ToString> From<T> for Trace {
    fn from(name: T) -> Self {
        let name = name.to_string();

        return Trace { name, is_silent: false };
    }
}