libdatadog 2.0.0.1.0 → 7.0.0.1.0

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

@@ -1,5 +1,6 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
 
 #ifndef DDOG_PROFILING_H
 #define DDOG_PROFILING_H
@@ -11,12 +12,36 @@
 #include <stdint.h>
 #include "common.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+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
  * * `base_url` - Contains a URL with scheme, host, and port e.g. "https://agent:8126/".
  */
-struct ddog_Endpoint ddog_Endpoint_agent(ddog_CharSlice base_url);
+struct ddog_prof_Endpoint ddog_prof_Endpoint_agent(ddog_CharSlice base_url);
 
 /**
  * Creates an endpoint that uses the Datadog intake directly aka agentless.
@@ -24,18 +49,21 @@ struct ddog_Endpoint ddog_Endpoint_agent(ddog_CharSlice base_url);
  * * `site` - Contains a host and port e.g. "datadoghq.com".
  * * `api_key` - Contains the Datadog API key.
  */
-struct ddog_Endpoint ddog_Endpoint_agentless(ddog_CharSlice site, ddog_CharSlice api_key);
+struct ddog_prof_Endpoint ddog_prof_Endpoint_agentless(ddog_CharSlice site, ddog_CharSlice api_key);
 
 /**
  * Creates a new exporter to be used to report profiling data.
  * # Arguments
- * * `profiling_library_name` - Profiling library name, usually dd-trace-something, e.g. "dd-trace-rb". See
- *   https://datadoghq.atlassian.net/wiki/spaces/PROF/pages/1538884229/Client#Header-values (Datadog internal link)
+ * * `profiling_library_name` - Profiling library name, usually dd-trace-something, e.g.
+ *   "dd-trace-rb". See
+ *   https://datadoghq.atlassian.net/wiki/spaces/PROF/pages/1538884229/Client#Header-values
+ *   (Datadog internal link)
  *   for a list of common values.
- * * `profliling_library_version` - Version used when publishing the profiling library to a package manager
+ * * `profliling_library_version` - Version used when publishing the profiling library to a package
+ *   manager
  * * `family` - Profile family, e.g. "ruby"
- * * `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`.
+ * * `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.
@@ -45,7 +73,7 @@ struct ddog_prof_Exporter_NewResult ddog_prof_Exporter_new(ddog_CharSlice profil
                                                            ddog_CharSlice profiling_library_version,
                                                            ddog_CharSlice family,
                                                            const struct ddog_Vec_Tag *tags,
-                                                           struct ddog_Endpoint endpoint);
+                                                           struct ddog_prof_Endpoint endpoint);
 
 /**
  * # Safety
@@ -59,17 +87,30 @@ 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.
+ *
+ * For details on the `optional_info_json`, please reference the Datadog-internal
+ * "RFC: Pprof System Info Support".
+ *
  * # 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`,
+ * `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,
-                                                                               const struct ddog_Vec_Tag *additional_tags,
-                                                                               const struct ddog_prof_ProfiledEndpointsStats *endpoints_stats,
+                                                                               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);
 
 /**
@@ -85,9 +126,8 @@ void ddog_prof_Exporter_Request_drop(struct ddog_prof_Exporter_Request **request
  *
  * # Arguments
  * * `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.
+ * * `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
@@ -99,10 +139,10 @@ struct ddog_prof_Exporter_SendResult ddog_prof_Exporter_send(struct ddog_prof_Ex
                                                              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.
+ * Can be passed as an argument to send and then be used to asynchronously cancel it from a
+ * different thread.
  */
-DDOG_CHECK_RETURN
-struct ddog_CancellationToken *ddog_CancellationToken_new(void);
+DDOG_CHECK_RETURN struct ddog_CancellationToken *ddog_CancellationToken_new(void);
 
 /**
  * A cloned CancellationToken is connected to the CancellationToken it was created from.
@@ -123,9 +163,9 @@ struct ddog_CancellationToken *ddog_CancellationToken_new(void);
  *     ddog_CancellationToken_drop(cancel_t2);
  * ```
  *
- * 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.
+ * 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.
@@ -155,21 +195,21 @@ void ddog_CancellationToken_drop(struct ddog_CancellationToken *token);
  * * `sample_types`
  * * `period` - Optional period of the profile. Passing None/null translates to zero values.
  * * `start_time` - Optional time the profile started at. Passing None/null will use the current
- *                  time.
+ *   time.
  *
  * # Safety
  * All slices must be have pointers that are suitably aligned for their type
  * 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
- * 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 +219,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 +228,9 @@ 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,
+                                                      int64_t timestamp);
 
 /**
  * Associate an endpoint to a given local root span id.
@@ -209,9 +250,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 +267,69 @@ 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
@@ -239,6 +341,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.
@@ -246,12 +349,13 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
  * # Arguments
  * * `profile` - a reference to the profile being serialized.
  * * `end_time` - optional end time of the profile. If None/null is passed, the current time will
- *                be used.
+ *   be used.
  * * `duration_nanos` - Optional duration of the profile. Passing None or a negative duration will
- *                      mean the duration will based on the end time minus the start time, but
- *                      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.
+ *   mean the duration will based on the end time minus the start time, but 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.
@@ -259,9 +363,10 @@ 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);
+                                                                     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);
 
@@ -279,7 +384,12 @@ 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);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
 
 #endif /* DDOG_PROFILING_H */

data/vendor/libdatadog-7.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/include/datadog/telemetry.h

@@ -0,0 +1,290 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_TELEMETRY_H
+#define DDOG_TELEMETRY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "common.h"
+
+void ddog_MaybeError_drop(ddog_MaybeError);
+
+/**
+ * # Safety
+ * * builder should be a non null pointer to a null pointer to a builder
+ */
+ddog_MaybeError ddog_builder_instantiate(struct ddog_TelemetryWorkerBuilder **out_builder,
+                                         ddog_CharSlice service_name,
+                                         ddog_CharSlice language_name,
+                                         ddog_CharSlice language_version,
+                                         ddog_CharSlice tracer_version);
+
+/**
+ * # Safety
+ * * builder should be a non null pointer to a null pointer to a builder
+ */
+ddog_MaybeError ddog_builder_instantiate_with_hostname(struct ddog_TelemetryWorkerBuilder **out_builder,
+                                                       ddog_CharSlice hostname,
+                                                       ddog_CharSlice service_name,
+                                                       ddog_CharSlice language_name,
+                                                       ddog_CharSlice language_version,
+                                                       ddog_CharSlice tracer_version);
+
+ddog_MaybeError ddog_builder_with_native_deps(struct ddog_TelemetryWorkerBuilder *builder,
+                                              bool include_native_deps);
+
+ddog_MaybeError ddog_builder_with_rust_shared_lib_deps(struct ddog_TelemetryWorkerBuilder *builder,
+                                                       bool include_rust_shared_lib_deps);
+
+ddog_MaybeError ddog_builder_with_config(struct ddog_TelemetryWorkerBuilder *builder,
+                                         ddog_CharSlice name,
+                                         ddog_CharSlice value,
+                                         enum ddog_ConfigurationOrigin origin);
+
+/**
+ * Builds the telemetry worker and return a handle to it
+ *
+ * # Safety
+ * * handle should be a non null pointer to a null pointer
+ */
+ddog_MaybeError ddog_builder_run(struct ddog_TelemetryWorkerBuilder *builder,
+                                 struct ddog_TelemetryWorkerHandle **out_handle);
+
+/**
+ * Builds the telemetry worker and return a handle to it. The worker will only process and send
+ * telemetry metrics and telemetry logs. Any lifecyle/dependency/configuration event will be
+ * ignored
+ *
+ * # Safety
+ * * handle should be a non null pointer to a null pointer
+ */
+ddog_MaybeError ddog_builder_run_metric_logs(struct ddog_TelemetryWorkerBuilder *builder,
+                                             struct ddog_TelemetryWorkerHandle **out_handle);
+
+ddog_MaybeError ddog_builder_with_str_application_service_version(struct ddog_TelemetryWorkerBuilder *builder,
+                                                                  ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_application_env(struct ddog_TelemetryWorkerBuilder *builder,
+                                                      ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_application_runtime_name(struct ddog_TelemetryWorkerBuilder *builder,
+                                                               ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_application_runtime_version(struct ddog_TelemetryWorkerBuilder *builder,
+                                                                  ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_application_runtime_patches(struct ddog_TelemetryWorkerBuilder *builder,
+                                                                  ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_host_container_id(struct ddog_TelemetryWorkerBuilder *builder,
+                                                        ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_host_os(struct ddog_TelemetryWorkerBuilder *builder,
+                                              ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_host_kernel_name(struct ddog_TelemetryWorkerBuilder *builder,
+                                                       ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_host_kernel_release(struct ddog_TelemetryWorkerBuilder *builder,
+                                                          ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_host_kernel_version(struct ddog_TelemetryWorkerBuilder *builder,
+                                                          ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_str_runtime_id(struct ddog_TelemetryWorkerBuilder *builder,
+                                                 ddog_CharSlice param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * application.service_version
+ *
+ *     * application.env
+ *
+ *     * application.runtime_name
+ *
+ *     * application.runtime_version
+ *
+ *     * application.runtime_patches
+ *
+ *     * host.container_id
+ *
+ *     * host.os
+ *
+ *     * host.kernel_name
+ *
+ *     * host.kernel_release
+ *
+ *     * host.kernel_version
+ *
+ *     * runtime_id
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_property_str(struct ddog_TelemetryWorkerBuilder *builder,
+                                               enum ddog_TelemetryWorkerBuilderStrProperty property,
+                                               ddog_CharSlice param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * application.service_version
+ *
+ *     * application.env
+ *
+ *     * application.runtime_name
+ *
+ *     * application.runtime_version
+ *
+ *     * application.runtime_patches
+ *
+ *     * host.container_id
+ *
+ *     * host.os
+ *
+ *     * host.kernel_name
+ *
+ *     * host.kernel_release
+ *
+ *     * host.kernel_version
+ *
+ *     * runtime_id
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_str_named_property(struct ddog_TelemetryWorkerBuilder *builder,
+                                                     ddog_CharSlice property,
+                                                     ddog_CharSlice param);
+
+ddog_MaybeError ddog_builder_with_bool_config_telemetry_debug_logging_enabled(struct ddog_TelemetryWorkerBuilder *builder,
+                                                                              bool param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * config.telemetry_debug_logging_enabled
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_property_bool(struct ddog_TelemetryWorkerBuilder *builder,
+                                                enum ddog_TelemetryWorkerBuilderBoolProperty property,
+                                                bool param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * config.telemetry_debug_logging_enabled
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_bool_named_property(struct ddog_TelemetryWorkerBuilder *builder,
+                                                      ddog_CharSlice property,
+                                                      bool param);
+
+ddog_MaybeError ddog_builder_with_endpoint_config_endpoint(struct ddog_TelemetryWorkerBuilder *builder,
+                                                           const struct ddog_Endpoint *param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * config.endpoint
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_property_endpoint(struct ddog_TelemetryWorkerBuilder *builder,
+                                                    enum ddog_TelemetryWorkerBuilderEndpointProperty property,
+                                                    const struct ddog_Endpoint *param);
+
+/**
+ *      Sets a property from it's string value.
+ *
+ *     Available properties:
+ *
+ *     * config.endpoint
+ *
+ *
+ */
+ddog_MaybeError ddog_builder_with_endpoint_named_property(struct ddog_TelemetryWorkerBuilder *builder,
+                                                          ddog_CharSlice property,
+                                                          const struct ddog_Endpoint *param);
+
+ddog_MaybeError ddog_handle_add_dependency(const struct ddog_TelemetryWorkerHandle *handle,
+                                           ddog_CharSlice dependency_name,
+                                           ddog_CharSlice dependency_version);
+
+ddog_MaybeError ddog_handle_add_integration(const struct ddog_TelemetryWorkerHandle *handle,
+                                            ddog_CharSlice dependency_name,
+                                            ddog_CharSlice dependency_version,
+                                            bool enabled,
+                                            struct ddog_Option_Bool compatible,
+                                            struct ddog_Option_Bool auto_enabled);
+
+/**
+ * * indentifier: identifies a logging location uniquely. This can for instance be the template
+ *   using for the log message or the concatenated file + line of the origin of the log
+ * * stack_trace: stack trace associated with the log. If no stack trace is available, an empty
+ *   string should be passed
+ */
+ddog_MaybeError ddog_handle_add_log(const struct ddog_TelemetryWorkerHandle *handle,
+                                    ddog_CharSlice indentifier,
+                                    ddog_CharSlice message,
+                                    enum ddog_LogLevel level,
+                                    ddog_CharSlice stack_trace);
+
+ddog_MaybeError ddog_handle_start(const struct ddog_TelemetryWorkerHandle *handle);
+
+struct ddog_TelemetryWorkerHandle *ddog_handle_clone(const struct ddog_TelemetryWorkerHandle *handle);
+
+ddog_MaybeError ddog_handle_stop(const struct ddog_TelemetryWorkerHandle *handle);
+
+/**
+ * * compatible: should be false if the metric is language specific, true otherwise
+ */
+struct ddog_ContextKey ddog_handle_register_metric_context(const struct ddog_TelemetryWorkerHandle *handle,
+                                                           ddog_CharSlice name,
+                                                           enum ddog_MetricType metric_type,
+                                                           struct ddog_Vec_Tag tags,
+                                                           bool common,
+                                                           enum ddog_MetricNamespace namespace_);
+
+ddog_MaybeError ddog_handle_add_point(const struct ddog_TelemetryWorkerHandle *handle,
+                                      const struct ddog_ContextKey *context_key,
+                                      double value);
+
+ddog_MaybeError ddog_handle_add_point_with_tags(const struct ddog_TelemetryWorkerHandle *handle,
+                                                const struct ddog_ContextKey *context_key,
+                                                double value,
+                                                struct ddog_Vec_Tag extra_tags);
+
+/**
+ * This function takes ownership of the handle. It should not be used after calling it
+ */
+void ddog_handle_wait_for_shutdown(struct ddog_TelemetryWorkerHandle *handle);
+
+/**
+ * This function takes ownership of the handle. It should not be used after calling it
+ */
+void ddog_handle_wait_for_shutdown_ms(struct ddog_TelemetryWorkerHandle *handle,
+                                      uint64_t wait_for_ms);
+
+/**
+ * Drops the handle without waiting for shutdown. The worker will continue running in the
+ * background until it exits by itself
+ */
+void ddog_handle_drop(struct ddog_TelemetryWorkerHandle *handle);
+
+#endif /* DDOG_TELEMETRY_H */

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

@@ -1,7 +1,5 @@
-# Unless explicitly stated otherwise all files in this repository are licensed
-# under the Apache License Version 2.0. This product includes software
-# developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present
-# Datadog, Inc.
+# Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
 
 prefix=${pcfiledir}/../..
 exec_prefix=${prefix}
@@ -10,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: 2.0.0
+Version: 
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: