refactor(libdd-crashtracker)!: avoid leaking Endpoint through the public API

bin_tests/src/bin/crashing_test_app.rs

@@ -18,7 +18,7 @@ mod unix {
     use std::sync::Arc;
     use std::time::Duration;
 
-    use libdd_common::{tag, Endpoint};
+    use libdd_common::tag;
     use libdd_crashtracker::{
         self as crashtracker, CrashtrackerConfiguration, CrashtrackerReceiverConfig, Metadata,
     };
@@ -91,19 +91,17 @@ mod unix {
         let stdout_filename = format!("{output_dir}/out.stdout");
 
         ensure!(!output_url.is_empty(), "output_url must not be empty");
-        let endpoint = Some(Endpoint::from_slice(&output_url));
-
-        let config = CrashtrackerConfiguration::new(
-            vec![], // additional_files
-            true,   // create_alt_stack
-            true,   // use_alt_stack
-            endpoint,
-            crashtracker::StacktraceCollection::EnabledWithSymbolsInReceiver,
-            crashtracker::default_signals(),
-            Some(TEST_COLLECTOR_TIMEOUT),
-            Some("".to_string()), // unix_socket_path
-            true,                 // demangle_names
-        )?;
+
+        let config = CrashtrackerConfiguration::builder()
+            .create_alt_stack(true)
+            .use_alt_stack(true)
+            .endpoint_url(&output_url)
+            .resolve_frames(crashtracker::StacktraceCollection::EnabledWithSymbolsInReceiver)
+            .signals(crashtracker::default_signals())
+            .timeout(TEST_COLLECTOR_TIMEOUT)
+            .unix_socket_path("".to_string())
+            .demangle_names(true)
+            .build()?;
 
         let metadata = Metadata {
             library_name: "libdatadog".to_owned(),

bin_tests/src/bin/crashtracker_bin_test.rs

@@ -22,7 +22,7 @@ mod unix {
     use std::process;
     use std::time::Duration;
 
-    use libdd_common::{tag, Endpoint};
+    use libdd_common::tag;
     use libdd_crashtracker::{
         self as crashtracker, CrashtrackerConfiguration, CrashtrackerReceiverConfig, Metadata,
         StackFrame, StackTrace,
@@ -73,12 +73,6 @@ mod unix {
         let stdout_filename = format!("{output_dir}/out.stdout");
         let output_dir: &Path = output_dir.as_ref();
 
-        let endpoint = if output_url.is_empty() {
-            None
-        } else {
-            Some(Endpoint::from_slice(output_url))
-        };
-
         // The configuration can be modified by a Behavior (testing plan), so it is mut here.
         // Unlike a normal harness, in this harness tests are run in individual processes, so race
         // issues are avoided.
@@ -97,17 +91,16 @@ mod unix {
             Err(_) => crashtracker::StacktraceCollection::WithoutSymbols,
         };
 
-        let mut config = CrashtrackerConfiguration::new(
-            vec![],
-            true,
-            true,
-            endpoint,
-            stacktrace_collection,
-            crashtracker::default_signals(),
-            Some(TEST_COLLECTOR_TIMEOUT),
-            Some("".to_string()),
-            true,
-        )?;
+        let mut config = CrashtrackerConfiguration::builder()
+            .create_alt_stack(true)
+            .demangle_names(true)
+            .endpoint_url(output_url)
+            .resolve_frames(stacktrace_collection)
+            .signals(crashtracker::default_signals())
+            .timeout(TEST_COLLECTOR_TIMEOUT)
+            .unix_socket_path("".to_string())
+            .use_alt_stack(true)
+            .build()?;
 
         let metadata = Metadata {
             library_name: "libdatadog".to_owned(),

bin_tests/tests/crashtracker_bin_test.rs

@@ -1331,23 +1331,23 @@ fn crash_tracking_empty_endpoint() {
 #[cfg_attr(miri, ignore)]
 #[cfg(unix)]
 fn test_receiver_emits_debug_logs_on_receiver_issue() -> anyhow::Result<()> {
+    use std::time::Duration;
+
     let receiver = artifacts::crashtracker_receiver(BuildProfile::Debug);
     let artifacts = build_artifacts(&[&receiver])?;
     let fixtures = bin_tests::test_runner::TestFixtures::new()?;
 
     let missing_file = fixtures.output_dir.join("missing_additional_file.txt");
 
-    let config = CrashtrackerConfiguration::new(
-        vec![missing_file.display().to_string()],
-        true,
-        true,
-        None,
-        StacktraceCollection::WithoutSymbols,
-        libdd_crashtracker::default_signals(),
-        Some(std::time::Duration::from_millis(500)),
-        None,
-        true,
-    )?;
+    let config = CrashtrackerConfiguration::builder()
+        .additional_files(vec![missing_file.display().to_string()])
+        .create_alt_stack(true)
+        .demangle_names(true)
+        .resolve_frames(StacktraceCollection::WithoutSymbols)
+        .signals(libdd_crashtracker::default_signals())
+        .timeout(Duration::from_millis(500))
+        .use_alt_stack(true)
+        .build()?;
 
     let metadata = Metadata {
         library_name: "libdatadog".to_owned(),

datadog-sidecar/src/unix.rs

@@ -220,18 +220,25 @@ fn init_crashtracker(dependency_paths: *const *const libc::c_char) -> anyhow::Re
         LogMethod::Disabled => None,
     };
 
+    let mut config_builder = CrashtrackerConfiguration::builder()
+        .create_alt_stack(true)
+        .use_alt_stack(true)
+        .resolve_frames(StacktraceCollection::EnabledWithSymbolsInReceiver)
+        .demangle_names(true);
+    if let Some(ep) = Config::get().crashtracker_endpoint.as_ref() {
+        config_builder = config_builder.endpoint_url(&ep.url.to_string());
+        if let Some(api_key) = ep.api_key.as_deref() {
+            config_builder = config_builder.endpoint_api_key(api_key);
+        }
+        config_builder = config_builder
+            .endpoint_timeout_ms(ep.timeout_ms)
+            .endpoint_use_system_resolver(ep.use_system_resolver);
+        if let Some(test_token) = ep.test_token.as_deref() {
+            config_builder = config_builder.endpoint_test_token(test_token);
+        }
+    }
     libdd_crashtracker::init(
-        CrashtrackerConfiguration::new(
-            vec![],
-            true,
-            true,
-            Config::get().crashtracker_endpoint.clone(),
-            StacktraceCollection::EnabledWithSymbolsInReceiver,
-            vec![],
-            None,
-            None,
-            true,
-        )?,
+        config_builder.build()?,
         CrashtrackerReceiverConfig::new(
             receiver_args,
             vec![],

examples/ffi/crashtracking.c

@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define MAX_FILE_PATH   512
 #define INIT_FROM_SLICE(s)                                                                         \
   { .ptr = s.ptr, .len = s.len }
 
@@ -51,10 +52,10 @@ int main(int argc, char **argv) {
   }
 
   // Build output file paths
-  char report_path[512];
-  char stderr_path[512];
-  char stdout_path[512];
-  snprintf(report_path, sizeof(report_path), "%s/crashreport.json", output_dir);
+  char report_path[MAX_FILE_PATH];
+  char stderr_path[MAX_FILE_PATH];
+  char stdout_path[MAX_FILE_PATH];
+  snprintf(report_path, sizeof(report_path), "file://%s/crashreport.json", output_dir);
   snprintf(stderr_path, sizeof(stderr_path), "%s/stderr.txt", output_dir);
   snprintf(stdout_path, sizeof(stdout_path), "%s/stdout.txt", output_dir);
 
@@ -82,13 +83,11 @@ int main(int argc, char **argv) {
       .optional_stdout_filename = slice(stdout_path),
   };
 
-  struct ddog_Endpoint *endpoint = ddog_endpoint_from_filename(slice(report_path));
-
   // Get the default signals and explicitly use them.
   struct ddog_crasht_Slice_CInt signals = ddog_crasht_default_signals();
   ddog_crasht_Config config = {
       .create_alt_stack = false,
-      .endpoint = endpoint,
+      .endpoint = slice(report_path),
       .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_INPROCESS_SYMBOLS,
       .signals = INIT_FROM_SLICE(signals),
   };
@@ -101,7 +100,6 @@ int main(int argc, char **argv) {
   };
 
   handle_result(ddog_crasht_init(config, receiver_config, metadata));
-  ddog_endpoint_drop(endpoint);
 
   handle_result(ddog_crasht_begin_op(DDOG_CRASHT_OP_TYPES_PROFILER_COLLECTING_SAMPLE));
   handle_uintptr_t_result(ddog_crasht_insert_span_id(0, 42));

examples/ffi/crashtracking_unhandled_exception.c

@@ -20,6 +20,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define MAX_FILE_PATH   512
+
 static ddog_CharSlice slice(const char *s) {
   return (ddog_CharSlice){.ptr = s, .len = strlen(s)};
 }
@@ -110,13 +112,13 @@ int main(int argc, char **argv) {
       .env = env_slice,
   };
 
-  struct ddog_Endpoint *endpoint =
-      ddog_endpoint_from_filename(slice(output_file));
+  char endpoint[MAX_FILE_PATH]; 
+  snprintf(endpoint, sizeof(endpoint), "file://%s", output_file);
 
   struct ddog_crasht_Slice_CInt signals = ddog_crasht_default_signals();
   ddog_crasht_Config config = {
       .create_alt_stack = false,
-      .endpoint = endpoint,
+      .endpoint = slice(endpoint),
       .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_DISABLED,
       .signals = {.ptr = signals.ptr, .len = signals.len},
   };
@@ -130,7 +132,6 @@ int main(int argc, char **argv) {
 
   handle_void(ddog_crasht_init(config, receiver_config, metadata),
                "ddog_crasht_init");
-  ddog_endpoint_drop(endpoint);
 
   // Build a runtime StackTrace with two synthetic frames.
   ddog_crasht_StackTrace_NewResult tr = ddog_crasht_StackTrace_new();

libdd-crashtracker-ffi/src/collector/datatypes.rs

@@ -1,7 +1,6 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-use libdd_common::Endpoint;
 use libdd_common_ffi::slice::{AsBytes, CharSlice};
 use libdd_common_ffi::{Error, Slice};
 pub use libdd_crashtracker::{OpTypes, StacktraceCollection};
@@ -61,7 +60,7 @@ pub struct Config<'a> {
     pub demangle_names: bool,
     /// The endpoint to send the crash report to (can be a file://).
     /// If None, the crashtracker will infer the agent host from env variables.
-    pub endpoint: Option<&'a Endpoint>,
+    pub endpoint: CharSlice<'a>,
     /// Optional filename for a unix domain socket if the receiver is used asynchonously
     pub optional_unix_socket_filename: CharSlice<'a>,
     pub resolve_frames: StacktraceCollection,
@@ -88,29 +87,23 @@ impl<'a> TryFrom<Config<'a>> for libdd_crashtracker::CrashtrackerConfiguration {
             }
             vec
         };
-        let create_alt_stack = value.create_alt_stack;
-        let use_alt_stack = value.use_alt_stack;
-        let endpoint = value.endpoint.cloned();
-        let resolve_frames = value.resolve_frames;
-        let signals = value.signals.iter().copied().collect();
-        let timeout = if value.timeout_ms == 0 {
-            None
-        } else {
-            Some(Duration::from_millis(value.timeout_ms as u64))
-        };
-        let unix_socket_path = value.optional_unix_socket_filename.try_to_string_option()?;
-        let demangle_names = value.demangle_names;
-        Self::new(
-            additional_files,
-            create_alt_stack,
-            use_alt_stack,
-            endpoint,
-            resolve_frames,
-            signals,
-            timeout,
-            unix_socket_path,
-            demangle_names,
-        )
+        let mut builder = Self::builder()
+            .additional_files(additional_files)
+            .create_alt_stack(value.create_alt_stack)
+            .demangle_names(value.demangle_names)
+            .resolve_frames(value.resolve_frames)
+            .signals(value.signals.iter().copied().collect())
+            .use_alt_stack(value.use_alt_stack);
+        if let Some(url) = value.endpoint.try_to_string_option()? {
+            builder = builder.endpoint_url(&url);
+        }
+        if value.timeout_ms != 0 {
+            builder = builder.timeout(Duration::from_millis(value.timeout_ms as u64));
+        }
+        if let Some(path) = value.optional_unix_socket_filename.try_to_string_option()? {
+            builder = builder.unix_socket_path(path);
+        }
+        builder.build()
     }
 }
 

libdd-crashtracker/benches/receiver_bench.rs

@@ -37,18 +37,18 @@ fn add_proc_info(report: &mut String) {
 fn add_config(report: &mut String) {
     writeln!(report, "{DD_CRASHTRACK_BEGIN_CONFIG}")
         .expect("Failed to write DD_CRASHTRACK_BEGIN_CONFIG");
-    let config = CrashtrackerConfiguration::new(
-        vec![], // additional_files
-        true,   // create_alt_stack
-        true,   // use_alt_stack
-        None,
-        StacktraceCollection::EnabledWithSymbolsInReceiver,
-        default_signals(),
-        Some(Duration::from_secs(10)),
-        Some("".to_string()), // unix_socket_path
-        true,                 // demangle_names
-    )
-    .expect("Failed to create crashtracker configuration");
+
+    let config = CrashtrackerConfiguration::builder()
+        .create_alt_stack(true)
+        .use_alt_stack(true)
+        .resolve_frames(StacktraceCollection::EnabledWithSymbolsInReceiver)
+        .signals(default_signals())
+        .timeout(Duration::from_secs(10))
+        .unix_socket_path("".to_string())
+        .demangle_names(true)
+        .build()
+        .expect("Failed to create crashtracker configuration");
+
     let config_str =
         serde_json::to_string(&config).expect("Failed to serialize crashtracker configuration");
     writeln!(report, "{config_str}").expect("Failed to write crashtracker configuration");