libdatadog 4.0.0.1.0 → 6.0.0.1.0

data/vendor/{libdatadog-4.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-6.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/common.h

@@ -67,15 +67,21 @@ typedef struct ddog_Error {
   struct ddog_Vec_U8 message;
 } ddog_Error;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_Slice_CChar {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   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;
 
 /**
@@ -107,6 +113,37 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
+typedef enum ddog_prof_CrashtrackerResolveFrames {
+  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_NEVER,
+  /**
+   * Resolving frames is experimental, and can fail/crash
+   */
+  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_EXPERIMENTAL_IN_PROCESS,
+  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_EXPERIMENTAL_IN_RECEIVER,
+} ddog_prof_CrashtrackerResolveFrames;
+
+/**
+ * This enum represents operations a profiler might be engaged in.
+ * The idea is that if a crash consistently occurs while a particular operation
+ * is ongoing, its likely related.
+ *
+ * In the future, we might also track wall-clock time of operations
+ * (or some statistical sampling thereof) using the same enum.
+ *
+ * NOTE: This enum is known to be non-exhaustive.  Feel free to add new types
+ *       as needed.
+ */
+typedef enum ddog_prof_ProfilingOpTypes {
+  DDOG_PROF_PROFILING_OP_TYPES_NOT_PROFILING = 0,
+  DDOG_PROF_PROFILING_OP_TYPES_COLLECTING_SAMPLE,
+  DDOG_PROF_PROFILING_OP_TYPES_UNWINDING,
+  DDOG_PROF_PROFILING_OP_TYPES_SERIALIZING,
+  /**
+   * Dummy value to allow easier iteration
+   */
+  DDOG_PROF_PROFILING_OP_TYPES_SIZE,
+} ddog_prof_ProfilingOpTypes;
+
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
@@ -115,6 +152,31 @@ typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats
 
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
+/**
+ * A generic result type for when a profiling operation may fail, but there's
+ * nothing to return in the case of success.
+ */
+typedef enum ddog_prof_Profile_Result_Tag {
+  DDOG_PROF_PROFILE_RESULT_OK,
+  DDOG_PROF_PROFILE_RESULT_ERR,
+} ddog_prof_Profile_Result_Tag;
+
+typedef struct ddog_prof_Profile_Result {
+  ddog_prof_Profile_Result_Tag tag;
+  union {
+    struct {
+      /**
+       * Do not use the value of Ok. This value only exists to overcome
+       * Rust -> C code generation.
+       */
+      bool ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_Result;
+
 typedef enum ddog_Endpoint_Tag {
   DDOG_ENDPOINT_AGENT,
   DDOG_ENDPOINT_AGENTLESS,
@@ -135,6 +197,71 @@ typedef struct ddog_Endpoint {
   };
 } ddog_Endpoint;
 
+typedef struct ddog_prof_CrashtrackerConfiguration {
+  bool create_alt_stack;
+  /**
+   * The endpoint to send the crash repor to (can be a file://)
+   */
+  struct ddog_Endpoint endpoint;
+  /**
+   * Optional filename to forward stderr to (useful for logging/debugging)
+   */
+  ddog_CharSlice optional_stderr_filename;
+  /**
+   * Optional filename to forward stdout to (useful for logging/debugging)
+   */
+  ddog_CharSlice optional_stdout_filename;
+  ddog_CharSlice path_to_receiver_binary;
+  /**
+   * Whether/when we should attempt to resolve frames
+   */
+  enum ddog_prof_CrashtrackerResolveFrames resolve_frames;
+} ddog_prof_CrashtrackerConfiguration;
+
+typedef struct ddog_prof_CrashtrackerMetadata {
+  ddog_CharSlice profiling_library_name;
+  ddog_CharSlice profiling_library_version;
+  ddog_CharSlice family;
+  /**
+   * Should include "service", "environment", etc
+   */
+  const struct ddog_Vec_Tag *tags;
+} ddog_prof_CrashtrackerMetadata;
+
+typedef struct ddog_Slice_U8 {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const uint8_t *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_U8;
+
+/**
+ * Use to represent bytes -- does not need to be valid UTF-8.
+ */
+typedef struct ddog_Slice_U8 ddog_ByteSlice;
+
+typedef struct ddog_prof_Exporter_File {
+  ddog_CharSlice name;
+  ddog_ByteSlice file;
+} ddog_prof_Exporter_File;
+
+typedef struct ddog_prof_Exporter_Slice_File {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_Exporter_File *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Exporter_Slice_File;
+
 typedef enum ddog_prof_Exporter_NewResult_Tag {
   DDOG_PROF_EXPORTER_NEW_RESULT_OK,
   DDOG_PROF_EXPORTER_NEW_RESULT_ERR,
@@ -177,34 +304,6 @@ typedef struct ddog_Timespec {
   uint32_t nanoseconds;
 } ddog_Timespec;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddog_Slice_U8 {
-  const uint8_t *ptr;
-  uintptr_t len;
-} ddog_Slice_U8;
-
-/**
- * Use to represent bytes -- does not need to be valid UTF-8.
- */
-typedef struct ddog_Slice_U8 ddog_ByteSlice;
-
-typedef struct ddog_prof_Exporter_File {
-  ddog_CharSlice name;
-  ddog_ByteSlice file;
-} ddog_prof_Exporter_File;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddog_prof_Exporter_Slice_File {
-  const struct ddog_prof_Exporter_File *ptr;
-  uintptr_t len;
-} ddog_prof_Exporter_Slice_File;
-
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
@@ -234,17 +333,40 @@ typedef struct ddog_prof_Profile {
   struct ddog_prof_Profile *inner;
 } ddog_prof_Profile;
 
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_Profile_NewResult_Tag {
+  DDOG_PROF_PROFILE_NEW_RESULT_OK,
+  DDOG_PROF_PROFILE_NEW_RESULT_ERR,
+} ddog_prof_Profile_NewResult_Tag;
+
+typedef struct ddog_prof_Profile_NewResult {
+  ddog_prof_Profile_NewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_Profile ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_NewResult;
+
 typedef struct ddog_prof_ValueType {
   ddog_CharSlice type_;
   ddog_CharSlice unit;
 } ddog_prof_ValueType;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_prof_Slice_ValueType {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_ValueType *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
   uintptr_t len;
 } ddog_prof_Slice_ValueType;
 
@@ -253,31 +375,6 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
-/**
- * A generic result type for when a profiling operation may fail, but there's
- * nothing to return in the case of success.
- */
-typedef enum ddog_prof_Profile_Result_Tag {
-  DDOG_PROF_PROFILE_RESULT_OK,
-  DDOG_PROF_PROFILE_RESULT_ERR,
-} ddog_prof_Profile_Result_Tag;
-
-typedef struct ddog_prof_Profile_Result {
-  ddog_prof_Profile_Result_Tag tag;
-  union {
-    struct {
-      /**
-       * Do not use the value of Ok. This value only exists to overcome
-       * Rust -> C code generation.
-       */
-      bool ok;
-    };
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_prof_Profile_Result;
-
 typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
@@ -342,21 +439,27 @@ typedef struct ddog_prof_Location {
   int64_t line;
 } ddog_prof_Location;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_prof_Slice_Location {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_Location *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
   uintptr_t len;
 } ddog_prof_Slice_Location;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_Slice_I64 {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const int64_t *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_I64;
 
@@ -379,12 +482,15 @@ typedef struct ddog_prof_Label {
   ddog_CharSlice num_unit;
 } ddog_prof_Label;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_prof_Slice_Label {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_Label *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
   uintptr_t len;
 } ddog_prof_Slice_Label;
 
@@ -409,12 +515,15 @@ typedef struct ddog_prof_Sample {
   struct ddog_prof_Slice_Label labels;
 } ddog_prof_Sample;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
 typedef struct ddog_prof_Slice_Usize {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const uintptr_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
   uintptr_t len;
 } ddog_prof_Slice_Usize;
 

data/vendor/{libdatadog-4.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-6.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/profiling.h

@@ -11,6 +11,26 @@
 #include <stdint.h>
 #include "common.h"
 
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_crashtracker_begin_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_crashtracker_end_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+
+DDOG_CHECK_RETURN struct ddog_prof_Profile_Result ddog_prof_crashtracker_shutdown(void);
+
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_crashtracker_update_on_fork(struct ddog_prof_CrashtrackerConfiguration config,
+                                                                      struct ddog_prof_CrashtrackerMetadata metadata);
+
+DDOG_CHECK_RETURN struct ddog_prof_Profile_Result ddog_prof_crashtracker_receiver_entry_point(void);
+
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_crashtracker_init(struct ddog_prof_CrashtrackerConfiguration config,
+                                                            struct ddog_prof_CrashtrackerMetadata metadata);
+
+DDOG_CHECK_RETURN struct ddog_prof_Exporter_Slice_File ddog_prof_Exporter_Slice_File_empty(void);
+
 /**
  * Creates an endpoint that uses the agent.
  * # Arguments
@@ -64,20 +84,25 @@ void ddog_prof_Exporter_drop(struct ddog_prof_Exporter *exporter);
  * If you use this parameter, please update the RFC with your use-case, so we can keep track of how this
  * is getting used.
  *
+ * For details on the `optional_info_json`, please reference the Datadog-internal
+ * "RFC: Pprof System Info Support".
+ *
  * # Safety
  * The `exporter`, `optional_additional_stats`, and `optional_endpoint_stats` args should be
  * valid objects created by this module.
- * NULL is allowed for `optional_additional_tags`, `optional_endpoints_stats` and
- * `optional_internal_metadata_json`.
+ * NULL is allowed for `optional_additional_tags`, `optional_endpoints_stats`,
+ * `optional_internal_metadata_json` and `optional_info_json`.
  */
 DDOG_CHECK_RETURN
 struct ddog_prof_Exporter_Request_BuildResult ddog_prof_Exporter_Request_build(struct ddog_prof_Exporter *exporter,
                                                                                struct ddog_Timespec start,
                                                                                struct ddog_Timespec end,
-                                                                               struct ddog_prof_Exporter_Slice_File files,
+                                                                               struct ddog_prof_Exporter_Slice_File files_to_compress_and_export,
+                                                                               struct ddog_prof_Exporter_Slice_File files_to_export_unmodified,
                                                                                const struct ddog_Vec_Tag *optional_additional_tags,
                                                                                const struct ddog_prof_ProfiledEndpointsStats *optional_endpoints_stats,
                                                                                const ddog_CharSlice *optional_internal_metadata_json,
+                                                                               const ddog_CharSlice *optional_info_json,
                                                                                uint64_t timeout_ms);
 
 /**
@@ -170,9 +195,9 @@ void ddog_CancellationToken_drop(struct ddog_CancellationToken *token);
  * and must have the correct number of elements for the slice.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
-                                               const struct ddog_prof_Period *period,
-                                               const struct ddog_Timespec *start_time);
+struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
+                                                         const struct ddog_prof_Period *period,
+                                                         const struct ddog_Timespec *start_time);
 
 /**
  * # Safety
@@ -197,7 +222,8 @@ void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
  */
 DDOG_CHECK_RETURN
 struct ddog_prof_Profile_Result ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
-                                                      struct ddog_prof_Sample sample);
+                                                      struct ddog_prof_Sample sample,
+                                                      int64_t timestamp);
 
 /**
  * Associate an endpoint to a given local root span id.
@@ -303,6 +329,7 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
 
 /**
  * Serialize the aggregated profile.
+ * Drains the data, and then resets the profile for future use.
  *
  * Don't forget to clean up the ok with `ddog_prof_EncodedProfile_drop` or
  * the error variant with `ddog_Error_drop` when you are done with them.
@@ -316,6 +343,7 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
  *                      under anomalous conditions this may fail as system clocks can be adjusted,
  *                      or the programmer accidentally passed an earlier time. The duration of
  *                      the serialized profile will be set to zero for these cases.
+ * * `start_time` - Optional start time for the next profile.
  *
  * # Safety
  * The `profile` must point to a valid profile object.
@@ -325,7 +353,8 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
 DDOG_CHECK_RETURN
 struct ddog_prof_Profile_SerializeResult ddog_prof_Profile_serialize(struct ddog_prof_Profile *profile,
                                                                      const struct ddog_Timespec *end_time,
-                                                                     const int64_t *duration_nanos);
+                                                                     const int64_t *duration_nanos,
+                                                                     const struct ddog_Timespec *start_time);
 
 DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_Vec_U8 *vec);
 

data/vendor/{libdatadog-4.0.0 → libdatadog-6.0.0}/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/lib/pkgconfig/datadog_profiling_with_rpath.pc

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