devoyage-subgraph 0.0.15

Subgraph is a CLI that instantly generates a GraphQL API around Mongo, SQL, and HTTP APIs.
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

use env_logger::Env;
use log::Level;
use serde::{Deserialize, Serialize};
use std::io::Write;
use std::{fmt, str::FromStr};

use crate::{cli_args::CliArgs, configuration::subgraph::SubGraphConfig};

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "lowercase")]
pub enum LogLevelEnum {
    Error,
    Warn,
    Info,
    Debug,
    Trace,
}

impl fmt::Display for LogLevelEnum {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let variant_str = match self {
            LogLevelEnum::Error => "error",
            LogLevelEnum::Warn => "warn",
            LogLevelEnum::Info => "info",
            LogLevelEnum::Debug => "debug",
            LogLevelEnum::Trace => "trace",
        };
        write!(f, "{}", variant_str)
    }
}

impl LogLevelEnum {
    pub fn parse_log_level(log_level_enum: LogLevelEnum) -> Level {
        match log_level_enum {
            LogLevelEnum::Error => Level::Error,
            LogLevelEnum::Warn => Level::Warn,
            LogLevelEnum::Info => Level::Info,
            LogLevelEnum::Debug => Level::Debug,
            LogLevelEnum::Trace => Level::Trace,
        }
    }
}

pub struct Logger;
impl Logger {
    pub fn init(args: &CliArgs, subgraph_config: &SubGraphConfig) {
        let log_level = match args.log_level.clone() {
            Some(level) => {
                let level_from_str = Level::from_str(&level);
                match level_from_str {
                    Ok(level) => level,
                    Err(_) => panic!("Failed to get log level from args."),
                }
            }
            None => match subgraph_config.clone().service.log_level {
                Some(level) => LogLevelEnum::parse_log_level(level),
                None => Level::Info,
            },
        };

        env_logger::Builder::from_env(Env::default().default_filter_or(log_level.to_string()))
            .format(|buf, record| {
                // Define color codes
                let color = match record.level() {
                    log::Level::Error => "\x1b[31m", // Red
                    log::Level::Warn => "\x1b[33m",  // Yellow
                    log::Level::Info => "\x1b[32m",  // Green
                    log::Level::Debug => "\x1b[34m", // Blue
                    log::Level::Trace => "\x1b[36m", // Cyan
                };

                // Reset color at the end
                let reset_color = "\x1b[0m";

                // Write the log message with color
                writeln!(
                    buf,
                    "{}[{}]{} {}{}",
                    color,
                    record.level(),
                    reset_color,
                    record.args(),
                    reset_color
                )
            })
            .init();
    }
}