add configurable log format and level (#822)

Related to #815 

Adds configurable logging output via `general.log_format` and
`general.log_level`.

- add `log_format` with `text` and `json` modes
- add `log_level` using `RUST_LOG` compatible filter syntax
- initialize logging from config during startup
- update `example.pgdog.toml` and generated JSON schema

Author: levish0

.schema/pgdog.schema.json

@@ -62,6 +62,8 @@
         "load_schema": "auto",
         "log_connections": true,
         "log_disconnections": true,
+        "log_format": "text",
+        "log_level": "info",
         "lsn_check_delay": 9223372036854775807,
         "lsn_check_interval": 5000,
         "lsn_check_timeout": 5000,
@@ -769,6 +771,16 @@
           "type": "boolean",
           "default": true
         },
+        "log_format": {
+          "description": "Format to use for PgDog application logs.\n\n_Default:_ `text`\n\nhttps://docs.pgdog.dev/configuration/pgdog.toml/general/#log_format",
+          "$ref": "#/$defs/LogFormat",
+          "default": "text"
+        },
+        "log_level": {
+          "description": "Log filter directives using the same syntax as the `RUST_LOG` environment variable.\n\n_Default:_ `info`\n\nhttps://docs.pgdog.dev/configuration/pgdog.toml/general/#log_level",
+          "type": "string",
+          "default": "info"
+        },
         "lsn_check_delay": {
           "description": "For how long to delay checking for replication delay.\n\nhttps://docs.pgdog.dev/configuration/pgdog.toml/general/#lsn_check_delay",
           "type": "integer",
@@ -1090,6 +1102,21 @@
         }
       ]
     },
+    "LogFormat": {
+      "description": "Format to use for PgDog application logs.",
+      "oneOf": [
+        {
+          "description": "Human-readable text logs (default).",
+          "type": "string",
+          "const": "text"
+        },
+        {
+          "description": "Structured JSON logs suitable for ECS/Datadog ingestion.",
+          "type": "string",
+          "const": "json"
+        }
+      ]
+    },
     "ManualQuery": {
       "description": "Queries with manual routing rules.",
       "type": "object",

Cargo.lock

@@ -131,6 +131,18 @@ openmetrics_port = 9090
 #
 # Default: none
 openmetrics_namespace = "pgdog_"
+# Log output format.
+#
+# Default: text
+#
+# Available options:
+# - text
+# - json
+log_format = "text"
+# Log filter directives using the same syntax as RUST_LOG.
+#
+# Default: info
+log_level = "info"
 # Configure levels of support for prepared statements.
 #
 # Default: enabled

example.pgdog.toml

@@ -1,8 +1,10 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::env;
+use std::fmt;
 use std::net::Ipv4Addr;
 use std::path::PathBuf;
+use std::str::FromStr;
 use std::time::Duration;
 
 use crate::pooling::ConnectionRecovery;
@@ -16,6 +18,38 @@ use super::database::{LoadBalancingStrategy, ReadWriteSplit, ReadWriteStrategy};
 use super::networking::TlsVerifyMode;
 use super::pooling::{PoolerMode, PreparedStatements};
 
+/// Format to use for PgDog application logs.
+#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq, Hash, Default, JsonSchema)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum LogFormat {
+    /// Human-readable text logs (default).
+    #[default]
+    Text,
+    /// Structured JSON logs suitable for ECS/Datadog ingestion.
+    Json,
+}
+
+impl fmt::Display for LogFormat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Text => f.write_str("text"),
+            Self::Json => f.write_str("json"),
+        }
+    }
+}
+
+impl FromStr for LogFormat {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_ascii_lowercase().as_str() {
+            "text" => Ok(Self::Text),
+            "json" => Ok(Self::Json),
+            _ => Err(()),
+        }
+    }
+}
+
 /// General settings are relevant to the operations of the pooler itself, or apply to all database pools.
 ///
 /// https://docs.pgdog.dev/configuration/pgdog.toml/general/
@@ -407,6 +441,22 @@ pub struct General {
     #[serde(default)]
     pub pub_sub_channel_size: usize,
 
+    /// Format to use for PgDog application logs.
+    ///
+    /// _Default:_ `text`
+    ///
+    /// https://docs.pgdog.dev/configuration/pgdog.toml/general/#log_format
+    #[serde(default = "General::log_format")]
+    pub log_format: LogFormat,
+
+    /// Log filter directives using the same syntax as the `RUST_LOG` environment variable.
+    ///
+    /// _Default:_ `info`
+    ///
+    /// https://docs.pgdog.dev/configuration/pgdog.toml/general/#log_level
+    #[serde(default = "General::log_level")]
+    pub log_level: String,
+
     /// If enabled, log every time a user creates a new connection to PgDog.
     ///
     /// _Default:_ `true`
@@ -642,6 +692,8 @@ impl Default for General {
             cross_shard_disabled: Self::cross_shard_disabled(),
             dns_ttl: Self::default_dns_ttl(),
             pub_sub_channel_size: Self::pub_sub_channel_size(),
+            log_format: Self::log_format(),
+            log_level: Self::log_level(),
             log_connections: Self::log_connections(),
             log_disconnections: Self::log_disconnections(),
             two_phase_commit: bool::default(),
@@ -1003,6 +1055,14 @@ impl General {
         Self::env_or_default("PGDOG_QUERY_CACHE_LIMIT", 50_000)
     }
 
+    pub fn log_format() -> LogFormat {
+        Self::env_enum_or_default("PGDOG_LOG_FORMAT")
+    }
+
+    pub fn log_level() -> String {
+        env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string())
+    }
+
     pub fn log_connections() -> bool {
         Self::env_bool_or_default("PGDOG_LOG_CONNECTIONS", true)
     }
@@ -1364,6 +1424,21 @@ mod tests {
         assert_eq!(General::log_disconnections(), true);
     }
 
+    #[test]
+    fn test_env_log_settings() {
+        env::set_var("PGDOG_LOG_FORMAT", "json");
+        env::set_var("RUST_LOG", "pgdog=debug,info");
+
+        assert_eq!(General::log_format(), LogFormat::Json);
+        assert_eq!(General::log_level(), "pgdog=debug,info");
+
+        env::remove_var("PGDOG_LOG_FORMAT");
+        env::remove_var("RUST_LOG");
+
+        assert_eq!(General::log_format(), LogFormat::Text);
+        assert_eq!(General::log_level(), "info");
+    }
+
     #[test]
     fn test_env_other_fields() {
         env::set_var("PGDOG_BROADCAST_ADDRESS", "192.168.1.100");

pgdog-config/src/general.rs

@@ -24,7 +24,7 @@ pub use database::{
     Database, EnumeratedDatabase, LoadBalancingStrategy, ReadWriteSplit, ReadWriteStrategy, Role,
 };
 pub use error::Error;
-pub use general::General;
+pub use general::{General, LogFormat};
 pub use memory::*;
 pub use networking::{MultiTenant, Tcp, TlsVerifyMode};
 pub use overrides::Overrides;

pgdog-config/src/lib.rs

@@ -20,7 +20,7 @@ tui = ["ratatui"]
 pin-project = "1"
 tokio = { version = "1", features = ["full"] }
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter", "std"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json", "std"] }
 parking_lot = "0.12"
 thiserror = "2"
 bytes = "1"

pgdog/Cargo.toml

@@ -1 +1 @@
-pub use pgdog_config::general::General;
+pub use pgdog_config::general::{General, LogFormat};

pgdog/src/config/general.rs

@@ -18,7 +18,7 @@ pub mod users;
 pub use core::{Config, ConfigAndUsers};
 pub use database::{Database, Role};
 pub use error::Error;
-pub use general::General;
+pub use general::{General, LogFormat};
 pub use memory::*;
 pub use networking::{MultiTenant, Tcp, TlsVerifyMode};
 pub use overrides::Overrides;

pgdog/src/config/mod.rs

@@ -19,6 +19,7 @@ pub mod tui;
 pub mod unique_id;
 pub mod util;
 
+use pgdog_config::{General, LogFormat};
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 
@@ -41,19 +42,56 @@ static GLOBAL: &stats_alloc::StatsAlloc<System> = &stats_alloc::INSTRUMENTED_SYS
 /// Using try_init and ignoring errors to allow
 /// for use in tests (setting up multiple times).
 pub fn logger() {
-    let format = fmt::layer()
-        .with_ansi(std::io::stderr().is_terminal())
-        .with_writer(std::io::stderr)
-        .with_file(false);
-    #[cfg(not(debug_assertions))]
-    let format = format.with_target(false);
-
-    let filter = EnvFilter::builder()
-        .with_default_directive(LevelFilter::INFO.into())
-        .from_env_lossy();
-
-    let _ = tracing_subscriber::registry()
-        .with(format)
-        .with(filter)
-        .try_init();
+    init_logger(None);
+}
+
+/// Setup the logger using PgDog configuration.
+pub fn logger_with_config(general: &General) {
+    init_logger(Some(general));
+}
+
+fn init_logger(general: Option<&General>) {
+    let filter = match general {
+        Some(general) => EnvFilter::builder()
+            .with_default_directive(LevelFilter::INFO.into())
+            .parse_lossy(general.log_level.as_str()),
+        None => EnvFilter::builder()
+            .with_default_directive(LevelFilter::INFO.into())
+            .from_env_lossy(),
+    };
+
+    match general
+        .map(|general| general.log_format)
+        .unwrap_or_default()
+    {
+        LogFormat::Text => {
+            let format = fmt::layer()
+                .with_ansi(std::io::stderr().is_terminal())
+                .with_writer(std::io::stderr)
+                .with_file(false);
+            #[cfg(not(debug_assertions))]
+            let format = format.with_target(false);
+
+            let _ = tracing_subscriber::registry()
+                .with(format)
+                .with(filter)
+                .try_init();
+        }
+        LogFormat::Json => {
+            let format = fmt::layer()
+                .json()
+                .with_ansi(false)
+                .with_writer(std::io::stderr)
+                .with_file(false)
+                .with_current_span(false)
+                .with_span_list(false);
+            #[cfg(not(debug_assertions))]
+            let format = format.with_target(false);
+
+            let _ = tracing_subscriber::registry()
+                .with(format)
+                .with(filter)
+                .try_init();
+        }
+    }
 }