libdatadog 1.0.1.1.0 → 3.0.0.1.0

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

@@ -46,21 +46,45 @@ typedef struct ddog_Tag ddog_Tag;
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
  */
-typedef struct ddog_Vec_Tag {
-  const struct ddog_Tag *ptr;
+typedef struct ddog_Vec_U8 {
+  const uint8_t *ptr;
   uintptr_t len;
   uintptr_t capacity;
-} ddog_Vec_Tag;
+} ddog_Vec_U8;
+
+/**
+ * Please treat this as opaque; do not reach into it, and especially don't
+ * write into it! The most relevant APIs are:
+ * * `ddog_Error_message`, to get the message as a slice.
+ * * `ddog_Error_drop`.
+ */
+typedef struct ddog_Error {
+  /**
+   * This is a String stuffed into the vec.
+   */
+  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 {
+  const char *ptr;
+  uintptr_t len;
+} ddog_Slice_CChar;
+
+typedef struct ddog_Slice_CChar ddog_CharSlice;
 
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
  */
-typedef struct ddog_Vec_U8 {
-  const uint8_t *ptr;
+typedef struct ddog_Vec_Tag {
+  const struct ddog_Tag *ptr;
   uintptr_t len;
   uintptr_t capacity;
-} ddog_Vec_U8;
+} ddog_Vec_Tag;
 
 typedef enum ddog_Vec_Tag_PushResult_Tag {
   DDOG_VEC_TAG_PUSH_RESULT_OK,
@@ -71,25 +95,14 @@ typedef struct ddog_Vec_Tag_PushResult {
   ddog_Vec_Tag_PushResult_Tag tag;
   union {
     struct {
-      struct ddog_Vec_U8 err;
+      struct ddog_Error err;
     };
   };
 } ddog_Vec_Tag_PushResult;
 
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddog_Slice_CChar {
-  const char *ptr;
-  uintptr_t len;
-} ddog_Slice_CChar;
-
-typedef struct ddog_Slice_CChar ddog_CharSlice;
-
 typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Vec_Tag tags;
-  struct ddog_Vec_U8 *error_message;
+  struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
 typedef struct ddog_CancellationToken ddog_CancellationToken;
@@ -100,21 +113,27 @@ typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
 typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
 
-/**
- * This type only exists to workaround a bug in cbindgen; may be removed in the
- * future.
- */
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
-/**
- * Holds the raw parts of a Rust Vec; it should only be created from Rust,
- * never from C.
- */
-typedef struct ddog_prof_Vec_U8 {
-  const uint8_t *ptr;
-  uintptr_t len;
-  uintptr_t capacity;
-} ddog_prof_Vec_U8;
+typedef enum ddog_Endpoint_Tag {
+  DDOG_ENDPOINT_AGENT,
+  DDOG_ENDPOINT_AGENTLESS,
+} ddog_Endpoint_Tag;
+
+typedef struct ddog_Endpoint_ddog_prof_Agentless_Body {
+  ddog_CharSlice _0;
+  ddog_CharSlice _1;
+} ddog_Endpoint_ddog_prof_Agentless_Body;
+
+typedef struct ddog_Endpoint {
+  ddog_Endpoint_Tag tag;
+  union {
+    struct {
+      ddog_CharSlice agent;
+    };
+    ddog_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
+  };
+} ddog_Endpoint;
 
 typedef enum ddog_prof_Exporter_NewResult_Tag {
   DDOG_PROF_EXPORTER_NEW_RESULT_OK,
@@ -128,30 +147,27 @@ typedef struct ddog_prof_Exporter_NewResult {
       struct ddog_prof_Exporter *ok;
     };
     struct {
-      struct ddog_prof_Vec_U8 err;
+      struct ddog_Error err;
     };
   };
 } ddog_prof_Exporter_NewResult;
 
-typedef enum ddog_Endpoint_Tag {
-  DDOG_ENDPOINT_AGENT,
-  DDOG_ENDPOINT_AGENTLESS,
-} ddog_Endpoint_Tag;
+typedef enum ddog_prof_Exporter_Request_BuildResult_Tag {
+  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_OK,
+  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR,
+} ddog_prof_Exporter_Request_BuildResult_Tag;
 
-typedef struct ddog_Endpoint_ddog_prof_Agentless_Body {
-  ddog_CharSlice _0;
-  ddog_CharSlice _1;
-} ddog_Endpoint_ddog_prof_Agentless_Body;
-
-typedef struct ddog_Endpoint {
-  ddog_Endpoint_Tag tag;
+typedef struct ddog_prof_Exporter_Request_BuildResult {
+  ddog_prof_Exporter_Request_BuildResult_Tag tag;
   union {
     struct {
-      ddog_CharSlice agent;
+      struct ddog_prof_Exporter_Request *ok;
+    };
+    struct {
+      struct ddog_Error err;
     };
-    ddog_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
   };
-} ddog_Endpoint;
+} ddog_prof_Exporter_Request_BuildResult;
 
 /**
  * Represents time since the Unix Epoch in seconds plus nanoseconds.
@@ -205,7 +221,7 @@ typedef struct ddog_prof_Exporter_SendResult {
       struct ddog_HttpStatus http_response;
     };
     struct {
-      struct ddog_prof_Vec_U8 err;
+      struct ddog_Error err;
     };
   };
 } ddog_prof_Exporter_SendResult;
@@ -229,6 +245,23 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
+typedef enum ddog_prof_Profile_AddResult_Tag {
+  DDOG_PROF_PROFILE_ADD_RESULT_OK,
+  DDOG_PROF_PROFILE_ADD_RESULT_ERR,
+} ddog_prof_Profile_AddResult_Tag;
+
+typedef struct ddog_prof_Profile_AddResult {
+  ddog_prof_Profile_AddResult_Tag tag;
+  union {
+    struct {
+      uint64_t ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_AddResult;
+
 typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
@@ -396,10 +429,36 @@ typedef struct ddog_prof_Sample {
   struct ddog_prof_Slice_Label labels;
 } ddog_prof_Sample;
 
+typedef enum ddog_prof_Profile_UpscalingRuleAddResult_Tag {
+  DDOG_PROF_PROFILE_UPSCALING_RULE_ADD_RESULT_OK,
+  DDOG_PROF_PROFILE_UPSCALING_RULE_ADD_RESULT_ERR,
+} ddog_prof_Profile_UpscalingRuleAddResult_Tag;
+
+typedef struct ddog_prof_Profile_UpscalingRuleAddResult {
+  ddog_prof_Profile_UpscalingRuleAddResult_Tag tag;
+  union {
+    struct {
+      bool ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_UpscalingRuleAddResult;
+
+/**
+ * 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 {
+  const uintptr_t *ptr;
+  uintptr_t len;
+} ddog_prof_Slice_Usize;
+
 typedef struct ddog_prof_EncodedProfile {
   struct ddog_Timespec start;
   struct ddog_Timespec end;
-  struct ddog_prof_Vec_U8 buffer;
+  struct ddog_Vec_U8 buffer;
   struct ddog_prof_ProfiledEndpointsStats *endpoints_stats;
 } ddog_prof_EncodedProfile;
 
@@ -415,17 +474,29 @@ typedef struct ddog_prof_Profile_SerializeResult {
       struct ddog_prof_EncodedProfile ok;
     };
     struct {
-      struct ddog_prof_Vec_U8 err;
+      struct ddog_Error err;
     };
   };
 } ddog_prof_Profile_SerializeResult;
 
+/**
+ * # Safety
+ * Only pass null or a valid reference to a `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);
+
 DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
 void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);
 
-void ddog_Vec_Tag_PushResult_drop(struct ddog_Vec_Tag_PushResult);
-
 /**
  * Creates a new Tag from the provided `key` and `value` by doing a utf8
  * lossy conversion, and pushes into the `vec`. The strings `key` and `value`

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

@@ -11,8 +11,6 @@
 #include <stdint.h>
 #include "common.h"
 
-void ddog_prof_Exporter_NewResult_drop(struct ddog_prof_Exporter_NewResult result);
-
 /**
  * Creates an endpoint that uses the agent.
  * # Arguments
@@ -39,6 +37,8 @@ struct ddog_Endpoint ddog_Endpoint_agentless(ddog_CharSlice site, ddog_CharSlice
  * * `tags` - Tags to include with every profile reported by this exporter. It's also possible to include
  *   profile-specific tags, see `additional_tags` on `profile_exporter_build`.
  * * `endpoint` - Configuration for reporting data
+ * # Safety
+ * All pointers must refer to valid objects of the correct types.
  */
 DDOG_CHECK_RETURN
 struct ddog_prof_Exporter_NewResult ddog_prof_Exporter_new(ddog_CharSlice profiling_library_name,
@@ -47,41 +47,64 @@ struct ddog_prof_Exporter_NewResult ddog_prof_Exporter_new(ddog_CharSlice profil
                                                            const struct ddog_Vec_Tag *tags,
                                                            struct ddog_Endpoint endpoint);
 
+/**
+ * # Safety
+ * The `exporter` may be null, but if non-null the pointer must point to a
+ * valid `ddog_prof_Exporter_Request` object made by the Rust Global
+ * allocator that has not already been dropped.
+ */
 void ddog_prof_Exporter_drop(struct ddog_prof_Exporter *exporter);
 
 /**
- * Builds a Request object based on the profile data supplied.
+ * If successful, builds a `ddog_prof_Exporter_Request` object based on the
+ * profile data supplied. If unsuccessful, it returns an error message.
+ *
+ * For details on the `optional_internal_metadata_json`, please reference the Datadog-internal
+ * "RFC: Attaching internal metadata to pprof profiles".
+ * If you use this parameter, please update the RFC with your use-case, so we can keep track of how this
+ * is getting used.
  *
  * # Safety
- * The `exporter` and the files inside of the `files` slice need to have been
- * created by this module.
+ * 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`.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Exporter_Request *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,
-                                                                    const struct ddog_Vec_Tag *additional_tags,
-                                                                    const struct ddog_prof_ProfiledEndpointsStats *endpoints_stats,
-                                                                    uint64_t timeout_ms);
+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,
+                                                                               const struct ddog_Vec_Tag *optional_additional_tags,
+                                                                               const struct ddog_prof_ProfiledEndpointsStats *optional_endpoints_stats,
+                                                                               const ddog_CharSlice *optional_internal_metadata_json,
+                                                                               uint64_t timeout_ms);
+
+/**
+ * # Safety
+ * Each pointer of `request` may be null, but if non-null the inner-most
+ * pointer must point to a valid `ddog_prof_Exporter_Request` object made by
+ * the Rust Global allocator.
+ */
+void ddog_prof_Exporter_Request_drop(struct ddog_prof_Exporter_Request **request);
 
 /**
  * Sends the request, returning the HttpStatus.
  *
  * # Arguments
- * * `exporter` - borrows the exporter for sending the request
- * * `request` - takes ownership of the request
- * * `cancel` - borrows the cancel, if any
+ * * `exporter` - Borrows the exporter for sending the request.
+ * * `request` - Takes ownership of the request, replacing it with a null
+ *               pointer. This is why it takes a double-pointer, rather than
+ *               a single one.
+ * * `cancel` - Borrows the cancel, if any.
  *
  * # Safety
  * All non-null arguments MUST have been created by created by apis in this module.
  */
 DDOG_CHECK_RETURN
 struct ddog_prof_Exporter_SendResult ddog_prof_Exporter_send(struct ddog_prof_Exporter *exporter,
-                                                             struct ddog_prof_Exporter_Request *request,
-                                                             struct ddog_CancellationToken *cancel);
-
-void ddog_prof_Exporter_Request_drop(struct ddog_prof_Exporter_Request *_request);
+                                                             struct ddog_prof_Exporter_Request **request,
+                                                             const struct ddog_CancellationToken *cancel);
 
 /**
  * Can be passed as an argument to send and then be used to asynchronously cancel it from a different thread.
@@ -111,20 +134,26 @@ struct ddog_CancellationToken *ddog_CancellationToken_new(void);
  * Without clone, both t1 and t2 would need to synchronize to make sure neither was using the cancel
  * before it could be dropped. With clone, there is no need for such synchronization, both threads
  * have their own cancel and should drop that cancel after they are done with it.
+ *
+ * # Safety
+ * If the `token` is non-null, it must point to a valid object.
  */
 DDOG_CHECK_RETURN
-struct ddog_CancellationToken *ddog_CancellationToken_clone(struct ddog_CancellationToken *cancel);
+struct ddog_CancellationToken *ddog_CancellationToken_clone(const struct ddog_CancellationToken *token);
 
 /**
  * Cancel send that is being called in another thread with the given token.
  * Note that cancellation is a terminal state; cancelling a token more than once does nothing.
  * Returns `true` if token was successfully cancelled.
  */
-bool ddog_CancellationToken_cancel(struct ddog_CancellationToken *cancel);
-
-void ddog_CancellationToken_drop(struct ddog_CancellationToken *_cancel);
+bool ddog_CancellationToken_cancel(const struct ddog_CancellationToken *cancel);
 
-void ddog_prof_Exporter_SendResult_drop(struct ddog_prof_Exporter_SendResult result);
+/**
+ * # Safety
+ * The `token` can be null, but non-null values must be created by the Rust
+ * Global allocator and must have not been dropped already.
+ */
+void ddog_CancellationToken_drop(struct ddog_CancellationToken *token);
 
 /**
  * Create a new profile with the given sample types. Must call
@@ -147,19 +176,28 @@ struct ddog_prof_Profile *ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType
 
 /**
  * # Safety
- * The `profile` must point to an object created by another FFI routine in this
- * module, such as `ddog_Profile_with_sample_types`.
+ * The `profile` can be null, but if non-null it must point to a valid object
+ * created by the Rust Global allocator.
  */
-void ddog_prof_Profile_drop(struct ddog_prof_Profile *_profile);
+void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
 
 /**
  * # Safety
  * The `profile` ptr must point to a valid Profile object created by this
  * module. All pointers inside the `sample` need to be valid for the duration
  * of this call.
+ *
+ * If successful, it returns the internal id of the sample (> 0) in the Ok
+ * variant. On error, it holds an error message in the error variant.
+ *
+ * # Safety
+ * The `profile` ptr must point to a valid Profile object created by this
+ * module.
  * This call is _NOT_ thread-safe.
  */
-uint64_t ddog_prof_Profile_add(struct ddog_prof_Profile *profile, struct ddog_prof_Sample sample);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_AddResult ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
+                                                         struct ddog_prof_Sample sample);
 
 /**
  * Associate an endpoint to a given local root span id.
@@ -171,7 +209,7 @@ uint64_t ddog_prof_Profile_add(struct ddog_prof_Profile *profile, struct ddog_pr
  *
  * # Arguments
  * * `profile` - a reference to the profile that will contain the samples.
- * * `local_root_span_id` - the value of the local root span id label to look for.
+ * * `local_root_span_id`
  * * `endpoint` - the value of the endpoint label to add for matching samples.
  *
  * # Safety
@@ -180,7 +218,7 @@ uint64_t ddog_prof_Profile_add(struct ddog_prof_Profile *profile, struct ddog_pr
  * This call is _NOT_ thread-safe.
  */
 void ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
-                                    ddog_CharSlice local_root_span_id,
+                                    uint64_t local_root_span_id,
                                     ddog_CharSlice endpoint);
 
 /**
@@ -200,8 +238,72 @@ void ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
                                           int64_t value);
 
 /**
- * Serialize the aggregated profile. Don't forget to clean up the result by
- * calling ddog_prof_Profile_SerializeResult_drop.
+ * Add a poisson-based upscaling rule which will be use to adjust values and make them
+ * closer to reality.
+ *
+ * # Arguments
+ * * `profile` - a reference to the profile that will contain the samples.
+ * * `offset_values` - offset of the values
+ * * `label_name` - name of the label used to identify sample(s)
+ * * `label_value` - value of the label used to identify sample(s)
+ * * `sum_value_offset` - offset of the value used as a sum (compute the average with `count_value_offset`)
+ * * `count_value_offset` - offset of the value used as a count (compute the average with `sum_value_offset`)
+ * * `sampling_distance` - this is the threshold for this sampling window. This value must not be equal to 0
+ *
+ * # Safety
+ * This function must be called before serialize and must not be called after.
+ * The `profile` ptr must point to a valid Profile object created by this
+ * module.
+ * This call is _NOT_ thread-safe.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_UpscalingRuleAddResult ddog_prof_Profile_add_upscaling_rule_poisson(struct ddog_prof_Profile *profile,
+                                                                                             struct ddog_prof_Slice_Usize offset_values,
+                                                                                             ddog_CharSlice label_name,
+                                                                                             ddog_CharSlice label_value,
+                                                                                             uintptr_t sum_value_offset,
+                                                                                             uintptr_t count_value_offset,
+                                                                                             uint64_t sampling_distance);
+
+/**
+ * Add a proportional-based upscaling rule which will be use to adjust values and make them
+ * closer to reality.
+ *
+ * # Arguments
+ * * `profile` - a reference to the profile that will contain the samples.
+ * * `offset_values` - offset of the values
+ * * `label_name` - name of the label used to identify sample(s)
+ * * `label_value` - value of the label used to identify sample(s)
+ * * `total_sampled` - number of sampled event (found in the pprof). This value must not be equal to 0
+ * * `total_real` - number of events the profiler actually witnessed. This value must not be equal to 0
+ *
+ * # Safety
+ * This function must be called before serialize and must not be called after.
+ * The `profile` ptr must point to a valid Profile object created by this
+ * module.
+ * This call is _NOT_ thread-safe.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_UpscalingRuleAddResult ddog_prof_Profile_add_upscaling_rule_proportional(struct ddog_prof_Profile *profile,
+                                                                                                  struct ddog_prof_Slice_Usize offset_values,
+                                                                                                  ddog_CharSlice label_name,
+                                                                                                  ddog_CharSlice label_value,
+                                                                                                  uint64_t total_sampled,
+                                                                                                  uint64_t total_real);
+
+/**
+ * # Safety
+ * Only pass a reference to a valid `ddog_prof_EncodedProfile`, or null. A
+ * valid reference also means that it hasn't already been dropped (do not
+ * call this twice on the same object).
+ */
+void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
+
+/**
+ * Serialize the aggregated profile.
+ *
+ * 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.
  *
  * # Arguments
  * * `profile` - a reference to the profile being serialized.
@@ -218,13 +320,12 @@ void ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
  * The `end_time` must be null or otherwise point to a valid TimeSpec object.
  * The `duration_nanos` must be null or otherwise point to a valid i64.
  */
+DDOG_CHECK_RETURN
 struct ddog_prof_Profile_SerializeResult ddog_prof_Profile_serialize(const struct ddog_prof_Profile *profile,
                                                                      const struct ddog_Timespec *end_time,
                                                                      const int64_t *duration_nanos);
 
-void ddog_prof_Profile_SerializeResult_drop(struct ddog_prof_Profile_SerializeResult _result);
-
-DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_prof_Vec_U8 *vec);
+DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_Vec_U8 *vec);
 
 /**
  * Resets all data in `profile` except the sample types and period. Returns

data/vendor/{libdatadog-1.0.1 → libdatadog-3.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: 1.0.1
+Version: 3.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: