handle periods

Author: danielsn

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

@@ -56,12 +56,22 @@ impl InternalProfile {
                     .duration_since(std::time::UNIX_EPOCH)
                     .unwrap_or_default()
                     .as_nanos() as i64,
-                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
+                duration_nanos, // Use calculated duration
+                period_type: self.period.as_ref().map(|(_, period_type)| {
+                    datadog_profiling_otel::ValueType {
+                        type_strindex: period_type.r#type.value.to_raw_id() as i32,
+                        unit_strindex: period_type.unit.value.to_raw_id() as i32,
+                        aggregation_temporality:
+                            datadog_profiling_otel::AggregationTemporality::Delta.into(),
+                    }
+                }),
+                period: self
+                    .period
+                    .map(|(period_value, _)| period_value)
+                    .unwrap_or(0),
+                comment_strindices: vec![], // We don't have comments
                 profile_id: vec![],         // TODO: Implement when we handle profile IDs
-                dropped_attributes_count: 0, // TODO: Implement when we handle dropped attributes
+                dropped_attributes_count: 0, // We don't drop attributes
                 original_payload_format: String::new(), // There is no original payload
                 original_payload: vec![],   // There is no original payload
                 attribute_indices: vec![],  // There are currently no attributes at this level
@@ -222,7 +232,8 @@ mod tests {
         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)
+            // Since we're testing with None, None, the duration should be > 0 (current time - start
+            // time)
             assert!(profile.duration_nanos > 0);
         }
     }
@@ -782,8 +793,10 @@ mod tests {
 
         // 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 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);
@@ -792,21 +805,69 @@ mod tests {
         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 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)
+        // 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 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);
     }
+
+    #[test]
+    fn test_period_conversion() {
+        // Create an internal profile with sample types and period
+        let sample_types = [crate::api::ValueType::new("cpu", "nanoseconds")];
+        let period = crate::api::Period {
+            r#type: crate::api::ValueType::new("cpu", "cycles"),
+            value: 1000,
+        };
+        let internal_profile = InternalProfile::new(&sample_types, Some(period));
+
+        // Convert to OpenTelemetry ProfilesData
+        let otel_profiles_data = internal_profile.serialize_into_otel(None, None).unwrap();
+
+        let profile = &otel_profiles_data.resource_profiles[0].scope_profiles[0].profiles[0];
+
+        // Should have period type information
+        assert!(profile.period_type.is_some());
+        let period_type = profile.period_type.as_ref().unwrap();
+
+        // The period type should be converted from the internal profile's period
+        // Note: The exact string indices depend on the string table, but we can verify they're
+        // valid
+        assert!(period_type.type_strindex >= 0);
+        assert!(period_type.unit_strindex >= 0);
+
+        // Should have the correct period value
+        assert_eq!(profile.period, 1000);
+
+        // Test without period
+        let internal_profile_no_period = InternalProfile::new(&sample_types, None);
+        let otel_profiles_data_no_period = internal_profile_no_period
+            .serialize_into_otel(None, None)
+            .unwrap();
+
+        let profile_no_period =
+            &otel_profiles_data_no_period.resource_profiles[0].scope_profiles[0].profiles[0];
+
+        // Should have no period type when no period is set
+        assert!(profile_no_period.period_type.is_none());
+        // Should have period value of 0 when no period is set
+        assert_eq!(profile_no_period.period, 0);
+    }
 }