profiles for the samples

Author: danielsn

datadog-profiling-otel/build.rs

@@ -9,26 +9,26 @@ fn main() {
     println!("cargo:rerun-if-changed=profiles.proto");
     println!("cargo:rerun-if-changed=opentelemetry/proto/common/v1/common.proto");
     println!("cargo:rerun-if-changed=opentelemetry/proto/resource/v1/resource.proto");
-    
+
     // Create the output directory
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
-    
+
     // Configure prost-build
     let mut config = prost_build::Config::new();
     config.out_dir(&out_dir);
-    
+
     // Compile the proto files - include all proto files so imports work correctly
     config
         .compile_protos(
             &[
                 "opentelemetry/proto/common/v1/common.proto",
                 "opentelemetry/proto/resource/v1/resource.proto",
-                "profiles.proto"
+                "profiles.proto",
             ],
-            &["."]
+            &["."],
         )
         .expect("Failed to compile protobuf files");
-    
+
     // Generate the module file with correct structure
     let module_content = r#"
 // Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
@@ -61,7 +61,6 @@ pub use opentelemetry::proto::profiles::v1development::*;
 pub use opentelemetry::proto::common::v1::*;
 pub use opentelemetry::proto::resource::v1::*;
 "#;
-    
-    std::fs::write(out_dir.join("mod.rs"), module_content)
-        .expect("Failed to write module file");
+
+    std::fs::write(out_dir.join("mod.rs"), module_content).expect("Failed to write module file");
 }

datadog-profiling-otel/examples/basic_usage.rs

@@ -6,22 +6,22 @@
 
 fn main() {
     use datadog_profiling_otel::*;
-    
+
     // Create a simple profile with some basic data
     let mut profiles_dict = ProfilesDictionary::default();
-    
+
     // Add some strings to the string table
     profiles_dict.string_table.push("cpu".to_string());
     profiles_dict.string_table.push("nanoseconds".to_string());
     profiles_dict.string_table.push("main".to_string());
-    
+
     // Create a sample type
     let sample_type = ValueType {
         type_strindex: 0, // "cpu"
         unit_strindex: 1, // "nanoseconds"
         aggregation_temporality: AggregationTemporality::Delta.into(),
     };
-    
+
     // Create a profile
     let profile = Profile {
         sample_type: Some(sample_type),
@@ -31,22 +31,28 @@ fn main() {
             .as_nanos() as i64,
         ..Default::default()
     };
-    
+
     // Create profiles data
     let mut profiles_data = ProfilesData {
         dictionary: Some(profiles_dict),
         ..Default::default()
     };
-    
+
     let mut scope_profiles = ScopeProfiles::default();
     scope_profiles.profiles.push(profile);
-    
+
     let mut resource_profiles = ResourceProfiles::default();
     resource_profiles.scope_profiles.push(scope_profiles);
-    
+
     profiles_data.resource_profiles.push(resource_profiles);
-    
+
     println!("Successfully created OpenTelemetry profile data!");
-    println!("Profile contains {} resource profiles", profiles_data.resource_profiles.len());
-    println!("Time: {}", profiles_data.resource_profiles[0].scope_profiles[0].profiles[0].time_nanos);
+    println!(
+        "Profile contains {} resource profiles",
+        profiles_data.resource_profiles.len()
+    );
+    println!(
+        "Time: {}",
+        profiles_data.resource_profiles[0].scope_profiles[0].profiles[0].time_nanos
+    );
 }

datadog-profiling-otel/src/lib.rs

@@ -15,19 +15,22 @@ pub use proto::*;
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_proto_generation() {
         // Test that we can create basic protobuf messages
         let mut profiles_dict = ProfilesDictionary::default();
         profiles_dict.string_table.push("test".to_string());
-        
+
         let profiles_data = ProfilesData {
             dictionary: Some(profiles_dict),
             ..Default::default()
         };
-        
+
         // Verify the data was set correctly
-        assert_eq!(profiles_data.dictionary.as_ref().unwrap().string_table[0], "test");
+        assert_eq!(
+            profiles_data.dictionary.as_ref().unwrap().string_table[0],
+            "test"
+        );
     }
 }

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

@@ -1,18 +1,21 @@
 // Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+//! All the mess here will go away once https://github.com/open-telemetry/opentelemetry-proto/pull/672/files is merged.
+
 use crate::collections::identifiable::Id;
 use crate::internal::Label as InternalLabel;
-use anyhow::{Result, Context};
+use anyhow::{Context, Result};
 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
-/// 
+/// * `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
@@ -25,33 +28,47 @@ pub fn convert_label_to_key_value(
     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()))?
+        .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()))?
+                .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)),
+                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
-            // But we track the mapping for building the attribute_units table
+            // 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)),
@@ -68,20 +85,20 @@ mod tests {
     #[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
+            "".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 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();
         assert_eq!(key_value.key, "thread_id");
         match key_value.value {
@@ -95,21 +112,21 @@ mod tests {
     #[test]
     fn test_convert_numeric_label() {
         let string_table = vec![
-            "".to_string(),           // index 0
+            "".to_string(),                // index 0
             "allocation_size".to_string(), // index 1
-            "bytes".to_string(),      // index 2
+            "bytes".to_string(),           // index 2
         ];
-        
+
         let label = InternalLabel::num(
             StringId::from_offset(1), // "allocation_size"
             1024,                     // 1024 bytes
             StringId::from_offset(2), // "bytes"
         );
-        
+
         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();
         assert_eq!(key_value.key, "allocation_size");
         match key_value.value {
@@ -123,12 +140,12 @@ mod tests {
     #[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 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());
@@ -137,12 +154,12 @@ mod tests {
     #[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 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());
@@ -151,21 +168,21 @@ mod tests {
     #[test]
     fn test_convert_numeric_label_with_unit_mapping() {
         let string_table = vec![
-            "".to_string(),           // index 0
+            "".to_string(),             // index 0
             "memory_usage".to_string(), // index 1
-            "megabytes".to_string(),  // index 2
+            "megabytes".to_string(),    // index 2
         ];
-        
+
         let label = InternalLabel::num(
             StringId::from_offset(1), // "memory_usage"
-            512,                       // 512 MB
+            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");
@@ -175,28 +192,28 @@ mod tests {
             }
             _ => 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
+            "".to_string(),        // index 0
+            "counter".to_string(), // index 1
         ];
-        
+
         let label = InternalLabel::num(
             StringId::from_offset(1), // "counter"
-            42,                        // 42
+            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");
@@ -206,7 +223,7 @@ mod tests {
             }
             _ => 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/location.rs

@@ -7,7 +7,8 @@ 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
+            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,
@@ -16,7 +17,7 @@ impl From<&InternalLocation> for datadog_profiling_otel::Location {
                 line: internal_location.line,
                 column: 0, // Not available in internal Location
             }],
-            is_folded: false, // Not available in internal Location
+            is_folded: false,          // Not available in internal Location
             attribute_indices: vec![], // Not available in internal Location
         }
     }