tidy up a bit

Author: fredr

runtimes/core/src/api/auth/local.rs

@@ -171,7 +171,7 @@ impl AuthHandler for LocalAuthHandler {
                     };
                     self.tracer.request_span_end(&model_resp, false);
                     self.requests_total
-                        .with([("code", &e.code.to_string())])
+                        .with([("code", e.code.to_string())])
                         .increment();
                     Err(e)
                 }

runtimes/core/src/api/endpoint.rs

@@ -687,7 +687,7 @@ impl EndpointHandler {
                     }),
                 };
                 self.shared.tracer.request_span_end(&model_resp, sensitive);
-                self.requests_total.with([("code", &code)]).increment();
+                self.requests_total.with([("code", code)]).increment();
             }
 
             if let Ok(val) = HeaderValue::from_str(request.span.0.serialize_encore().as_str()) {

runtimes/core/src/metrics/counter.rs

@@ -79,13 +79,13 @@ where
     pub fn with<L, K, V>(&self, dynamic_labels: L) -> Counter<T>
     where
         L: IntoIterator<Item = (K, V)>,
-        K: AsRef<str>,
-        V: AsRef<str>,
+        K: Into<String>,
+        V: Into<String>,
     {
         // Convert dynamic_labels to HashMap first
         let dynamic_labels_map: HashMap<String, String> = dynamic_labels
             .into_iter()
-            .map(|(k, v)| (k.as_ref().to_string(), v.as_ref().to_string()))
+            .map(|(k, v)| (k.into(), v.into()))
             .collect();
 
         // Validate required keys are present
@@ -138,3 +138,77 @@ where
         )
     }
 }
+
+/// Builder for creating counter schemas with static labels and required dynamic keys
+pub struct CounterSchemaBuilder<T> {
+    name: String,
+    static_labels: Vec<(String, String)>,
+    required_dynamic_keys: HashSet<String>,
+    registry: Arc<metrics::Registry>,
+    _phantom: std::marker::PhantomData<T>,
+}
+
+impl<T> CounterSchemaBuilder<T>
+where
+    Arc<AtomicU64>: CounterOps<T>,
+    T: One + Send + Sync + 'static,
+{
+    pub(crate) fn new(name: String, registry: Arc<metrics::Registry>) -> Self {
+        Self {
+            name,
+            static_labels: Vec::new(),
+            required_dynamic_keys: HashSet::new(),
+            registry,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+
+    /// Add static labels that are set once when the schema is created
+    pub fn static_labels<I, K, V>(mut self, labels: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        for (key, value) in labels {
+            self.static_labels
+                .push((key.as_ref().to_string(), value.as_ref().to_string()));
+        }
+        self
+    }
+
+    /// Add a single static label
+    pub fn static_label(mut self, key: &str, value: &str) -> Self {
+        self.static_labels
+            .push((key.to_string(), value.to_string()));
+        self
+    }
+
+    /// Specify required dynamic label keys that must be provided at increment time
+    pub fn require_dynamic_keys<I, K>(mut self, keys: I) -> Self
+    where
+        I: IntoIterator<Item = K>,
+        K: AsRef<str>,
+    {
+        for key in keys {
+            self.required_dynamic_keys.insert(key.as_ref().to_string());
+        }
+        self
+    }
+
+    /// Add a single required dynamic key
+    pub fn require_dynamic_key(mut self, key: &str) -> Self {
+        self.required_dynamic_keys.insert(key.to_string());
+        self
+    }
+
+    /// Build the counter schema
+    pub fn build(self) -> Schema<T> {
+        Schema::new(
+            self.name,
+            self.static_labels,
+            self.required_dynamic_keys,
+            self.registry,
+        )
+    }
+}

runtimes/core/src/metrics/exporter/gcp.rs

@@ -82,14 +82,12 @@ impl Gcp {
             self.project_id
         );
 
-        // Convert our metrics to Google Cloud TimeSeries format
         let time_series = self.get_metric_data(metrics);
 
         // Send metrics in batches (Google Cloud allows up to 200 time series per request)
         for batch in time_series.chunks(200) {
             if let Err(e) = self.send_time_series_batch(client, batch.to_vec()).await {
                 log::error!("Failed to export metrics batch: {}", e);
-                // Continue with remaining batches even if one fails
             }
         }
 

runtimes/core/src/metrics/gauge.rs

@@ -90,13 +90,13 @@ where
     pub fn with<L, K, V>(&self, dynamic_labels: L) -> Gauge<T>
     where
         L: IntoIterator<Item = (K, V)>,
-        K: AsRef<str>,
-        V: AsRef<str>,
+        K: Into<String>,
+        V: Into<String>,
     {
         // Convert dynamic_labels to HashMap first
         let dynamic_labels_map: HashMap<String, String> = dynamic_labels
             .into_iter()
-            .map(|(k, v)| (k.as_ref().to_string(), v.as_ref().to_string()))
+            .map(|(k, v)| (k.into(), v.into()))
             .collect();
 
         // Validate required keys are present
@@ -133,3 +133,77 @@ where
         )
     }
 }
+
+/// Builder for creating gauge schemas with static labels and required dynamic keys
+pub struct GaugeSchemaBuilder<T> {
+    name: String,
+    static_labels: Vec<(String, String)>,
+    required_dynamic_keys: HashSet<String>,
+    registry: Arc<metrics::Registry>,
+    _phantom: std::marker::PhantomData<T>,
+}
+
+impl<T> GaugeSchemaBuilder<T>
+where
+    Arc<AtomicU64>: GaugeOps<T>,
+    T: Send + Sync + 'static,
+{
+    pub(crate) fn new(name: String, registry: Arc<metrics::Registry>) -> Self {
+        Self {
+            name,
+            static_labels: Vec::new(),
+            required_dynamic_keys: HashSet::new(),
+            registry,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+
+    /// Add static labels that are set once when the schema is created
+    pub fn static_labels<I, K, V>(mut self, labels: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        for (key, value) in labels {
+            self.static_labels
+                .push((key.as_ref().to_string(), value.as_ref().to_string()));
+        }
+        self
+    }
+
+    /// Add a single static label
+    pub fn static_label(mut self, key: &str, value: &str) -> Self {
+        self.static_labels
+            .push((key.to_string(), value.to_string()));
+        self
+    }
+
+    /// Specify required dynamic label keys that must be provided at set/add/sub time
+    pub fn require_dynamic_keys<I, K>(mut self, keys: I) -> Self
+    where
+        I: IntoIterator<Item = K>,
+        K: AsRef<str>,
+    {
+        for key in keys {
+            self.required_dynamic_keys.insert(key.as_ref().to_string());
+        }
+        self
+    }
+
+    /// Add a single required dynamic key
+    pub fn require_dynamic_key(mut self, key: &str) -> Self {
+        self.required_dynamic_keys.insert(key.to_string());
+        self
+    }
+
+    /// Build the gauge schema
+    pub fn build(self) -> Schema<T> {
+        Schema::new(
+            self.name,
+            self.static_labels,
+            self.required_dynamic_keys,
+            self.registry,
+        )
+    }
+}

runtimes/core/src/metrics/manager.rs

@@ -96,7 +96,6 @@ impl Manager {
         }
     }
 
-    /// Get direct access to the registry
     pub fn registry(&self) -> &Registry {
         &self.registry
     }

runtimes/core/src/metrics/mod.rs

@@ -16,7 +16,7 @@ pub use manager::Manager;
 pub use registry::{CollectedMetric, MetricValue, Registry};
 pub use system::SystemMetricsCollector;
 
-/// Create a requests counter schema with service and endpoint static labels, requiring code as dynamic label
+/// Create a requests counter schema
 pub fn requests_total_counter(
     registry: &Registry,
     service: &str,
@@ -29,7 +29,7 @@ pub fn requests_total_counter(
         .build()
 }
 
-/// Create a memory usage gauge schema requiring type label as dynamic
+/// Create a memory usage gauge schema
 pub fn memory_usage_gauge_schema(registry: &Registry) -> gauge::Schema<u64> {
     registry
         .gauge_schema::<u64>("e_sys_memory_used_bytes")