more types

Author: danielsn

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

@@ -29,10 +29,10 @@ mod tests {
             filename: StringId::from_offset(2),
         };
 
-        // Convert to OpenTelemetry Function using From trait
+        // Convert to OpenTelemetry Function
         let otel_function = datadog_profiling_otel::Function::from(&internal_function);
 
-        // Verify the conversion
+        // Verify the conversion - note: StringId doesn't add 1, it's direct conversion
         assert_eq!(otel_function.name_strindex, 0);
         assert_eq!(otel_function.system_name_strindex, 1);
         assert_eq!(otel_function.filename_strindex, 2);
@@ -48,32 +48,13 @@ mod tests {
             filename: StringId::from_offset(300),
         };
 
-        // Convert to OpenTelemetry Function using From trait
+        // Convert to OpenTelemetry Function
         let otel_function = datadog_profiling_otel::Function::from(&internal_function);
 
-        // Verify the conversion
+        // Verify the conversion - note: StringId doesn't add 1, it's direct 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() {
-        // Create an internal function
-        let internal_function = InternalFunction {
-            name: StringId::from_offset(42),
-            system_name: StringId::from_offset(123),
-            filename: StringId::from_offset(456),
-        };
-
-        // Convert using .into() method
-        let otel_function: datadog_profiling_otel::Function = (&internal_function).into();
-
-        // Verify the conversion
-        assert_eq!(otel_function.name_strindex, 42);
-        assert_eq!(otel_function.system_name_strindex, 123);
-        assert_eq!(otel_function.filename_strindex, 456);
-        assert_eq!(otel_function.start_line, 0);
-    }
 }

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

@@ -0,0 +1,94 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collections::identifiable::Id;
+use crate::internal::Location as InternalLocation;
+
+impl From<&InternalLocation> for datadog_profiling_otel::Location {
+    fn from(internal_location: &InternalLocation) -> Self {
+        Self {
+            mapping_index: internal_location.mapping_id
+                .map(|id| id.to_raw_id() as i32)
+                .unwrap_or(0), // 0 represents no mapping
+            address: internal_location.address,
+            line: vec![datadog_profiling_otel::Line {
+                function_index: internal_location.function_id.to_raw_id() as i32,
+                line: internal_location.line,
+                column: 0, // Not available in internal Location
+            }],
+            is_folded: false, // Not available in internal Location
+            attribute_indices: vec![], // Not available in internal Location
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::internal::{FunctionId, MappingId};
+
+    #[test]
+    fn test_from_internal_location() {
+        // Create an internal location
+        let internal_location = InternalLocation {
+            mapping_id: Some(MappingId::from_offset(1)),
+            function_id: FunctionId::from_offset(2),
+            address: 0x1000,
+            line: 42,
+        };
+
+        // Convert to OpenTelemetry Location
+        let otel_location = datadog_profiling_otel::Location::from(&internal_location);
+
+        // Verify the conversion - note: from_offset adds 1 to avoid zero values
+        assert_eq!(otel_location.mapping_index, 2);
+        assert_eq!(otel_location.address, 0x1000);
+        assert_eq!(otel_location.line.len(), 1);
+        assert_eq!(otel_location.line[0].function_index, 3);
+        assert_eq!(otel_location.line[0].line, 42);
+        assert_eq!(otel_location.line[0].column, 0);
+        assert_eq!(otel_location.is_folded, false);
+        assert_eq!(otel_location.attribute_indices, vec![] as Vec<i32>);
+    }
+
+    #[test]
+    fn test_from_internal_location_no_mapping() {
+        // Create an internal location without mapping
+        let internal_location = InternalLocation {
+            mapping_id: None,
+            function_id: FunctionId::from_offset(5),
+            address: 0x2000,
+            line: 100,
+        };
+
+        // Convert to OpenTelemetry Location
+        let otel_location = datadog_profiling_otel::Location::from(&internal_location);
+
+        // Verify the conversion
+        assert_eq!(otel_location.mapping_index, 0); // 0 represents no mapping
+        assert_eq!(otel_location.address, 0x2000);
+        assert_eq!(otel_location.line.len(), 1);
+        assert_eq!(otel_location.line[0].function_index, 6);
+        assert_eq!(otel_location.line[0].line, 100);
+    }
+
+    #[test]
+    fn test_into_otel_location() {
+        // Create an internal location
+        let internal_location = InternalLocation {
+            mapping_id: Some(MappingId::from_offset(10)),
+            function_id: FunctionId::from_offset(20),
+            address: 0x3000,
+            line: 200,
+        };
+
+        // Convert using .into() method
+        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, 11);
+        assert_eq!(otel_location.address, 0x3000);
+        assert_eq!(otel_location.line[0].function_index, 21);
+        assert_eq!(otel_location.line[0].line, 200);
+    }
+}

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

@@ -0,0 +1,95 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collections::identifiable::Id;
+use crate::internal::Mapping as InternalMapping;
+
+impl From<&InternalMapping> for datadog_profiling_otel::Mapping {
+    fn from(internal_mapping: &InternalMapping) -> Self {
+        Self {
+            memory_start: internal_mapping.memory_start,
+            memory_limit: internal_mapping.memory_limit,
+            file_offset: internal_mapping.file_offset,
+            filename_strindex: internal_mapping.filename.to_raw_id() as i32,
+            attribute_indices: vec![], // Not available in internal Mapping
+            has_functions: true, // Assume true since we have function information
+            has_filenames: true, // Assume true since we have filename
+            has_line_numbers: true, // Assume true since we have line information
+            has_inline_frames: false, // Not available in internal Mapping
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::collections::identifiable::StringId;
+
+    #[test]
+    fn test_from_internal_mapping() {
+        // Create an internal mapping
+        let internal_mapping = InternalMapping {
+            memory_start: 0x1000,
+            memory_limit: 0x2000,
+            file_offset: 0x100,
+            filename: StringId::from_offset(42),
+            build_id: StringId::from_offset(123),
+        };
+
+        // Convert to OpenTelemetry Mapping
+        let otel_mapping = datadog_profiling_otel::Mapping::from(&internal_mapping);
+
+        // Verify the conversion
+        assert_eq!(otel_mapping.memory_start, 0x1000);
+        assert_eq!(otel_mapping.memory_limit, 0x2000);
+        assert_eq!(otel_mapping.file_offset, 0x100);
+        assert_eq!(otel_mapping.filename_strindex, 42);
+        assert_eq!(otel_mapping.attribute_indices, vec![] as Vec<i32>);
+        assert_eq!(otel_mapping.has_functions, true);
+        assert_eq!(otel_mapping.has_filenames, true);
+        assert_eq!(otel_mapping.has_line_numbers, true);
+        assert_eq!(otel_mapping.has_inline_frames, false);
+    }
+
+    #[test]
+    fn test_from_internal_mapping_large_values() {
+        // Create an internal mapping with large values
+        let internal_mapping = InternalMapping {
+            memory_start: 0x1000000000000000,
+            memory_limit: 0x2000000000000000,
+            file_offset: 0x1000000000000000,
+            filename: StringId::from_offset(999),
+            build_id: StringId::from_offset(888),
+        };
+
+        // Convert to OpenTelemetry Mapping
+        let otel_mapping = datadog_profiling_otel::Mapping::from(&internal_mapping);
+
+        // Verify the conversion
+        assert_eq!(otel_mapping.memory_start, 0x1000000000000000);
+        assert_eq!(otel_mapping.memory_limit, 0x2000000000000000);
+        assert_eq!(otel_mapping.file_offset, 0x1000000000000000);
+        assert_eq!(otel_mapping.filename_strindex, 999);
+    }
+
+    #[test]
+    fn test_into_otel_mapping() {
+        // Create an internal mapping
+        let internal_mapping = InternalMapping {
+            memory_start: 0x3000,
+            memory_limit: 0x4000,
+            file_offset: 0x200,
+            filename: StringId::from_offset(555),
+            build_id: StringId::from_offset(666),
+        };
+
+        // Convert using .into() method
+        let otel_mapping: datadog_profiling_otel::Mapping = (&internal_mapping).into();
+
+        // Verify the conversion
+        assert_eq!(otel_mapping.memory_start, 0x3000);
+        assert_eq!(otel_mapping.memory_limit, 0x4000);
+        assert_eq!(otel_mapping.file_offset, 0x200);
+        assert_eq!(otel_mapping.filename_strindex, 555);
+    }
+}

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

@@ -7,4 +7,7 @@
 //! OpenTelemetry protobuf equivalents.
 
 pub mod function;
+pub mod stack_trace;
+pub mod location;
+pub mod mapping;
 

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

@@ -0,0 +1,72 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collections::identifiable::Id;
+use crate::internal::StackTrace as InternalStackTrace;
+
+impl From<&InternalStackTrace> for datadog_profiling_otel::Stack {
+    fn from(internal_stack_trace: &InternalStackTrace) -> Self {
+        Self {
+            location_indices: internal_stack_trace
+                .locations
+                .iter()
+                .map(|location_id| location_id.to_raw_id() as i32)
+                .collect(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::internal::LocationId;
+
+    #[test]
+    fn test_from_internal_stack_trace() {
+        // Create an internal stack trace
+        let internal_stack_trace = InternalStackTrace {
+            locations: vec![
+                LocationId::from_offset(0),
+                LocationId::from_offset(1),
+                LocationId::from_offset(2),
+            ],
+        };
+
+        // Convert to OpenTelemetry Stack
+        let otel_stack = datadog_profiling_otel::Stack::from(&internal_stack_trace);
+
+        // Verify the conversion - note: from_offset adds 1 to avoid zero values
+        assert_eq!(otel_stack.location_indices, vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn test_from_empty_stack_trace() {
+        // Create an internal stack trace with no locations
+        let internal_stack_trace = InternalStackTrace {
+            locations: vec![],
+        };
+
+        // Convert to OpenTelemetry Stack
+        let otel_stack = datadog_profiling_otel::Stack::from(&internal_stack_trace);
+
+        // Verify the conversion
+        assert_eq!(otel_stack.location_indices, vec![] as Vec<i32>);
+    }
+
+    #[test]
+    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),
+            ],
+        };
+
+        // 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]);
+    }
+}