zeke 0.1.6

a http library for rust built on top of tokio
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
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

use std::{fs::{self, OpenOptions}, path::Path};
use std::io::Write;

#[derive(Debug, Clone,)]
pub enum Logs {
	Trace,
	ServerError,
    HttpTest,
	Debug,
	FuzzFail,
}

impl Logs {
    pub fn as_str(&self) -> &'static str {
        match *self {
			Logs::Trace => "trace.log",
			Logs::ServerError => "error.log",
            Logs::HttpTest => "test.log",
			Logs::Debug => "debug.log",
			Logs::FuzzFail => "fuzz_fail.log",
        }
    }
}

impl Copy for Logs {}

#[derive(Debug, Clone)]
pub struct Logger {
	log_root_dir: String,
	spawn_time: std::time::Instant,
	last_logged: std::time::Instant,
}
impl Logger {
	pub fn new() -> Self {
		Self {
			log_root_dir: "logs".to_string(),
			spawn_time: std::time::Instant::now(),
			last_logged: std::time::Instant::now(),
		}
	}
	pub fn reset_log(&self, file_name: Logs) {
		let file_path = format!("{}/{}", self.log_root_dir, file_name.as_str());
		let directory = Path::new(&self.log_root_dir);
		if !directory.exists() {
			fs::create_dir_all(directory).expect("Unable to create directory");
		}
		let mut file = OpenOptions::new()
			.create(true)
			.write(true)
			.truncate(true)
			.open(&file_path)
			.expect("Unable to open file");
		writeln!(file, "").expect("Unable to write to file");
	}
    pub fn elapsed(&self) -> String {
        let elapsed = self.spawn_time.elapsed();
		let micros = elapsed.as_micros();
		if micros < 1000 {
			return format!("{}µs", micros);
		}
		let millis = elapsed.as_millis();
		if millis < 1000 {
			return format!("{}ms", millis);
		}
		let seconds = elapsed.as_secs();
		if seconds < 60 {
			return format!("{}s", seconds);
		}
		return format!("{}ms", millis);

    }
	pub fn logged(&self) -> std::time::Duration {
		self.last_logged.elapsed()
	}
    pub fn log(&self, file_name: Logs, message: &str) {
        let file_path = format!("{}/{}", self.log_root_dir, file_name.as_str());
        let directory = Path::new(&self.log_root_dir);
        if !directory.exists() {
            fs::create_dir_all(directory).expect("Unable to create directory");
        }
        let mut file = OpenOptions::new()
            .create(true)
            .write(true)
            .append(true)
            .open(&file_path)
            .expect("Unable to open file");
        writeln!(file, "{:?}: {}", self.elapsed(), message).expect("Unable to write to file");
		writeln!(file, "\n").expect("Unable to write to file");
    }
    pub fn http(&self, file_name: Logs, label: &str, req: &String, res: &String) {
        let file_path = format!("{}/{}", self.log_root_dir, file_name.as_str());
        let directory = Path::new(&self.log_root_dir);
        if !directory.exists() {
            fs::create_dir_all(directory).expect("Unable to create directory");
        }
        let mut file = OpenOptions::new()
            .create(true)
            .write(true)
            .append(true)
            .open(&file_path)
            .expect("Unable to open file");
    
        writeln!(file, "{:?}: {}", self.elapsed(), label).expect("Unable to write to file");
		writeln!(file, "\treq: {:?}", req).expect("Unable to write to file");
		writeln!(file, "\tres: {:?}", res).expect("Unable to write to file");
        writeln!(file, "\n").expect("Unable to write to file");
    }
    pub fn dbg(&self, message: &str) {
        let file_path = format!("{}/{}", self.log_root_dir, Logs::Debug.as_str());
        let directory = Path::new(&self.log_root_dir);
        if !directory.exists() {
            fs::create_dir_all(directory).expect("Unable to create directory");
        }
        let mut file = OpenOptions::new()
            .create(true)
            .write(true)
            .append(true)
            .open(&file_path)
            .expect("Unable to open file");
        writeln!(file, "{:?}: {}", self.elapsed(), message).expect("Unable to write to file");
		writeln!(file, "\n").expect("Unable to write to file");
    }
}