libdatadog 30.0.0.1.0 → 33.0.0.1.0

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

@@ -0,0 +1,216 @@
+// 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);
+
+/**
+ * Return a read-only pointer to the response body. This pointer is only valid as long as
+ * `response` is valid.
+ */
+const uint8_t *ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response,
+                                                     uintptr_t *out_len);
+
+/**
+ * Free `response` and all its contents. After being called response will not point to a valid
+ * memory address so any further actions on it could lead to undefined behavior.
+ */
+void ddog_trace_exporter_response_free(struct ddog_TraceExporterResponse *response);
+
+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 environment 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);
+
+/**
+ * Enables health metrics emission.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_health_metrics(struct ddog_TraceExporterConfig *config,
+                                                                                 bool is_enabled);
+
+/**
+ * Enables telemetry metrics.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_telemetry(struct ddog_TraceExporterConfig *config,
+                                                                            const struct ddog_TelemetryClientConfig *telemetry_cfg);
+
+/**
+ * Set client-side stats computation status.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_compute_stats(struct ddog_TraceExporterConfig *config,
+                                                                             bool is_enabled);
+
+/**
+ * Sets `Datadog-Client-Computed-Stats` header to `true`.
+ * This indicates that the upstream system has already computed the stats,
+ * and no further stats computation should be performed.
+ *
+ * <div class="warning">
+ * This method must not be used when `compute_stats` is enabled, as it could
+ * result in duplicate stats computation.
+ * </div>
+ *
+ * A common use case is in Application Security Monitoring (ASM) scenarios:
+ * when APM is disabled but ASM is enabled, setting this header to `true`
+ * ensures that no stats are computed at any level (exporter or agent).
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_stats(struct ddog_TraceExporterConfig *config,
+                                                                                     bool client_computed_stats);
+
+/**
+ * Sets the process tags to be included in the stats payload.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_process_tags(struct ddog_TraceExporterConfig *config,
+                                                                            ddog_CharSlice process_tags);
+
+/**
+ * Sets the `X-Datadog-Test-Session-Token` header. Only used for testing with the test agent.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_test_session_token(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice token);
+
+/**
+ * Sets the timeout in ms for all agent's connections.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_connection_timeout(struct ddog_TraceExporterConfig *config,
+                                                                                  uint64_t timeout_ms);
+
+/**
+ * Sets a shared runtime for the TraceExporter to use for background workers.
+ *
+ * `handle` must have been initialized with [`ddog_shared_runtime_new`].
+ *
+ * When set, the exporter will use the provided runtime instead of creating its own.
+ * This allows multiple exporters (or other components) to share a single runtime.
+ * The config holds a clone of the `Arc` (increments the strong count), so the
+ * original handle remains valid and must still be freed with
+ * [`ddog_shared_runtime_free`].
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(struct ddog_TraceExporterConfig *config,
+                                                                              struct ddog_SharedRuntime *handle);
+
+/**
+ * Enables OTLP HTTP/JSON export and sets the endpoint URL.
+ *
+ * When set, traces are sent to this URL in OTLP HTTP/JSON format instead of the Datadog
+ * agent. The host language is responsible for resolving the endpoint from its configuration
+ * (e.g. `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`) before calling this function.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice url);
+
+/**
+ * Create a new TraceExporter instance.
+ *
+ * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces in
+ * OTLP HTTP/JSON to that endpoint instead of the Datadog agent. The same payload (e.g.
+ * MessagePack) is passed to `ddog_trace_exporter_send`; the library decodes and converts to
+ * OTLP when OTLP is enabled.
+ *
+ * # 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(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(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_out` - Optional handle to store a pointer to the agent response information.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporter *handle,
+                                                         ddog_ByteSlice trace,
+                                                         struct ddog_TraceExporterResponse **response_out);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_DATA_PIPELINE_H */

data/vendor/libdatadog-33.0.0/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/ffe.h

@@ -0,0 +1,179 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_FFE_H
+#define DDOG_FFE_H
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Evaluates a feature flag.
+ *
+ * # Ownership
+ *
+ * The caller must call `ddog_ffe_assignment_drop` on the returned value to free resources.
+ *
+ * # Safety
+ *
+ * - `config` must be a valid `Configuration` handle
+ * - `flag_key` must be a valid C string
+ * - `context` must be a valid `EvaluationContext` handle
+ */
+DDOG_CHECK_RETURN
+ddog_ffe_Handle_ResolutionDetails ddog_ffe_get_assignment(ddog_ffe_Handle_Configuration config,
+                                                          const char *flag_key,
+                                                          enum ddog_ffe_ExpectedFlagType expected_type,
+                                                          ddog_ffe_Handle_EvaluationContext context);
+
+/**
+ * Get value produced by evaluation.
+ *
+ * # Ownership
+ *
+ * The returned `VariantValue` borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_VariantValue ddog_ffe_assignment_get_value(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Get variant key produced by evaluation. Returns `NULL` if evaluation did not produce any value.
+ *
+ * # Ownership
+ *
+ * The returned string borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_variant(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Get allocation key produced by evaluation. Returns `NULL` if evaluation did not produce any
+ * value.
+ *
+ * # Ownership
+ *
+ * The returned string borrows from `assignment`. It must not be used after `assignment` is
+ * freed.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_allocation_key(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+enum ddog_ffe_Reason ddog_ffe_assignment_get_reason(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+enum ddog_ffe_ErrorCode ddog_ffe_assignment_get_error_code(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_error_message(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Get the serial_id produced by evaluation.
+ *
+ * Returns `None` if the assignment has no serial_id or evaluation did not produce any value.
+ *
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_Option_I32 ddog_ffe_assignment_get_serial_id(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+bool ddog_ffe_assignment_get_do_log(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * # Safety
+ * `assignment` must be a valid handle.
+ */
+struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_flag_metadata(ddog_ffe_Handle_ResolutionDetails assignment);
+
+/**
+ * Frees an Assignment handle.
+ *
+ * # Safety
+ * - `assignment` must be a valid Assignment handle
+ */
+void ddog_ffe_assignment_drop(ddog_ffe_Handle_ResolutionDetails *assignment);
+
+/**
+ * Creates a new Configuration from JSON bytes.
+ *
+ * # Ownership
+ *
+ * The caller must call `ddog_ffe_configuration_drop` to release resources allocated for
+ * configuration.
+ *
+ * # Safety
+ *
+ * - `json_bytes` must point to valid memory.
+ */
+DDOG_CHECK_RETURN
+struct ddog_ffe_Result_HandleConfiguration ddog_ffe_configuration_new(struct ddog_ffe_BorrowedStr json_bytes);
+
+/**
+ * Frees a Configuration.
+ *
+ * # Safety
+ *
+ * `config` must be a valid Configuration handle created by `ddog_ffe_configuration_new`.
+ */
+void ddog_ffe_configuration_drop(ddog_ffe_Handle_Configuration *config);
+
+/**
+ * Creates a new EvaluationContext with the given targeting key and attributes.
+ *
+ * # Ownership
+ *
+ * `ddog_ffe_evaluation_context_drop` must be called on the result value to free resources.
+ *
+ * # Safety
+ * - `targeting_key` must be a valid C string or NULL.
+ * - `attributes` must point to a valid array of valid `AttributePair` structs (can be null if
+ *   `attributes_count` is 0)
+ */
+DDOG_CHECK_RETURN
+ddog_ffe_Handle_EvaluationContext ddog_ffe_evaluation_context_new(const char *targeting_key,
+                                                                  const struct ddog_ffe_AttributePair *attributes,
+                                                                  uintptr_t attributes_count);
+
+/**
+ * Frees an EvaluationContext
+ *
+ * # Safety
+ * `context` must be a valid EvaluationContext handle created by `ddog_ffe_evaluation_context_new`
+ */
+void ddog_ffe_evaluation_context_drop(ddog_ffe_Handle_EvaluationContext *context);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_FFE_H */