unkey 0.6.0

An asynchronous Rust SDK for the Unkey API.
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
89
90
91

lazy_static::lazy_static! {
    /// An environment variable containing the log level env var.
    pub(crate) static ref UNKEY_LOG: Log = match option_env!("UNKEY_LOG") {
        None => Log::None,
        Some(level) => match level {
           "debug" | "DEBUG" => Log::Debug,
           "info" | "INFO" => Log::Info,
           "error" | "ERROR" => Log::Error,
           _ => {
               eprintln!("Invalid UNKEY_LOG level detected: {level}");
               Log::None
           }
        }
    };
}

/// The different logging levels supported by the crate.
#[derive(Eq, PartialEq, PartialOrd)]
pub(crate) enum Log {
    None,
    Error,
    Info,
    Debug,
}

impl From<&Log> for String {
    fn from(val: &Log) -> String {
        let message = match val {
            Log::Debug => "[DEBUG]",
            Log::Info => "[INFO] ",
            Log::Error => "[ERROR]",
            Log::None => "",
        };

        message.to_string()
    }
}

impl From<Log> for String {
    fn from(val: Log) -> String {
        (&val).into()
    }
}

impl std::fmt::Display for Log {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s: String = self.into();
        write!(f, "{s}")
    }
}

/// Logs the given message at the given level.
macro_rules! log {
    ($level:expr, $message:expr) => {
        if *$crate::logging::UNKEY_LOG >= $level {
            match $level {
                $crate::logging::Log::None => (),
                $crate::logging::Log::Error => eprintln!("{} {}", $level, $message),
                $crate::logging::Log::Info | $crate::logging::Log::Debug => {
                    println!("{} {}", $level, $message)
                }
            }
        }
    };
}

/// Logs the given message at the debug level.
macro_rules! debug {
    ($message:expr) => {
        $crate::logging::log!($crate::logging::Log::Debug, $message)
    };
}

/// Logs the given message at the infomation level.
macro_rules! info {
    ($message:expr) => {
        $crate::logging::log!($crate::logging::Log::Info, $message)
    };
}

/// Logs the given message at the error level.
macro_rules! error {
    ($message:expr) => {
        $crate::logging::log!($crate::logging::Log::Error, $message)
    };
}

pub(crate) use debug;
pub(crate) use error;
pub(crate) use info;
pub(crate) use log;