add support for multiple log formats (#517)

this commit adds the tracing-subscriber crate and use its formatters to
support multiple log formats.

More details in
https://github.com/postgresml/pgcat/issues/464#issuecomment-1641430299

Signed-off-by: Sebastian Webber <sebastian@swebber.me>

src/cmd_args.rs

@@ -1,17 +1,27 @@
-use clap::Parser;
-use log::LevelFilter;
+use clap::{Parser, ValueEnum};
+use tracing::Level;
 
 /// PgCat: Nextgen PostgreSQL Pooler
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
-pub(crate) struct Args {
+pub struct Args {
     #[arg(default_value_t = String::from("pgcat.toml"), env)]
     pub config_file: String,
 
-    #[arg(short, long, default_value_t = LevelFilter::Info, env)]
-    pub log_level: log::LevelFilter,
+    #[arg(short, long, default_value_t = tracing::Level::INFO, env)]
+    pub log_level: Level,
+
+    #[clap(short='F', long, value_enum, default_value_t=LogFormat::Text, env)]
+    pub log_format: LogFormat,
 }
 
-pub(crate) fn parse() -> Args {
+pub fn parse() -> Args {
     return Args::parse();
 }
+
+#[derive(ValueEnum, Clone, Debug)]
+pub enum LogFormat {
+    Text,
+    Structured,
+    Debug,
+}

src/lib.rs

@@ -1,13 +1,13 @@
 pub mod admin;
 pub mod auth_passthrough;
 pub mod client;
+pub mod cmd_args;
 pub mod config;
 pub mod constants;
 pub mod dns_cache;
 pub mod errors;
 pub mod messages;
 pub mod mirrors;
-pub mod multi_logger;
 pub mod plugins;
 pub mod pool;
 pub mod prometheus;

src/main.rs

@@ -61,18 +61,31 @@ use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::broadcast;
 
+use pgcat::cmd_args;
+use pgcat::cmd_args::LogFormat;
 use pgcat::config::{get_config, reload_config, VERSION};
 use pgcat::dns_cache;
 use pgcat::messages::configure_socket;
 use pgcat::pool::{ClientServerMap, ConnectionPool};
 use pgcat::prometheus::start_metric_server;
 use pgcat::stats::{Collector, Reporter, REPORTER};
-
-mod cmd_args;
+use tracing_subscriber;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = cmd_args::parse();
-    pgcat::multi_logger::MultiLogger::init(args.log_level).unwrap();
+    match args.log_format {
+        LogFormat::Structured => tracing_subscriber::fmt()
+            .json()
+            .with_max_level(args.log_level)
+            .init(),
+        LogFormat::Debug => tracing_subscriber::fmt()
+            .pretty()
+            .with_max_level(args.log_level)
+            .init(),
+        _ => tracing_subscriber::fmt()
+            .with_max_level(args.log_level)
+            .init(),
+    };
 
     info!("Welcome to PgCat! Meow. (Version {})", VERSION);
 

src/multi_logger.rs

@@ -1,83 +0,0 @@
-use log::{Level, LevelFilter, Log, Metadata, Record, SetLoggerError};
-
-// This is a special kind of logger that allows sending logs to different
-// targets depending on the log level.
-//
-// By default, if nothing is set, it acts as a regular env_log logger,
-// it sends everything to standard error.
-//
-// If the Env variable `STDOUT_LOG` is defined, it will be used for
-// configuring the standard out logger.
-//
-// The behavior is:
-//   - If it is an error, the message is written to standard error.
-//   - If it is not, and it matches the log level of the standard output logger (`STDOUT_LOG` env var), it will be send to standard output.
-//   - If the above is not true, it is sent to the stderr logger that will log it or not depending on the value
-//     of the RUST_LOG env var.
-//
-// So to summarize, if no `STDOUT_LOG` env var is present, the logger is the default logger. If `STDOUT_LOG` is set, everything
-// but errors, that matches the log level set in the `STDOUT_LOG` env var is sent to stdout. You can have also some esoteric configuration
-// where you set `RUST_LOG=debug` and `STDOUT_LOG=info`, in here, errors will go to stderr, warns and infos to stdout and debugs to stderr.
-//
-pub struct MultiLogger {
-    stderr_logger: env_logger::Logger,
-    stdout_logger: env_logger::Logger,
-}
-
-impl MultiLogger {
-    fn new(filter: LevelFilter) -> Self {
-        let stderr_logger = env_logger::builder()
-            .filter(None, filter)
-            .format_timestamp_micros()
-            .build();
-        let stdout_logger = env_logger::Builder::from_env("STDOUT_LOG")
-            .format_timestamp_micros()
-            .target(env_logger::Target::Stdout)
-            .build();
-
-        Self {
-            stderr_logger,
-            stdout_logger,
-        }
-    }
-
-    pub fn init(filter: LevelFilter) -> Result<(), SetLoggerError> {
-        let logger = Self::new(filter);
-
-        log::set_max_level(logger.stderr_logger.filter());
-        log::set_boxed_logger(Box::new(logger))
-    }
-}
-
-impl Log for MultiLogger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.stderr_logger.enabled(metadata) && self.stdout_logger.enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        if record.level() == Level::Error {
-            self.stderr_logger.log(record);
-        } else {
-            if self.stdout_logger.matches(record) {
-                self.stdout_logger.log(record);
-            } else {
-                self.stderr_logger.log(record);
-            }
-        }
-    }
-
-    fn flush(&self) {
-        self.stderr_logger.flush();
-        self.stdout_logger.flush();
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_init() {
-        MultiLogger::init(LevelFilter::Error).unwrap();
-    }
-}