use into_iter

Author: danielsn

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

@@ -4,6 +4,14 @@
 use crate::collections::identifiable::Id;
 use crate::internal::Function as InternalFunction;
 
+// For owned values - forward to reference version
+impl From<InternalFunction> for datadog_profiling_otel::Function {
+    fn from(internal_function: InternalFunction) -> Self {
+        Self::from(&internal_function)
+    }
+}
+
+// For references (existing implementation)
 impl From<&InternalFunction> for datadog_profiling_otel::Function {
     fn from(internal_function: &InternalFunction) -> Self {
         Self {
@@ -41,20 +49,58 @@ mod tests {
 
     #[test]
     fn test_from_internal_function_with_large_offsets() {
-        // Create an internal function with larger offsets
+        // Create an internal function with large offsets
+        let internal_function = InternalFunction {
+            name: StringId::from_offset(999999),
+            system_name: StringId::from_offset(888888),
+            filename: StringId::from_offset(777777),
+        };
+
+        // Convert to OpenTelemetry Function
+        let otel_function = datadog_profiling_otel::Function::from(&internal_function);
+
+        // Verify the conversion
+        assert_eq!(otel_function.name_strindex, 999999);
+        assert_eq!(otel_function.system_name_strindex, 888888);
+        assert_eq!(otel_function.filename_strindex, 777777);
+        assert_eq!(otel_function.start_line, 0);
+    }
+
+    #[test]
+    fn test_into_otel_function() {
+        // Create an internal function
         let internal_function = InternalFunction {
             name: StringId::from_offset(100),
             system_name: StringId::from_offset(200),
             filename: StringId::from_offset(300),
         };
 
-        // Convert to OpenTelemetry Function
-        let otel_function = datadog_profiling_otel::Function::from(&internal_function);
+        // Convert using .into() method
+        let otel_function: datadog_profiling_otel::Function = (&internal_function).into();
 
-        // Verify the conversion - note: StringId doesn't add 1, it's direct conversion
+        // Verify the conversion
         assert_eq!(otel_function.name_strindex, 100);
         assert_eq!(otel_function.system_name_strindex, 200);
         assert_eq!(otel_function.filename_strindex, 300);
         assert_eq!(otel_function.start_line, 0);
     }
+
+    #[test]
+    fn test_into_otel_function_owned() {
+        // Create an internal function
+        let internal_function = InternalFunction {
+            name: StringId::from_offset(400),
+            system_name: StringId::from_offset(500),
+            filename: StringId::from_offset(600),
+        };
+
+        // Convert using .into() method with owned value
+        let otel_function: datadog_profiling_otel::Function = internal_function.into();
+
+        // Verify the conversion
+        assert_eq!(otel_function.name_strindex, 400);
+        assert_eq!(otel_function.system_name_strindex, 500);
+        assert_eq!(otel_function.filename_strindex, 600);
+        assert_eq!(otel_function.start_line, 0);
+    }
 }

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

@@ -4,6 +4,14 @@
 use crate::collections::identifiable::Id;
 use crate::internal::Location as InternalLocation;
 
+// For owned values - forward to reference version
+impl From<InternalLocation> for datadog_profiling_otel::Location {
+    fn from(internal_location: InternalLocation) -> Self {
+        Self::from(&internal_location)
+    }
+}
+
+// For references (existing implementation)
 impl From<&InternalLocation> for datadog_profiling_otel::Location {
     fn from(internal_location: &InternalLocation) -> Self {
         Self {
@@ -92,4 +100,24 @@ mod tests {
         assert_eq!(otel_location.line[0].function_index, 21);
         assert_eq!(otel_location.line[0].line, 200);
     }
+
+    #[test]
+    fn test_into_otel_location_owned() {
+        // Create an internal location
+        let internal_location = InternalLocation {
+            mapping_id: Some(MappingId::from_offset(30)),
+            function_id: FunctionId::from_offset(40),
+            address: 0x4000,
+            line: 300,
+        };
+
+        // Convert using .into() method with owned value
+        let otel_location: datadog_profiling_otel::Location = internal_location.into();
+
+        // Verify the conversion - note: from_offset adds 1 to avoid zero values
+        assert_eq!(otel_location.mapping_index, 31);
+        assert_eq!(otel_location.address, 0x4000);
+        assert_eq!(otel_location.line[0].function_index, 41);
+        assert_eq!(otel_location.line[0].line, 300);
+    }
 }

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

@@ -4,6 +4,14 @@
 use crate::collections::identifiable::Id;
 use crate::internal::Mapping as InternalMapping;
 
+// For owned values - forward to reference version
+impl From<InternalMapping> for datadog_profiling_otel::Mapping {
+    fn from(internal_mapping: InternalMapping) -> Self {
+        Self::from(&internal_mapping)
+    }
+}
+
+// For references (existing implementation)
 impl From<&InternalMapping> for datadog_profiling_otel::Mapping {
     fn from(internal_mapping: &InternalMapping) -> Self {
         Self {
@@ -92,4 +100,25 @@ mod tests {
         assert_eq!(otel_mapping.file_offset, 0x200);
         assert_eq!(otel_mapping.filename_strindex, 555);
     }
+
+    #[test]
+    fn test_into_otel_mapping_owned() {
+        // Create an internal mapping
+        let internal_mapping = InternalMapping {
+            memory_start: 0x5000,
+            memory_limit: 0x6000,
+            file_offset: 0x300,
+            filename: StringId::from_offset(777),
+            build_id: StringId::from_offset(888),
+        };
+
+        // Convert using .into() method with owned value
+        let otel_mapping: datadog_profiling_otel::Mapping = internal_mapping.into();
+
+        // Verify the conversion
+        assert_eq!(otel_mapping.memory_start, 0x5000);
+        assert_eq!(otel_mapping.memory_limit, 0x6000);
+        assert_eq!(otel_mapping.file_offset, 0x300);
+        assert_eq!(otel_mapping.filename_strindex, 777);
+    }
 }

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

@@ -69,12 +69,12 @@ impl InternalProfile {
                     .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
+                comment_strindices: vec![],  // We don't have comments
+                profile_id: vec![],          // TODO: Implement when we handle profile IDs
                 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
+                original_payload: vec![],    // There is no original payload
+                attribute_indices: vec![],   // There are currently no attributes at this level
             };
 
             profiles.push(profile);
@@ -149,30 +149,10 @@ impl InternalProfile {
 
         // Convert the ProfilesDictionary components
         let dictionary = datadog_profiling_otel::ProfilesDictionary {
-            // Convert mappings
-            mapping_table: self.mappings.iter().map(|mapping| mapping.into()).collect(),
-
-            // Convert locations
-            location_table: self
-                .locations
-                .iter()
-                .map(|location| location.into())
-                .collect(),
-
-            // Convert functions
-            function_table: self
-                .functions
-                .iter()
-                .map(|function| function.into())
-                .collect(),
-
-            // Convert stack traces
-            stack_table: self
-                .stack_traces
-                .iter()
-                .map(|stack_trace| stack_trace.into())
-                .collect(),
-
+            mapping_table: self.mappings.into_iter().map(From::from).collect(),
+            location_table: self.locations.into_iter().map(From::from).collect(),
+            function_table: self.functions.into_iter().map(From::from).collect(),
+            stack_table: self.stack_traces.into_iter().map(From::from).collect(),
             string_table,
             attribute_table,
             attribute_units,

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

@@ -4,6 +4,14 @@
 use crate::collections::identifiable::Id;
 use crate::internal::StackTrace as InternalStackTrace;
 
+// For owned values - forward to reference version
+impl From<InternalStackTrace> for datadog_profiling_otel::Stack {
+    fn from(internal_stack_trace: InternalStackTrace) -> Self {
+        Self::from(&internal_stack_trace)
+    }
+}
+
+// For references (existing implementation)
 impl From<&InternalStackTrace> for datadog_profiling_otel::Stack {
     fn from(internal_stack_trace: &InternalStackTrace) -> Self {
         Self {
@@ -55,13 +63,35 @@ mod tests {
     fn test_into_otel_stack() {
         // Create an internal stack trace
         let internal_stack_trace = InternalStackTrace {
-            locations: vec![LocationId::from_offset(42), LocationId::from_offset(123)],
+            locations: vec![
+                LocationId::from_offset(10),
+                LocationId::from_offset(20),
+                LocationId::from_offset(30),
+            ],
         };
 
         // Convert using .into() method
         let otel_stack: datadog_profiling_otel::Stack = (&internal_stack_trace).into();
 
         // Verify the conversion - note: from_offset adds 1 to avoid zero values
-        assert_eq!(otel_stack.location_indices, vec![43, 124]);
+        assert_eq!(otel_stack.location_indices, vec![11, 21, 31]);
+    }
+
+    #[test]
+    fn test_into_otel_stack_owned() {
+        // Create an internal stack trace
+        let internal_stack_trace = InternalStackTrace {
+            locations: vec![
+                LocationId::from_offset(40),
+                LocationId::from_offset(50),
+                LocationId::from_offset(60),
+            ],
+        };
+
+        // Convert using .into() method with owned value
+        let otel_stack: datadog_profiling_otel::Stack = internal_stack_trace.into();
+
+        // Verify the conversion - note: from_offset adds 1 to avoid zero values
+        assert_eq!(otel_stack.location_indices, vec![41, 51, 61]);
     }
 }