libdatadog 44.0.1.1.0 → 46.0.0.1.0

data/vendor/libdatadog-46.0.0/x86_64-linux/include/datadog/ddsketch.h

@@ -0,0 +1,89 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_DDSKETCH_H
+#define DDOG_DDSKETCH_H
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Creates a new DDSketch instance with default configuration.
+ */
+struct ddsketch_Handle_DDSketch ddog_ddsketch_new(void);
+
+/**
+ * Drops a DDSketch instance.
+ *
+ * # Safety
+ *
+ * The sketch handle must have been created by this library and not already dropped.
+ */
+void ddog_ddsketch_drop(struct ddsketch_Handle_DDSketch *sketch);
+
+/**
+ * Adds a point to the DDSketch.
+ *
+ * # Safety
+ *
+ * The `sketch` parameter must be a valid pointer to a DDSketch handle.
+ */
+struct ddog_VoidResult ddog_ddsketch_add(struct ddsketch_Handle_DDSketch *sketch, double point);
+
+/**
+ * Adds a point with a specific count to the DDSketch.
+ *
+ * # Safety
+ *
+ * The `sketch` parameter must be a valid pointer to a DDSketch handle.
+ */
+struct ddog_VoidResult ddog_ddsketch_add_with_count(struct ddsketch_Handle_DDSketch *sketch,
+                                                    double point,
+                                                    double count);
+
+/**
+ * Returns the count of points in the DDSketch via the output parameter.
+ *
+ * # Safety
+ *
+ * The `sketch` parameter must be a valid pointer to a DDSketch handle.
+ * The `count_out` parameter must be a valid pointer to uninitialized f64 memory.
+ */
+struct ddog_VoidResult ddog_ddsketch_count(struct ddsketch_Handle_DDSketch *sketch,
+                                           double *count_out);
+
+/**
+ * Returns the protobuf-encoded bytes of the DDSketch.
+ * The sketch handle is consumed by this operation.
+ *
+ * # Safety
+ *
+ * The `sketch` parameter must be a valid pointer to a DDSketch handle.
+ * The returned vector must be freed with `ddog_Vec_U8_drop`.
+ */
+struct ddog_Vec_U8 ddog_ddsketch_encode(struct ddsketch_Handle_DDSketch *sketch);
+
+/**
+ * Frees the memory allocated for a `Vec<u8>` returned by ddsketch functions.
+ *
+ * # Safety
+ *
+ * The vec parameter must be a valid `Vec<u8>` returned by this library.
+ * After being called, the vec will not point to valid memory.
+ */
+void ddog_Vec_U8_drop(struct ddog_Vec_U8 _vec);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_DDSKETCH_H */

data/vendor/libdatadog-46.0.0/x86_64-linux/include/datadog/library-config.h

@@ -0,0 +1,138 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_LIBRARY_CONFIG_H
+#define DDOG_LIBRARY_CONFIG_H
+
+#pragma once
+
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+struct ddog_Configurator *ddog_library_configurator_new(bool debug_logs, ddog_CharSlice language);
+
+void ddog_library_configurator_with_local_path(struct ddog_Configurator *c,
+                                               struct ddog_CStr local_path);
+
+void ddog_library_configurator_with_fleet_path(struct ddog_Configurator *c,
+                                               struct ddog_CStr local_path);
+
+void ddog_library_configurator_with_process_info(struct ddog_Configurator *c,
+                                                 struct ddog_ProcessInfo p);
+
+void ddog_library_configurator_drop(struct ddog_Configurator*);
+
+/**
+ * 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.
+ */
+struct ddog_TracerMetadata *ddog_tracer_metadata_new(void);
+
+/**
+ * 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.
+ */
+void ddog_tracer_metadata_free(struct ddog_TracerMetadata *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.
+ */
+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
+ * separately, but will ignore resulting errors.
+ *
+ * # 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.
+ *
+ * # Platform Support
+ * This function currently only supports Linux via `memfd`. On other platforms,
+ * it will return an error.
+ */
+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
+
+#endif  /* DDOG_LIBRARY_CONFIG_H */

data/vendor/libdatadog-46.0.0/x86_64-linux/include/datadog/otel-thread-ctx.h

@@ -0,0 +1,116 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_OTEL_THREAD_CTX_H
+#define DDOG_OTEL_THREAD_CTX_H
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if defined(DDOG_OTEL_THREAD_CTX_SANITY_CHECK)
+/**
+ * Verify that this binary was linked with the correct options such that the thread contexts are
+ * visible to an external reader (typically the eBPF profiler).
+ *
+ * Returns `VoidResult::Ok` if all checks pass, or a `VoidResult::Err` with a
+ * diagnostic message on failure.
+ */
+struct ddog_VoidResult ddog_otel_thread_ctx_sanity_check(void);
+#endif
+
+/**
+ * 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`.
+ */
+struct ddog_ThreadContextHandle *ddog_otel_thread_ctx_new(const uint8_t (*trace_id)[16],
+                                                          const uint8_t (*span_id)[8],
+                                                          uint8_t trace_flags,
+                                                          const uint8_t (*local_root_span_id)[8]);
+
+/**
+ * Free an owned thread context.
+ *
+ * # 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.
+ */
+void ddog_otel_thread_ctx_free(struct ddog_ThreadContextHandle *ctx);
+
+/**
+ * Attach `ctx` to the current thread. Returns the previously attached context if any, or null
+ * otherwise.
+ *
+ * # Safety
+ *
+ * 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);
+
+/**
+ * Remove the currently attached context from the TLS slot.
+ *
+ * Returns the detached context (caller now owns it and must release it with
+ * `ddog_otel_thread_ctx_free`), or null if the slot was empty.
+ */
+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`.
+ */
+void ddog_otel_thread_ctx_update(const uint8_t (*trace_id)[16],
+                                 const uint8_t (*span_id)[8],
+                                 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
+
+#endif  /* DDOG_OTEL_THREAD_CTX_H */