Add durable function tag for enhanced metrics

Author: lym953

bottlecap/src/flushing/service.rs

@@ -98,6 +98,22 @@ impl FlushingService {
         let series = flush_response.series;
         let sketches = flush_response.distributions;
 
+        debug!(
+            "FLUSHING_SERVICE | flushing {} series batch(es) and {} sketch batch(es)",
+            series.len(),
+            sketches.len()
+        );
+        for (i, sketch_payload) in sketches.iter().enumerate() {
+            for sketch in &sketch_payload.sketches {
+                debug!(
+                    "FLUSHING_SERVICE | sketch batch[{}]: metric='{}' tags={:?}",
+                    i,
+                    sketch.metric,
+                    sketch.tags
+                );
+            }
+        }
+
         for (idx, flusher) in self.metrics_flushers.iter().enumerate() {
             let flusher = flusher.clone();
             let series_clone = series.clone();

bottlecap/src/lifecycle/invocation/processor.rs

@@ -285,11 +285,18 @@ impl Processor {
     /// This is used to create a cold start span, since this telemetry event does not
     /// provide a `request_id`, we try to guess which invocation is the cold start.
     pub fn on_platform_init_start(&mut self, time: DateTime<Utc>, runtime_version: Option<String>) {
+        debug!(
+            "PlatformInitStart received: runtime_version={:?}",
+            runtime_version
+        );
         if runtime_version
             .as_deref()
             .is_some_and(|rv| rv.contains("DurableFunction"))
         {
+            debug!("DurableFunction detected in runtime_version, setting durable_function:true tag on enhanced metrics");
             self.enhanced_metrics.set_durable_function_tag();
+        } else {
+            debug!("runtime_version does not contain 'DurableFunction', skipping durable_function tag");
         }
         let start_time: i64 = SystemTime::from(time)
             .duration_since(UNIX_EPOCH)

bottlecap/src/metrics/enhanced/lambda.rs

@@ -63,8 +63,13 @@ impl Lambda {
 
     /// Sets the `durable_function:true` tag in `dynamic_value_tags`
     pub fn set_durable_function_tag(&mut self) {
+        debug!("Enhanced metrics: inserting durable_function:true into dynamic_value_tags");
         self.dynamic_value_tags
             .insert(String::from("durable_function"), String::from("true"));
+        debug!(
+            "Enhanced metrics: dynamic_value_tags after set_durable_function_tag: {:?}",
+            self.dynamic_value_tags
+        );
     }
 
     fn get_dynamic_value_tags(&self) -> Option<SortedTags> {
@@ -76,6 +81,11 @@ impl Lambda {
 
         let string_tags = vec_tags.join(",");
 
+        debug!(
+            "Enhanced metrics: get_dynamic_value_tags returning tag string: {:?}",
+            string_tags
+        );
+
         SortedTags::parse(&string_tags).ok()
     }
 
@@ -152,10 +162,15 @@ impl Lambda {
         if !self.config.enhanced_metrics {
             return;
         }
+        debug!(
+            "Enhanced metrics: creating metric '{}' with dynamic_value_tags: {:?}",
+            metric_name, self.dynamic_value_tags
+        );
+        let tags = self.get_dynamic_value_tags();
         let metric = Metric::new(
             metric_name.into(),
             MetricValue::distribution(1f64),
-            self.get_dynamic_value_tags(),
+            tags,
             Some(timestamp),
         );
         if let Err(e) = self.aggr_handle.insert_batch(vec![metric]) {