handle labels

Author: danielsn

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

@@ -0,0 +1,134 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collections::identifiable::Id;
+use crate::internal::Label as InternalLabel;
+use anyhow::{Result, Context};
+
+/// 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
+/// 
+/// # 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],
+) -> Result<datadog_profiling_otel::KeyValue> {
+    // Get the key string
+    let key_id = label.get_key().to_raw_id() as usize;
+    let key = string_table
+        .get(key_id)
+        .with_context(|| format!("Key string index {} out of bounds (string table has {} elements)", key_id, string_table.len()))?
+        .to_string();
+    
+    match label.get_value() {
+        crate::internal::LabelValue::Str(str_id) => {
+            let str_value_id = str_id.to_raw_id() as usize;
+            let str_value = string_table
+                .get(str_value_id)
+                .with_context(|| format!("Value string index {} out of bounds (string table has {} elements)", str_value_id, string_table.len()))?
+                .to_string();
+            
+            Ok(datadog_profiling_otel::KeyValue {
+                key,
+                value: Some(datadog_profiling_otel::key_value::Value::StringValue(str_value)),
+            })
+        }
+        crate::internal::LabelValue::Num { num, num_unit: _ } => {
+            // Note: OpenTelemetry KeyValue doesn't support units, so we only store the numeric value
+            Ok(datadog_profiling_otel::KeyValue {
+                key,
+                value: Some(datadog_profiling_otel::key_value::Value::IntValue(*num)),
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::collections::identifiable::StringId;
+
+    #[test]
+    fn test_convert_string_label() {
+        let string_table = vec![
+            "".to_string(),           // index 0
+            "thread_id".to_string(),  // index 1
+            "main".to_string(),       // index 2
+        ];
+        
+        let label = InternalLabel::str(
+            StringId::from_offset(1), // "thread_id"
+            StringId::from_offset(2), // "main"
+        );
+        
+        let result = convert_label_to_key_value(&label, &string_table);
+        assert!(result.is_ok());
+        
+        let key_value = result.unwrap();
+        assert_eq!(key_value.key, "thread_id");
+        match key_value.value {
+            Some(datadog_profiling_otel::key_value::Value::StringValue(s)) => {
+                assert_eq!(s, "main");
+            }
+            _ => panic!("Expected StringValue"),
+        }
+    }
+
+    #[test]
+    fn test_convert_numeric_label() {
+        let string_table = vec![
+            "".to_string(),           // index 0
+            "allocation_size".to_string(), // index 1
+            "bytes".to_string(),      // index 2
+        ];
+        
+        let label = InternalLabel::num(
+            StringId::from_offset(1), // "allocation_size"
+            1024,                     // 1024 bytes
+            StringId::from_offset(2), // "bytes"
+        );
+        
+        let result = convert_label_to_key_value(&label, &string_table);
+        assert!(result.is_ok());
+        
+        let key_value = result.unwrap();
+        assert_eq!(key_value.key, "allocation_size");
+        match key_value.value {
+            Some(datadog_profiling_otel::key_value::Value::IntValue(n)) => {
+                assert_eq!(n, 1024);
+            }
+            _ => panic!("Expected IntValue"),
+        }
+    }
+
+    #[test]
+    fn test_convert_label_out_of_bounds() {
+        let string_table = vec!["".to_string()]; // Only one string
+        
+        let label = InternalLabel::str(
+            StringId::from_offset(1), // This index doesn't exist
+            StringId::from_offset(0), // This index exists
+        );
+        
+        let result = convert_label_to_key_value(&label, &string_table);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_convert_label_empty_string_table() {
+        let string_table: Vec<String> = vec![];
+        
+        let label = InternalLabel::str(
+            StringId::from_offset(0), // Even index 0 is out of bounds
+            StringId::from_offset(0),
+        );
+        
+        let result = convert_label_to_key_value(&label, &string_table);
+        assert!(result.is_err());
+    }
+}

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

@@ -11,4 +11,5 @@ pub mod stack_trace;
 pub mod location;
 pub mod mapping;
 pub mod profile;
+pub mod label;