libdatadog 2.0.0.1.0-aarch64-linux → 4.0.0.1.0-aarch64-linux

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

@@ -40,6 +40,8 @@
 #  define DDOG_CHECK_RETURN
 #endif
 
+typedef struct ddog_Endpoint ddog_Endpoint;
+
 typedef struct ddog_Tag ddog_Tag;
 
 /**
@@ -107,8 +109,6 @@ typedef struct ddog_Vec_Tag_ParseResult {
 
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
-typedef struct ddog_prof_Profile ddog_prof_Profile;
-
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
 typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
@@ -226,6 +226,14 @@ typedef struct ddog_prof_Exporter_SendResult {
   };
 } ddog_prof_Exporter_SendResult;
 
+/**
+ * Represents a profile. Do not access its member for any reason, only use
+ * the C API functions on this struct.
+ */
+typedef struct ddog_prof_Profile {
+  struct ddog_prof_Profile *inner;
+} ddog_prof_Profile;
+
 typedef struct ddog_prof_ValueType {
   ddog_CharSlice type_;
   ddog_CharSlice unit;
@@ -245,22 +253,30 @@ 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;
+/**
+ * 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_AddResult {
-  ddog_prof_Profile_AddResult_Tag tag;
+typedef struct ddog_prof_Profile_Result {
+  ddog_prof_Profile_Result_Tag tag;
   union {
     struct {
-      uint64_t ok;
+      /**
+       * 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_AddResult;
+} ddog_prof_Profile_Result;
 
 typedef struct ddog_prof_Mapping {
   /**
@@ -309,31 +325,12 @@ typedef struct ddog_prof_Function {
   int64_t start_line;
 } ddog_prof_Function;
 
-typedef struct ddog_prof_Line {
-  /**
-   * The corresponding profile.Function for this line.
-   */
-  struct ddog_prof_Function function;
-  /**
-   * Line number in source code.
-   */
-  int64_t line;
-} ddog_prof_Line;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddog_prof_Slice_Line {
-  const struct ddog_prof_Line *ptr;
-  uintptr_t len;
-} ddog_prof_Slice_Line;
-
 typedef struct ddog_prof_Location {
   /**
    * todo: how to handle unknown mapping?
    */
   struct ddog_prof_Mapping mapping;
+  struct ddog_prof_Function function;
   /**
    * The instruction address for this location, if available.  It
    * should be within [Mapping.memory_start...Mapping.memory_limit]
@@ -342,24 +339,7 @@ typedef struct ddog_prof_Location {
    * the beginning of the instruction if necessary.
    */
   uint64_t address;
-  /**
-   * Multiple line indicates this location has inlined functions,
-   * where the last entry represents the caller into which the
-   * preceding entries were inlined.
-   *
-   * E.g., if memcpy() is inlined into printf:
-   *    line[0].function_name == "memcpy"
-   *    line[1].function_name == "printf"
-   */
-  struct ddog_prof_Slice_Line lines;
-  /**
-   * Provides an indication that multiple symbols map to this location's
-   * address, for example due to identical code folding by the linker. In that
-   * case the line information above represents one of the multiple
-   * symbols. This field must be recomputed when the symbolization state of the
-   * profile changes.
-   */
-  bool is_folded;
+  int64_t line;
 } ddog_prof_Location;
 
 /**
@@ -429,6 +409,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 {
+  const uintptr_t *ptr;
+  uintptr_t len;
+} ddog_prof_Slice_Usize;
+
 typedef struct ddog_prof_EncodedProfile {
   struct ddog_Timespec start;
   struct ddog_Timespec end;
@@ -467,6 +456,17 @@ void ddog_Error_drop(struct ddog_Error *error);
  */
 ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
 
+DDOG_CHECK_RETURN struct ddog_Endpoint *ddog_endpoint_from_url(ddog_CharSlice url);
+
+DDOG_CHECK_RETURN struct ddog_Endpoint *ddog_endpoint_from_api_key(ddog_CharSlice api_key);
+
+DDOG_CHECK_RETURN
+struct ddog_Error *ddog_endpoint_from_api_key_and_site(ddog_CharSlice api_key,
+                                                       ddog_CharSlice site,
+                                                       struct ddog_Endpoint **endpoint);
+
+void ddog_endpoint_drop(struct ddog_Endpoint*);
+
 DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
 void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);

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

@@ -59,17 +59,25 @@ void ddog_prof_Exporter_drop(struct ddog_prof_Exporter *exporter);
  * 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`, `additional_stats`, and `endpoint_stats` args should be
- * valid objects created by this module, except NULL is allowed.
+ * 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_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 *additional_tags,
-                                                                               const struct ddog_prof_ProfiledEndpointsStats *endpoints_stats,
+                                                                               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);
 
 /**
@@ -162,14 +170,14 @@ 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 ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
+                                               const struct ddog_prof_Period *period,
+                                               const struct ddog_Timespec *start_time);
 
 /**
  * # Safety
- * The `profile` can be null, but if non-null it must point to a valid object
- * created by the Rust Global allocator.
+ * The `profile` can be null, but if non-null it must point to a Profile
+ * made by this module, which has not previously been dropped.
  */
 void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
 
@@ -179,8 +187,8 @@ void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
  * 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.
+ * If successful, it returns 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
@@ -188,8 +196,8 @@ void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
  * This call is _NOT_ thread-safe.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_AddResult ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
-                                                         struct ddog_prof_Sample sample);
+struct ddog_prof_Profile_Result ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
+                                                      struct ddog_prof_Sample sample);
 
 /**
  * Associate an endpoint to a given local root span id.
@@ -209,9 +217,10 @@ struct ddog_prof_Profile_AddResult ddog_prof_Profile_add(struct ddog_prof_Profil
  * module.
  * This call is _NOT_ thread-safe.
  */
-void ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
-                                    uint64_t local_root_span_id,
-                                    ddog_CharSlice endpoint);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
+                                                               uint64_t local_root_span_id,
+                                                               ddog_CharSlice endpoint);
 
 /**
  * Count the number of times an endpoint has been seen.
@@ -225,9 +234,64 @@ void ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
  * module.
  * This call is _NOT_ thread-safe.
  */
-void ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
-                                          ddog_CharSlice endpoint,
-                                          int64_t value);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
+                                                                     ddog_CharSlice endpoint,
+                                                                     int64_t value);
+
+/**
+ * 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_Result 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_Result 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
@@ -259,7 +323,7 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
  * 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,
+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);
 
@@ -279,7 +343,8 @@ DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_Ve
  * can be called across an FFI boundary, the compiler cannot enforce this.
  * If `time` is not null, it must point to a valid Timespec object.
  */
-bool ddog_prof_Profile_reset(struct ddog_prof_Profile *profile,
-                             const struct ddog_Timespec *start_time);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_reset(struct ddog_prof_Profile *profile,
+                                                        const struct ddog_Timespec *start_time);
 
 #endif /* DDOG_PROFILING_H */

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