libdatadog 40.0.0.2.0 → 45.0.0.1.0

data/vendor/{libdatadog-40.0.0/aarch64-linux → libdatadog-45.0.0/x86_64-linux-musl}/include/datadog/common.h

@@ -52,8 +52,22 @@
 
 typedef struct ddog_Endpoint ddog_Endpoint;
 
+/**
+ * A shared handle to a [`MutableMetadata`].
+ *
+ * This is a cheap-to-clone `Arc<ArcSwap<MutableMetadata>>`: all clones observe the same
+ * underlying value. See the
+ * [module documentation](self) for the write/read protocol.
+ */
+typedef struct ddog_MutableMetadataHandle ddog_MutableMetadataHandle;
+
 typedef struct ddog_Tag ddog_Tag;
 
+typedef struct ddog_ArrayQueue {
+  struct ddog_ArrayQueue *inner;
+  void (*item_delete_fn)(void*);
+} ddog_ArrayQueue;
+
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
@@ -77,46 +91,6 @@ typedef struct ddog_Error {
   struct ddog_Vec_U8 message;
 } ddog_Error;
 
-typedef struct ddog_Slice_CChar {
-  /**
-   * Should be non-null and suitably aligned for the underlying type. It is
-   * allowed but not recommended for the pointer to be null when the len is
-   * zero.
-   */
-  const char *ptr;
-  /**
-   * The number of elements (not bytes) that `.ptr` points to. Must be less
-   * than or equal to [isize::MAX].
-   */
-  uintptr_t len;
-} ddog_Slice_CChar;
-
-/**
- * Use to represent strings -- should be valid UTF-8.
- */
-typedef struct ddog_Slice_CChar ddog_CharSlice;
-
-typedef enum ddog_Option_Error_Tag {
-  DDOG_OPTION_ERROR_SOME_ERROR,
-  DDOG_OPTION_ERROR_NONE_ERROR,
-} ddog_Option_Error_Tag;
-
-typedef struct ddog_Option_Error {
-  ddog_Option_Error_Tag tag;
-  union {
-    struct {
-      struct ddog_Error some;
-    };
-  };
-} ddog_Option_Error;
-
-typedef struct ddog_Option_Error ddog_MaybeError;
-
-typedef struct ddog_ArrayQueue {
-  struct ddog_ArrayQueue *inner;
-  void (*item_delete_fn)(void*);
-} ddog_ArrayQueue;
-
 typedef enum ddog_ArrayQueue_NewResult_Tag {
   DDOG_ARRAY_QUEUE_NEW_RESULT_OK,
   DDOG_ARRAY_QUEUE_NEW_RESULT_ERR,
@@ -210,6 +184,59 @@ typedef struct ddog_ArrayQueue_UsizeResult {
   };
 } ddog_ArrayQueue_UsizeResult;
 
+typedef struct ddog_Slice_CChar {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const char *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_CChar;
+
+/**
+ * Use to represent strings -- should be valid UTF-8.
+ */
+typedef struct ddog_Slice_CChar ddog_CharSlice;
+
+typedef enum ddog_Option_Error_Tag {
+  DDOG_OPTION_ERROR_SOME_ERROR,
+  DDOG_OPTION_ERROR_NONE_ERROR,
+} ddog_Option_Error_Tag;
+
+typedef struct ddog_Option_Error {
+  ddog_Option_Error_Tag tag;
+  union {
+    struct {
+      struct ddog_Error some;
+    };
+  };
+} ddog_Option_Error;
+
+typedef struct ddog_Option_Error ddog_MaybeError;
+
+/**
+ * A generic result type for when an operation may fail,
+ * but there's nothing to return in the case of success.
+ */
+typedef enum ddog_VoidResult_Tag {
+  DDOG_VOID_RESULT_OK,
+  DDOG_VOID_RESULT_ERR,
+} ddog_VoidResult_Tag;
+
+typedef struct ddog_VoidResult {
+  ddog_VoidResult_Tag tag;
+  union {
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_VoidResult;
+
 typedef enum ddog_Option_U32_Tag {
   DDOG_OPTION_U32_SOME_U32,
   DDOG_OPTION_U32_NONE_U32,
@@ -384,6 +411,14 @@ typedef enum ddog_prof_SampleType {
    * serialization.
    */
   DDOG_PROF_SAMPLE_TYPE_CUSTOM5,
+  /**
+   * Time spent in garbage collection.
+   */
+  DDOG_PROF_SAMPLE_TYPE_GC_TIME,
+  /**
+   * Number of garbage-collection samples / pause events.
+   */
+  DDOG_PROF_SAMPLE_TYPE_GC_SAMPLES,
 } ddog_prof_SampleType;
 
 typedef enum ddog_prof_Utf8Option {
@@ -517,24 +552,6 @@ typedef struct ddog_prof_ProfileExporter_Result {
   };
 } ddog_prof_ProfileExporter_Result;
 
-/**
- * A generic result type for when an operation may fail,
- * but there's nothing to return in the case of success.
- */
-typedef enum ddog_VoidResult_Tag {
-  DDOG_VOID_RESULT_OK,
-  DDOG_VOID_RESULT_ERR,
-} ddog_VoidResult_Tag;
-
-typedef struct ddog_VoidResult {
-  ddog_VoidResult_Tag tag;
-  union {
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_VoidResult;
-
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
@@ -1759,14 +1776,6 @@ typedef struct ddog_TelemetryClientConfig {
    * How often telemetry should be sent, in milliseconds.
    */
   uint64_t interval;
-  /**
-   * A V4 UUID that represents a tracer session. This ID should:
-   * - Be generated when the tracer starts
-   * - Be identical within the context of a host (i.e. multiple threads/processes that belong to
-   *   a single instrumented app should share the same runtime_id)
-   * - Be associated with traces to allow correlation between traces and telemetry data
-   */
-  ddog_CharSlice runtime_id;
   /**
    * Whether to enable debug mode for telemetry.
    * When enabled, sets the DD-Telemetry-Debug-Enabled header to true.
@@ -1971,6 +1980,37 @@ typedef struct ddog_ProcessInfo {
   ddog_CharSlice language;
 } ddog_ProcessInfo;
 
+/**
+ * C-compatible representation of an anonymous file handle
+ */
+typedef struct ddog_TracerMemfdHandle {
+  /**
+   * File descriptor (relevant only on Linux)
+   */
+  int fd;
+} ddog_TracerMemfdHandle;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_Result_TracerMemfdHandle_Tag {
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_OK_TRACER_MEMFD_HANDLE,
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_ERR_TRACER_MEMFD_HANDLE,
+} ddog_Result_TracerMemfdHandle_Tag;
+
+typedef struct ddog_Result_TracerMemfdHandle {
+  ddog_Result_TracerMemfdHandle_Tag tag;
+  union {
+    struct {
+      struct ddog_TracerMemfdHandle ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_Result_TracerMemfdHandle;
+
 /**
  * Ffi safe type representing an owned null-terminated C array
  * Equivalent to a std::ffi::CString
@@ -2028,37 +2068,6 @@ typedef struct ddog_LibraryConfigLoggedResult {
   };
 } ddog_LibraryConfigLoggedResult;
 
-/**
- * C-compatible representation of an anonymous file handle
- */
-typedef struct ddog_TracerMemfdHandle {
-  /**
-   * File descriptor (relevant only on Linux)
-   */
-  int fd;
-} ddog_TracerMemfdHandle;
-
-/**
- * A generic result type for when an operation may fail,
- * or may return <T> in case of success.
- */
-typedef enum ddog_Result_TracerMemfdHandle_Tag {
-  DDOG_RESULT_TRACER_MEMFD_HANDLE_OK_TRACER_MEMFD_HANDLE,
-  DDOG_RESULT_TRACER_MEMFD_HANDLE_ERR_TRACER_MEMFD_HANDLE,
-} ddog_Result_TracerMemfdHandle_Tag;
-
-typedef struct ddog_Result_TracerMemfdHandle {
-  ddog_Result_TracerMemfdHandle_Tag tag;
-  union {
-    struct {
-      struct ddog_TracerMemfdHandle ok;
-    };
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_Result_TracerMemfdHandle;
-
 /**
  * Log level for filtering log events.
  */
@@ -2438,10 +2447,9 @@ typedef struct ddog_SharedRuntimeFFIError {
 #define ddog_MAX_ATTRS_DATA_SIZE 612
 
 /**
- * Opaque handle to a thread context record. Used to allow the FFI to convert [ThreadContext]
- * to and from raw pointers without exposing [ThreadContextRecord], as the latter needs extra
- * care to be manipulated (async-signal-safety, seq-lock-like modification protocol through
- * [ThreadContextRecord::valid], etc.)
+ * Opaque handle to a thread context record. Used to pass an owned thread context to and from C
+ * without exposing `ThreadContext`, as the underlying record needs extra care to be
+ * manipulated (async-signal-safety, seq-lock-like modification protocol, etc.)
  */
 typedef struct ddog_ThreadContextHandle {
 
@@ -2942,27 +2950,6 @@ typedef void (*ddog_crasht_RuntimeStacktraceStringCallback)(void (*emit_stacktra
 extern "C" {
 #endif // __cplusplus
 
-/**
- * Drops the error. It should not be used after this, though the
- * implementation tries to limit the damage in the case of use-after-free and
- * double-free scenarios.
- *
- * # Safety
- *
- * Only pass null or a pointer to a valid, mutable `ddog_Error`.
- */
-void ddog_Error_drop(struct ddog_Error *error);
-
-/**
- * Returns a CharSlice of the error's message that is valid until the error
- * is dropped.
- * # Safety
- * Only pass null or a valid reference to a `ddog_Error`.
- */
-ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
-
-void ddog_MaybeError_drop(ddog_MaybeError);
-
 /**
  * Creates a new ArrayQueue with the given capacity and item_delete_fn.
  * The item_delete_fn is called when an item is dropped from the queue.
@@ -3057,6 +3044,73 @@ void ddog_endpoint_set_use_system_resolver(struct ddog_Endpoint *endpoint,
 
 void ddog_endpoint_drop(struct ddog_Endpoint*);
 
+/**
+ * Drops the error. It should not be used after this, though the
+ * implementation tries to limit the damage in the case of use-after-free and
+ * double-free scenarios.
+ *
+ * # Safety
+ *
+ * Only pass null or a pointer to a valid, mutable `ddog_Error`.
+ */
+void ddog_Error_drop(struct ddog_Error *error);
+
+/**
+ * Returns a CharSlice of the error's message that is valid until the error
+ * is dropped.
+ * # Safety
+ * Only pass null or a valid reference to a `ddog_Error`.
+ */
+ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
+
+void ddog_MaybeError_drop(ddog_MaybeError);
+
+/**
+ * Creates a shared, updatable metadata handle initialized with default values.
+ *
+ * Use the metadata setters to configure or update its values.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable (uninitialized) memory for a
+ * `ddog_MutableMetadataHandle *`.
+ */
+void ddog_mutable_metadata_new(struct ddog_MutableMetadataHandle **out_handle);
+
+/**
+ * Frees a `ddog_MutableMetadataHandle` handle.
+ *
+ * Call once this handle is no longer needed. It must not be used concurrently
+ * with this call or accessed afterward. Other cloned handles remain valid.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid mutable metadata handle obtained through [`ddog_mutable_metadata_new`]
+ */
+void ddog_mutable_metadata_free(struct ddog_MutableMetadataHandle *handle);
+
+/**
+ * Replaces the `runtime_id` held by the shared mutable metadata handle.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid mutable metadata handle obtained through [`ddog_mutable_metadata_new`]
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_mutable_metadata_set_runtime_id(const struct ddog_MutableMetadataHandle *handle,
+                                                            ddog_CharSlice runtime_id);
+
+/**
+ * Replaces the `process_tags` held by the shared mutable metadata handle.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid mutable metadata handle obtained through [`ddog_mutable_metadata_new`]
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_mutable_metadata_set_process_tags(const struct ddog_MutableMetadataHandle *handle,
+                                                              ddog_CharSlice process_tags);
+
 struct ddog_Option_U32 ddog_Option_U32_some(uint32_t v);
 
 struct ddog_Option_U32 ddog_Option_U32_none(void);

data/vendor/{libdatadog-40.0.0 → libdatadog-45.0.0}/x86_64-linux-musl/include/datadog/data-pipeline.h

@@ -137,6 +137,13 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_telemetry(stru
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_compute_stats(struct ddog_TraceExporterConfig *config,
                                                                              bool is_enabled);
 
+/**
+ * Indicates that the tracer has already marked top-level spans with `_dd.top_level`.
+ * Sets the `Datadog-Client-Computed-Top-Level` header without enabling stats computation.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_top_level(struct ddog_TraceExporterConfig *config,
+                                                                                         bool client_computed_top_level);
+
 /**
  * Sets `Datadog-Client-Computed-Stats` header to `true`.
  * This indicates that the upstream system has already computed the stats,
@@ -154,12 +161,31 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_compute_stats(str
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_stats(struct ddog_TraceExporterConfig *config,
                                                                                      bool client_computed_stats);
 
+/**
+ * Shares a mutable metadata handle with the exporter config.
+ *
+ * When set, this supersedes `ddog_trace_exporter_config_set_process_tags` and
+ * `ddog_trace_exporter_config_set_runtime_id`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_mutable_metadata(struct ddog_TraceExporterConfig *config,
+                                                                                const ddog_MutableMetadataHandle *metadata);
+
 /**
  * Sets the process tags to be included in the stats payload.
+ *
+ * This should not be used when `ddog_trace_exporter_config_set_mutable_metadata` is used.
  */
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_process_tags(struct ddog_TraceExporterConfig *config,
                                                                             ddog_CharSlice process_tags);
 
+/**
+ * Sets the runtime id used in payloads.
+ *
+ * This should not be used when `ddog_trace_exporter_config_set_mutable_metadata` is used.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_runtime_id(struct ddog_TraceExporterConfig *config,
+                                                                          ddog_CharSlice runtime_id);
+
 /**
  * Sets the `X-Datadog-Test-Session-Token` header. Only used for testing with the test agent.
  */
@@ -187,19 +213,21 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(st
                                                                               struct ddog_ForkSafeRuntime *handle);
 
 /**
- * Enables OTLP HTTP/JSON export and sets the endpoint URL.
+ * Enables OTLP trace export and sets the endpoint URL.
  *
- * When set, traces are sent to this URL in OTLP HTTP/JSON format instead of the Datadog
- * agent. The host language is responsible for resolving the endpoint from its configuration
- * (e.g. `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`) before calling this function.
+ * When set, traces are sent to this URL using the protocol selected by
+ * `ddog_trace_exporter_config_set_otlp_protocol` instead of the Datadog agent. The host language
+ * is responsible for resolving the endpoint from its configuration (e.g.
+ * `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`) before calling this function.
  */
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(struct ddog_TraceExporterConfig *config,
                                                                              ddog_CharSlice url);
 
 /**
- * Sets the OTLP export protocol. Accepts the OTel-standard values `http/json` (default) or
- * `http/protobuf`; `grpc` is rejected as not yet supported. The host language resolves the value
+ * Sets the OTLP export protocol. Accepts the OTel-standard values `http/json` (default),
+ * `http/protobuf`, or `grpc`; unknown values are rejected. The host language resolves the value
  * (e.g. from `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`).
+ * The `grpc` protocol currently supports plaintext `http://` endpoints only.
  *
  * Has no effect unless an OTLP endpoint is also configured via
  * `ddog_trace_exporter_config_set_otlp_endpoint`; without one, traces are sent to the
@@ -240,6 +268,48 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_stats_cardinality
  */
 struct ddog_CardinalityLimitConfig ddog_trace_exporter_config_default_stats_cardinality_limit(void);
 
+/**
+ * Enables agentless APM trace export and sets the intake URL and API key.
+ *
+ * When set, APM trace spans are sent directly to the Datadog HTTP intake in JSON format
+ * (`POST /v1/input`) instead of through the Datadog Agent. Agentless trace export is mutually
+ * exclusive with both an agent URL ([`ddog_trace_exporter_config_set_url`]) and an OTLP endpoint
+ * ([`ddog_trace_exporter_config_set_otlp_endpoint`]); combining either with this setter causes
+ * [`ddog_trace_exporter_new`] to return an error.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_agentless_endpoint(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice url,
+                                                                                  ddog_CharSlice api_key);
+
+/**
+ * Sets the request timeout (in milliseconds) used by the agentless intake transport.
+ *
+ * Defaults to 15 seconds when unset. Calling this without also setting an agentless endpoint
+ * causes [`ddog_trace_exporter_new`] to return an error.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_agentless_timeout(struct ddog_TraceExporterConfig *config,
+                                                                                 uint64_t timeout_ms);
+
+/**
+ * Sets the span obfuscation configuration from a JSON string.
+ *
+ * `json` is deserialized into `ObfuscationConfig` (the same struct the Datadog Agent uses),
+ * which controls obfuscation of HTTP URLs, SQL resources, Redis/Valkey commands, memcached
+ * commands, credit-card numbers, elasticsearch/opensearch/mongodb bodies, and tag-replace
+ * rules. Obfuscation is applied to every span on the agentless export path (see
+ * [`ddog_trace_exporter_config_set_agentless_endpoint`]); it has no effect on the agent path.
+ *
+ * Returns an error if `json` is not valid UTF-8 or fails to deserialize. Example:
+ * ```c
+ * ddog_trace_exporter_config_set_obfuscation_config(
+ *   cfg, DDOG_CHARSLICE_C(
+ *     "{\"http\":{\"remove_query_string\":true},"
+ *     "\"credit_cards\":{\"enabled\":true}}"));
+ * ```
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_obfuscation_config(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice json);
+
 /**
  * Configure the exporter to write traces as newline-delimited JSON to stdout (the Datadog
  * Forwarder "log exporter" path) instead of sending them to a Datadog agent. Used in serverless
@@ -262,9 +332,9 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_output_to_log(str
 /**
  * Create a new TraceExporter instance.
  *
- * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces to
- * that endpoint in OTLP over HTTP — JSON or protobuf per the configured protocol — instead of
- * to the Datadog agent. The same payload (e.g. MessagePack) is passed to
+ * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces using
+ * the configured `http/json`, `http/protobuf`, or `grpc` protocol instead of the Datadog agent.
+ * The same payload (e.g. MessagePack) is passed to
  * `ddog_trace_exporter_send`; the library decodes and converts it to OTLP when OTLP is enabled.
  *
  * # Arguments

data/vendor/{libdatadog-40.0.0 → libdatadog-45.0.0}/x86_64-linux-musl/include/datadog/ffe.h

@@ -147,6 +147,18 @@ struct ddog_ffe_Result_HandleConfiguration ddog_ffe_configuration_new(struct ddo
  */
 void ddog_ffe_configuration_drop(ddog_ffe_Handle_Configuration *config);
 
+/**
+ * Get the config-level `observeFullEvaluationData` flag.
+ *
+ * Opt-in boolean for emitting full flag evaluation data from SDKs to Datadog. Flag evaluation data
+ * may contain PII; defaults to `false` for privacy.
+ *
+ * # Safety
+ *
+ * `config` must be a valid `Configuration` handle created by `ddog_ffe_configuration_new`.
+ */
+bool ddog_ffe_configuration_get_observe_full_evaluation_data(ddog_ffe_Handle_Configuration config);
+
 /**
  * Creates a new EvaluationContext with the given targeting key and attributes.
  *

data/vendor/{libdatadog-40.0.0 → libdatadog-45.0.0}/x86_64-linux-musl/include/datadog/library-config.h

@@ -24,32 +24,8 @@ void ddog_library_configurator_with_fleet_path(struct ddog_Configurator *c,
 void ddog_library_configurator_with_process_info(struct ddog_Configurator *c,
                                                  struct ddog_ProcessInfo p);
 
-void ddog_library_configurator_with_detect_process_info(struct ddog_Configurator *c);
-
 void ddog_library_configurator_drop(struct ddog_Configurator*);
 
-struct ddog_LibraryConfigLoggedResult ddog_library_configurator_get(const struct ddog_Configurator *configurator);
-
-/**
- * Returns a static null-terminated string, containing the name of the environment variable
- * associated with the library configuration
- */
-struct ddog_CStr ddog_library_config_source_to_string(enum ddog_LibraryConfigSource name);
-
-/**
- * Returns a static null-terminated string with the path to the managed stable config yaml config
- * file
- */
-struct ddog_CStr ddog_library_config_fleet_stable_config_path(void);
-
-/**
- * Returns a static null-terminated string with the path to the local stable config yaml config
- * file
- */
-struct ddog_CStr ddog_library_config_local_stable_config_path(void);
-
-void ddog_library_config_drop(struct ddog_LibraryConfigLoggedResult config_result);
-
 /**
  * Allocates and returns a pointer to a new `TracerMetadata` object on the heap.
  *
@@ -89,6 +65,29 @@ void ddog_tracer_metadata_set(struct ddog_TracerMetadata *ptr,
                               enum ddog_MetadataKind kind,
                               const char *value);
 
+/**
+ * Includes thread-context discovery metadata in the `TracerMetadata` object pointed to by `ptr`.
+ *
+ * If the builder has no thread-context metadata, configures it to publish
+ * the `tlsdesc_v1_dev` schema and a key map containing `datadog.local_root_span_id`.
+ * If the thread-context metadata is already set, leaves it unchanged.
+ *
+ * This function only updates the builder. Call `ddog_tracer_metadata_store` to publish it.
+ *
+ * # Arguments
+ * - `ptr`: Pointer to a `TracerMetadata` instance.
+ *
+ * # Safety
+ * - If non-null, `ptr` must point to a valid, properly aligned, live `TracerMetadata`.
+ * - The caller must ensure exclusive access to the instance for the duration of the call.
+ * - Ownership remains with the caller
+ *
+ * # Returns
+ * - On success: `VoidResult::Ok`, also when thread-context metadata is already present
+ * - An error if `ptr` is null.
+ */
+struct ddog_VoidResult ddog_tracer_metadata_include_otel_thread_context(struct ddog_TracerMetadata *ptr);
+
 /**
  * Serializes the `TracerMetadata` into a platform-specific memory handle (e.g., memfd on Linux).
  * This function also attempts to publish the tracer metadata as an OTel process context
@@ -108,6 +107,30 @@ void ddog_tracer_metadata_set(struct ddog_TracerMetadata *ptr,
  */
 struct ddog_Result_TracerMemfdHandle ddog_tracer_metadata_store(struct ddog_TracerMetadata *ptr);
 
+void ddog_library_configurator_with_detect_process_info(struct ddog_Configurator *c);
+
+struct ddog_LibraryConfigLoggedResult ddog_library_configurator_get(const struct ddog_Configurator *configurator);
+
+/**
+ * Returns a static null-terminated string, containing the name of the environment variable
+ * associated with the library configuration
+ */
+struct ddog_CStr ddog_library_config_source_to_string(enum ddog_LibraryConfigSource name);
+
+/**
+ * Returns a static null-terminated string with the path to the managed stable config yaml
+ * config file
+ */
+struct ddog_CStr ddog_library_config_fleet_stable_config_path(void);
+
+/**
+ * Returns a static null-terminated string with the path to the local stable config yaml config
+ * file
+ */
+struct ddog_CStr ddog_library_config_local_stable_config_path(void);
+
+void ddog_library_config_drop(struct ddog_LibraryConfigLoggedResult config_result);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/{libdatadog-40.0.0/aarch64-linux-musl → libdatadog-45.0.0/x86_64-linux-musl}/include/datadog/otel-thread-ctx.h

@@ -29,6 +29,15 @@ struct ddog_VoidResult ddog_otel_thread_ctx_sanity_check(void);
 /**
  * Allocate and initialise a new thread context, including its W3C trace-flags byte.
  *
+ * `trace_id`, `span_id`, and `local_root_span_id` use W3C Trace Context byte order,
+ * equivalent to big-endian when interpreted as integers.
+ *
+ * When representing an active trace, both `trace_id` and `span_id` must be nonzero. Otherwise,
+ * `trace_id`, `span_id`, and `trace_flags` must be zero.
+ *
+ * This function does not validate IDs or reject invalid combinations of `trace_id`, `span_id`,
+ * and `trace_flags`.
+ *
  * Returns a non-null owned handle that must eventually be released with
  * `ddog_otel_thread_ctx_free`.
  */
@@ -42,9 +51,11 @@ struct ddog_ThreadContextHandle *ddog_otel_thread_ctx_new(const uint8_t (*trace_
  *
  * # Safety
  *
+ * **`ctx` must not be a handle to a  currently attached to a thread**. Only free detached
+ * contexts.
+ *
  * `ctx` must be a valid non-null pointer obtained from `ddog_otel_thread_ctx_new` or
- * `ddog_otel_thread_ctx_detach`, and must not be used after this call. In particular, `ctx`
- * must not be currently attached to a thread.
+ * `ddog_otel_thread_ctx_detach`, and must not be used after this call.
  */
 void ddog_otel_thread_ctx_free(struct ddog_ThreadContextHandle *ctx);
 
@@ -54,9 +65,10 @@ void ddog_otel_thread_ctx_free(struct ddog_ThreadContextHandle *ctx);
  *
  * # Safety
  *
- * `ctx` must be a valid non-null pointer obtained from this API. Ownership of `ctx` is
- * transferred to the TLS slot: the caller must not drop `ctx` while it is still actively
- * attached.
+ * Ownership of `ctx` is transferred to the TLS slot. **The caller must NOT free `ctx` while it
+ * is still actively attached**.
+ *
+ * `ctx` must be a valid non-null pointer obtained from this API.
  */
 struct ddog_ThreadContextHandle *ddog_otel_thread_ctx_attach(struct ddog_ThreadContextHandle *ctx);
 
@@ -70,6 +82,7 @@ struct ddog_ThreadContextHandle *ddog_otel_thread_ctx_detach(void);
 
 /**
  * Update the currently attached context in-place, including its W3C trace-flags byte.
+ * Uses the same ID byte order and zero-value rules as `ddog_otel_thread_ctx_new`.
  *
  * If no context is currently attached, one is created and attached, equivalent to calling
  * `ddog_otel_thread_ctx_new` followed by `ddog_otel_thread_ctx_attach`.
@@ -79,6 +92,23 @@ void ddog_otel_thread_ctx_update(const uint8_t (*trace_id)[16],
                                  uint8_t trace_flags,
                                  const uint8_t (*local_root_span_id)[8]);
 
+/**
+ * Update `ctx` and attach it to the current thread. Returns the previously attached different
+ * context, if any. Uses the same ID byte order and zero-value rules as
+ * `ddog_otel_thread_ctx_new`.
+ *
+ * # Safety
+ *
+ * `ctx` may be null; otherwise it must be a valid non-null pointer obtained from this API.
+ * If attached, it must be attached only to the calling native thread and must not be
+ * concurrently updated or freed. A non-null returned context is owned by the caller.
+ */
+struct ddog_ThreadContextHandle *ddog_otel_thread_ctx_update_and_attach(struct ddog_ThreadContextHandle *ctx,
+                                                                        const uint8_t (*trace_id)[16],
+                                                                        const uint8_t (*span_id)[8],
+                                                                        uint8_t trace_flags,
+                                                                        const uint8_t (*local_root_span_id)[8]);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus