libdatadog 22.0.1.1.0 → 24.0.1.1.0

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

@@ -263,12 +263,6 @@ typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
-/**
- * A tag is a combination of a wire_type, stored in the least significant
- * three bits, and the field number that is defined in the .proto file.
- */
-typedef struct ddog_Tag ddog_Tag;
-
 typedef struct ddog_Slice_U8 {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -457,6 +451,12 @@ typedef struct ddog_CancellationToken {
 typedef struct ddog_prof_Profile {
   struct ddog_prof_Profile *inner;
 } ddog_prof_Profile;
+/**
+ * When testing on some profiles that can't be shared publicly,
+ * level 1 provided better compressed files while taking less or equal
+ * time compared to lz4.
+ */
+#define ddog_prof_Profile_COMPRESSION_LEVEL 1
 
 /**
  * Returned by [ddog_prof_Profile_new].
@@ -1558,6 +1558,216 @@ typedef struct ddsketch_Handle_DDSketch {
   struct ddsketch_DDSketch *inner;
 } ddsketch_Handle_DDSketch;
 
+typedef enum ddog_ffe_ErrorCode {
+  DDOG_FFE_ERROR_CODE_OK,
+  DDOG_FFE_ERROR_CODE_TYPE_MISMATCH,
+  DDOG_FFE_ERROR_CODE_PARSE_ERROR,
+  DDOG_FFE_ERROR_CODE_FLAG_NOT_FOUND,
+  DDOG_FFE_ERROR_CODE_TARGETING_KEY_MISSING,
+  DDOG_FFE_ERROR_CODE_INVALID_CONTEXT,
+  DDOG_FFE_ERROR_CODE_PROVIDER_NOT_READY,
+  DDOG_FFE_ERROR_CODE_GENERAL,
+} ddog_ffe_ErrorCode;
+
+typedef enum ddog_ffe_ExpectedFlagType {
+  DDOG_FFE_EXPECTED_FLAG_TYPE_STRING,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_INTEGER,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_FLOAT,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_BOOLEAN,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_OBJECT,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_NUMBER,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_ANY,
+} ddog_ffe_ExpectedFlagType;
+
+typedef enum ddog_ffe_Reason {
+  DDOG_FFE_REASON_STATIC,
+  DDOG_FFE_REASON_DEFAULT,
+  DDOG_FFE_REASON_TARGETING_MATCH,
+  DDOG_FFE_REASON_SPLIT,
+  DDOG_FFE_REASON_DISABLED,
+  DDOG_FFE_REASON_ERROR,
+} ddog_ffe_Reason;
+
+/**
+ * Remote configuration for the feature flagging client. It's a central piece that defines client
+ * behavior.
+ */
+typedef struct ddog_ffe_Configuration ddog_ffe_Configuration;
+
+/**
+ * `Subject` is a bundle of subject attributes and a key.
+ */
+typedef struct ddog_ffe_EvaluationContext ddog_ffe_EvaluationContext;
+
+/**
+ * Opaque type representing a result of evaluation.
+ */
+typedef struct ddog_ffe_ResolutionDetails ddog_ffe_ResolutionDetails;
+
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_ResolutionDetails *ddog_ffe_Handle_ResolutionDetails;
+
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_Configuration *ddog_ffe_Handle_Configuration;
+
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_EvaluationContext *ddog_ffe_Handle_EvaluationContext;
+
+/**
+ * A string that has been borrowed. Beware that it is NOT nul-terminated!
+ *
+ * # Ownership
+ *
+ * This string is non-owning. You must not free `ptr`.
+ *
+ * # Safety
+ *
+ * - The string is not NUL-terminated, it can only be used with API that accept the len as an
+ *   additional parameter.
+ * - The value must not be used after the value it borrowed from has been moved, modified, or
+ *   freed.
+ */
+typedef struct ddog_ffe_BorrowedStr {
+  /**
+   * May be NULL if `len` is `0`.
+   */
+  const uint8_t *ptr;
+  uintptr_t len;
+} ddog_ffe_BorrowedStr;
+
+typedef enum ddog_ffe_VariantValue_Tag {
+  /**
+   * Evaluation did not produce any value.
+   */
+  DDOG_FFE_VARIANT_VALUE_NONE,
+  DDOG_FFE_VARIANT_VALUE_STRING,
+  DDOG_FFE_VARIANT_VALUE_INTEGER,
+  DDOG_FFE_VARIANT_VALUE_FLOAT,
+  DDOG_FFE_VARIANT_VALUE_BOOLEAN,
+  DDOG_FFE_VARIANT_VALUE_OBJECT,
+} ddog_ffe_VariantValue_Tag;
+
+typedef struct ddog_ffe_VariantValue {
+  ddog_ffe_VariantValue_Tag tag;
+  union {
+    struct {
+      struct ddog_ffe_BorrowedStr string;
+    };
+    struct {
+      int64_t integer;
+    };
+    struct {
+      double float_;
+    };
+    struct {
+      bool boolean;
+    };
+    struct {
+      struct ddog_ffe_BorrowedStr object;
+    };
+  };
+} ddog_ffe_VariantValue;
+
+typedef struct ddog_ffe_KeyValue_BorrowedStr {
+  struct ddog_ffe_BorrowedStr key;
+  struct ddog_ffe_BorrowedStr value;
+} ddog_ffe_KeyValue_BorrowedStr;
+
+typedef struct ddog_ffe_ArrayMap_BorrowedStr {
+  const struct ddog_ffe_KeyValue_BorrowedStr *elements;
+  uintptr_t count;
+} ddog_ffe_ArrayMap_BorrowedStr;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_ffe_Result_HandleConfiguration_Tag {
+  DDOG_FFE_RESULT_HANDLE_CONFIGURATION_OK_HANDLE_CONFIGURATION,
+  DDOG_FFE_RESULT_HANDLE_CONFIGURATION_ERR_HANDLE_CONFIGURATION,
+} ddog_ffe_Result_HandleConfiguration_Tag;
+
+typedef struct ddog_ffe_Result_HandleConfiguration {
+  ddog_ffe_Result_HandleConfiguration_Tag tag;
+  union {
+    struct {
+      ddog_ffe_Handle_Configuration ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_ffe_Result_HandleConfiguration;
+
+/**
+ * # Safety
+ * - `string` must be a valid C string.
+ */
+typedef enum ddog_ffe_AttributeValue_Tag {
+  DDOG_FFE_ATTRIBUTE_VALUE_STRING,
+  DDOG_FFE_ATTRIBUTE_VALUE_NUMBER,
+  DDOG_FFE_ATTRIBUTE_VALUE_BOOLEAN,
+} ddog_ffe_AttributeValue_Tag;
+
+typedef struct ddog_ffe_AttributeValue {
+  ddog_ffe_AttributeValue_Tag tag;
+  union {
+    struct {
+      const char *string;
+    };
+    struct {
+      double number;
+    };
+    struct {
+      bool boolean;
+    };
+  };
+} ddog_ffe_AttributeValue;
+
+/**
+ * Represents a key-value pair for attributes.
+ *
+ * # Safety
+ * - `name` must be a valid C string.
+ */
+typedef struct ddog_ffe_AttributePair {
+  const char *name;
+  struct ddog_ffe_AttributeValue value;
+} ddog_ffe_AttributePair;
+
 typedef enum ddog_crasht_BuildIdType {
   DDOG_CRASHT_BUILD_ID_TYPE_GNU,
   DDOG_CRASHT_BUILD_ID_TYPE_GO,
@@ -1565,6 +1775,14 @@ typedef enum ddog_crasht_BuildIdType {
   DDOG_CRASHT_BUILD_ID_TYPE_SHA1,
 } ddog_crasht_BuildIdType;
 
+/**
+ * Result type for runtime callback registration
+ */
+typedef enum ddog_crasht_CallbackResult {
+  DDOG_CRASHT_CALLBACK_RESULT_OK,
+  DDOG_CRASHT_CALLBACK_RESULT_ERROR,
+} ddog_crasht_CallbackResult;
+
 typedef enum ddog_crasht_DemangleOptions {
   DDOG_CRASHT_DEMANGLE_OPTIONS_COMPLETE,
   DDOG_CRASHT_DEMANGLE_OPTIONS_NAME_ONLY,
@@ -1758,7 +1976,7 @@ typedef struct ddog_crasht_Config {
   /**
    * Timeout in milliseconds before the signal handler starts tearing things down to return.
    * If 0, uses the default timeout as specified in
-   * `datadog_crashtracker::shared::constants::DD_CRASHTRACK_DEFAULT_TIMEOUT`. Otherwise, uses
+   * `libdd_crashtracker::shared::constants::DD_CRASHTRACK_DEFAULT_TIMEOUT`. Otherwise, uses
    * the specified timeout value.
    * This is given as a uint32_t, but the actual timeout needs to fit inside of an i32 (max
    * 2^31-1). This is a limitation of the various interfaces used to guarantee the timeout.
@@ -1976,6 +2194,46 @@ typedef struct  ddog_crasht_StackTrace_NewResult {
   };
 }  ddog_crasht_StackTrace_NewResult;
 
+typedef struct ddog_crasht_RuntimeStackFrame {
+  /**
+   * Line number in source file (0 if unknown)
+   */
+  uint32_t line;
+  /**
+   * Column number in source file (0 if unknown)
+   */
+  uint32_t column;
+  /**
+   * Function name (fully qualified if possible)
+   */
+  ddog_CharSlice function;
+  /**
+   * Source file name
+   */
+  ddog_CharSlice file;
+  /**
+   * Type name (class/module/namespace/etc.)
+   */
+  ddog_CharSlice type_name;
+} ddog_crasht_RuntimeStackFrame;
+
+typedef void (*ddog_crasht_RuntimeStackFrameCallback)(void (*emit_frame)(const struct ddog_crasht_RuntimeStackFrame*));
+
+/**
+ * Function signature for runtime stacktrace string collection callbacks
+ *
+ * This callback is invoked during crash handling in a signal context, so it must be signal-safe:
+ *
+ * # Parameters
+ * - `emit_stacktrace_string`: Function to call for complete stacktrace string (takes C string)
+ *
+ * # Safety
+ * The callback function is marked unsafe because:
+ * - It receives function pointers that take raw pointers as parameters
+ * - All C strings passed must be null-terminated and remain valid for the call duration
+ */
+typedef void (*ddog_crasht_RuntimeStacktraceStringCallback)(void (*emit_stacktrace_string)(const char*));
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus

data/vendor/{libdatadog-22.0.1/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-24.0.1/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl}/include/datadog/crashtracker.h

@@ -410,6 +410,16 @@ DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_CrashInfo_resolve_names(struct ddog_crasht_Handle_CrashInfo *crash_info,
                                                            uint32_t pid);
 
+/**
+ * # Safety
+ * The `crash_info` can be null, but if non-null it must point to a Builder made by this module,
+ * which has not previously been dropped.
+ * This function will:
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_CrashInfo_enrich_callstacks(struct ddog_crasht_Handle_CrashInfo *crash_info,
+                                                               uint32_t pid);
+
 /**
  * # Safety
  * The `crash_info` can be null, but if non-null it must point to a Builder made by this module,
@@ -633,27 +643,19 @@ struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_trace_id(struct ddog_cr
  * The CharSlice must be valid.
  */
 DDOG_CHECK_RETURN
-struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_uuid(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
-                                                              ddog_CharSlice uuid);
+struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_message(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
+                                                                 ddog_CharSlice message);
 
 /**
  * # Safety
  * The `builder` can be null, but if non-null it must point to a Builder made by this module,
  * which has not previously been dropped.
- * The CharSlice must be valid.
- */
-DDOG_CHECK_RETURN
-struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_uuid_random(struct ddog_crasht_Handle_CrashInfoBuilder *builder);
-
-/**
- * # Safety
- * The `crash_info` can be null, but if non-null it must point to a Builder made by this module,
- * which has not previously been dropped.
- * The CharSlice must be valid.
+ * All arguments must be valid.
+ * This method requires that the builder has a UUID, siginfo, and metadata set
  */
 DDOG_CHECK_RETURN
-struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_message(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
-                                                                 ddog_CharSlice message);
+struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_upload_ping_to_endpoint(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
+                                                                            const struct ddog_Endpoint *endpoint);
 
 /**
  * Create a new StackFrame, and returns an opaque reference to it.
@@ -852,7 +854,7 @@ struct ddog_StringWrapperResult ddog_crasht_demangle(ddog_CharSlice name,
  * signal handler is dangerous, so we fork a sidecar to do the stuff we aren't
  * allowed to do in the handler.
  *
- * See comments in [datadog-crashtracker/lib.rs] for a full architecture description.
+ * See comments in [libdd-crashtracker/lib.rs] for a full architecture description.
  * # Safety
  * No safety concerns
  */
@@ -866,7 +868,7 @@ DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_receiver_entry_point_stdin(
  * signal handler is dangerous, so we fork a sidecar to do the stuff we aren't
  * allowed to do in the handler.
  *
- * See comments in [datadog-crashtracker/lib.rs] for a full architecture
+ * See comments in [libdd-crashtracker/lib.rs] for a full architecture
  * description.
  * # Safety
  * No safety concerns
@@ -874,6 +876,76 @@ DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_receiver_entry_point_stdin(
 DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_receiver_entry_point_unix_socket(ddog_CharSlice socket_path);
 
+/**
+ * Register a runtime stack collection callback
+ *
+ * # Arguments
+ * - `callback`: The callback function to invoke during crashes
+ *
+ * # Returns
+ * - `CallbackResult::Ok` if registration succeeds
+ * - `CallbackResult::Error` if registration fails
+ *
+ * # Safety
+ * - The callback must be signal-safe
+ * - Only one callback can be registered at a time
+ * - The callback must be registered once on CrashTracker initialization, before any crash occurs
+ *
+ * # Example Usage from C
+ * ```c
+ * static void my_runtime_callback(
+ *     void (*emit_frame)(const ddog_RuntimeStackFrameFFI*),
+ * ) {
+ *     // Collect runtime frames and call emit_frame for each one
+ *     const char* function_name = "my_function";
+ *     const char* file_name = "script.rb";
+ *     ddog_CharSlice type_name = DDOG_CHARSLICE_FROM_CSTR("MyModule.MyClass");
+ *     ddog_crasht_RuntimeStackFrameFFI frame = {
+ *         .type_name = type_name,
+ *         .function = DDOG_CHARSLICE_FROM_CSTR(function_name),
+ *         .file = DDOG_CHARSLICE_FROM_CSTR(file_name),
+ *         .line = 42,
+ *         .column = 10
+ *     };
+ *     emit_frame(&frame);
+ * }
+ */
+enum ddog_crasht_CallbackResult ddog_crasht_register_runtime_frame_callback(ddog_crasht_RuntimeStackFrameCallback callback);
+
+/**
+ * Register a runtime stacktrace string collection callback
+ *
+ * # Arguments
+ * - `callback`: The callback function to invoke during crashes
+ *
+ * # Returns
+ * - `CallbackResult::Ok` if registration succeeds (replaces any existing callback)
+ * - `CallbackResult::Error` if registration fails
+ *
+ * # Safety
+ * - The callback must be signal-safe
+ * - Only one callback can be registered at a time (this replaces any existing one)
+ */
+enum ddog_crasht_CallbackResult ddog_crasht_register_runtime_stacktrace_string_callback(ddog_crasht_RuntimeStacktraceStringCallback callback);
+
+/**
+ * Returns true if a callback is registered, false otherwise
+ *
+ * # Safety
+ * This function is safe to call at any time
+ */
+bool ddog_crasht_is_runtime_callback_registered(void);
+
+/**
+ * Get the callback type from the currently registered callback context
+ *
+ * # Safety
+ * - The returned pointer is valid only while the callback remains registered
+ * - The caller should not free the returned pointer
+ * - The returned string should be copied if it needs to persist beyond callback lifetime
+ */
+const char *ddog_crasht_get_registered_callback_type(void);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/libdatadog-24.0.1/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl/include/datadog/ffe.h

@@ -0,0 +1,175 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_FFE_H
+#define DDOG_FFE_H
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Evaluates a feature flag.
+ *
+ * # Ownership
+ *
+ * The caller must call `ddog_ffe_assignment_drop` on the returned value to free resources.
+ *
+ * # Safety
+ *
+ * - `config` must be a valid `Configuration` handle
+ * - `flag_key` must be a valid C string
+ * - `context` must be a valid `EvaluationContext` handle
+ */
+DDOG_CHECK_RETURN
+ddog_ffe_Handle_ResolutionDetails ddog_ffe_get_assignment(ddog_ffe_Handle_Configuration config,
+                                                          const char *flag_key,
+                                                          enum ddog_ffe_ExpectedFlagType expected_type,
+                                                          ddog_ffe_Handle_EvaluationContext context);
+
+/**
+ * Get value produced by evaluation.
+ *
+ * # Ownership
+ *
+ * The returned `VariantValue` borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_VariantValue ddog_ffe_assignment_get_value(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Get variant key produced by evaluation. Returns `NULL` if evaluation did not produce any value.
+ *
+ * # Ownership
+ *
+ * The returned string borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_variant(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Get allocation key produced by evaluation. Returns `NULL` if evaluation did not produce any
+ * value.
+ *
+ * # Ownership
+ *
+ * The returned string borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_allocation_key(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+enum ddog_ffe_Reason ddog_ffe_assignment_get_reason(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+enum ddog_ffe_ErrorCode ddog_ffe_assignment_get_error_code(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_error_message(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+bool ddog_ffe_assignment_get_do_log(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_flag_metadata(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_extra_logging(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Frees an Assignment handle.
+ *
+ * # Safety
+ * - `assignment` must be a valid Assignment handle
+ */
+void ddog_ffe_assignment_drop(ddog_ffe_Handle_ResolutionDetails *assignment);
+
+/**
+ * Creates a new Configuration from JSON bytes.
+ *
+ * # Ownership
+ *
+ * The caller must call `ddog_ffe_configuration_drop` to release resources allocated for
+ * configuration.
+ *
+ * # Safety
+ *
+ * - `json_bytes` must point to valid memory.
+ */
+DDOG_CHECK_RETURN
+struct ddog_ffe_Result_HandleConfiguration ddog_ffe_configuration_new(struct ddog_ffe_BorrowedStr json_bytes);
+
+/**
+ * Frees a Configuration.
+ *
+ * # Safety
+ *
+ * `config` must be a valid Configuration handle created by `ddog_ffe_configuration_new`.
+ */
+void ddog_ffe_configuration_drop(ddog_ffe_Handle_Configuration *config);
+
+/**
+ * Creates a new EvaluationContext with the given targeting key and attributes.
+ *
+ * # Ownership
+ *
+ * `ddog_ffe_evaluation_context_drop` must be called on the result value to free resources.
+ *
+ * # Safety
+ * - `targeting_key` must be a valid C string or NULL.
+ * - `attributes` must point to a valid array of valid `AttributePair` structs (can be null if
+ *   `attributes_count` is 0)
+ */
+DDOG_CHECK_RETURN
+ddog_ffe_Handle_EvaluationContext ddog_ffe_evaluation_context_new(const char *targeting_key,
+                                                                  const struct ddog_ffe_AttributePair *attributes,
+                                                                  uintptr_t attributes_count);
+
+/**
+ * Frees an EvaluationContext
+ *
+ * # Safety
+ * `context` must be a valid EvaluationContext handle created by `ddog_ffe_evaluation_context_new`
+ */
+void ddog_ffe_evaluation_context_drop(ddog_ffe_Handle_EvaluationContext *context);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_FFE_H */

data/vendor/{libdatadog-22.0.1 → libdatadog-24.0.1}/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl/lib/pkgconfig/datadog_profiling_with_rpath.pc

@@ -8,7 +8,7 @@ includedir=${prefix}/include
 
 Name: datadog_profiling
 Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
-Version: 22.0.1
+Version: 24.0.1
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: