2022-02-09 10:28:59 +00:00
|
|
|
// logger.rs
|
|
|
|
//
|
|
|
|
// Copyright 2022 Stéphane Cerveau <scerveau@collabora.com>
|
|
|
|
//
|
|
|
|
// This file is part of GstPipelineStudio
|
|
|
|
//
|
|
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
|
2022-01-17 13:39:26 +00:00
|
|
|
use gtk::glib::Sender;
|
2022-01-13 16:24:02 +00:00
|
|
|
use log::{debug, error, info, trace, warn};
|
|
|
|
use simplelog::*;
|
2022-01-04 16:48:32 +00:00
|
|
|
use std::fmt;
|
2022-01-13 16:24:02 +00:00
|
|
|
use std::io;
|
2022-01-04 16:48:32 +00:00
|
|
|
|
2022-01-13 16:24:02 +00:00
|
|
|
use std::fs::File;
|
2022-01-04 16:48:32 +00:00
|
|
|
|
|
|
|
#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
|
2022-01-13 16:24:02 +00:00
|
|
|
|
2022-01-04 16:48:32 +00:00
|
|
|
pub enum LogLevel {
|
2022-02-16 16:07:57 +00:00
|
|
|
Off,
|
2022-01-04 16:48:32 +00:00
|
|
|
Error,
|
2022-01-10 17:33:08 +00:00
|
|
|
Warning,
|
2022-01-04 16:48:32 +00:00
|
|
|
Info,
|
|
|
|
Debug,
|
2022-01-13 16:24:02 +00:00
|
|
|
Trace,
|
2022-01-04 16:48:32 +00:00
|
|
|
}
|
2022-02-16 16:07:57 +00:00
|
|
|
|
|
|
|
impl LogLevel {
|
|
|
|
pub fn from_u32(value: u32) -> LogLevel {
|
|
|
|
match value {
|
|
|
|
0 => LogLevel::Off,
|
|
|
|
1 => LogLevel::Error,
|
|
|
|
2 => LogLevel::Warning,
|
|
|
|
3 => LogLevel::Info,
|
|
|
|
4 => LogLevel::Debug,
|
|
|
|
5 => LogLevel::Trace,
|
|
|
|
_ => panic!("Unknown value: {}", value),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-04 16:48:32 +00:00
|
|
|
impl fmt::Display for LogLevel {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2023-02-13 15:38:33 +00:00
|
|
|
write!(f, "{self:?}")
|
2022-01-04 16:48:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! GPS_ERROR (
|
|
|
|
() => ($crate::print!("\n"));
|
|
|
|
($($arg:tt)*) => ({
|
|
|
|
logger::print_log(logger::LogLevel::Error, format_args!($($arg)*).to_string());
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! GPS_WARN (
|
|
|
|
() => ($crate::print!("\n"));
|
|
|
|
($($arg:tt)*) => ({
|
|
|
|
logger::print_log(logger::LogLevel::Warning, format_args!($($arg)*).to_string());
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! GPS_INFO (
|
|
|
|
() => ($crate::print!("\n"));
|
|
|
|
($($arg:tt)*) => ({
|
|
|
|
logger::print_log(logger::LogLevel::Info, format_args!($($arg)*).to_string());
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[macro_export]
|
2022-01-13 16:24:02 +00:00
|
|
|
macro_rules! GPS_DEBUG (
|
2022-01-04 16:48:32 +00:00
|
|
|
() => ($crate::print!("\n"));
|
|
|
|
($($arg:tt)*) => ({
|
2022-01-13 16:24:02 +00:00
|
|
|
logger::print_log(logger::LogLevel::Debug, format_args!($($arg)*).to_string());
|
2022-01-04 16:48:32 +00:00
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[macro_export]
|
2022-01-13 16:24:02 +00:00
|
|
|
macro_rules! GPS_TRACE (
|
2022-01-04 16:48:32 +00:00
|
|
|
() => ($crate::print!("\n"));
|
|
|
|
($($arg:tt)*) => ({
|
2022-01-13 16:24:02 +00:00
|
|
|
logger::print_log(logger::LogLevel::Trace, format_args!($($arg)*).to_string());
|
2022-01-04 16:48:32 +00:00
|
|
|
})
|
|
|
|
);
|
|
|
|
|
2022-01-13 16:24:02 +00:00
|
|
|
struct WriteAdapter {
|
|
|
|
sender: Sender<String>,
|
|
|
|
buffer: String,
|
2022-01-04 16:48:32 +00:00
|
|
|
}
|
|
|
|
|
2022-01-13 16:24:02 +00:00
|
|
|
impl io::Write for WriteAdapter {
|
|
|
|
// On write we forward each u8 of the buffer to the sender and return the length of the buffer
|
|
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
|
|
self.buffer
|
|
|
|
.push_str(&String::from_utf8(buf.to_vec()).unwrap());
|
|
|
|
if self.buffer.ends_with('\n') {
|
|
|
|
self.buffer.pop();
|
|
|
|
self.sender.send(self.buffer.clone()).unwrap();
|
|
|
|
self.buffer = String::from("");
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(buf.len())
|
|
|
|
}
|
2022-01-04 16:48:32 +00:00
|
|
|
|
2022-01-13 16:24:02 +00:00
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
|
|
Ok(())
|
2022-01-04 16:48:32 +00:00
|
|
|
}
|
|
|
|
}
|
2022-01-13 16:24:02 +00:00
|
|
|
|
|
|
|
fn translate_to_simple_logger(log_level: LogLevel) -> LevelFilter {
|
|
|
|
match log_level {
|
2022-02-16 16:07:57 +00:00
|
|
|
LogLevel::Off => LevelFilter::Off,
|
2022-01-13 16:24:02 +00:00
|
|
|
LogLevel::Error => LevelFilter::Error,
|
|
|
|
LogLevel::Warning => LevelFilter::Warn,
|
|
|
|
LogLevel::Info => LevelFilter::Info,
|
|
|
|
LogLevel::Debug => LevelFilter::Debug,
|
|
|
|
LogLevel::Trace => LevelFilter::Trace,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn init_logger(sender: Sender<String>, log_file: &str) {
|
|
|
|
simplelog::CombinedLogger::init(vec![
|
|
|
|
WriteLogger::new(
|
|
|
|
translate_to_simple_logger(LogLevel::Trace),
|
|
|
|
Config::default(),
|
2022-11-17 12:02:02 +00:00
|
|
|
File::create(log_file).unwrap_or_else(|_| panic!("Unable to create log {}", log_file)),
|
2022-01-13 16:24:02 +00:00
|
|
|
),
|
|
|
|
WriteLogger::new(
|
|
|
|
translate_to_simple_logger(LogLevel::Debug),
|
|
|
|
Config::default(),
|
|
|
|
WriteAdapter {
|
|
|
|
sender,
|
|
|
|
buffer: String::from(""),
|
|
|
|
},
|
|
|
|
),
|
|
|
|
TermLogger::new(
|
|
|
|
LevelFilter::Info,
|
|
|
|
Config::default(),
|
|
|
|
TerminalMode::Mixed,
|
|
|
|
ColorChoice::Auto,
|
|
|
|
),
|
|
|
|
])
|
|
|
|
.unwrap();
|
|
|
|
}
|
|
|
|
|
2022-02-16 16:07:57 +00:00
|
|
|
pub fn set_log_level(level: LogLevel) {
|
|
|
|
log::set_max_level(translate_to_simple_logger(level));
|
|
|
|
}
|
|
|
|
|
2022-01-13 16:24:02 +00:00
|
|
|
pub fn print_log(log_level: LogLevel, msg: String) {
|
|
|
|
match log_level {
|
|
|
|
LogLevel::Error => {
|
|
|
|
error!("{}", msg);
|
|
|
|
}
|
|
|
|
LogLevel::Warning => {
|
|
|
|
warn!("{}", msg);
|
|
|
|
}
|
|
|
|
LogLevel::Info => {
|
|
|
|
info!("{}", msg);
|
|
|
|
}
|
|
|
|
LogLevel::Debug => {
|
|
|
|
debug!("{}", msg);
|
|
|
|
}
|
|
|
|
LogLevel::Trace => {
|
|
|
|
trace!("{}", msg);
|
|
|
|
}
|
2022-02-16 16:07:57 +00:00
|
|
|
_ => {}
|
2022-01-13 16:24:02 +00:00
|
|
|
};
|
|
|
|
}
|