v/vlib/log/log.v

186 lines
4.7 KiB
V
Raw Normal View History

// 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.
2019-06-26 02:14:38 +02:00
module log
2020-04-26 13:49:31 +02:00
import os
import time
import term
2019-06-26 02:14:38 +02:00
// Level defines possible log levels used by `Log`
2020-04-06 17:22:53 +02:00
pub enum Level {
2019-12-01 10:50:13 +01:00
fatal = 1
2019-11-25 05:50:59 +01:00
error
2019-12-01 10:50:13 +01:00
warn
2019-11-25 05:50:59 +01:00
info
debug
}
pub enum LogTarget {
console
file
both
}
// tag returns the tag for log level `l` as a string.
2021-01-08 11:26:37 +01:00
fn tag_to_cli(l Level) string {
2019-11-25 05:50:59 +01:00
return match l {
.fatal { term.red('FATAL') }
.error { term.red('ERROR') }
2020-07-23 07:02:53 +02:00
.warn { term.yellow('WARN ') }
.info { term.white('INFO ') }
.debug { term.blue('DEBUG') }
2019-11-25 05:50:59 +01:00
}
}
2021-01-08 11:26:37 +01:00
// 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 {
2019-11-25 05:50:59 +01:00
fatal(s string)
error(s string)
warn(s string)
info(s string)
debug(s string)
}
// Log represents a logging object
2019-10-28 16:53:02 +01:00
pub struct Log {
2019-12-01 10:50:13 +01:00
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
2019-06-26 02:14:38 +02:00
}
// set_level sets the internal logging to `level`.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) set_level(level Level) {
2020-04-06 17:22:53 +02:00
l.level = level
2019-11-25 05:50:59 +01:00
}
// set_output_level sets the internal logging output to `level`.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) set_output_level(level Level) {
2019-11-25 05:50:59 +01:00
l.level = level
2019-06-26 02:14:38 +02:00
}
// set_full_logpath sets the output label and output path from `full_log_path`.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) set_full_logpath(full_log_path string) {
2020-07-23 07:02:53 +02:00
rlog_file := os.real_path(full_log_path)
l.set_output_label(os.file_name(rlog_file))
2020-10-01 01:30:22 +02:00
l.set_output_path(os.dir(rlog_file))
}
2019-12-01 10:50:13 +01:00
// set_output_label sets the `label` for the output.
2020-07-23 07:02:53 +02:00
pub fn (mut l Log) set_output_label(label string) {
2019-11-25 05:50:59 +01:00
l.output_label = label
2019-07-24 17:50:29 +02:00
}
// set_output_path sets the file to which output is logged to.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) set_output_path(output_file_path string) {
if l.ofile.is_opened {
2020-07-23 07:02:53 +02:00
l.ofile.close()
}
l.output_target = .file
2020-07-23 07:02:53 +02:00
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')
2019-12-01 10:50:13 +01:00
}
l.ofile = ofile
2019-11-25 05:50:59 +01:00
}
// 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.
2020-07-23 07:02:53 +02:00
pub fn (mut l Log) flush() {
l.ofile.flush()
}
// close closes the log file.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) close() {
2020-07-23 07:02:53 +02:00
l.ofile.close()
2019-12-01 10:50:13 +01:00
}
// log_file writes log line `s` with `level` to the log file.
2020-05-17 13:51:18 +02:00
fn (mut l Log) log_file(s string, level Level) {
2019-11-25 05:50:59 +01:00
timestamp := time.now().format_ss()
2021-01-08 11:26:37 +01:00
e := tag_to_file(level)
l.ofile.writeln('$timestamp [$e] $s') or { panic(err) }
2019-11-25 05:50:59 +01:00
}
// log_cli writes log line `s` with `level` to stdout.
2020-04-06 17:22:53 +02:00
fn (l &Log) log_cli(s string, level Level) {
timestamp := time.now().format_ss()
e := tag_to_cli(level)
println('$timestamp [$e] $s')
2019-07-24 17:50:29 +02:00
}
// 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.
2021-04-02 12:53:29 +02:00
pub fn (mut l Log) send_output(s &string, level Level) {
if l.output_target == .file || l.output_target == .both {
2019-12-01 10:50:13 +01:00
l.log_file(s, level)
}
if l.output_target == .console || l.output_target == .both {
2019-12-01 10:50:13 +01:00
l.log_cli(s, level)
2019-11-25 05:50:59 +01:00
}
2019-06-26 02:14:38 +02:00
}
// fatal logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.fatal` category.
2020-07-23 07:02:53 +02:00
pub fn (mut l Log) fatal(s string) {
if int(l.level) < int(Level.fatal) {
2020-07-23 07:02:53 +02:00
return
}
2019-12-01 10:50:13 +01:00
l.send_output(s, .fatal)
l.ofile.close()
panic('$l.output_label: $s')
}
2019-11-25 05:50:59 +01:00
// error logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.error` category.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) error(s string) {
if int(l.level) < int(Level.error) {
2020-07-23 07:02:53 +02:00
return
}
2019-12-01 10:50:13 +01:00
l.send_output(s, .error)
2019-06-26 02:14:38 +02:00
}
// warn logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.warn` category.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) warn(s string) {
if int(l.level) < int(Level.warn) {
2020-07-23 07:02:53 +02:00
return
}
2019-12-01 10:50:13 +01:00
l.send_output(s, .warn)
2019-06-26 02:14:38 +02:00
}
// info logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.info` category.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) info(s string) {
if int(l.level) < int(Level.info) {
2020-07-23 07:02:53 +02:00
return
}
2019-12-01 10:50:13 +01:00
l.send_output(s, .info)
2019-06-26 02:14:38 +02:00
}
// debug logs line `s` via `send_output` if `Log.level` is greater than or equal to the `Level.debug` category.
2020-05-17 13:51:18 +02:00
pub fn (mut l Log) debug(s string) {
if int(l.level) < int(Level.debug) {
2020-07-23 07:02:53 +02:00
return
}
2019-12-01 10:50:13 +01:00
l.send_output(s, .debug)
2019-07-16 17:59:07 +02:00
}