libdatadog 14.3.1.1.0 → 16.0.1.1.0

data/vendor/libdatadog-16.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/data-pipeline.h

@@ -0,0 +1,123 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_DATA_PIPELINE_H
+#define DDOG_DATA_PIPELINE_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Frees `error` and all its contents. After being called error will not point to a valid memory
+ * address so any further actions on it could lead to undefined behavior.
+ */
+void ddog_trace_exporter_error_free(struct ddog_TraceExporterError *error);
+
+void ddog_trace_exporter_config_new(struct ddog_TraceExporterConfig **out_handle);
+
+/**
+ * Frees TraceExporterConfig handle internal resources.
+ */
+void ddog_trace_exporter_config_free(struct ddog_TraceExporterConfig *handle);
+
+/**
+ * Sets traces destination.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_url(struct ddog_TraceExporterConfig *config,
+                                                                   ddog_CharSlice url);
+
+/**
+ * Sets tracer's version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_tracer_version(struct ddog_TraceExporterConfig *config,
+                                                                              ddog_CharSlice version);
+
+/**
+ * Sets tracer's language to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_language(struct ddog_TraceExporterConfig *config,
+                                                                        ddog_CharSlice lang);
+
+/**
+ * Sets tracer's language version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_lang_version(struct ddog_TraceExporterConfig *config,
+                                                                            ddog_CharSlice version);
+
+/**
+ * Sets tracer's language interpreter to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_lang_interpreter(struct ddog_TraceExporterConfig *config,
+                                                                                ddog_CharSlice interpreter);
+
+/**
+ * Sets hostname information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_hostname(struct ddog_TraceExporterConfig *config,
+                                                                        ddog_CharSlice hostname);
+
+/**
+ * Sets environmet information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_env(struct ddog_TraceExporterConfig *config,
+                                                                   ddog_CharSlice env);
+
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_version(struct ddog_TraceExporterConfig *config,
+                                                                       ddog_CharSlice version);
+
+/**
+ * Sets service name to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_service(struct ddog_TraceExporterConfig *config,
+                                                                       ddog_CharSlice service);
+
+/**
+ * Create a new TraceExporter instance.
+ *
+ * # Arguments
+ *
+ * * `out_handle` - The handle to write the TraceExporter instance in.
+ * * `config` - The configuration used to set up the TraceExporter handle.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_new(struct ddog_TraceExporter **out_handle,
+                                                        const struct ddog_TraceExporterConfig *config);
+
+/**
+ * Free the TraceExporter instance.
+ *
+ * # Arguments
+ *
+ * * handle - The handle to the TraceExporter instance.
+ */
+void ddog_trace_exporter_free(struct ddog_TraceExporter *handle);
+
+/**
+ * Send traces to the Datadog Agent.
+ *
+ * # Arguments
+ *
+ * * `handle` - The handle to the TraceExporter instance.
+ * * `trace` - The traces to send to the Datadog Agent in the input format used to create the
+ *   TraceExporter. The memory for the trace must be valid for the life of the call to this
+ *   function.
+ * * `trace_count` - The number of traces to send to the Datadog Agent.
+ * * `response` - Optional parameter that will ontain the agent response information.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send(const struct ddog_TraceExporter *handle,
+                                                         ddog_ByteSlice trace,
+                                                         uintptr_t trace_count,
+                                                         struct ddog_AgentResponse *response);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_DATA_PIPELINE_H */

data/vendor/libdatadog-16.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/library-config.h

@@ -0,0 +1,61 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_LIBRARY_CONFIG_H
+#define DDOG_LIBRARY_CONFIG_H
+
+#pragma once
+
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+struct ddog_Configurator *ddog_library_configurator_new(bool debug_logs, ddog_CharSlice language);
+
+void ddog_library_configurator_with_local_path(struct ddog_Configurator *c,
+                                               struct ddog_CStr local_path);
+
+void ddog_library_configurator_with_fleet_path(struct ddog_Configurator *c,
+                                               struct ddog_CStr local_path);
+
+void ddog_library_configurator_with_process_info(struct ddog_Configurator *c,
+                                                 struct ddog_ProcessInfo p);
+
+void ddog_library_configurator_drop(struct ddog_Configurator*);
+
+struct ddog_Result_VecLibraryConfig ddog_library_configurator_get(const struct ddog_Configurator *configurator);
+
+/**
+ * Returns a static null-terminated string, containing the name of the environment variable
+ * associated with the library configuration
+ */
+struct ddog_CStr ddog_library_config_name_to_env(enum ddog_LibraryConfigName name);
+
+/**
+ * Returns a static null-terminated string, containing the name of the environment variable
+ * associated with the library configuration
+ */
+struct ddog_CStr ddog_library_config_source_to_string(enum ddog_LibraryConfigSource name);
+
+/**
+ * Returns a static null-terminated string with the path to the managed stable config yaml config
+ * file
+ */
+struct ddog_CStr ddog_library_config_fleet_stable_config_path(void);
+
+/**
+ * Returns a static null-terminated string with the path to the local stable config yaml config
+ * file
+ */
+struct ddog_CStr ddog_library_config_local_stable_config_path(void);
+
+void ddog_library_config_drop(struct ddog_Vec_LibraryConfig);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_LIBRARY_CONFIG_H */

data/vendor/{libdatadog-14.3.1 → libdatadog-16.0.1}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/profiling.h

@@ -205,6 +205,16 @@ struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_
                                                          const struct ddog_prof_Period *period,
                                                          const struct ddog_Timespec *start_time);
 
+/**
+ * Same as `ddog_profile_new` but also configures a `string_storage` for the profile.
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_NewResult ddog_prof_Profile_with_string_storage(struct ddog_prof_Slice_ValueType sample_types,
+                                                                         const struct ddog_prof_Period *period,
+                                                                         const struct ddog_Timespec *start_time,
+                                                                         struct ddog_prof_ManagedStringStorage string_storage);
+
 /**
  * # Safety
  * The `profile` can be null, but if non-null it must point to a Profile
@@ -387,6 +397,69 @@ DDOG_CHECK_RETURN
 struct ddog_prof_Profile_Result ddog_prof_Profile_reset(struct ddog_prof_Profile *profile,
                                                         const struct ddog_Timespec *start_time);
 
+DDOG_CHECK_RETURN
+struct ddog_prof_ManagedStringStorageNewResult ddog_prof_ManagedStringStorage_new(void);
+
+/**
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+void ddog_prof_ManagedStringStorage_drop(struct ddog_prof_ManagedStringStorage storage);
+
+/**
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_ManagedStringStorageInternResult ddog_prof_ManagedStringStorage_intern(struct ddog_prof_ManagedStringStorage storage,
+                                                                                        ddog_CharSlice string);
+
+/**
+ * Interns all the strings in `strings`, writing the resulting id to the same
+ * offset in `output_ids`.
+ *
+ * This can fail if:
+ *  1. The given `output_ids_size` doesn't match the size of the input slice.
+ *  2. The internal storage pointer is null.
+ *  3. It fails to acquire a lock (e.g. it was poisoned).
+ *  4. Defensive checks against bugs fail.
+ *
+ * If a failure occurs, do not use any of the ids in the output array. After
+ * this point, you should only use read-only routines (except for drop) on
+ * the managed string storage.
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+ddog_prof_MaybeError ddog_prof_ManagedStringStorage_intern_all(struct ddog_prof_ManagedStringStorage storage,
+                                                               struct ddog_prof_Slice_CharSlice strings,
+                                                               struct ddog_prof_ManagedStringId *output_ids,
+                                                               uintptr_t output_ids_size);
+
+/**
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+ddog_prof_MaybeError ddog_prof_ManagedStringStorage_unintern(struct ddog_prof_ManagedStringStorage storage,
+                                                             struct ddog_prof_ManagedStringId id);
+
+/**
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+ddog_prof_MaybeError ddog_prof_ManagedStringStorage_unintern_all(struct ddog_prof_ManagedStringStorage storage,
+                                                                 struct ddog_prof_Slice_ManagedStringId ids);
+
+/**
+ * Returns a string given its id.
+ * This API is mostly for testing, overall you should avoid reading back strings from libdatadog
+ * once they've been interned and should instead always operate on the id.
+ * Remember to `ddog_StringWrapper_drop` the string once you're done with it.
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+DDOG_CHECK_RETURN
+struct ddog_StringWrapperResult ddog_prof_ManagedStringStorage_get_string(struct ddog_prof_ManagedStringStorage storage,
+                                                                          struct ddog_prof_ManagedStringId id);
+
+/**
+ * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
+ */
+ddog_prof_MaybeError ddog_prof_ManagedStringStorage_advance_gen(struct ddog_prof_ManagedStringStorage storage);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus