Update frontend metric names, and update metrics.rs to compile

Author: keivenchang

components/metrics/Cargo.toml

@@ -38,4 +38,4 @@ tracing = { workspace = true }
 # TODO: Update axum to 0.8
 axum = { version = "0.6" }
 clap = { version = "4.5", features = ["derive", "env"] }
-reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
+reqwest = { version = "0.12.22", default-features = false, features = ["json", "rustls-tls"] }

lib/llm/src/http/service/metrics.rs

@@ -12,6 +12,9 @@ pub use prometheus::Registry;
 
 use super::RouteDoc;
 
+/// Metric prefix for all HTTP service metrics
+pub const FRONTEND_METRIC_PREFIX: &str = "dynamo_frontend";
+
 /// Value for the `status` label in the request counter for successful requests
 pub const REQUEST_STATUS_SUCCESS: &str = "success";
 
@@ -24,6 +27,11 @@ pub const REQUEST_TYPE_STREAM: &str = "stream";
 /// Partial value for the `type` label in the request counter for unary requests
 pub const REQUEST_TYPE_UNARY: &str = "unary";
 
+/// Helper function to construct metric names with the standard prefix
+fn frontend_metric_name(suffix: &str) -> String {
+    format!("{}_{}", FRONTEND_METRIC_PREFIX, suffix)
+}
+
 pub struct Metrics {
     request_counter: IntCounterVec,
     inflight_gauge: IntGaugeVec,
@@ -99,7 +107,7 @@ impl Default for Metrics {
 }
 
 impl Metrics {
-    /// Create Metrics with hardcoded "dynamo" prefix
+    /// Create Metrics with the standard prefix defined by [`FRONTEND_METRIC_PREFIX`]
     /// The following metrics will be created:
     /// - `dynamo_frontend_requests_total` - IntCounterVec for the total number of requests processed
     /// - `dynamo_frontend_inflight_requests` - IntGaugeVec for the number of inflight requests
@@ -111,7 +119,7 @@ impl Metrics {
     pub fn new() -> Self {
         let request_counter = IntCounterVec::new(
             Opts::new(
-                "dynamo_frontend_requests_total",
+                frontend_metric_name("requests_total"),
                 "Total number of LLM requests processed",
             ),
             &["model", "endpoint", "request_type", "status"],
@@ -120,7 +128,7 @@ impl Metrics {
 
         let inflight_gauge = IntGaugeVec::new(
             Opts::new(
-                "dynamo_frontend_inflight_requests",
+                frontend_metric_name("inflight_requests"),
                 "Number of inflight requests",
             ),
             &["model"],
@@ -131,7 +139,7 @@ impl Metrics {
 
         let request_duration = HistogramVec::new(
             HistogramOpts::new(
-                "dynamo_frontend_request_duration_seconds",
+                frontend_metric_name("request_duration_seconds"),
                 "Duration of LLM requests",
             )
             .buckets(buckets),
@@ -141,7 +149,7 @@ impl Metrics {
 
         let input_sequence_length = HistogramVec::new(
             HistogramOpts::new(
-                "dynamo_frontend_input_sequence_tokens",
+                frontend_metric_name("input_sequence_tokens"),
                 "Input sequence length in tokens",
             )
             .buckets(vec![
@@ -154,7 +162,7 @@ impl Metrics {
 
         let output_sequence_length = HistogramVec::new(
             HistogramOpts::new(
-                "dynamo_frontend_output_sequence_tokens",
+                frontend_metric_name("output_sequence_tokens"),
                 "Output sequence length in tokens",
             )
             .buckets(vec![
@@ -166,7 +174,7 @@ impl Metrics {
 
         let time_to_first_token = HistogramVec::new(
             HistogramOpts::new(
-                "dynamo_frontend_time_to_first_token_seconds",
+                frontend_metric_name("time_to_first_token_seconds"),
                 "Time to first token in seconds",
             )
             .buckets(vec![
@@ -179,7 +187,7 @@ impl Metrics {
 
         let inter_token_latency = HistogramVec::new(
             HistogramOpts::new(
-                "dynamo_frontend_inter_token_latency_seconds",
+                frontend_metric_name("inter_token_latency_seconds"),
                 "Inter-token latency in seconds",
             )
             .buckets(vec![

lib/llm/tests/http-service.rs

@@ -22,7 +22,7 @@ use dynamo_llm::http::{
     },
     service::{
         error::HttpError,
-        metrics::{Endpoint, RequestType, Status},
+        metrics::{Endpoint, FRONTEND_METRIC_PREFIX, RequestType, Status},
         service_v2::HttpService,
         Metrics,
     },
@@ -357,7 +357,7 @@ async fn test_http_service() {
     let families = registry.gather();
     let histogram_metric_family = families
         .into_iter()
-        .find(|m| m.get_name() == "dynamo_frontend_request_duration_seconds")
+        .find(|m| m.get_name() == &format!("{}_request_duration_seconds", FRONTEND_METRIC_PREFIX))
         .expect("Histogram metric not found");
 
     assert_eq!(

lib/runtime/src/http_server.rs

@@ -65,25 +65,7 @@ impl Clone for HttpServerInfo {
     }
 }
 
-pub struct HttpMetricsRegistry {
-    pub drt: Arc<crate::DistributedRuntime>,
-}
 
-impl crate::traits::DistributedRuntimeProvider for HttpMetricsRegistry {
-    fn drt(&self) -> &crate::DistributedRuntime {
-        &self.drt
-    }
-}
-
-impl MetricsRegistry for HttpMetricsRegistry {
-    fn basename(&self) -> String {
-        "http_server".to_string()
-    }
-
-    fn parent_hierarchy(&self) -> Vec<String> {
-        [self.drt().parent_hierarchy(), vec![self.drt().basename()]].concat()
-    }
-}
 
 /// HTTP server state containing metrics and uptime tracking
 pub struct HttpServerState {
@@ -96,10 +78,9 @@ pub struct HttpServerState {
 impl HttpServerState {
     /// Create new HTTP server state with the provided metrics registry
     pub fn new(drt: Arc<crate::DistributedRuntime>) -> anyhow::Result<Self> {
-        let http_metrics_registry = Arc::new(HttpMetricsRegistry { drt: drt.clone() });
         // Note: This metric is created at the DRT level (no namespace), so we manually add "dynamo_" prefix
         // to maintain consistency with the project's metric naming convention
-        let uptime_gauge = http_metrics_registry.as_ref().create_gauge(
+        let uptime_gauge = drt.as_ref().create_gauge(
             "dynamo_uptime_seconds",
             "Total uptime of the DistributedRuntime in seconds",
             &[],
@@ -370,7 +351,7 @@ mod tests {
         let expected = "\
 # HELP dynamo_uptime_seconds Total uptime of the DistributedRuntime in seconds
 # TYPE dynamo_uptime_seconds gauge
-dynamo_uptime_seconds{namespace=\"http_server\"} 42
+dynamo_uptime_seconds 42
 ";
         assert_eq!(response, expected);
     }
@@ -445,8 +426,8 @@ dynamo_uptime_seconds{namespace=\"http_server\"} 42
                     let tracestate_value = "vendor1=opaqueValue1,vendor2=opaqueValue2";
                     let mut headers = reqwest::header::HeaderMap::new();
                     headers.insert(
-                        reqwest::header::HeaderName.from_static("traceparent"),
-                        reqwest::header::HeaderValue.from_str(traceparent_value)?,
+                        reqwest::header::HeaderName::from_static("traceparent"),
+                        reqwest::header::HeaderValue::from_str(traceparent_value).unwrap(),
                     );
                     let url = format!("http://{}{}", addr, path);
                     let response = client.get(&url).send().await.unwrap();

lib/runtime/src/metrics.rs

@@ -645,6 +645,7 @@ mod tests {
 mod test_prefixes {
     use super::create_test_drt;
     use super::*;
+    use prometheus::core::Collector;
 
     #[test]
     fn test_hierarchical_prefixes_and_parent_hierarchies() {
@@ -810,17 +811,32 @@ mod test_prefixes {
         );
         println!("Invalid namespace prefix: '{}'", invalid_namespace.prefix());
 
-        // Try to create a metric - this should fail because the namespace name will be used in the metric name
+        // Try to create a metric - this should succeed because the namespace name will be sanitized
         let result = invalid_namespace.create_counter("test_counter", "A test counter", &[]);
         println!("Result with invalid namespace 'test-namespace':");
         println!("{:?}", result);
 
-        // The result should be an error from Prometheus
+        // The result should succeed because invalid names are sanitized
         assert!(
-            result.is_err(),
-            "Creating metric with invalid namespace should fail"
+            result.is_ok(),
+            "Creating metric with invalid namespace should succeed after sanitization"
         );
 
+        // Verify the metric name was sanitized (hyphen removed)
+        if let Ok(counter) = &result {
+            let metric_name = counter.desc()[0].fq_name.as_str();
+            assert!(
+                metric_name.contains("testnamespace"),
+                "Metric name should contain sanitized namespace 'testnamespace', got: {}",
+                metric_name
+            );
+            assert!(
+                !metric_name.contains("test-namespace"),
+                "Metric name should not contain unsanitized namespace 'test-namespace', got: {}",
+                metric_name
+            );
+        }
+
         // For comparison, show a valid namespace works
         let valid_namespace = drt.namespace("test_namespace").unwrap();
         let valid_result = valid_namespace.create_counter("test_counter", "A test counter", &[]);
@@ -926,15 +942,15 @@ testnamespace_testgauge{{component="testcomponent",namespace="testnamespace"}} 5
         println!("{}", namespace_output);
 
         let expected_namespace_output = format!(
-            r#"# HELP testintcounter A test int counter
-# TYPE testintcounter counter
-testintcounter{{namespace="testnamespace"}} 12345
-# HELP testnamespace_testcounter A test counter
+            r#"# HELP testnamespace_testcounter A test counter
 # TYPE testnamespace_testcounter counter
 testnamespace_testcounter{{component="testcomponent",endpoint="testendpoint",namespace="testnamespace"}} 123.456789
 # HELP testnamespace_testgauge A test gauge
 # TYPE testnamespace_testgauge gauge
 testnamespace_testgauge{{component="testcomponent",namespace="testnamespace"}} 50000
+# HELP testnamespace_testintcounter A test int counter
+# TYPE testnamespace_testintcounter counter
+testnamespace_testintcounter{{namespace="testnamespace"}} 12345
 "#
         );
 
@@ -1015,9 +1031,6 @@ testhistogram_bucket{{le="10"}} 3
 testhistogram_bucket{{le="+Inf"}} 3
 testhistogram_sum 7.5
 testhistogram_count 3
-# HELP testintcounter A test int counter
-# TYPE testintcounter counter
-testintcounter{{namespace="testnamespace"}} 12345
 # HELP testintgauge A test int gauge
 # TYPE testintgauge gauge
 testintgauge 42
@@ -1031,6 +1044,9 @@ testnamespace_testcounter{{component="testcomponent",endpoint="testendpoint",nam
 # HELP testnamespace_testgauge A test gauge
 # TYPE testnamespace_testgauge gauge
 testnamespace_testgauge{{component="testcomponent",namespace="testnamespace"}} 50000
+# HELP testnamespace_testintcounter A test int counter
+# TYPE testnamespace_testintcounter counter
+testnamespace_testintcounter{{namespace="testnamespace"}} 12345
 "#
         );