libdatadog 16.0.1.1.0-x86_64-linux → 19.1.0.1.0-x86_64-linux

data/vendor/{libdatadog-16.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu → libdatadog-19.1.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl}/include/datadog/crashtracker.h

@@ -12,6 +12,13 @@
 #include <stdint.h>
 #include "common.h"
 
+#if defined(_WIN32) && defined(_CRASHTRACKING_COLLECTOR)
+#include <werapi.h>
+#include <windows.h>
+#endif
+
+
+
 typedef enum  ddog_crasht_CrashInfoBuilder_NewResult_Tag {
   DDOG_CRASHT_CRASH_INFO_BUILDER_NEW_RESULT_OK,
   DDOG_CRASHT_CRASH_INFO_BUILDER_NEW_RESULT_ERR,
@@ -51,23 +58,32 @@ extern "C" {
 #endif // __cplusplus
 
 /**
- * Cleans up after the crash-tracker:
- * Unregister the crash handler, restore the previous handler (if any), and
- * shut down the receiver.  Note that the use of this function is optional:
- * the receiver will automatically shutdown when the pipe is closed on program
- * exit.
+ * Disables the crashtracker.
+ * Note that this does not restore the old signal handlers, but rather turns crash-tracking into a
+ * no-op, and then chains the old handlers.  This means that handlers registered after the
+ * crashtracker will continue to work as expected.
  *
  * # Preconditions
- *   This function assumes that the crashtracker has previously been
- *   initialized.
+ *   None
  * # Safety
- *   Crash-tracking functions are not reentrant.
- *   No other crash-handler functions should be called concurrently.
+ *   None
  * # Atomicity
- *   This function is not atomic. A crash during its execution may lead to
- *   unexpected crash-handling behaviour.
+ *   This function is atomic and idempotent.  Calling it multiple times is allowed.
+ */
+DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_disable(void);
+
+/**
+ * Enables the crashtracker, if it had been previously disabled.
+ * If crashtracking has not been initialized, this function will have no effect.
+ *
+ * # Preconditions
+ *   None
+ * # Safety
+ *   None
+ * # Atomicity
+ *   This function is atomic and idempotent.  Calling it multiple times is allowed.
  */
-DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_shutdown(void);
+DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_enable(void);
 
 /**
  * Reinitialize the crash-tracking infrastructure after a fork.
@@ -110,6 +126,24 @@ struct ddog_VoidResult ddog_crasht_init(struct ddog_crasht_Config config,
                                         struct ddog_crasht_ReceiverConfig receiver_config,
                                         struct ddog_crasht_Metadata metadata);
 
+/**
+ * Reconfigure the crashtracker and re-enables it.
+ * If the crashtracker has not been initialized, this function will have no effect.
+ *
+ * # Preconditions
+ *   None.
+ * # Safety
+ *   Crash-tracking functions are not reentrant.
+ *   No other crash-handler functions should be called concurrently.
+ * # Atomicity
+ *   This function is not atomic. A crash during its execution may lead to
+ *   unexpected crash-handling behaviour.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_reconfigure(struct ddog_crasht_Config config,
+                                               struct ddog_crasht_ReceiverConfig receiver_config,
+                                               struct ddog_crasht_Metadata metadata);
+
 /**
  * Initialize the crash-tracking infrastructure without launching the receiver.
  *
@@ -126,6 +160,11 @@ DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_init_without_receiver(struct ddog_crasht_Config config,
                                                          struct ddog_crasht_Metadata metadata);
 
+/**
+ * Returns a list of signals suitable for use in a crashtracker config.
+ */
+struct ddog_crasht_Slice_CInt ddog_crasht_default_signals(void);
+
 /**
  * Removes all existing additional tags
  * Expected to be used after a fork, to reset the additional tags on the child
@@ -325,6 +364,61 @@ struct ddog_VoidResult ddog_crasht_remove_trace_id(uint64_t id_high,
                                                    uint64_t id_low,
                                                    uintptr_t idx);
 
+#if (defined(_CRASHTRACKING_COLLECTOR) && defined(_WIN32))
+/**
+ * Initialize the crash-tracking infrastructure.
+ *
+ * # Preconditions
+ *   None.
+ * # Safety
+ *   Crash-tracking functions are not reentrant.
+ *   No other crash-handler functions should be called concurrently.
+ * # Atomicity
+ *   This function is not atomic. A crash during its execution may lead to
+ *   unexpected crash-handling behaviour.
+ */
+DDOG_CHECK_RETURN
+bool ddog_crasht_init_windows(ddog_CharSlice module,
+                              const struct ddog_Endpoint *endpoint,
+                              struct ddog_crasht_Metadata metadata);
+#endif
+
+#if (defined(_CRASHTRACKING_COLLECTOR) && defined(_WIN32))
+HRESULT OutOfProcessExceptionEventSignatureCallback(const void *_context,
+                                                    const WER_RUNTIME_EXCEPTION_INFORMATION *_exception_information,
+                                                    int32_t _index,
+                                                    uint16_t *_name,
+                                                    uint32_t *_name_size,
+                                                    uint16_t *_value,
+                                                    uint32_t *_value_size);
+#endif
+
+#if (defined(_CRASHTRACKING_COLLECTOR) && defined(_WIN32))
+HRESULT OutOfProcessExceptionEventDebuggerLaunchCallback(const void *_context,
+                                                         const WER_RUNTIME_EXCEPTION_INFORMATION *_exception_information,
+                                                         BOOL *_is_custom_debugger,
+                                                         uint16_t *_debugger_launch,
+                                                         uint32_t *_debugger_launch_size,
+                                                         BOOL *_is_debugger_auto_launch);
+#endif
+
+#if (defined(_CRASHTRACKING_COLLECTOR) && defined(_WIN32))
+HRESULT OutOfProcessExceptionEventCallback(const void *context,
+                                           const WER_RUNTIME_EXCEPTION_INFORMATION *exception_information,
+                                           BOOL *_ownership_claimed,
+                                           uint16_t *_event_name,
+                                           uint32_t *_size,
+                                           uint32_t *_signature_count);
+#endif
+
+/**
+ * # Safety
+ * The `crash_info` can be null, but if non-null it must point to a Builder made by this module,
+ * which has not previously been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_CrashInfo_demangle_names(struct ddog_crasht_Handle_CrashInfo *crash_info);
+
 /**
  * # Safety
  * The `builder` can be null, but if non-null it must point to a Frame
@@ -585,6 +679,16 @@ struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_uuid(struct ddog_crasht
 DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_uuid_random(struct ddog_crasht_Handle_CrashInfoBuilder *builder);
 
+/**
+ * # Safety
+ * The `crash_info` can be null, but if non-null it must point to a Builder made by this module,
+ * which has not previously been dropped.
+ * The CharSlice must be valid.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_message(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
+                                                                 ddog_CharSlice message);
+
 /**
  * Create a new StackFrame, and returns an opaque reference to it.
  * # Safety
@@ -782,7 +886,7 @@ struct ddog_StringWrapperResult ddog_crasht_demangle(ddog_CharSlice name,
  * signal handler is dangerous, so we fork a sidecar to do the stuff we aren't
  * allowed to do in the handler.
  *
- * See comments in [crashtracker/lib.rs] for a full architecture description.
+ * See comments in [datadog-crashtracker/lib.rs] for a full architecture description.
  * # Safety
  * No safety concerns
  */
@@ -796,7 +900,7 @@ DDOG_CHECK_RETURN struct ddog_VoidResult ddog_crasht_receiver_entry_point_stdin(
  * signal handler is dangerous, so we fork a sidecar to do the stuff we aren't
  * allowed to do in the handler.
  *
- * See comments in [profiling/crashtracker/mod.rs] for a full architecture
+ * See comments in [datadog-crashtracker/lib.rs] for a full architecture
  * description.
  * # Safety
  * No safety concerns

data/vendor/{libdatadog-16.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu → libdatadog-19.1.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl}/include/datadog/data-pipeline.h

@@ -21,6 +21,18 @@ extern "C" {
  */
 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 char *ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response);
+
+/**
+ * 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);
 
 /**
@@ -65,7 +77,7 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_hostname(struct d
                                                                         ddog_CharSlice hostname);
 
 /**
- * Sets environmet information to be included in the headers request.
+ * 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);
@@ -79,6 +91,56 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_version(struct dd
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_service(struct ddog_TraceExporterConfig *config,
                                                                        ddog_CharSlice service);
 
+/**
+ * Enables 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 `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);
+
+/**
+ * Enables or disables the rates payload version feature.
+ * When enabled, the trace exporter checks the payload version in the agent's response.
+ * If the version hasn't changed since the last payload, the exporter will return an empty
+ * response.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_rates_payload_version(struct ddog_TraceExporterConfig *config,
+                                                                                     bool rates_payload_version);
+
+/**
+ * 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);
+
 /**
  * Create a new TraceExporter instance.
  *
@@ -109,12 +171,12 @@ void ddog_trace_exporter_free(struct ddog_TraceExporter *handle);
  *   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.
+ * * `response_out` - Optional handle to store a pointer to 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);
+                                                         struct ddog_TraceExporterResponse **response_out);
 
 #ifdef __cplusplus
 }  // extern "C"

data/vendor/{libdatadog-16.0.1 → libdatadog-19.1.0}/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/include/datadog/library-config.h

@@ -24,16 +24,12 @@ void ddog_library_configurator_with_fleet_path(struct ddog_Configurator *c,
 void ddog_library_configurator_with_process_info(struct ddog_Configurator *c,
                                                  struct ddog_ProcessInfo p);
 
+void ddog_library_configurator_with_detect_process_info(struct ddog_Configurator *c);
+
 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
@@ -54,6 +50,22 @@ struct ddog_CStr ddog_library_config_local_stable_config_path(void);
 
 void ddog_library_config_drop(struct ddog_Vec_LibraryConfig);
 
+/**
+ * Store tracer metadata to a file handle
+ *
+ * # Safety
+ *
+ * Accepts raw C-compatible strings
+ */
+struct ddog_Result_TracerMemfdHandle ddog_store_tracer_metadata(uint8_t schema_version,
+                                                                ddog_CharSlice runtime_id,
+                                                                ddog_CharSlice tracer_language,
+                                                                ddog_CharSlice tracer_version,
+                                                                ddog_CharSlice hostname,
+                                                                ddog_CharSlice service_name,
+                                                                ddog_CharSlice service_env,
+                                                                ddog_CharSlice service_version);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/libdatadog-19.1.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/include/datadog/log.h

@@ -0,0 +1,63 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_LOG_H
+#define DDOG_LOG_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "common.h"
+
+/**
+ * Configures the logger to write to stdout or stderr with the specified configuration.
+ *
+ * # Arguments
+ * * `config` - Configuration for standard stream logging including target
+ *
+ * # Errors
+ * Returns an error if the logger cannot be configured.
+ */
+struct ddog_Error *ddog_logger_configure_std(struct ddog_StdConfig config);
+
+/**
+ * Disables logging by configuring a no-op logger.
+ *
+ * # Errors
+ * Returns an error if the logger cannot be configured.
+ */
+struct ddog_Error *ddog_logger_disable_std(void);
+
+/**
+ * Configures the logger to write to a file with the specified configuration.
+ *
+ * # Arguments
+ * * `config` - Configuration for file logging including path
+ *
+ * # Errors
+ * Returns an error if the logger cannot be configured.
+ */
+struct ddog_Error *ddog_logger_configure_file(struct ddog_FileConfig config);
+
+/**
+ * Disables file logging by configuring a no-op file writer.
+ *
+ * # Errors
+ * Returns an error if the logger cannot be configured.
+ */
+struct ddog_Error *ddog_logger_disable_file(void);
+
+/**
+ * Sets the global log level.
+ *
+ * # Arguments
+ * * `log_level` - The minimum level for events to be logged
+ *
+ * # Errors
+ * Returns an error if the log level cannot be set.
+ */
+struct ddog_Error *ddog_logger_set_log_level(enum ddog_LogEventLevel log_level);
+
+#endif  /* DDOG_LOG_H */