feat(http): wire EngineRouter into query handler — Gorilla-S3 archive routes via router (Phase 6 follow-up)

[zzylol]

Summary

• Plug the Phase-5 EngineRouter (PR feat(capability): Phase 5 — QueryEngine trait + StorageBackend routing for Gorilla-S3 #86) onto the backend HTTP query path — per-metric StreamingConfig::storage_backend() now drives dispatch, so GorillaS3Archive metrics answer from the archive engine and DoubleWrite walks the §8 fallback list.
• Warm-tier metrics keep the direct SimpleEngine::handle_query path (preserving the KeyByLabelNames the Prometheus adapter needs) — non-warm-tier metrics dispatch through router.execute(...) so additional engines (Gorilla, ColdJsonl, future stand-ins) compose without further HTTP-layer changes.
• Every response now carries a data_source: <id> info-line on the Prometheus extension infos array — closes the AccuracyExact + DataSourceMarker SKIP from PR feat(planner): (metric, role)-keyed WorkloadStore + PlanStore (B2 full) #283 e2e.
• main.rs registers GorillaQueryEngine against the router whenever ASAP_GORILLA_S3_BUCKET + ASAP_GORILLA_S3_REGION are set; otherwise the router stays single-engine and a non-warm metric trips a fail-loud 503 NoEngineRegistered.

Files touched

• asap-query-engine/src/drivers/query/servers/http.rs — state struct + dispatch + tests.
• asap-query-engine/src/main.rs — env-gated GorillaQueryEngine registration.

(2 files; engine internals from PRs #84/#85/#86 untouched.)

HTTP server state delta

HttpServer and AppState gain a query_router: Arc<EngineRouter> field alongside the existing Arc<SimpleEngine>. HttpServer::new builds a fresh router and registers the supplied SimpleEngine for the warm tier; a new builder with_query_engine(Arc<dyn QueryEngine>) plugs in additional engines (called from main.rs for the cold-archive GorillaQueryEngine). The range-query path keeps using SimpleEngine directly until the router gains a range API.

Engine registration (main.rs excerpt)

let mut server = HttpServer::new(http_config, engine, store.clone(), query_tracker)
    .with_hot_reload_config(hot_reload_config.clone());
match GorillaS3Config::from_env() {
    Ok(s3_cfg) => match GorillaS3ColdStore::with_default_backend(s3_cfg) {
        Ok(cold_store) => {
            let gorilla = Arc::new(GorillaQueryEngine::with_gorilla_s3(
                Arc::new(cold_store),
                GorillaEngineConfig::default(),
            ));
            server = server.with_query_engine(gorilla as Arc<dyn QueryEngine>);
        }
        Err(e) => warn!("ASAP_GORILLA_S3_* set but cold store init failed: {e}"),
    },
    Err(_) => info!("ASAP_GORILLA_S3_* unset — router warm-tier-only"),
}

Test additions (6, all in http.rs::tests)

• http_routes_warm_tier_metric_to_simple_engine — data_source: sketch_warm lands on the response.
• http_routes_archive_metric_to_gorilla_engine — pins storage_backend = GorillaS3Archive, registers a mock engine, asserts data_source: gorilla_archive + that the mock was hit.
• http_query_with_no_storage_config_defaults_to_warm_tier — back-compat: legacy YAML without storage_backend still routes to warm.
• http_returns_503_when_no_engines_registered — ColdJsonlFallback-pinned metric with no engine for that id surfaces NoEngineRegistered → 503.
• http_passes_through_accuracy_envelope — accuracy envelope and data_source info-line both round-trip on the router path.
• http_router_falls_through_to_jsonl_when_archive_fails — graceful fallback (design.md §8): DoubleWrite deploy with a failing archive engine still answers via JSONL.

Verification

• cargo build --release -p query_engine_rust clean.
• cargo test --release -p query_engine_rust http — 74/74 passing (including all 6 new tests).
• cargo test --release -p query_engine_rust --lib — 838/872 passing; the 34 failures are pre-existing on main (datafusion plan-execution + schema-timeline tests, unrelated to this PR).
• cargo clippy --release -p query_engine_rust --all-targets -- -D warnings — 5 pre-existing baseline errors in simple_engine.rs / count_sketch_accumulator.rs / otel.rs (untouched by this PR; confirmed identical on main).
• No docker, no submodule drift, file domain respected.

Open questions

• Per-metric storage_backend lookup — StreamingConfig today exposes only a single global storage_backend() accessor (no per-agg_id / per-metric variant). The HTTP layer threads that global into router.execute, so a deploy with mixed warm-tier and cold-archive metrics under the same backend wouldn't be served correctly — both would route to whichever axis is pinned globally. A separate small PR should add a StreamingConfig::storage_backend_for_metric(metric_name) accessor and an AggregationConfig::storage_backend field to make this per-metric. Flagging here per the autopilot rules.
• (Statistic, AccuracyTarget) defaults — the router-path dispatch defaults these to (Sum, Approximate) because the HTTP layer doesn't parse PromQL; the router consults them only for DoubleWrite head-selection, which degenerates safely for the other deploy shapes. A follow-up should thread real values through once the Phase-6 query-tracker exposes them.
• HTTP error format — additive only. New router-path errors emit { status, errorType, error } matching the existing PrometheusResponse::error shape; no consumer migration needed.

Doc-tightening for design-gorilla-s3-cold-engine.md §8

None needed — the §8 routing matrix is exactly what the router walks; this PR is the wiring step the doc already anticipates.

Test plan

• cargo test --release -p query_engine_rust http — all green.
• cargo build --release -p query_engine_rust — clean.
• cargo clippy --release -p query_engine_rust --all-targets — no new warnings (5 pre-existing baseline only).
• Phase-6 e2e — un-SKIP AccuracyExact + DataSourceMarker once this lands.

🤖 Generated with Claude Code