[profiling] Support OTel signal

Cargo.toml

@@ -15,6 +15,7 @@ members = [
   "datadog-live-debugger-ffi",
   "datadog-profiling",
   "datadog-profiling-ffi",
+  "datadog-profiling-otel",
   "datadog-profiling-protobuf",
   "datadog-profiling-replayer",
   "datadog-remote-config",

bin_tests/tests/crashtracker_bin_test.rs

@@ -145,6 +145,7 @@ fn test_crasht_tracking_validate_callstack() {
     test_crash_tracking_callstack()
 }
 
+#[cfg(not(any(all(target_arch = "x86_64", target_env = "musl"), target_os = "macos")))]
 fn test_crash_tracking_callstack() {
     let (_, crashtracker_receiver) = setup_crashtracking_crates(BuildProfile::Release);
 

datadog-profiling-ffi/src/profiles/datatypes.rs

@@ -754,7 +754,8 @@ pub unsafe extern "C" fn ddog_prof_Profile_serialize(
         }
 
         let end_time = end_time.map(SystemTime::from);
-        old_profile.serialize_into_compressed_pprof(end_time, None)
+        // TODO: make this an option instead of hardcoding to otel
+        old_profile.serialize_into_compressed_otel(end_time, None)
     })()
     .context("ddog_prof_Profile_serialize failed")
     .into()

datadog-profiling-otel/Cargo.toml

@@ -0,0 +1,25 @@
+# Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "datadog-profiling-otel"
+rust-version.workspace = true
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+
+[lib]
+bench = false
+
+[dependencies]
+prost = "0.13"
+prost-types = "0.13"
+zstd = "0.13"
+anyhow = "1.0"
+
+[build-dependencies]
+prost-build = "0.13"
+protoc-bin-vendored = "3.0.0"
+
+[dev-dependencies]
+bolero = "0.13"

datadog-profiling-otel/README.md

@@ -0,0 +1,23 @@
+# datadog-profiling-otel
+
+This module provides Rust bindings for the OpenTelemetry profiling protobuf definitions, generated using the `prost` library.
+This crate implements serialization of data into the otel profiling format; if you're building a profiler you usually don't want to use this crate directly, and instead should use datadog-profiling and ask it to serialize using ottel.
+
+## Usage
+
+See the [basic_usage.rs](examples/basic_usage.rs) example for a complete demonstration of how to create OpenTelemetry profile data.
+
+### Running Examples
+
+```bash
+# Run the basic usage example
+cargo run --example basic_usage
+
+# Run tests
+cargo test
+
+# Build
+cargo build
+```
+
+

datadog-profiling-otel/build.rs

@@ -0,0 +1,35 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    // protoc is required to compile proto files. This uses protoc-bin-vendored to provide
+    // the protoc binary, setting the env var to tell prost_build where to find it.
+    std::env::set_var("PROTOC", protoc_bin_vendored::protoc_bin_path().unwrap());
+
+    // Tell Cargo to rerun this build script if the proto files change
+    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",
+            ],
+            &["."],
+        )
+        .expect("Failed to compile protobuf files");
+}

datadog-profiling-otel/examples/basic_usage.rs

@@ -0,0 +1,55 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+// This example demonstrates how to use the generated protobuf code
+// from the OpenTelemetry profiles.proto file.
+
+fn main() {
+    use datadog_profiling_otel::*;
+
+    let mut profiles_dict = ProfilesDictionary::default();
+
+    profiles_dict.string_table.push("cpu".to_string());
+    profiles_dict.string_table.push("nanoseconds".to_string());
+    profiles_dict.string_table.push("main".to_string());
+
+    let sample_type = ValueType {
+        type_strindex: 0, // "cpu"
+        unit_strindex: 1, // "nanoseconds"
+        aggregation_temporality: AggregationTemporality::Delta.into(),
+    };
+
+    let profile = Profile {
+        sample_type: Some(sample_type),
+        time_nanos: std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as i64,
+        ..Default::default()
+    };
+
+    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
+    );
+    let serialized = profiles_data.serialize_into_compressed_proto().unwrap();
+    println!("Serialized size: {} bytes", serialized.len());
+}

datadog-profiling-otel/opentelemetry/proto/common/v1/common.proto

@@ -0,0 +1,40 @@
+// Copyright 2023, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package opentelemetry.proto.common.v1;
+
+// KeyValue is a key-value pair that is used to store Span attributes, Link
+// attributes, etc.
+message KeyValue {
+  string key = 1;
+  oneof value {
+    string string_value = 2;
+    bool bool_value = 3;
+    int64 int_value = 4;
+    double double_value = 5;
+    bytes bytes_value = 6;
+  }
+}
+
+// InstrumentationScope is a message representing the instrumentation scope information
+// such as the fully qualified name and version.
+message InstrumentationScope {
+  // An empty instrumentation scope name means the name is unknown.
+  string name = 1;
+  string version = 2;
+  repeated KeyValue attributes = 3;
+  uint32 dropped_attributes_count = 4;
+}

datadog-profiling-otel/opentelemetry/proto/resource/v1/resource.proto

@@ -0,0 +1,29 @@
+// Copyright 2023, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package opentelemetry.proto.resource.v1;
+
+import "opentelemetry/proto/common/v1/common.proto";
+
+// Resource information.
+message Resource {
+  // Set of attributes that describe the resource.
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
+
+  // dropped_attributes_count is the number of dropped attributes. If the value is 0,
+  // then no attributes were dropped.
+  uint32 dropped_attributes_count = 2;
+}