duration

Author: danielsn

datadog-profiling/src/internal/profile/otel_emitter/profile.rs

@@ -18,9 +18,23 @@ impl InternalProfile {
     ///   earlier time. The duration will be set to zero these cases.
     pub fn serialize_into_otel(
         mut self,
-        _end_time: Option<std::time::SystemTime>,
-        _duration: Option<std::time::Duration>,
+        end_time: Option<std::time::SystemTime>,
+        duration: Option<std::time::Duration>,
     ) -> anyhow::Result<datadog_profiling_otel::ProfilesData> {
+        // Calculate duration using the same logic as encode
+        let end = end_time.unwrap_or_else(std::time::SystemTime::now);
+        let start = self.start_time;
+        let duration_nanos = duration
+            .unwrap_or_else(|| {
+                end.duration_since(start).unwrap_or({
+                    // Let's not throw away the whole profile just because the clocks were wrong.
+                    // todo: log that the clock went backward (or programmer mistake).
+                    std::time::Duration::ZERO
+                })
+            })
+            .as_nanos()
+            .min(i64::MAX as u128) as i64;
+
         // Create individual OpenTelemetry Profiles for each ValueType
         let mut profiles = Vec::with_capacity(self.sample_types.len());
 
@@ -42,7 +56,7 @@ impl InternalProfile {
                     .duration_since(std::time::UNIX_EPOCH)
                     .unwrap_or_default()
                     .as_nanos() as i64,
-                duration_nanos: 0,          // TODO: Calculate from internal profile
+                duration_nanos,             // Use calculated duration
                 period_type: None,          // TODO: Implement when we handle period types
                 period: 0,                  // TODO: Implement when we handle periods
                 comment_strindices: vec![], // TODO: Implement when we handle comments
@@ -202,6 +216,15 @@ mod tests {
         assert_eq!(dictionary.attribute_units.len(), 0);
 
         assert_eq!(otel_profiles_data.resource_profiles.len(), 1);
+
+        // Check duration calculation - only if profiles exist
+        let scope_profile = &otel_profiles_data.resource_profiles[0].scope_profiles[0];
+        if !scope_profile.profiles.is_empty() {
+            let profile = &scope_profile.profiles[0];
+            // When no duration is provided, it should calculate from current time - start time
+            // Since we're testing with None, None, the duration should be > 0 (current time - start time)
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -245,6 +268,14 @@ mod tests {
         assert_eq!(otel_function2.name_strindex, 7);
         assert_eq!(otel_function2.system_name_strindex, 8);
         assert_eq!(otel_function2.filename_strindex, 9);
+
+        // Check duration calculation - only if profiles exist
+        let scope_profile = &otel_profiles_data.resource_profiles[0].scope_profiles[0];
+        if !scope_profile.profiles.is_empty() {
+            let profile = &scope_profile.profiles[0];
+            // When no duration is provided, it should calculate from current time - start time
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -314,6 +345,14 @@ mod tests {
         // and the unit should map to the "bytes" string index
         assert!(unit.attribute_key_strindex > 0);
         assert!(unit.unit_strindex > 0);
+
+        // Check duration calculation - only if profiles exist
+        let scope_profile = &otel_profiles_data.resource_profiles[0].scope_profiles[0];
+        if !scope_profile.profiles.is_empty() {
+            let profile = &scope_profile.profiles[0];
+            // When no duration is provided, it should calculate from current time - start time
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -350,6 +389,12 @@ mod tests {
         let allocations_sample_type = allocations_profile.sample_type.as_ref().unwrap();
         assert_eq!(allocations_sample_type.type_strindex, 6); // "allocations" string index
         assert_eq!(allocations_sample_type.unit_strindex, 7); // "count" string index
+
+        // Check duration calculation for both profiles
+        for profile in &scope_profile.profiles {
+            // When no duration is provided, it should calculate from current time - start time
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -429,6 +474,12 @@ mod tests {
         assert_eq!(memory_sample.values, vec![2048]);
         assert_eq!(memory_sample.stack_index, 0); // First stack trace
         assert_eq!(memory_sample.attribute_indices.len(), 0); // No labels
+
+        // Check duration calculation for both profiles
+        for profile in &otel_profiles_data.resource_profiles[0].scope_profiles[0].profiles {
+            // When no duration is provided, it should calculate from current time - start time
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -505,6 +556,10 @@ mod tests {
         assert_eq!(sample.attribute_indices.len(), 2);
         // The attribute indices should correspond to the labels in the attribute table
         assert!(sample.attribute_indices[0] >= 0);
+
+        // Check duration calculation
+        // When no duration is provided, it should calculate from current time - start time
+        assert!(profile.duration_nanos > 0);
         assert!(sample.attribute_indices[1] >= 0);
 
         // Verify the attributes were converted correctly
@@ -568,6 +623,10 @@ mod tests {
         // Verify the sample has the correct timestamp
         assert_eq!(sample.timestamps_unix_nano.len(), 1);
         assert_eq!(sample.timestamps_unix_nano[0], 1234567890);
+
+        // Check duration calculation
+        // When no duration is provided, it should calculate from current time - start time
+        assert!(profile.duration_nanos > 0);
     }
 
     #[test]
@@ -629,6 +688,12 @@ mod tests {
         assert_eq!(profile1.sample.len(), 1);
         let memory_sample = &profile1.sample[0];
         assert_eq!(memory_sample.values, vec![1024]);
+
+        // Check duration calculation for both profiles
+        for profile in &otel_profiles_data.resource_profiles[0].scope_profiles[0].profiles {
+            // When no duration is provided, it should calculate from current time - start time
+            assert!(profile.duration_nanos > 0);
+        }
     }
 
     #[test]
@@ -703,5 +768,45 @@ mod tests {
         for sample in &profile.sample {
             assert_eq!(sample.stack_index, 0);
         }
+
+        // Check duration calculation
+        // When no duration is provided, it should calculate from current time - start time
+        assert!(profile.duration_nanos > 0);
+    }
+
+    #[test]
+    fn test_duration_calculation() {
+        // Create an internal profile with sample types
+        let sample_types = [crate::api::ValueType::new("cpu", "nanoseconds")];
+        let internal_profile = InternalProfile::new(&sample_types, None);
+
+        // Test with explicit duration
+        let explicit_duration = std::time::Duration::from_secs(5);
+        let otel_profiles_data = internal_profile.serialize_into_otel(None, Some(explicit_duration)).unwrap();
+        
+        let profile = &otel_profiles_data.resource_profiles[0].scope_profiles[0].profiles[0];
+        // Should use the explicit duration (5 seconds = 5_000_000_000 nanoseconds)
+        assert_eq!(profile.duration_nanos, 5_000_000_000);
+
+        // Test with explicit end_time
+        let internal_profile2 = InternalProfile::new(&sample_types, None);
+        let start_time = internal_profile2.start_time;
+        let end_time = start_time + std::time::Duration::from_secs(3);
+        let otel_profiles_data2 = internal_profile2.serialize_into_otel(Some(end_time), None).unwrap();
+        
+        let profile2 = &otel_profiles_data2.resource_profiles[0].scope_profiles[0].profiles[0];
+        // Should calculate duration from end_time - start_time (3 seconds = 3_000_000_000 nanoseconds)
+        assert_eq!(profile2.duration_nanos, 3_000_000_000);
+
+        // Test with both end_time and duration (duration should take precedence)
+        let internal_profile3 = InternalProfile::new(&sample_types, None);
+        let start_time3 = internal_profile3.start_time;
+        let end_time3 = start_time3 + std::time::Duration::from_secs(10);
+        let duration3 = std::time::Duration::from_secs(7);
+        let otel_profiles_data3 = internal_profile3.serialize_into_otel(Some(end_time3), Some(duration3)).unwrap();
+        
+        let profile3 = &otel_profiles_data3.resource_profiles[0].scope_profiles[0].profiles[0];
+        // Should use the explicit duration (7 seconds = 7_000_000_000 nanoseconds)
+        assert_eq!(profile3.duration_nanos, 7_000_000_000);
     }
 }