refactor(self-hosting): forward every setting, drop dead config (#3047)

fluxer_common/Cargo.toml

@@ -16,6 +16,7 @@ serde_json = "1.0.151"
 tempfile = "3.27.0"
 time = { version = "0.3.55", features = ["formatting", "macros", "parsing"] }
 tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.23", default-features = false, features = ["env-filter"] }
 base64 = "0.23"
 hex = "0.4.3"
 hmac = "0.13.0"

fluxer_common/src/config.rs

@@ -34,7 +34,7 @@ pub struct GeoipS3Config {
 }
 
 pub fn read_geoip_s3_config_from_env(source: &GeoipSourceConfig) -> Option<GeoipS3Config> {
-    read_geoip_s3_config(source, |name| env::var(name).ok())
+    read_geoip_s3_config(source, env_value)
 }
 
 fn read_geoip_s3_config<F>(source: &GeoipSourceConfig, mut read_var: F) -> Option<GeoipS3Config>
@@ -123,26 +123,23 @@ fn percent_decode(value: &str) -> String {
         .unwrap_or_else(|_| value.to_owned())
 }
 
-pub fn read_env(name: &str, fallback: &str) -> String {
-    env::var(name).unwrap_or_else(|_| fallback.to_owned())
+pub fn env_value(name: &str) -> Option<String> {
+    env::var(name).ok().filter(|value| !value.trim().is_empty())
 }
 
-pub fn read_env_preferred(names: &[&str], fallback: &str) -> String {
-    names
-        .iter()
-        .find_map(|name| env::var(name).ok().filter(|value| !value.trim().is_empty()))
-        .unwrap_or_else(|| fallback.to_owned())
+pub fn read_env(name: &str, fallback: &str) -> String {
+    env_value(name).unwrap_or_else(|| fallback.to_owned())
 }
 
 pub fn read_first_env(names: &[&str], fallback: &str) -> String {
     names
         .iter()
-        .find_map(|name| env::var(name).ok())
+        .find_map(|name| env_value(name))
         .unwrap_or_else(|| fallback.to_owned())
 }
 
-pub fn read_bool_env(names: &[&str], fallback: bool) -> bool {
-    let Some(value) = names.iter().find_map(|name| env::var(name).ok()) else {
+pub fn read_bool_env(name: &str, fallback: bool) -> bool {
+    let Some(value) = env_value(name) else {
         return fallback;
     };
     matches!(
@@ -151,11 +148,10 @@ pub fn read_bool_env(names: &[&str], fallback: bool) -> bool {
     )
 }
 
-pub fn non_empty_env(name: &str) -> Option<String> {
-    env::var(name)
-        .ok()
-        .map(|v| v.trim().to_owned())
-        .filter(|v| !v.is_empty())
+pub fn env_filter(default: &str) -> tracing_subscriber::EnvFilter {
+    env_value("RUST_LOG")
+        .and_then(|filter| tracing_subscriber::EnvFilter::try_new(filter).ok())
+        .unwrap_or_else(|| tracing_subscriber::EnvFilter::new(default))
 }
 
 pub fn normalize_base_path(value: &str) -> String {
@@ -295,7 +291,7 @@ pub fn normalize_public_endpoint(url: &str, base_domain: &str, public_port: Opti
 }
 
 pub fn try_normalize_public_endpoint_from_env(url: &str) -> anyhow::Result<String> {
-    let (base_domain, public_port) = resolve_public_domain_and_port(|name| env::var(name).ok())?;
+    let (base_domain, public_port) = resolve_public_domain_and_port(env_value)?;
     Ok(normalize_public_endpoint(url, &base_domain, public_port))
 }
 
@@ -767,6 +763,45 @@ mod tests {
         assert_eq!(None, port);
     }
 
+    #[test]
+    fn a_blank_value_reads_as_unset() {
+        unsafe {
+            env::set_var("FLUXER_COMMON_TEST_BLANK_EMPTY", "");
+            env::set_var("FLUXER_COMMON_TEST_BLANK_SPACES", "  \t");
+            env::set_var("FLUXER_COMMON_TEST_BLANK_SET", "value");
+            env::set_var("FLUXER_COMMON_TEST_BLANK_TRUE", "true");
+        }
+        assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_EMPTY"));
+        assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_SPACES"));
+        assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_MISSING"));
+        assert_eq!(
+            "fallback",
+            read_env("FLUXER_COMMON_TEST_BLANK_EMPTY", "fallback")
+        );
+        assert_eq!(
+            "fallback",
+            read_env("FLUXER_COMMON_TEST_BLANK_SPACES", "fallback")
+        );
+        assert_eq!(
+            "value",
+            read_env("FLUXER_COMMON_TEST_BLANK_SET", "fallback")
+        );
+        assert_eq!(
+            "value",
+            read_first_env(
+                &[
+                    "FLUXER_COMMON_TEST_BLANK_EMPTY",
+                    "FLUXER_COMMON_TEST_BLANK_SPACES",
+                    "FLUXER_COMMON_TEST_BLANK_SET",
+                ],
+                "fallback"
+            )
+        );
+        assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_EMPTY", true));
+        assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_SPACES", true));
+        assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_TRUE", false));
+    }
+
     #[test]
     fn trim_trailing_slash_works() {
         assert_eq!(