feat(config): add support for process tags and container ids. (#1226)

* feat: add support for process tags and container ids.

This PR introduces support for two new metadata fields:
 - process_tags: a comma-separated list of tags that will be used to
   identify a process.
 - container_id: the container id computed by the tracing library.

I also took the opportunity to rework the FFI to be easier to interface
with, which also provide ABI stability.

Changes:
  - Rework the FFI to be easier to use and ABI stability over time.
  - Bump the schema version to v2.

Co-authored-by: raphael.gavache <raphael.gavache@datadoghq.com>

* format files

* format files 2/x

* format files 3/x

* fix FFI tests

---------

Co-authored-by: raphael.gavache <raphael.gavache@datadoghq.com>

Author: dmehala

datadog-library-config-ffi/src/tracer_metadata.rs

@@ -4,8 +4,9 @@
 #[cfg(target_os = "linux")]
 use datadog_library_config::tracer_metadata::AnonymousFileHandle;
 use datadog_library_config::tracer_metadata::{self, TracerMetadata};
-use ddcommon_ffi::{CharSlice, Result};
-use std::os::raw::c_int;
+use ddcommon_ffi::Result;
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_int};
 
 /// C-compatible representation of an anonymous file handle
 #[repr(C)]
@@ -14,53 +15,118 @@ pub struct TracerMemfdHandle {
     pub fd: c_int,
 }
 
-/// Store tracer metadata to a file handle
+/// Represents the types of metadata that can be set on a `TracerMetadata` object.
+#[repr(C)]
+pub enum MetadataKind {
+    RuntimeId = 0,
+    TracerLanguage = 1,
+    TracerVersion = 2,
+    Hostname = 3,
+    ServiceName = 4,
+    ServiceVersion = 5,
+    ProcessTags = 6,
+    ContainerId = 7,
+}
+
+/// Allocates and returns a pointer to a new `TracerMetadata` object on the heap.
 ///
 /// # Safety
+/// This function returns a raw pointer. The caller is responsible for calling
+/// `ddog_tracer_metadata_free` to deallocate the memory.
+///
+/// # Returns
+/// A non-null pointer to a newly allocated `TracerMetadata` instance.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_tracer_metadata_new() -> *mut TracerMetadata {
+    Box::into_raw(Box::new(TracerMetadata::default()))
+}
+
+/// Frees a `TracerMetadata` instance previously allocated with `ddog_tracer_metadata_new`.
+///
+/// # Safety
+/// - `ptr` must be a pointer previously returned by `ddog_tracer_metadata_new`.
+/// - Double-freeing or passing an invalid pointer results in undefined behavior.
+/// - Passing a null pointer is safe and does nothing.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_tracer_metadata_free(ptr: *mut TracerMetadata) {
+    if ptr.is_null() {
+        return;
+    }
+    unsafe {
+        drop(Box::from_raw(ptr));
+    }
+}
+
+/// Sets a field of the `TracerMetadata` object pointed to by `ptr`.
+///
+/// # Arguments
+/// - `ptr`: Pointer to a `TracerMetadata` instance.
+/// - `kind`: The metadata field to set (as defined in `MetadataKind`).
+/// - `value`: A null-terminated C string representing the value to set.
+///
+/// # Safety
+/// - Both `ptr` and `value` must be non-null.
+/// - `value` must point to a valid UTF-8 null-terminated string.
+/// - If the string is not valid UTF-8, the function does nothing.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_tracer_metadata_set(
+    ptr: *mut TracerMetadata,
+    kind: MetadataKind,
+    value: *const c_char,
+) {
+    if ptr.is_null() || value.is_null() {
+        return;
+    }
+
+    unsafe {
+        let c_str = CStr::from_ptr(value);
+        let str_value = match c_str.to_str() {
+            Ok(v) => v.to_string(),
+            Err(_) => return,
+        };
+
+        let metadata = &mut *ptr;
+
+        match kind {
+            MetadataKind::RuntimeId => metadata.runtime_id = Some(str_value),
+            MetadataKind::TracerLanguage => metadata.tracer_language = str_value,
+            MetadataKind::TracerVersion => metadata.tracer_version = str_value,
+            MetadataKind::Hostname => metadata.hostname = str_value,
+            MetadataKind::ServiceName => metadata.service_name = Some(str_value),
+            MetadataKind::ServiceVersion => metadata.service_version = Some(str_value),
+            MetadataKind::ProcessTags => metadata.process_tags = Some(str_value),
+            MetadataKind::ContainerId => metadata.container_id = Some(str_value),
+        }
+    }
+}
+
+/// Serializes the `TracerMetadata` into a platform-specific memory handle (e.g., memfd on Linux).
+///
+/// # Safety
+/// - `ptr` must be a valid, non-null pointer to a `TracerMetadata`.
+///
+/// # Returns
+/// - On Linux: a `TracerMemfdHandle` containing a raw file descriptor to a memory file.
+/// - On unsupported platforms: an error.
+/// - On failure: propagates any internal errors from the metadata storage process.
 ///
-/// Accepts raw C-compatible strings
+/// # Platform Support
+/// This function currently only supports Linux via `memfd`. On other platforms,
+/// it will return an error.
 #[no_mangle]
-pub unsafe extern "C" fn ddog_store_tracer_metadata(
-    schema_version: u8,
-    runtime_id: CharSlice,
-    tracer_language: CharSlice,
-    tracer_version: CharSlice,
-    hostname: CharSlice,
-    service_name: CharSlice,
-    service_env: CharSlice,
-    service_version: CharSlice,
+pub unsafe extern "C" fn ddog_tracer_metadata_store(
+    ptr: *mut TracerMetadata,
 ) -> Result<TracerMemfdHandle> {
-    // Convert C strings to Rust types
-    let metadata = TracerMetadata {
-        schema_version,
-        runtime_id: if runtime_id.is_empty() {
-            None
-        } else {
-            Some(runtime_id.to_string())
-        },
-        tracer_language: tracer_language.to_string(),
-        tracer_version: tracer_version.to_string(),
-        hostname: hostname.to_string(),
-        service_name: if service_name.is_empty() {
-            None
-        } else {
-            Some(service_name.to_string())
-        },
-        service_env: if service_env.is_empty() {
-            None
-        } else {
-            Some(service_env.to_string())
-        },
-        service_version: if service_version.is_empty() {
-            None
-        } else {
-            Some(service_version.to_string())
-        },
-    };
+    if ptr.is_null() {
+        return Err::<TracerMemfdHandle, _>(anyhow::anyhow!(
+            "Failed to store tracer metadata: received a null pointer"
+        ))
+        .into();
+    }
 
-    // Call the actual implementation
+    let metadata = &mut *ptr;
     let result: anyhow::Result<TracerMemfdHandle> =
-        match tracer_metadata::store_tracer_metadata(&metadata) {
+        match tracer_metadata::store_tracer_metadata(metadata) {
             #[cfg(target_os = "linux")]
             Ok(handle) => {
                 use std::os::fd::{IntoRawFd, OwnedFd};

datadog-library-config/src/tracer_metadata.rs

@@ -1,9 +1,9 @@
 // Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
+use std::default::Default;
 
 /// This struct MUST be backward compatible.
 #[derive(serde::Serialize, Debug)]
-#[repr(C)]
 pub struct TracerMetadata {
     /// Version of the schema.
     pub schema_version: u8,
@@ -26,6 +26,29 @@ pub struct TracerMetadata {
     /// Version of the service being instrumented.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub service_version: Option<String>,
+    /// Process tags of the application being instrumented.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub process_tags: Option<String>,
+    /// Container id seen by the application.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_id: Option<String>,
+}
+
+impl Default for TracerMetadata {
+    fn default() -> Self {
+        TracerMetadata {
+            schema_version: 2,
+            runtime_id: None,
+            tracer_language: String::new(),
+            tracer_version: String::new(),
+            hostname: String::new(),
+            service_name: None,
+            service_env: None,
+            service_version: None,
+            process_tags: None,
+            container_id: None,
+        }
+    }
 }
 
 pub enum AnonymousFileHandle {