feat(config): configuration override using env vars

added log filter to env vars

Author: dotansimha

Cargo.lock

@@ -5,5 +5,12 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 #[ntex::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    router_entrypoint().await
+    match router_entrypoint().await {
+        Ok(_) => Ok(()),
+        Err(err) => {
+            eprintln!("Failed to start Hive Router:\n  {}", err);
+
+            Err(err)
+        }
+    }
 }

bin/router/src/main.rs

@@ -22,7 +22,9 @@ thiserror = { workspace = true }
 http = { workspace = true }
 jsonwebtoken = { workspace = true }
 retry-policies = { workspace = true}
+tracing = { workspace = true }
 
 schemars = "1.0.4"
 humantime-serde = "1.1.1"
 config = { version = "0.15.14", features = ["yaml", "json", "json5"] }
+envconfig = "0.11.0"

lib/router-config/Cargo.toml

@@ -0,0 +1,92 @@
+use config::{builder::BuilderState, ConfigBuilder, ConfigError};
+use envconfig::Envconfig;
+use tracing::debug;
+
+use crate::log::{LogFormat, LogLevel};
+
+#[derive(Envconfig)]
+pub struct EnvVarOverrides {
+    // Logger overrides
+    #[envconfig(from = "LOG_LEVEL")]
+    pub log_level: Option<LogLevel>,
+    #[envconfig(from = "LOG_FORMAT")]
+    pub log_format: Option<LogFormat>,
+    #[envconfig(from = "LOG_FILTER")]
+    pub log_filter: Option<String>,
+
+    // HTTP overrides
+    #[envconfig(from = "PORT")]
+    pub http_port: Option<u64>,
+    #[envconfig(from = "HOST")]
+    pub http_host: Option<String>,
+
+    // Supergraph overrides
+    #[envconfig(from = "SUPERGRAPH_FILE_PATH")]
+    pub supergraph_file_path: Option<String>,
+    #[envconfig(from = "HIVE_CDN_ENDPOINT")]
+    pub hive_console_cdn_endpoint: Option<String>,
+    #[envconfig(from = "HIVE_CDN_KEY")]
+    pub hive_console_cdn_key: Option<String>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum EnvVarOverridesError {
+    #[error("Failed to override configuration: {0}")]
+    FailedToOverrideConfig(#[from] ConfigError),
+    #[error("Cannot override supergraph source due to conflict: SUPERGRAPH_FILE_PATH and HIVE_CDN_ENDPOINT cannot be used together")]
+    ConflictingSupergraphSource,
+    #[error("Missing required environment variable: {0}")]
+    MissingRequiredEnvVar(&'static str),
+}
+
+impl EnvVarOverrides {
+    pub fn apply_overrides<T: BuilderState>(
+        mut self,
+        mut config: ConfigBuilder<T>,
+    ) -> Result<ConfigBuilder<T>, EnvVarOverridesError> {
+        if let Some(log_level) = self.log_level.take() {
+            debug!("[config-override] 'log.level' = {:?}", log_level);
+            config = config.set_override("log.level", log_level.as_str())?;
+        }
+        if let Some(log_format) = self.log_format.take() {
+            debug!("[config-override] 'log.format' = {:?}", log_format);
+            config = config.set_override("log.format", log_format.as_str())?;
+        }
+        if let Some(log_filter) = self.log_filter.take() {
+            debug!("[config-override] 'log.filter' = {:?}", log_filter);
+            config = config.set_override("log.filter", log_filter)?;
+        }
+
+        if let Some(http_port) = self.http_port.take() {
+            debug!("[config-override] 'http.port' = {}", http_port);
+            config = config.set_override("http.port", http_port)?;
+        }
+
+        if let Some(http_host) = self.http_host.take() {
+            debug!("[config-override] 'http.host' = {}", http_host);
+            config = config.set_override("http.host", http_host)?;
+        }
+
+        if self.supergraph_file_path.is_some() && self.hive_console_cdn_endpoint.is_some() {
+            return Err(EnvVarOverridesError::ConflictingSupergraphSource);
+        }
+
+        if let Some(supergraph_file_path) = self.supergraph_file_path.take() {
+            config = config.set_override("supergraph.source", "file")?;
+            config = config.set_override("supergraph.path", supergraph_file_path)?;
+        }
+
+        if let Some(hive_console_cdn_endpoint) = self.hive_console_cdn_endpoint.take() {
+            config = config.set_override("supergraph.source", "hive")?;
+            config = config.set_override("supergraph.endpoint", hive_console_cdn_endpoint)?;
+
+            if let Some(hive_console_cdn_key) = self.hive_console_cdn_key.take() {
+                config = config.set_override("supergraph.key", hive_console_cdn_key)?;
+            } else {
+                return Err(EnvVarOverridesError::MissingRequiredEnvVar("HIVE_CDN_KEY"));
+            }
+        }
+
+        Ok(config)
+    }
+}

lib/router-config/src/env_overrides.rs

@@ -1,5 +1,6 @@
 pub mod cors;
 pub mod csrf;
+mod env_overrides;
 pub mod headers;
 pub mod http_server;
 pub mod jwt_auth;
@@ -10,14 +11,19 @@ pub mod query_planner;
 pub mod supergraph;
 pub mod traffic_shaping;
 
-use config::{Config, Environment, File, FileFormat, FileSourceFile};
+use config::{Config, File, FileFormat, FileSourceFile};
+use envconfig::Envconfig;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 use crate::{
-    http_server::HttpServerConfig, log::LoggingConfig, primitives::file_path::with_start_path,
-    query_planner::QueryPlannerConfig, supergraph::SupergraphSource,
+    env_overrides::{EnvVarOverrides, EnvVarOverridesError},
+    http_server::HttpServerConfig,
+    log::LoggingConfig,
+    primitives::file_path::with_start_path,
+    query_planner::QueryPlannerConfig,
+    supergraph::SupergraphSource,
     traffic_shaping::TrafficShapingExecutorConfig,
 };
 
@@ -74,7 +80,9 @@ pub struct HiveRouterConfig {
 #[derive(Debug, thiserror::Error)]
 pub enum RouterConfigError {
     #[error("Failed to load configuration: {0}")]
-    ConfigLoadError(config::ConfigError),
+    ConfigLoadError(#[from] config::ConfigError),
+    #[error("Failed to apply configuration overrides: {0}")]
+    EnvVarOverridesError(#[from] EnvVarOverridesError),
 }
 
 static DEFAULT_FILE_NAMES: &[&str] = &[
@@ -86,7 +94,8 @@ static DEFAULT_FILE_NAMES: &[&str] = &[
 
 pub fn load_config(
     overide_config_path: Option<String>,
-) -> Result<HiveRouterConfig, config::ConfigError> {
+) -> Result<HiveRouterConfig, RouterConfigError> {
+    let env_overrides = EnvVarOverrides::init_from_env().expect("failed to init env overrides");
     let mut config = Config::builder();
     let mut config_root_path = std::env::current_dir().expect("failed to get current directory");
 
@@ -106,15 +115,10 @@ pub fn load_config(
         }
     }
 
+    config = env_overrides.apply_overrides(config)?;
+
     let mut base_cfg = with_start_path(&config_root_path, || {
-        config
-            .add_source(
-                Environment::with_prefix("HIVE")
-                    .separator("__")
-                    .prefix_separator("__"),
-            )
-            .build()?
-            .try_deserialize::<HiveRouterConfig>()
+        config.build()?.try_deserialize::<HiveRouterConfig>()
     })?;
 
     base_cfg.root_directory = config_root_path;

lib/router-config/src/lib.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -28,6 +30,21 @@ pub enum LogLevel {
     Error,
 }
 
+impl FromStr for LogLevel {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "trace" => Ok(LogLevel::Trace),
+            "debug" => Ok(LogLevel::Debug),
+            "info" => Ok(LogLevel::Info),
+            "warn" => Ok(LogLevel::Warn),
+            "error" => Ok(LogLevel::Error),
+            _ => Err(format!("Invalid log level: {}", s)),
+        }
+    }
+}
+
 impl Default for LogLevel {
     #[cfg(debug_assertions)]
     fn default() -> Self {
@@ -62,6 +79,29 @@ pub enum LogFormat {
     Json,
 }
 
+impl LogFormat {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            LogFormat::PrettyTree => "pretty-tree",
+            LogFormat::PrettyCompact => "pretty-compact",
+            LogFormat::Json => "json",
+        }
+    }
+}
+
+impl FromStr for LogFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "pretty-tree" => Ok(LogFormat::PrettyTree),
+            "pretty-compact" => Ok(LogFormat::PrettyCompact),
+            "json" => Ok(LogFormat::Json),
+            _ => Err(format!("Invalid log format: {}", s)),
+        }
+    }
+}
+
 impl Default for LogFormat {
     #[cfg(debug_assertions)]
     fn default() -> Self {