Add EdgeZero canary routing (rollout_pct flag + FNV-1a bucket assignment) (PR 19)

crates/trusted-server-adapter-fastly/src/logging.rs

@@ -16,25 +16,77 @@ fn target_label(target: &str) -> &str {
     }
 }
 
+/// Environment variable that explicitly overrides the Fastly logger's maximum level.
+///
+/// Production ships at `Info`. `fastly compute serve`/Viceroy does not propagate
+/// arbitrary shell environment variables into the Compute guest, so this override
+/// only takes effect where the guest environment is populated deliberately (e.g.
+/// the integration-test harness). Routine local validation does not depend on it —
+/// see [`init_logger`], which auto-raises the level under Viceroy via the
+/// [`LOCAL_HOSTNAME_ENV`] signal. The level stays at the safe default when this
+/// variable is unset or unparseable.
+const LOG_LEVEL_ENV: &str = "EDGEZERO_LOG_LEVEL";
+
+/// Fastly-provided hostname environment variable, visible to guest code.
+///
+/// Viceroy (`fastly compute serve`) reports [`LOCAL_HOSTNAME`]; production cache
+/// nodes report their real hostname. [`init_logger`] reads it to raise the log
+/// level for local route-decision observability without affecting production.
+///
+/// Fastly-specific by design: this signal exists *because* Compute exposes a
+/// guest-visible hostname that is fixed to `localhost` only under the simulator.
+/// It must not be copied verbatim into the axum/spin/cloudflare adapters, where
+/// it carries no such meaning and would mis-detect the runtime environment.
+const LOCAL_HOSTNAME_ENV: &str = "FASTLY_HOSTNAME";
+
+/// Hostname value Viceroy reports for [`LOCAL_HOSTNAME_ENV`] in local runs.
+const LOCAL_HOSTNAME: &str = "localhost";
+
+/// Resolves the logger's maximum level from an optional configured value,
+/// falling back to `Info` when it is absent or not a recognised level filter.
+fn resolve_max_level(configured: Option<&str>) -> log::LevelFilter {
+    configured
+        .and_then(|value| value.trim().parse::<log::LevelFilter>().ok())
+        .unwrap_or(log::LevelFilter::Info)
+}
+
 /// Initialises the Fastly-backed `fern` logger and installs it as the global logger.
 ///
 /// Log records are forwarded to the `tslog` Fastly endpoint and echoed to stdout.
 /// Each line is prefixed with an RFC 3339 timestamp, level, and the final segment
 /// of the record's target module path.
 ///
+/// The maximum level defaults to `Info`. Under Viceroy (`fastly compute serve`)
+/// it is auto-raised to `debug` so route-decision lines are observable locally,
+/// detected via the [`LOCAL_HOSTNAME_ENV`] signal. An explicit [`LOG_LEVEL_ENV`]
+/// value takes precedence where the guest environment is populated — the value is
+/// used as-is, so `error`/`off` lowers it just as `debug` raises it; see
+/// [`resolve_max_level`].
+///
 /// # Panics
 ///
 /// Panics if the Fastly logger cannot be built or if the global logger has already
 /// been set.
 pub(crate) fn init_logger() {
+    let configured = std::env::var(LOG_LEVEL_ENV).ok().or_else(|| {
+        // Viceroy reports the guest host as `localhost`; production cache nodes
+        // report their real hostname. Raise to debug only in that local
+        // environment so route-decision lines surface under `fastly compute
+        // serve` while production stays at the safe `Info` default.
+        (std::env::var(LOCAL_HOSTNAME_ENV).as_deref() == Ok(LOCAL_HOSTNAME))
+            .then(|| "debug".to_owned())
+    });
+    let max_level = resolve_max_level(configured.as_deref());
+
     let logger = Logger::builder()
         .default_endpoint("tslog")
         .echo_stdout(true)
-        .max_level(log::LevelFilter::Info)
+        .max_level(max_level)
         .build()
         .expect("should build Logger");
 
     fern::Dispatch::new()
+        .level(max_level)
         .format(|out, message, record| {
             out.finish(format_args!(
                 "{} {} [{}] {}",
@@ -77,4 +129,36 @@ mod tests {
             "should strip separator when trailing segment is empty"
         );
     }
+
+    #[test]
+    fn resolve_max_level_defaults_to_info_when_unset() {
+        assert_eq!(
+            resolve_max_level(None),
+            log::LevelFilter::Info,
+            "should default to Info when the override is unset"
+        );
+    }
+
+    #[test]
+    fn resolve_max_level_raises_to_debug_for_viceroy_validation() {
+        assert_eq!(
+            resolve_max_level(Some("debug")),
+            log::LevelFilter::Debug,
+            "should raise to Debug so route-decision lines are observable locally"
+        );
+        assert_eq!(
+            resolve_max_level(Some("  DEBUG  ")),
+            log::LevelFilter::Debug,
+            "should accept case-insensitive, surrounding-whitespace values"
+        );
+    }
+
+    #[test]
+    fn resolve_max_level_falls_back_to_info_on_unrecognised_value() {
+        assert_eq!(
+            resolve_max_level(Some("not-a-level")),
+            log::LevelFilter::Info,
+            "should keep the safe Info default for an unparseable override"
+        );
+    }
 }