refactor(metrics): colocate stage histogram boundaries

Signed-off-by: nachiketb <nachiketb@nvidia.com>

Author: nachiketb-nvidia

crates/libsy/src/algorithms/util/stage.rs

@@ -62,6 +62,11 @@ const EXPLORING_METRIC: &str = "switchyard.stage_router.exploring";
 /// Distribution of production-oriented tool activity.
 const PRODUCTION_INTENSITY_METRIC: &str = "switchyard.stage_router.production_intensity";
 
+// Histogram boundaries live with the instruments so every host exports the
+// same stage-router distributions without duplicating algorithm knowledge.
+const SCORE_BUCKETS: &[f64] = &[-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0];
+const UNIT_BUCKETS: &[f64] = &[0.0, 0.1, 0.25, 0.5, 0.75, 0.9, 1.0];
+
 /// The two tiers a turn can route to.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Tier {
@@ -288,15 +293,23 @@ fn record_score_metrics(signal: &ToolSignals, outcome: &PickOutcome) {
     };
     let dimensions = dimensions_from_signal(signal);
     let meter = meter();
-    for (name, value) in [
-        (SCORE_METRIC, score),
-        (CONFIDENCE_METRIC, confidence),
-        (SEVERITY_METRIC, dimensions.severity),
-        (SPINNING_METRIC, dimensions.spinning),
-        (EXPLORING_METRIC, dimensions.exploring),
-        (PRODUCTION_INTENSITY_METRIC, dimensions.production_intensity),
+    for (name, value, boundaries) in [
+        (SCORE_METRIC, score, SCORE_BUCKETS),
+        (CONFIDENCE_METRIC, confidence, UNIT_BUCKETS),
+        (SEVERITY_METRIC, dimensions.severity, UNIT_BUCKETS),
+        (SPINNING_METRIC, dimensions.spinning, UNIT_BUCKETS),
+        (EXPLORING_METRIC, dimensions.exploring, UNIT_BUCKETS),
+        (
+            PRODUCTION_INTENSITY_METRIC,
+            dimensions.production_intensity,
+            UNIT_BUCKETS,
+        ),
     ] {
-        meter.f64_histogram(name).build().record(value, &[]);
+        meter
+            .f64_histogram(name)
+            .with_boundaries(boundaries.to_vec())
+            .build()
+            .record(value, &[]);
     }
 }
 

crates/switchyard-server/src/metrics.rs

@@ -42,7 +42,7 @@ fn initialize() -> Result<Metrics, String> {
         .map_err(|error| format!("failed to initialize Prometheus metrics: {error}"))?;
     let mut builder = SdkMeterProvider::builder()
         .with_reader(exporter)
-        .with_view(histogram_buckets)
+        .with_view(routing_overhead_buckets)
         .with_resource(crate::observability::resource());
     if crate::observability::otlp_enabled("METRICS") {
         let exporter = opentelemetry_otlp::MetricExporter::builder()
@@ -70,15 +70,13 @@ pub(crate) fn flush() {
     }
 }
 
-fn histogram_buckets(instrument: &Instrument) -> Option<Stream> {
-    let boundaries = if instrument.name() == "switchyard.routing_overhead_ms" {
-        ROUTING_OVERHEAD_BUCKETS_MS
-    } else {
-        crate::stats::algorithm_histogram_buckets(instrument.name())?
-    };
+fn routing_overhead_buckets(instrument: &Instrument) -> Option<Stream> {
+    if instrument.name() != "switchyard.routing_overhead_ms" {
+        return None;
+    }
     Stream::builder()
         .with_aggregation(Aggregation::ExplicitBucketHistogram {
-            boundaries: boundaries.to_vec(),
+            boundaries: ROUTING_OVERHEAD_BUCKETS_MS.to_vec(),
             // Cumulative min/max cover the whole process, so they aren't useful.
             record_min_max: false,
         })

crates/switchyard-server/src/stats.rs

@@ -8,5 +8,4 @@ mod algorithms;
 mod cache_eligibility;
 
 pub(crate) use accumulator::{StatsAccumulator, StatsSnapshot, TokenUsage};
-pub(crate) use algorithms::histogram_buckets as algorithm_histogram_buckets;
 pub(crate) use cache_eligibility::{prefix_probe, tracking_enabled_from_env};

crates/switchyard-server/src/stats/algorithms.rs

@@ -58,7 +58,3 @@ impl AlgorithmStats {
         }
     }
 }
-
-pub(crate) fn histogram_buckets(metric: &str) -> Option<&'static [f64]> {
-    stage_router::histogram_buckets(metric)
-}

crates/switchyard-server/src/stats/algorithms/stage_router.rs

@@ -16,18 +16,6 @@ const SPINNING_METRIC: &str = "switchyard_stage_router_spinning";
 const EXPLORING_METRIC: &str = "switchyard_stage_router_exploring";
 const PRODUCTION_INTENSITY_METRIC: &str = "switchyard_stage_router_production_intensity";
 
-const SCORE_INSTRUMENT: &str = "switchyard.stage_router.score";
-const UNIT_INSTRUMENTS: &[&str] = &[
-    "switchyard.stage_router.confidence",
-    "switchyard.stage_router.severity",
-    "switchyard.stage_router.spinning",
-    "switchyard.stage_router.exploring",
-    "switchyard.stage_router.production_intensity",
-];
-
-const SCORE_BUCKETS: &[f64] = &[-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0];
-const UNIT_BUCKETS: &[f64] = &[0.0, 0.1, 0.25, 0.5, 0.75, 0.9, 1.0];
-
 #[derive(Clone, Debug, Default)]
 pub(super) struct StageRouterCumulative {
     decisions: BTreeMap<DecisionKey, u64>,
@@ -204,16 +192,6 @@ fn round4(value: f64) -> f64 {
     if rounded == 0.0 { 0.0 } else { rounded }
 }
 
-pub(super) fn histogram_buckets(metric: &str) -> Option<&'static [f64]> {
-    if metric == SCORE_INSTRUMENT {
-        Some(SCORE_BUCKETS)
-    } else if UNIT_INSTRUMENTS.contains(&metric) {
-        Some(UNIT_BUCKETS)
-    } else {
-        None
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use opentelemetry::KeyValue;