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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module log
import os
import time
import term
// Level defines possible log levels used by `Log`
pub enum Level {
fatal = 1
error
warn
info
debug
}
pub enum LogTarget {
console
file
both
}
// tag returns the tag for log level `l` as a string.
fn tag_to_cli(l Level) string {
return match l {
.fatal { term.red('FATAL') }
.error { term.red('ERROR') }
.warn { term.yellow('WARN ') }
.info { term.white('INFO ') }
.debug { term.blue('DEBUG') }
}
}
// tag returns the tag for log level `l` as a string.
fn tag_to_file(l Level) string {
return match l {
.fatal { 'FATAL' }
.error { 'ERROR' }
.warn { 'WARN ' }
.info { 'INFO ' }
.debug { 'DEBUG' }
}
}
interface Logger {
fatal(s string)
error(s string)
warn(s string)
info(s string)
debug(s string)
}
// Log represents a logging object
pub struct Log {
mut:
level Level
output_label string
ofile os.File
output_target LogTarget // if true output to file else use stdout/stderr.
pub mut:
output_file_name string // log output to this file
}
// set_level sets the internal logging to `level`.
pub fn (mut l Log) set_level(level Level) {
l.level = level
}
// set_output_level sets the internal logging output to `level`.
pub fn (mut l Log) set_output_level(level Level) {
l.level = level
}
// set_full_logpath sets the output label and output path from `full_log_path`.
pub fn (mut l Log) set_full_logpath(full_log_path string) {
rlog_file := os.real_path(full_log_path)
l.set_output_label(os.file_name(rlog_file))
l.set_output_path(os.dir(rlog_file))
}
// set_output_label sets the `label` for the output.
pub fn (mut l Log) set_output_label(label string) {
l.output_label = label
}
// set_output_path sets the file to which output is logged to.
pub fn (mut l Log) set_output_path(output_file_path string) {
if l.ofile.is_opened {
l.ofile.close()
}
l.output_target = .file
l.output_file_name = os.join_path(os.real_path(output_file_path), l.output_label)
ofile := os.open_append(l.output_file_name) or {
panic('error while opening log file $l.output_file_name for appending')
}
l.ofile = ofile
}
// log_to_console_too turns on logging to the console too, in addition to logging to a file.
// You have to call it *after* calling .set_output_path(output_file_path).
pub fn (mut l Log) log_to_console_too() {
if l.output_target != .file {
panic('log_to_console_too should be called *after* .set_output_path')
}
l.output_target = .both
}
// flush writes the log file content to disk.
pub fn (mut l Log) flush() {
l.ofile.flush()
}
// close closes the log file.
pub fn (mut l Log) close() {
l.ofile.close()
}
// log_file writes log line `s` with `level` to the log file.
fn (mut l Log) log_file(s string, level Level) {
timestamp := time.now().format_ss()
e := tag_to_file(level)
l.ofile.writeln('$timestamp [$e] $s') or { panic(err) }
}
// log_cli writes log line `s` with `level` to stdout.
fn (l &Log) log_cli(s string, level Level) {
timestamp := time.now().format_ss()
e := tag_to_cli(level)
println('$timestamp [$e] $s')
}
// send_output writes log line `s` with `level` to either the log file or the console
// according to the value of the `.output_target` field.
pub fn (mut l Log) send_output(s &string, level Level) {
if l.output_target == .file || l.output_target == .both {
l.log_file(s, level)
}
if l.output_target == .console || l.output_target == .both {
l.log_cli(s, level)
}
}
// fatal logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.fatal` category.
pub fn (mut l Log) fatal(s string) {
if int(l.level) < int(Level.fatal) {
return
}
l.send_output(s, .fatal)
l.ofile.close()
panic('$l.output_label: $s')
}
// error logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.error` category.
pub fn (mut l Log) error(s string) {
if int(l.level) < int(Level.error) {
return
}
l.send_output(s, .error)
}
// warn logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.warn` category.
pub fn (mut l Log) warn(s string) {
if int(l.level) < int(Level.warn) {
return
}
l.send_output(s, .warn)
}
// info logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.info` category.
pub fn (mut l Log) info(s string) {
if int(l.level) < int(Level.info) {
return
}
l.send_output(s, .info)
}
// debug logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.debug` category.
pub fn (mut l Log) debug(s string) {
if int(l.level) < int(Level.debug) {
return
}
l.send_output(s, .debug)
}
|
