libdatadog 33.0.0.1.0 → 40.0.0.2.0

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

@@ -279,6 +279,14 @@ typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
  * - **dd-trace-dotnet**: Sample type definitions for allocations, locks, CPU, walltime,
  *   exceptions, live objects, HTTP requests
  * - **pprof-nodejs**: `profile-serializer.ts` (value type functions)
+ *
+ * # Adding new types
+ *
+ * To prototype a new profile type without a libdatadog release, use one of
+ * the `Custom1` through `Custom5` slots and configure its concrete `(type,
+ * unit)` string pair on the profile before serialization. Once the type is
+ * stable and agreed upon across profiler teams, add a dedicated variant here
+ * so callers can use the type-safe path.
  */
 typedef enum ddog_prof_SampleType {
   DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES,
@@ -351,9 +359,31 @@ typedef enum ddog_prof_SampleType {
    * Legacy: Use `WallTime` instead for consistency with naming scheme
    */
   DDOG_PROF_SAMPLE_TYPE_WALL_LEGACY,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_COUNT,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_NANOSECONDS,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_BYTES,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM1,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM2,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM3,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM4,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM5,
 } ddog_prof_SampleType;
 
 typedef enum ddog_prof_Utf8Option {
@@ -375,8 +405,6 @@ typedef enum ddog_prof_Utf8Option {
 
 typedef struct ddog_OpaqueCancellationToken ddog_OpaqueCancellationToken;
 
-typedef struct ddog_prof_EncodedProfile ddog_prof_EncodedProfile;
-
 typedef struct ddog_prof_ExporterManager ddog_prof_ExporterManager;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
@@ -891,23 +919,6 @@ typedef struct ddog_prof_StringHeader {
   uint8_t _0;
 } ddog_prof_StringHeader;
 
-/**
- * An FFI-safe string ID where a null StringId2 maps to `StringRef::EMPTY`.
- * The representation is ensured to be a  pointer for ABI stability, but
- * callers should not generally dereference this pointer. When using the id,
- * the caller needs to be sure that the `ProfilesDictionary` or string set it
- * refers to is the same one that the operations are performed on; it is not
- * generally guaranteed that ids from one dictionary/set can be used in
- * another, even if it happens to work by implementation detail. There is an
- * exception is for well-known strings, which are considered present in every
- * string set.
- *
- * Equality and hashing are defined by pointer identity, so they are only
- * meaningful when comparing ids that originate from the same
- * `ProfilesDictionary`.
- */
-typedef struct ddog_prof_StringHeader *ddog_prof_StringId2;
-
 /**
  * An FFI-safe version of the Mapping which allows null. Be sure to maintain
  * layout-compatibility with it, except that StringId2 may be null.
@@ -920,21 +931,6 @@ typedef struct ddog_prof_Mapping2 {
   ddog_prof_StringId2 build_id;
 } ddog_prof_Mapping2;
 
-/**
- * An FFI-safe representation of a "handle" to a mapping which has been
- * stored in the `ProfilesDictionary`. The representation is ensured to be a
- * pointer for ABI stability, but callers should not generally dereference
- * this pointer. When using the id, the caller needs to be sure that the
- * `ProfilesDictionary` it refers to is the same one that the operations are
- * performed on; it is not generally guaranteed that ids from one dictionary
- * can be used in another dictionary, even if it happens to work by
- * implementation detail.
- *
- * `Eq`/`Hash` and other comparisons are based on this handle value, and are
- * only intended for ids produced by the same `ProfilesDictionary`.
- */
-typedef struct ddog_prof_Mapping2 *ddog_prof_MappingId2;
-
 /**
  * An FFI-safe version of the Function which allows null. Be sure to maintain
  * layout-compatibility with it, except that StringId2 may be null.
@@ -949,21 +945,6 @@ typedef struct ddog_prof_Function2 {
   ddog_prof_StringId2 file_name;
 } ddog_prof_Function2;
 
-/**
- * An FFI-safe representation of a "handle" to a function which has been
- * stored in the `ProfilesDictionary`. The representation is ensured to be a
- * pointer for ABI stability, but callers should not generally dereference
- * this pointer. When using the id, the caller needs to be sure that the
- * `ProfilesDictionary` it refers to is the same one that the operations are
- * performed on; it is not generally guaranteed that ids from one dictionary
- * can be used in another dictionary, even if it happens to work by
- * implementation detail.
- *
- * `Eq`/`Hash` and other comparisons are based on this handle value, and are
- * only intended for ids produced by the same `ProfilesDictionary`.
- */
-typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
-
 /**
  * A location keyed by `MappingId2`/`FunctionId2` handles.
  *
@@ -1163,8 +1144,6 @@ typedef struct OpaqueStringId {
 } OpaqueStringId;
 #define OpaqueStringId_ZERO (OpaqueStringId){  }
 
-typedef struct OpaqueStringId OpaqueStringId;
-
 typedef struct ddog_prof_StringId {
   struct ddog_prof_Generation generation;
   OpaqueStringId id;
@@ -1513,8 +1492,6 @@ typedef struct ddog_StringWrapperResult {
   };
 } ddog_StringWrapperResult;
 
-typedef struct ddog_prof_StringId ddog_prof_StringId;
-
 typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_ENV_VAR,
   DDOG_CONFIGURATION_ORIGIN_CODE,
@@ -1524,6 +1501,9 @@ typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_LOCAL_STABLE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_FLEET_STABLE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_CALCULATED,
+  DDOG_CONFIGURATION_ORIGIN_OTEL_ENV_VAR,
+  DDOG_CONFIGURATION_ORIGIN_INI,
+  DDOG_CONFIGURATION_ORIGIN_UNKNOWN,
 } ddog_ConfigurationOrigin;
 
 typedef enum ddog_LogLevel {
@@ -1544,12 +1524,17 @@ typedef enum ddog_MetricNamespace {
   DDOG_METRIC_NAMESPACE_TELEMETRY,
   DDOG_METRIC_NAMESPACE_APM,
   DDOG_METRIC_NAMESPACE_SIDECAR,
+  DDOG_METRIC_NAMESPACE_CIVISIBILITY,
+  DDOG_METRIC_NAMESPACE_MLOBS,
+  DDOG_METRIC_NAMESPACE_DDTRACEAPI,
+  DDOG_METRIC_NAMESPACE_AI_GUARD,
 } ddog_MetricNamespace;
 
 typedef enum ddog_MetricType {
   DDOG_METRIC_TYPE_GAUGE,
   DDOG_METRIC_TYPE_COUNT,
   DDOG_METRIC_TYPE_DISTRIBUTION,
+  DDOG_METRIC_TYPE_RATE,
 } ddog_MetricType;
 
 typedef enum ddog_TelemetryWorkerBuilderBoolProperty {
@@ -1586,9 +1571,10 @@ typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
  * The worker won't send data to the agent until you call `TelemetryWorkerHandle::send_start`
  *
  * To stop the worker, call `TelemetryWorkerHandle::send_stop` which trigger flush asynchronously
- * then `TelemetryWorkerHandle::wait_for_shutdown`
+ * then `TelemetryWorkerHandle::wait_for_shutdown` (native only — wasm callers rely on the
+ * SharedRuntime worker JoinHandle instead).
  */
-typedef struct ddog_TelemetryWorkerHandle ddog_TelemetryWorkerHandle;
+typedef struct ddog_TelemetryWorkerHandle_NativeCapabilities ddog_TelemetryWorkerHandle_NativeCapabilities;
 
 typedef enum ddog_Option_U64_Tag {
   DDOG_OPTION_U64_SOME_U64,
@@ -1604,6 +1590,12 @@ typedef struct ddog_Option_U64 {
   };
 } ddog_Option_U64;
 
+/**
+ * FFI-facing alias: the C ABI surface is native-only, so the worker handle is
+ * always pinned to [`NativeCapabilities`].
+ */
+typedef struct ddog_TelemetryWorkerHandle_NativeCapabilities ddog_TelemetryWorkerHandle;
+
 typedef enum ddog_Option_Bool_Tag {
   DDOG_OPTION_BOOL_SOME_BOOL,
   DDOG_OPTION_BOOL_NONE_BOOL,
@@ -1624,7 +1616,38 @@ typedef struct ddog_ContextKey {
 } ddog_ContextKey;
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerSpanEvent ddog_TracerSpanEvent;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
+typedef struct ddog_TraceExporterCancelToken ddog_TraceExporterCancelToken;
+typedef uint8_t ddog_TracerValueKind;
+
+
+#define DDOG_TRACER_VALUE_NIL 0
+
+#define DDOG_TRACER_VALUE_BOOL 1
+
+#define DDOG_TRACER_VALUE_I64 2
+
+#define DDOG_TRACER_VALUE_U64 3
+
+#define DDOG_TRACER_VALUE_F64 4
+
+#define DDOG_TRACER_VALUE_STRING 5
+
+#define DDOG_TRACER_VALUE_BINARY 6
+
+#define DDOG_TRACER_VALUE_ARRAY 7
+
+#define DDOG_TRACER_VALUE_MAP 8
+
+#define ddog_CollapsedFieldSet_RESOURCE_NAME (1 << 0)
+
+#define ddog_CollapsedFieldSet_HTTP_ENDPOINT (1 << 1)
+
+#define ddog_CollapsedFieldSet_PEER_TAGS (1 << 2)
 
+#define ddog_CollapsedFieldSet_ADDITIONAL_TAGS (1 << 3)
 
 /**
  * Represent error codes that `Error` struct can hold
@@ -1667,17 +1690,13 @@ typedef enum ddog_TraceExporterErrorCode {
 typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
 
 /**
- * A shared runtime that manages PausableWorkers and provides fork safety hooks.
+ * Owns a tokio runtime and manages [`PausableWorker`]s on it.
  *
- * The SharedRuntime owns a tokio runtime and tracks PausableWorkers spawned on it.
- * It provides methods to safely pause workers before forking and restart them
- * after fork in both parent and child processes.
- *
- * # Mutex lock order
- * When locking both [Self::runtime] and [Self::workers], the mutex must be locked in the order of
- * the fields in the struct. When possible avoid holding both locks simultaneously.
+ * Supports the full fork protocol ([`before_fork`](Self::before_fork) /
+ * [`after_fork_parent`](Self::after_fork_parent) /
+ * [`after_fork_child`](Self::after_fork_child)) and synchronous [`shutdown`](Self::shutdown).
  */
-typedef struct ddog_SharedRuntime ddog_SharedRuntime;
+typedef struct ddog_ForkSafeRuntime ddog_ForkSafeRuntime;
 
 /**
  * The TraceExporterConfig object will hold the configuration properties for the TraceExporter.
@@ -1686,6 +1705,11 @@ typedef struct ddog_SharedRuntime ddog_SharedRuntime;
  */
 typedef struct ddog_TraceExporterConfig ddog_TraceExporterConfig;
 
+/**
+ * Opaque owned MessagePack blob produced from structured-value tokens.
+ */
+typedef struct ddog_TracerEncodedValue ddog_TracerEncodedValue;
+
 /**
  * Structure that contains error information that `TraceExporter` API can return.
  */
@@ -1694,6 +1718,39 @@ typedef struct ddog_TraceExporterError {
   char *msg;
 } ddog_TraceExporterError;
 
+/**
+ * One value in a flat preorder representation of a structured value.
+ *
+ * Scalar tokens use the corresponding scalar field. String and binary tokens
+ * use `bytes`. Array and map tokens use `child_count`; a map is followed by
+ * two values per entry (key, then value). All other fields must be ignored.
+ * `kind` remains a raw integer so malformed C input can be rejected without
+ * constructing an invalid Rust enum discriminant.
+ */
+typedef struct ddog_TracerValueToken {
+  uint8_t kind;
+  uint8_t bool_value;
+  uint32_t child_count;
+  int64_t i64_value;
+  uint64_t u64_value;
+  double f64_value;
+  ddog_ByteSlice bytes;
+} ddog_TracerValueToken;
+
+typedef struct ddog_Slice_TracerValueToken {
+  /**
+   * 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 struct ddog_TracerValueToken *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_TracerValueToken;
+
 /**
  * FFI compatible configuration for the TelemetryClient.
  */
@@ -1730,6 +1787,142 @@ typedef struct ddog_TelemetryClientConfig {
   ddog_CharSlice parent_session_id;
 } ddog_TelemetryClientConfig;
 
+/**
+ * Config to override the default stats cardinality limit values
+ */
+typedef struct ddog_CardinalityLimitConfig {
+  /**
+   * The whole-key cardinality limit (defaults to 7000)
+   */
+  uintptr_t whole_key_limit;
+  /**
+   * The per-field cardinality limit for the Resource field (defaults to 1024)
+   */
+  uintptr_t resource_limit;
+  /**
+   * The per-field cardinality limit for the HttpEndpoint field (defaults to 512)
+   */
+  uintptr_t http_endpoint_limit;
+  /**
+   * The per-field cardinality limit for the PeerTags field (defaults to 512)
+   */
+  uintptr_t peer_tags_limit;
+  /**
+   * The per-field cardinality limit for the AdditionalTags field (defaults to 100)
+   */
+  uintptr_t additional_tags_limit;
+} ddog_CardinalityLimitConfig;
+
+/**
+ * FFI-safe bundle of scalar fields for creating a [`TracerSpan`].
+ *
+ * Passed by reference to [`ddog_tracer_span_new`] so that adding or
+ * changing fields does not break the function signature.
+ */
+typedef struct ddog_TracerSpanFields {
+  ddog_CharSlice service;
+  ddog_CharSlice name;
+  ddog_CharSlice resource;
+  ddog_CharSlice span_type;
+  uint64_t trace_id_low;
+  uint64_t trace_id_high;
+  uint64_t span_id;
+  uint64_t parent_id;
+  int64_t start;
+  int64_t duration;
+  int32_t error;
+} ddog_TracerSpanFields;
+
+/**
+ * A string attribute belonging to a [`TracerSpanLink`].
+ */
+typedef struct ddog_TracerSpanLinkAttribute {
+  ddog_CharSlice key;
+  ddog_CharSlice value;
+} ddog_TracerSpanLinkAttribute;
+
+typedef struct ddog_Slice_TracerSpanLinkAttribute {
+  /**
+   * 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 struct ddog_TracerSpanLinkAttribute *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_TracerSpanLinkAttribute;
+
+/**
+ * FFI-safe representation of one complete span link.
+ */
+typedef struct ddog_TracerSpanLink {
+  uint64_t trace_id_low;
+  uint64_t trace_id_high;
+  uint64_t span_id;
+  struct ddog_Slice_TracerSpanLinkAttribute attributes;
+  ddog_CharSlice tracestate;
+  uint32_t flags;
+} ddog_TracerSpanLink;
+
+typedef struct ddog_Slice_TracerSpanLink {
+  /**
+   * 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 struct ddog_TracerSpanLink *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_TracerSpanLink;
+
+typedef struct ddog_Slice_CharSlice {
+  /**
+   * 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 ddog_CharSlice *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_CharSlice;
+
+typedef struct ddog_Slice_Bool {
+  /**
+   * 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 bool *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_Bool;
+
+typedef struct ddog_Slice_F64 {
+  /**
+   * 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 double *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_F64;
+
 typedef enum ddog_LibraryConfigSource {
   DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
   DDOG_LIBRARY_CONFIG_SOURCE_FLEET_STABLE_CONFIG = 1,
@@ -1772,20 +1965,6 @@ typedef struct ddog_CStr {
   uintptr_t length;
 } ddog_CStr;
 
-typedef struct ddog_Slice_CharSlice {
-  /**
-   * 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 ddog_CharSlice *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_CharSlice;
-
 typedef struct ddog_ProcessInfo {
   struct ddog_Slice_CharSlice args;
   struct ddog_Slice_CharSlice envp;
@@ -2207,6 +2386,67 @@ typedef struct ddog_ffe_AttributePair {
   struct ddog_ffe_AttributeValue value;
 } ddog_ffe_AttributePair;
 
+/**
+ * Error codes for ForkSafeRuntime FFI operations.
+ */
+typedef enum ddog_SharedRuntimeErrorCode {
+  /**
+   * Invalid argument provided (e.g. null handle).
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_INVALID_ARGUMENT,
+  /**
+   * The runtime is not available or in an invalid state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_UNAVAILABLE,
+  /**
+   * Failed to acquire a lock on internal state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_LOCK_FAILED,
+  /**
+   * A worker operation failed.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_WORKER_ERROR,
+  /**
+   * Failed to create the tokio runtime.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_CREATION,
+  /**
+   * Shutdown timed out.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_SHUTDOWN_TIMED_OUT,
+  /**
+   * An unexpected panic occurred inside the FFI call.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_PANIC,
+} ddog_SharedRuntimeErrorCode;
+
+/**
+ * Error returned by ForkSafeRuntime FFI functions.
+ */
+typedef struct ddog_SharedRuntimeFFIError {
+  enum ddog_SharedRuntimeErrorCode code;
+  /**
+   * The error message is always defined when the error is returned by a ddog_shared_runtime
+   * ffi.
+   */
+  char *msg;
+} ddog_SharedRuntimeFFIError;
+
+/**
+ * Maximum size in bytes of the `attrs_data` field of a thread context record.
+ */
+#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.)
+ */
+typedef struct ddog_ThreadContextHandle {
+
+} ddog_ThreadContextHandle;
+
 typedef enum ddog_crasht_BuildIdType {
   DDOG_CRASHT_BUILD_ID_TYPE_GNU,
   DDOG_CRASHT_BUILD_ID_TYPE_GO,

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-40.0.0/aarch64-linux}/include/datadog/crashtracker.h

@@ -170,6 +170,25 @@ struct ddog_VoidResult ddog_crasht_report_unhandled_exception(ddog_CharSlice err
                                                               ddog_CharSlice error_message,
                                                               struct ddog_crasht_Handle_StackTrace *runtime_stack);
 
+/**
+ * Register the expected PID of the socket-based crash receiver
+ *
+ * When `collect_all_threads` is enabled and the receiver is reached via a Unix
+ * socket, the crash handler will only grant ptrace permission if the socket
+ * peer's PID matches this registered value.
+ *
+ * Call this after establishing a trusted connection to the sidecar
+ *
+ * # Safety
+ *   This function is safe to call from any thread at any time.
+ */
+void ddog_crasht_set_expected_receiver_pid(int32_t pid);
+
+/**
+ * Returns the currently registered expected receiver PID, or 0 if unset.
+ */
+int32_t ddog_crasht_get_expected_receiver_pid(void);
+
 /**
  * Removes all existing additional tags
  * Expected to be used after a fork, to reset the additional tags on the child