//! Layered configuration. //! //! Precedence, lowest to highest: built-in defaults, TOML file, `SKYG_*` //! environment variables (`__` separates nesting, e.g. `SKYG_SERVER__PORT`), //! CLI overrides. //! //! No field is an `Option` so the effective config serializes to TOML. //! An empty string or empty list means "unset". use std::collections::BTreeMap; use std::net::{IpAddr, Ipv4Addr}; use std::path::{Path, PathBuf}; use figment::providers::{Env, Format, Serialized, Toml}; use figment::Figment; use serde::{Deserialize, Serialize}; /// Default config file location, used only when it exists and `--config` is absent. pub const DEFAULT_CONFIG_PATH: &str = "/etc/skyg-linux-tracker.toml"; /// Environment variable prefix. pub const ENV_PREFIX: &str = "SKYG_"; #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct Config { pub server: ServerConfig, pub auth: AuthConfig, pub otel: OtelConfig, pub sources: SourcesConfig, pub limits: LimitsConfig, } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct ServerConfig { /// Listen address. Non-loopback requires `auth.enabled = true`. pub bind: IpAddr, pub port: u16, /// Extra `Host` header values accepted on `/mcp`, added to the defaults /// (loopback names plus `bind`). pub allowed_hosts: Vec, /// Extra `Origin` values accepted on `/mcp`, added to the defaults /// (loopback origins plus `bind`). Entries include a scheme. pub allowed_origins: Vec, /// Optional native TLS (off by default). pub tls: TlsConfig, } /// Native TLS for REST and `/mcp`. Optional: when `enabled` is false the /// paths are ignored and never read. #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct TlsConfig { pub enabled: bool, /// PEM certificate chain (leaf first). pub cert_file: PathBuf, /// PEM private key (PKCS#8, PKCS#1 or SEC1). pub key_file: PathBuf, } impl ServerConfig { /// Host names always accepted: loopback plus `bind` (unless unspecified). pub fn default_hosts(&self) -> Vec { let mut v: Vec = ["localhost", "127.0.0.1", "::1"] .into_iter() .map(String::from) .collect(); if !self.bind.is_unspecified() { v.push(self.bind.to_string()); } v } } impl Default for ServerConfig { fn default() -> Self { Self { bind: IpAddr::V4(Ipv4Addr::LOCALHOST), port: 1984, allowed_hosts: Vec::new(), allowed_origins: Vec::new(), tls: TlsConfig::default(), } } } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct AuthConfig { pub enabled: bool, pub db_path: PathBuf, } impl Default for AuthConfig { fn default() -> Self { Self { enabled: true, db_path: PathBuf::from("/var/lib/skyg-linux-tracker/db.sqlite"), } } } #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] pub enum OtelProtocol { #[default] #[serde(rename = "grpc")] Grpc, #[serde(rename = "http/protobuf")] HttpProtobuf, } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct OtelConfig { pub enabled: bool, pub endpoint: String, pub protocol: OtelProtocol, pub service_name: String, /// Extra OTLP headers or gRPC metadata (for example `authorization`). pub headers: BTreeMap, pub export_unit_metrics: bool, pub export_logs: bool, pub metrics_interval_secs: u64, pub logs: OtelLogsConfig, pub metrics: OtelMetricsConfig, } impl Default for OtelConfig { fn default() -> Self { Self { enabled: false, endpoint: "http://localhost:4317".into(), protocol: OtelProtocol::Grpc, service_name: "skyg-linux-tracker".into(), headers: BTreeMap::new(), export_unit_metrics: true, export_logs: false, metrics_interval_secs: 30, logs: OtelLogsConfig::default(), metrics: OtelMetricsConfig::default(), } } } /// Which journal units / containers feed OTel logs. Empty means all. #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct OtelLogsConfig { pub journal_units: Vec, pub docker_containers: Vec, } /// Glob allowlists for exported metrics. /// /// Empty `units` means `*.service` and `*.timer`. Empty `containers` /// means all containers. #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct OtelMetricsConfig { pub units: Vec, pub containers: Vec, } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct SourcesConfig { pub docker_socket: PathBuf, /// Journal namespace. Empty means the default journal. pub journal_namespace: String, } impl Default for SourcesConfig { fn default() -> Self { Self { docker_socket: PathBuf::from("/var/run/docker.sock"), journal_namespace: String::new(), } } } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct LimitsConfig { /// Maximum journal lines per snapshot or MCP call. pub max_lines: usize, /// Maximum container log lines (`tail`). pub max_tail: usize, /// Maximum duration of a bounded follow, in seconds. pub max_follow_secs: u64, } impl Default for LimitsConfig { fn default() -> Self { Self { max_lines: 1000, max_tail: 1000, max_follow_secs: 60, } } } #[derive(Debug, thiserror::Error)] pub enum ConfigError { #[error("config file not found: {0}")] MissingFile(PathBuf), #[error("invalid configuration: {0}")] Load(Box), #[error("invalid configuration: {0}")] Invalid(String), } impl From for ConfigError { fn from(e: figment::Error) -> Self { Self::Load(Box::new(e)) } } /// Highest-precedence layer. Only `Some` fields are applied. #[derive(Debug, Clone, Default)] pub struct CliOverrides { pub bind: Option, pub port: Option, pub auth_enabled: Option, pub db_path: Option, pub docker_socket: Option, pub journal_namespace: Option, pub otel_enabled: Option, pub otel_endpoint: Option, } impl CliOverrides { fn apply(&self, mut fig: Figment) -> Figment { fn put(fig: Figment, key: &str, v: &Option) -> Figment { match v { Some(v) => fig.merge(Serialized::default(key, v)), None => fig, } } fig = put(fig, "server.bind", &self.bind); fig = put(fig, "server.port", &self.port); fig = put(fig, "auth.enabled", &self.auth_enabled); fig = put(fig, "auth.db_path", &self.db_path); fig = put(fig, "sources.docker_socket", &self.docker_socket); fig = put(fig, "sources.journal_namespace", &self.journal_namespace); fig = put(fig, "otel.enabled", &self.otel_enabled); fig = put(fig, "otel.endpoint", &self.otel_endpoint); fig } } impl Config { /// Build the merged config. /// /// `file`: explicit `--config` path (must exist). When `None`, the default /// path is read only if present. pub fn load(file: Option<&Path>, cli: &CliOverrides) -> Result { let mut fig = Figment::from(Serialized::defaults(Config::default())); match file { Some(p) => { if !p.exists() { return Err(ConfigError::MissingFile(p.to_path_buf())); } fig = fig.merge(Toml::file(p)); } None => { let p = Path::new(DEFAULT_CONFIG_PATH); if p.exists() { fig = fig.merge(Toml::file(p)); } } } fig = fig.merge(Env::prefixed(ENV_PREFIX).split("__")); fig = cli.apply(fig); let cfg: Config = fig.extract()?; cfg.validate()?; Ok(cfg) } /// Cross-field validation. pub fn validate(&self) -> Result<(), ConfigError> { if self.server.port == 0 { return Err(ConfigError::Invalid( "server.port must be greater than zero".into(), )); } let tls = &self.server.tls; if tls.enabled && (tls.cert_file.as_os_str().is_empty() || tls.key_file.as_os_str().is_empty()) { return Err(ConfigError::Invalid( "server.tls.enabled = true requires both server.tls.cert_file and server.tls.key_file" .into(), )); } if !self.auth.enabled && !self.server.bind.is_loopback() { return Err(ConfigError::Invalid(format!( "auth.enabled = false is only allowed on a loopback bind address (server.bind = {})", self.server.bind ))); } if self.limits.max_lines == 0 || self.limits.max_tail == 0 || self.limits.max_follow_secs == 0 { return Err(ConfigError::Invalid( "limits.* must be greater than zero".into(), )); } if self.otel.metrics_interval_secs == 0 { return Err(ConfigError::Invalid( "otel.metrics_interval_secs must be greater than zero".into(), )); } Ok(()) } /// Effective config as TOML, with OTLP header values redacted. pub fn to_toml_redacted(&self) -> Result { let mut c = self.clone(); for v in c.otel.headers.values_mut() { *v = "***".into(); } toml::to_string_pretty(&c) } } #[cfg(test)] #[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error mod tests { use super::*; use figment::Jail; fn load(file: Option<&str>, cli: &CliOverrides) -> Result { Config::load(file.map(Path::new), cli) } #[test] fn port_zero_rejected() { Jail::expect_with(|_| { let cli = CliOverrides { port: Some(0), ..Default::default() }; assert!(load(None, &cli).is_err()); Ok(()) }); } #[test] fn defaults_only() { Jail::expect_with(|_| { let c = load(None, &CliOverrides::default()).unwrap(); assert_eq!(c, Config::default()); assert_eq!(c.server.port, 1984); assert!(c.auth.enabled); assert_eq!(c.limits.max_lines, 1000); assert_eq!(c.limits.max_follow_secs, 60); Ok(()) }); } #[test] fn file_overrides_defaults() { Jail::expect_with(|jail| { jail.create_file( "c.toml", r#" [server] port = 8000 [otel.headers] authorization = "Bearer x" [otel.metrics] units = ["nginx.service"] [limits] max_lines = 50 "#, )?; let c = load(Some("c.toml"), &CliOverrides::default()).unwrap(); assert_eq!(c.server.port, 8000); assert_eq!(c.otel.headers["authorization"], "Bearer x"); assert_eq!(c.otel.metrics.units, vec!["nginx.service"]); assert_eq!(c.limits.max_lines, 50); assert_eq!(c.limits.max_tail, 1000); Ok(()) }); } #[test] fn env_overrides_file() { Jail::expect_with(|jail| { jail.create_file("c.toml", "[server]\nport = 8000\n")?; jail.set_env("SKYG_SERVER__PORT", "8100"); jail.set_env("SKYG_LIMITS__MAX_TAIL", "7"); let c = load(Some("c.toml"), &CliOverrides::default()).unwrap(); assert_eq!(c.server.port, 8100); assert_eq!(c.limits.max_tail, 7); Ok(()) }); } #[test] fn cli_overrides_env() { Jail::expect_with(|jail| { jail.create_file("c.toml", "[server]\nport = 8000\n")?; jail.set_env("SKYG_SERVER__PORT", "8100"); let cli = CliOverrides { port: Some(8200), ..Default::default() }; let c = load(Some("c.toml"), &cli).unwrap(); assert_eq!(c.server.port, 8200); Ok(()) }); } #[test] fn auth_off_with_public_bind_is_rejected() { Jail::expect_with(|jail| { jail.set_env("SKYG_AUTH__ENABLED", "false"); jail.set_env("SKYG_SERVER__BIND", "0.0.0.0"); assert!(matches!( load(None, &CliOverrides::default()), Err(ConfigError::Invalid(_)) )); jail.set_env("SKYG_SERVER__BIND", "127.0.0.1"); assert!(load(None, &CliOverrides::default()).is_ok()); Ok(()) }); } #[test] fn missing_explicit_file_is_error() { Jail::expect_with(|_| { assert!(matches!( load(Some("nope.toml"), &CliOverrides::default()), Err(ConfigError::MissingFile(_)) )); Ok(()) }); } #[test] fn tls_enabled_requires_both_paths() { let mut c = Config::default(); assert!(!c.server.tls.enabled); c.validate().unwrap(); c.server.tls.enabled = true; assert!(c.validate().is_err()); c.server.tls.cert_file = "/c.pem".into(); assert!(c.validate().is_err()); c.server.tls.key_file = "/k.pem".into(); c.validate().unwrap(); } #[test] fn tls_disabled_ignores_paths_and_env_overrides() { let mut c = Config::default(); c.server.tls.cert_file = "/nonexistent/c.pem".into(); c.server.tls.key_file = "/nonexistent/k.pem".into(); c.validate().unwrap(); Jail::expect_with(|jail| { jail.set_env("SKYG_SERVER__TLS__ENABLED", "true"); jail.set_env("SKYG_SERVER__TLS__CERT_FILE", "/c.pem"); jail.set_env("SKYG_SERVER__TLS__KEY_FILE", "/k.pem"); let c = load(None, &CliOverrides::default()).unwrap(); assert!(c.server.tls.enabled); assert_eq!(c.server.tls.cert_file, Path::new("/c.pem")); assert!(c.to_toml_redacted().unwrap().contains("[server.tls]")); Ok(()) }); } #[test] fn example_file_matches_defaults() { let c: Config = toml::from_str(include_str!("../config.example.toml")).unwrap(); assert_eq!(c, Config::default()); } #[test] fn toml_roundtrip_and_redaction() { let mut c = Config::default(); c.otel .headers .insert("authorization".into(), "secret".into()); let s = c.to_toml_redacted().unwrap(); assert!(!s.contains("secret")); assert!(s.contains("port = 1984")); } }