collect CPU offsets at PlatformStart

Author: shreyamalpani

bottlecap/src/lifecycle/invocation/processor.rs

@@ -22,8 +22,7 @@ use crate::{
     },
     metrics::enhanced::lambda::{EnhancedMetricData, Lambda as EnhancedMetrics},
     proc::{
-        self, CPUData, NetworkData,
-        constants::{ETC_PATH, PROC_PATH},
+        self, CPUData, NetworkData, constants::{ETC_PATH, PROC_PATH}
     },
     tags::{lambda::tags::resolve_runtime_from_proc, provider},
     traces::{
@@ -141,15 +140,11 @@ impl Processor {
             // Resume tmp, fd, and threads enhanced metrics monitoring
             self.enhanced_metrics.resume_usage_metrics_monitoring();
 
-            // Collect offsets for network and cpu metrics
             let network_offset: Option<NetworkData> = proc::get_network_data().ok();
-            let cpu_offset: Option<CPUData> = proc::get_cpu_data().ok();
-            let uptime_offset: Option<f64> = proc::get_uptime().ok();
-
             let enhanced_metric_offsets = Some(EnhancedMetricData {
                 network_offset,
-                cpu_offset,
-                uptime_offset,
+                cpu_offset: None,
+                uptime_offset: None,
             });
             self.context_buffer
                 .add_enhanced_metric_data(&request_id, enhanced_metric_offsets);
@@ -319,6 +314,23 @@ impl Processor {
             .try_into()
             .unwrap_or_default();
         self.context_buffer.add_start_time(&request_id, start_time);
+        
+        if self.config.lambda_proc_enhanced_metrics {
+            let cpu_offset: Option<CPUData> = proc::get_cpu_data().ok();
+            let uptime_offset: Option<f64> = proc::get_uptime().ok();
+            if let Some(context) = self.context_buffer.get_mut(&request_id) {
+                if let Some(ref mut enhanced_data) = context.enhanced_metric_data {
+                    enhanced_data.cpu_offset = cpu_offset;
+                    enhanced_data.uptime_offset = uptime_offset;
+                } else {
+                    context.enhanced_metric_data = Some(EnhancedMetricData {
+                        network_offset: None,
+                        cpu_offset,
+                        uptime_offset,
+                    });
+                }
+            }
+        }
     }
 
     #[allow(clippy::too_many_arguments)]

bottlecap/src/metrics/enhanced/lambda.rs

@@ -369,6 +369,12 @@ impl Lambda {
         let num_cores = cpu_data_end.individual_cpu_idle_times.len() as f64;
         let uptime = uptime_data_end - uptime_data_offset;
         let total_idle_time = cpu_data_end.total_idle_time_ms - cpu_data_offset.total_idle_time_ms;
+        
+        // Change in uptime should be positive and greater than total idle time across all cores
+        if uptime <= 0.0 || (uptime * num_cores) < total_idle_time {
+            debug!("Invalid uptime, skipping CPU utilization metrics");
+            return;
+        }
 
         let mut max_idle_time = 0.0;
         let mut min_idle_time = f64::MAX;
@@ -383,6 +389,8 @@ impl Lambda {
                 cpu_data_offset.individual_cpu_idle_times.get(cpu_name)
             {
                 let idle_time = cpu_idle_time - cpu_idle_time_offset;
+                let idle_time = idle_time.max(0.0); // Ensure idle time is non-negative
+                
                 if idle_time < min_idle_time {
                     min_idle_time = idle_time;
                 }
@@ -394,15 +402,15 @@ impl Lambda {
 
         // Maximally utilized CPU is the one with the least time spent in the idle process
         // Multiply by 100 to report as percentage
-        let cpu_max_utilization = ((uptime - min_idle_time) / uptime) * 100.0;
+        let cpu_max_utilization = ((uptime - min_idle_time).max(0.0) / uptime) * 100.0;
 
         // Minimally utilized CPU is the one with the most time spent in the idle process
         // Multiply by 100 to report as percentage
-        let cpu_min_utilization = ((uptime - max_idle_time) / uptime) * 100.0;
+        let cpu_min_utilization = ((uptime - max_idle_time).max(0.0) / uptime) * 100.0;
 
         // CPU total utilization is the proportion of total non-idle time to the total uptime across all cores
         let cpu_total_utilization_decimal =
-            ((uptime * num_cores) - total_idle_time) / (uptime * num_cores);
+            ((uptime * num_cores) - total_idle_time).max(0.0) / (uptime * num_cores);
         // Multiply by 100 to report as percentage
         let cpu_total_utilization_pct = cpu_total_utilization_decimal * 100.0;
         // Multiply by num_cores to report in terms of cores