starting to handle the profile dictionaries

Author: danielsn

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

@@ -10,4 +10,5 @@ pub mod function;
 pub mod stack_trace;
 pub mod location;
 pub mod mapping;
+pub mod profile;
 

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

@@ -0,0 +1,149 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::internal::Profile as InternalProfile;
+use crate::iter::{IntoLendingIterator, LendingIterator};
+
+impl From<InternalProfile> for datadog_profiling_otel::ProfilesData {
+    fn from(internal_profile: InternalProfile) -> Self {
+        // Convert the ProfilesDictionary components
+        let dictionary = datadog_profiling_otel::ProfilesDictionary {
+            // Convert mappings
+            mapping_table: internal_profile
+                .mappings
+                .iter()
+                .map(|mapping| mapping.into())
+                .collect(),
+            
+            // Convert locations
+            location_table: internal_profile
+                .locations
+                .iter()
+                .map(|location| location.into())
+                .collect(),
+            
+            // Convert functions
+            function_table: internal_profile
+                .functions
+                .iter()
+                .map(|function| function.into())
+                .collect(),
+            
+            // Convert stack traces
+            stack_table: internal_profile
+                .stack_traces
+                .iter()
+                .map(|stack_trace| stack_trace.into())
+                .collect(),
+            
+            // Convert string table using into_lending_iter
+            // Note: We can't use .map().collect() here because LendingIterator doesn't implement
+            // the standard Iterator trait. LendingIterator is designed for yielding references
+            // with lifetimes tied to the iterator itself, so we need to manually iterate and
+            // convert each string reference to an owned String.
+            string_table: {
+                let mut strings = Vec::with_capacity(internal_profile.strings.len());
+                let mut iter = internal_profile.strings.into_lending_iter();
+                while let Some(s) = iter.next() {
+                    strings.push(s.to_string());
+                }
+                strings
+            },
+            
+            // For now, set empty defaults for fields we're not handling yet
+            link_table: vec![], // TODO: Implement when we handle links
+            attribute_table: vec![], // TODO: Implement when we handle attributes
+            attribute_units: vec![], // TODO: Implement when we handle attribute units
+        };
+
+        // Create a basic ResourceProfiles structure
+        let resource_profiles = vec![datadog_profiling_otel::ResourceProfiles {
+            resource: None, // TODO: Implement when we handle resources
+            scope_profiles: vec![datadog_profiling_otel::ScopeProfiles {
+                scope: None, // TODO: Implement when we handle scopes
+                profiles: vec![], // TODO: Implement when we handle individual profiles
+                schema_url: String::new(), // TODO: Implement when we handle schema URLs
+                default_sample_type: None, // TODO: Implement when we handle sample types
+            }],
+            schema_url: String::new(), // TODO: Implement when we handle schema URLs
+        }];
+
+        Self {
+            resource_profiles,
+            dictionary: Some(dictionary),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::internal::profile::Profile as InternalProfile;
+    use datadog_profiling_otel::ProfilesData;
+
+    #[test]
+    fn test_from_internal_profile_empty() {
+        // Create an empty internal profile
+        let internal_profile = InternalProfile::new(&[], None);
+
+        // Convert to OpenTelemetry ProfilesData
+        let otel_profiles_data = ProfilesData::from(internal_profile);
+
+        // Verify the conversion
+        assert!(otel_profiles_data.dictionary.is_some());
+        let dictionary = otel_profiles_data.dictionary.unwrap();
+        
+        assert_eq!(dictionary.mapping_table.len(), 0);
+        assert_eq!(dictionary.location_table.len(), 0);
+        assert_eq!(dictionary.function_table.len(), 0);
+        assert_eq!(dictionary.stack_table.len(), 0);
+        assert_eq!(dictionary.string_table.len(), 4); // Default strings: "", "local root span id", "trace endpoint", "end_timestamp_ns"
+        assert_eq!(dictionary.link_table.len(), 0);
+        assert_eq!(dictionary.attribute_table.len(), 0);
+        assert_eq!(dictionary.attribute_units.len(), 0);
+        
+        assert_eq!(otel_profiles_data.resource_profiles.len(), 1);
+    }
+
+    #[test]
+    fn test_from_internal_profile_with_data() {
+        // Create an internal profile with some data
+        let mut internal_profile = InternalProfile::new(&[], None);
+        
+        // Add some functions using the API Function type
+        let function1 = crate::api::Function {
+            name: "test_function_1",
+            system_name: "test_system_1",
+            filename: "test_file_1.rs",
+        };
+        let function2 = crate::api::Function {
+            name: "test_function_2",
+            system_name: "test_system_2",
+            filename: "test_file_2.rs",
+        };
+        
+        let _function1_id = internal_profile.add_function(&function1);
+        let _function2_id = internal_profile.add_function(&function2);
+
+        // Convert to OpenTelemetry ProfilesData
+        let otel_profiles_data = ProfilesData::from(internal_profile);
+
+        // Verify the conversion
+        assert!(otel_profiles_data.dictionary.is_some());
+        let dictionary = otel_profiles_data.dictionary.unwrap();
+        
+        assert_eq!(dictionary.function_table.len(), 2);
+        assert_eq!(dictionary.string_table.len(), 10); // 4 default strings + 6 strings from the 2 functions
+        
+        // Verify the first function conversion - using actual observed values
+        let otel_function1 = &dictionary.function_table[0];
+        assert_eq!(otel_function1.name_strindex, 4);
+        assert_eq!(otel_function1.system_name_strindex, 5);
+        assert_eq!(otel_function1.filename_strindex, 6);
+        
+        // Verify the second function conversion - using actual observed values
+        let otel_function2 = &dictionary.function_table[1];
+        assert_eq!(otel_function2.name_strindex, 7);
+        assert_eq!(otel_function2.system_name_strindex, 8);
+        assert_eq!(otel_function2.filename_strindex, 9);
+    }
+}