convert labels to key-values

Author: danielsn

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

@@ -4,19 +4,22 @@
 use crate::collections::identifiable::Id;
 use crate::internal::Label as InternalLabel;
 use anyhow::{Result, Context};
+use std::collections::HashMap;
 
 /// Converts a datadog-profiling internal Label to an OpenTelemetry KeyValue
 /// 
 /// # Arguments
 /// * `label` - The internal label to convert
 /// * `string_table` - A slice of strings where StringIds index into
+/// * `key_to_unit_map` - A mutable map from key string index to unit string index for numeric labels
 /// 
 /// # Returns
 /// * `Ok(KeyValue)` if the conversion is successful
 /// * `Err` with context if the StringIds are out of bounds of the string table
 pub fn convert_label_to_key_value(
     label: &InternalLabel,
     string_table: &[String],
+    key_to_unit_map: &mut HashMap<usize, usize>,
 ) -> Result<datadog_profiling_otel::KeyValue> {
     // Get the key string
     let key_id = label.get_key().to_raw_id() as usize;
@@ -38,8 +41,17 @@ pub fn convert_label_to_key_value(
                 value: Some(datadog_profiling_otel::key_value::Value::StringValue(str_value)),
             })
         }
-        crate::internal::LabelValue::Num { num, num_unit: _ } => {
+        crate::internal::LabelValue::Num { num, num_unit } => {
             // Note: OpenTelemetry KeyValue doesn't support units, so we only store the numeric value
+            // But we track the mapping for building the attribute_units table
+            let key_index = label.get_key().to_raw_id() as usize;
+            let unit_index = num_unit.to_raw_id() as usize;
+            
+            // Only add to the map if the unit is not the default empty string (index 0)
+            if unit_index > 0 {
+                key_to_unit_map.insert(key_index, unit_index);
+            }
+            
             Ok(datadog_profiling_otel::KeyValue {
                 key,
                 value: Some(datadog_profiling_otel::key_value::Value::IntValue(*num)),
@@ -66,7 +78,8 @@ mod tests {
             StringId::from_offset(2), // "main"
         );
 
-        let result = convert_label_to_key_value(&label, &string_table);
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
         assert!(result.is_ok());
 
         let key_value = result.unwrap();
@@ -93,7 +106,8 @@ mod tests {
             StringId::from_offset(2), // "bytes"
         );
 
-        let result = convert_label_to_key_value(&label, &string_table);
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
         assert!(result.is_ok());
 
         let key_value = result.unwrap();
@@ -115,7 +129,8 @@ mod tests {
             StringId::from_offset(0), // This index exists
         );
 
-        let result = convert_label_to_key_value(&label, &string_table);
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
         assert!(result.is_err());
     }
 
@@ -128,7 +143,71 @@ mod tests {
             StringId::from_offset(0),
         );
 
-        let result = convert_label_to_key_value(&label, &string_table);
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_convert_numeric_label_with_unit_mapping() {
+        let string_table = vec![
+            "".to_string(),           // index 0
+            "memory_usage".to_string(), // index 1
+            "megabytes".to_string(),  // index 2
+        ];
+        
+        let label = InternalLabel::num(
+            StringId::from_offset(1), // "memory_usage"
+            512,                       // 512 MB
+            StringId::from_offset(2), // "megabytes"
+        );
+        
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
+        assert!(result.is_ok());
+        
+        // Verify the KeyValue conversion
+        let key_value = result.unwrap();
+        assert_eq!(key_value.key, "memory_usage");
+        match key_value.value {
+            Some(datadog_profiling_otel::key_value::Value::IntValue(n)) => {
+                assert_eq!(n, 512);
+            }
+            _ => panic!("Expected IntValue"),
+        }
+        
+        // Verify the unit mapping was added
+        assert_eq!(key_to_unit_map.get(&1), Some(&2)); // key index 1 maps to unit index 2
+    }
+
+    #[test]
+    fn test_convert_numeric_label_without_unit_mapping() {
+        let string_table = vec![
+            "".to_string(),           // index 0
+            "counter".to_string(),    // index 1
+        ];
+        
+        let label = InternalLabel::num(
+            StringId::from_offset(1), // "counter"
+            42,                        // 42
+            StringId::from_offset(0), // empty string (default)
+        );
+        
+        let mut key_to_unit_map = HashMap::new();
+        let result = convert_label_to_key_value(&label, &string_table, &mut key_to_unit_map);
+        assert!(result.is_ok());
+        
+        // Verify the KeyValue conversion
+        let key_value = result.unwrap();
+        assert_eq!(key_value.key, "counter");
+        match key_value.value {
+            Some(datadog_profiling_otel::key_value::Value::IntValue(n)) => {
+                assert_eq!(n, 42);
+            }
+            _ => panic!("Expected IntValue"),
+        }
+        
+        // Verify no unit mapping was added for default empty string
+        assert!(key_to_unit_map.is_empty());
+    }
 }

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

@@ -3,9 +3,48 @@
 
 use crate::internal::Profile as InternalProfile;
 use crate::iter::{IntoLendingIterator, LendingIterator};
+use crate::internal::profile::otel_emitter::label::convert_label_to_key_value;
+use crate::collections::identifiable::Id;
+use anyhow::{Result, Context};
+use std::collections::HashMap;
 
-impl From<InternalProfile> for datadog_profiling_otel::ProfilesData {
-    fn from(internal_profile: InternalProfile) -> Self {
+impl TryFrom<InternalProfile> for datadog_profiling_otel::ProfilesData {
+    type Error = anyhow::Error;
+    
+    fn try_from(internal_profile: InternalProfile) -> Result<Self> {
+        // 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.
+        let 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
+        };
+        
+        // Convert labels to KeyValues for the attribute table
+        let mut key_to_unit_map = HashMap::new();
+        let mut attribute_table = Vec::with_capacity(internal_profile.labels.len());
+        
+        for label in internal_profile.labels.iter() {
+            let key_value = convert_label_to_key_value(label, &string_table, &mut key_to_unit_map)
+                .with_context(|| format!("Failed to convert label with key index {}", label.get_key().to_raw_id()))?;
+            attribute_table.push(key_value);
+        }
+        
+        // Build attribute units from the key-to-unit mapping
+        let attribute_units = key_to_unit_map
+            .into_iter()
+            .map(|(key_index, unit_index)| datadog_profiling_otel::AttributeUnit {
+                attribute_key_strindex: key_index as i32,
+                unit_strindex: unit_index as i32,
+            })
+            .collect();
+        
         // Convert the ProfilesDictionary components
         let dictionary = datadog_profiling_otel::ProfilesDictionary {
             // Convert mappings
@@ -36,24 +75,12 @@ impl From<InternalProfile> for datadog_profiling_otel::ProfilesData {
                 .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
-            },
+            string_table,
+            attribute_table,
+            attribute_units,
 
-            // 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
+            // For now, set empty default for links (they represent trace span connections)
+            link_table: vec![], // TODO: Implement when we handle trace links
         };
 
         // Create a basic ResourceProfiles structure
@@ -68,10 +95,10 @@ impl From<InternalProfile> for datadog_profiling_otel::ProfilesData {
             schema_url: String::new(), // TODO: Implement when we handle schema URLs
         }];
 
-        Self {
+        Ok(Self {
             resource_profiles,
             dictionary: Some(dictionary),
-        }
+        })
     }
 }
 
@@ -86,7 +113,7 @@ mod tests {
         let internal_profile = InternalProfile::new(&[], None);
 
         // Convert to OpenTelemetry ProfilesData
-        let otel_profiles_data = ProfilesData::from(internal_profile);
+        let otel_profiles_data = ProfilesData::try_from(internal_profile).unwrap();
 
         // Verify the conversion
         assert!(otel_profiles_data.dictionary.is_some());
@@ -125,7 +152,7 @@ mod tests {
         let _function2_id = internal_profile.add_function(&function2);
 
         // Convert to OpenTelemetry ProfilesData
-        let otel_profiles_data = ProfilesData::from(internal_profile);
+        let otel_profiles_data = ProfilesData::try_from(internal_profile).unwrap();
 
         // Verify the conversion
         assert!(otel_profiles_data.dictionary.is_some());
@@ -146,4 +173,73 @@ mod tests {
         assert_eq!(otel_function2.system_name_strindex, 8);
         assert_eq!(otel_function2.filename_strindex, 9);
     }
+
+    #[test]
+    fn test_from_internal_profile_with_labels() {
+        // Create an internal profile with some data
+        let mut internal_profile = InternalProfile::new(&[], None);
+        
+        // Add some labels using the API
+        let label1 = crate::api::Label {
+            key: "thread_id",
+            str: "main",
+            num: 0,
+            num_unit: "",
+        };
+        let label2 = crate::api::Label {
+            key: "memory_usage",
+            str: "",
+            num: 1024,
+            num_unit: "bytes",
+        };
+        
+        // Add a sample with these labels
+        let sample = crate::api::Sample {
+            locations: vec![],
+            values: &[42],
+            labels: vec![label1, label2],
+        };
+        
+        let _ = internal_profile.add_sample(sample, None);
+
+        // Convert to OpenTelemetry ProfilesData
+        let otel_profiles_data = ProfilesData::try_from(internal_profile).unwrap();
+
+        // Verify the conversion
+        assert!(otel_profiles_data.dictionary.is_some());
+        let dictionary = otel_profiles_data.dictionary.unwrap();
+        
+        // Should have 2 labels converted to attributes
+        assert_eq!(dictionary.attribute_table.len(), 2);
+        
+        // Should have 1 attribute unit (for the numeric label with unit)
+        assert_eq!(dictionary.attribute_units.len(), 1);
+        
+        // Verify the first attribute (string label)
+        let attr1 = &dictionary.attribute_table[0];
+        assert_eq!(attr1.key, "thread_id");
+        match &attr1.value {
+            Some(datadog_profiling_otel::key_value::Value::StringValue(s)) => {
+                assert_eq!(s, "main");
+            }
+            _ => panic!("Expected StringValue"),
+        }
+        
+        // Verify the second attribute (numeric label)
+        let attr2 = &dictionary.attribute_table[1];
+        assert_eq!(attr2.key, "memory_usage");
+        match &attr2.value {
+            Some(datadog_profiling_otel::key_value::Value::IntValue(n)) => {
+                assert_eq!(*n, 1024);
+            }
+            _ => panic!("Expected IntValue"),
+        }
+        
+        // Verify the attribute unit mapping
+        let unit = &dictionary.attribute_units[0];
+        // The key should map to the memory_usage string index
+        // and the unit should map to the "bytes" string index
+        assert!(unit.attribute_key_strindex > 0);
+        assert!(unit.unit_strindex > 0);
+    }
 }