datadog 2.29.0 → 2.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f762ad624ddb0a21d753a524132de0f59e617e63f723fabc6c305949a77554d
-  data.tar.gz: 217159cbaea1102ba47a97deb73927919d8152264701322719aad722391d75aa
+  metadata.gz: f2983471f43d0c9b3473b3c65d0ca656514c6cf8cd7a32e35ec26826193fe533
+  data.tar.gz: 687d088d90ce4ee0ae5af66d9e604135f058bd7609641f4c7963f1ba32a2bb37
 SHA512:
-  metadata.gz: 711466d29940c6b22b5964744e7d1b6dbf5a002ca5992dbc01d61718f16cc66b33dcc7bee2604c4c2ba64a9efb8014114d015d44a109e1b5f55b1375d36c927a
-  data.tar.gz: 1490e2ab41fdf0c7ce673bbb7eaa1ccc28073cd757576a30734ce3674bef89fd58aa2876b2e9d2e26e12119e45b1d90f787e260d86cfc6e1fa5055bf14ba16b0
+  metadata.gz: 96f3744eadab0292666e18beac7deab2a6b7ef61b0da216ab4490e7621b0cec7839d18a519079b5b0563e2a260388b63ef59b5243a65c3d6ba997f3c7981986c
+  data.tar.gz: a82f01f50d499f1a08309f23144e5453cb9cf79bdc5b0c7daa9b3c9c373e3a41983babe3f86dc027f2dd2e9f056bc4b7645a49f799531e40eae9455ab7e00a6d

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [2.30.0] - 2026-03-19
+
+### Added
+
+* Core: Enable `libdatadog`-based features and tests on macOS ([#5351][])
+* Tracing: Add `_dd.p.ksr` propagated tag to transmit Knuth sampling rate for backend resampling ([#5436][])
+* Tracing: Integrations: Add `DD_TRACE_<INTEGRATION>_DISTRIBUTED_TRACING` environment variables to control distributed tracing per integration ([#5396][])
+* Profiling: Add profiler setting `experimental_use_system_dns` to use system DNS resolver (defaults to true) ([#5425][], [#5449][])
+* Profiling: Allow lowering CPU profiling sampling interval with `experimental_cpu_sampling_interval_ms` setting ([#5424][])
+
+### Changed
+
+* Core: Enable process tags by default by setting `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED`, expanding tag collection for Tracing, Database Monitoring, Data Streams Monitoring, Profiling, Runtime Metrics, Process Discovery, Remote Configuration, Telemetry, Dynamic Instrumentation, and CrashTracking ([#5432][])
+* Core: Upgrade `libdatadog` dependency to version 29.0.0 ([#5274][], [#5461][])
+* Core: Remove dependency on `pkg-config` system tool for native extension builds ([#5469][])
+* Profiling: Improve profiling error message when another profiler is present ([#5375][])
+
+### Fixed
+
+* Tracing: Integrations: Fix `endpoint_render.grape` ActiveSupport notification instrumentation for `grape` 3.x ([#5414][])
+* Tracing: Integrations: Fix compatibility with `dalli` version 5.x and later ([#5435][])
+* Dynamic Instrumentation: Fix JSON serialization failures when snapshots contain binary data and invalid UTF-8 strings ([#5434][])
+* Dynamic Instrumentation: Show ERROR probe status when custom serializers produce non-JSON-encodable data instead of silent failures ([#5448][])
+* Data Streams: Fix Data Streams Monitoring to correctly report the configured environment instead of showing `env:none` ([#5427][])
+
 ## [2.29.0] - 2026-02-20
 
 
@@ -3514,7 +3539,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.29.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.30.0...master
+[2.30.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.29.0...v2.30.0
 [2.29.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.28.0...v2.29.0
 [2.28.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.27.0...v2.28.0
 [2.27.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.26.0...v2.27.0
@@ -5194,6 +5220,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5247]: https://github.com/DataDog/dd-trace-rb/issues/5247
 [#5254]: https://github.com/DataDog/dd-trace-rb/issues/5254
 [#5273]: https://github.com/DataDog/dd-trace-rb/issues/5273
+[#5274]: https://github.com/DataDog/dd-trace-rb/issues/5274
 [#5278]: https://github.com/DataDog/dd-trace-rb/issues/5278
 [#5283]: https://github.com/DataDog/dd-trace-rb/issues/5283
 [#5294]: https://github.com/DataDog/dd-trace-rb/issues/5294
@@ -5207,9 +5234,24 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5341]: https://github.com/DataDog/dd-trace-rb/issues/5341
 [#5342]: https://github.com/DataDog/dd-trace-rb/issues/5342
 [#5347]: https://github.com/DataDog/dd-trace-rb/issues/5347
+[#5351]: https://github.com/DataDog/dd-trace-rb/issues/5351
 [#5352]: https://github.com/DataDog/dd-trace-rb/issues/5352
 [#5368]: https://github.com/DataDog/dd-trace-rb/issues/5368
 [#5371]: https://github.com/DataDog/dd-trace-rb/issues/5371
+[#5375]: https://github.com/DataDog/dd-trace-rb/issues/5375
+[#5396]: https://github.com/DataDog/dd-trace-rb/issues/5396
+[#5414]: https://github.com/DataDog/dd-trace-rb/issues/5414
+[#5424]: https://github.com/DataDog/dd-trace-rb/issues/5424
+[#5425]: https://github.com/DataDog/dd-trace-rb/issues/5425
+[#5427]: https://github.com/DataDog/dd-trace-rb/issues/5427
+[#5432]: https://github.com/DataDog/dd-trace-rb/issues/5432
+[#5434]: https://github.com/DataDog/dd-trace-rb/issues/5434
+[#5435]: https://github.com/DataDog/dd-trace-rb/issues/5435
+[#5436]: https://github.com/DataDog/dd-trace-rb/issues/5436
+[#5448]: https://github.com/DataDog/dd-trace-rb/issues/5448
+[#5449]: https://github.com/DataDog/dd-trace-rb/issues/5449
+[#5461]: https://github.com/DataDog/dd-trace-rb/issues/5461
+[#5469]: https://github.com/DataDog/dd-trace-rb/issues/5469
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5364,4 +5406,4 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@y-yagi]: https://github.com/y-yagi
 [@yujideveloper]: https://github.com/yujideveloper
 [@yukimurasawa]: https://github.com/yukimurasawa
-[@zachmccormick]: https://github.com/zachmccormick
+[@zachmccormick]: https://github.com/zachmccormick

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -102,6 +102,7 @@ typedef struct {
   bool gvl_profiling_enabled;
   bool skip_idle_samples_for_testing;
   bool sighandler_sampling_enabled;
+  uint32_t cpu_sampling_interval_ms;
   VALUE self_instance;
   VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
@@ -239,16 +240,16 @@ static VALUE _native_delayed_error(DDTRACE_UNUSED VALUE self, VALUE instance, VA
 static VALUE _native_hold_signals(DDTRACE_UNUSED VALUE self);
 static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self);
 #ifndef NO_GVL_INSTRUMENTATION
-static void on_gvl_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *event_data, DDTRACE_UNUSED void *_unused);
-static void after_gvl_running_from_postponed_job(DDTRACE_UNUSED void *_unused);
+  static void on_gvl_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *event_data, DDTRACE_UNUSED void *_unused);
+  static void after_gvl_running_from_postponed_job(DDTRACE_UNUSED void *_unused);
+  static VALUE rescued_after_gvl_running_from_postponed_job(VALUE self_instance);
+  static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception);
 #endif
-static VALUE rescued_after_gvl_running_from_postponed_job(VALUE self_instance);
 static VALUE _native_gvl_profiling_hook_active(DDTRACE_UNUSED VALUE self, VALUE instance);
 static VALUE handle_sampling_failure_rescued_sample_from_postponed_job(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_thread_context_collector_sample_after_gc(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instance, VALUE exception);
-static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception);
 static inline void during_sample_enter(cpu_and_wall_time_worker_state* state);
 static inline void during_sample_exit(cpu_and_wall_time_worker_state* state);
 static void after_allocation_from_postponed_job(DDTRACE_UNUSED void *_unused);
@@ -383,6 +384,7 @@ static VALUE _native_new(VALUE klass) {
   state->gvl_profiling_enabled = false;
   state->skip_idle_samples_for_testing = false;
   state->sighandler_sampling_enabled = false;
+  state->cpu_sampling_interval_ms = 10;
   state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
@@ -427,6 +429,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE gvl_profiling_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("gvl_profiling_enabled")));
   VALUE skip_idle_samples_for_testing = rb_hash_fetch(options, ID2SYM(rb_intern("skip_idle_samples_for_testing")));
   VALUE sighandler_sampling_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("sighandler_sampling_enabled")));
+  VALUE cpu_sampling_interval_ms = rb_hash_fetch(options, ID2SYM(rb_intern("cpu_sampling_interval_ms")));
 
   ENFORCE_BOOLEAN(gc_profiling_enabled);
   ENFORCE_BOOLEAN(no_signals_workaround_enabled);
@@ -437,6 +440,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ENFORCE_BOOLEAN(gvl_profiling_enabled);
   ENFORCE_BOOLEAN(skip_idle_samples_for_testing)
   ENFORCE_BOOLEAN(sighandler_sampling_enabled)
+  ENFORCE_TYPE(cpu_sampling_interval_ms, T_FIXNUM);
 
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
@@ -449,6 +453,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   state->gvl_profiling_enabled = (gvl_profiling_enabled == Qtrue);
   state->skip_idle_samples_for_testing = (skip_idle_samples_for_testing == Qtrue);
   state->sighandler_sampling_enabled = (sighandler_sampling_enabled == Qtrue);
+  state->cpu_sampling_interval_ms = NUM2INT(cpu_sampling_interval_ms);
 
   double total_overhead_target_percentage = NUM2DBL(dynamic_sampling_rate_overhead_target_percentage);
   if (!state->allocation_profiling_enabled) {
@@ -556,8 +561,9 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   // @ivoanjo: I suspect this will never happen, but the cost of getting it wrong is really high (VM terminates) so this
   // is a just-in-case situation.
   //
-  // Note 2: This can raise exceptions as well, so make sure that all cleanups are done by the time we get here.
-  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal);
+  // Note 2: If exception_state is set, we have a pending exception that we'll re-raise below.
+  // In that case, we don't want replace_sigprof_signal_handler_with_empty_handler to raise another exception.
+  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal, !exception_state);
 
   // Ensure that instance is not garbage collected while the native sampling loop is running; this is probably not needed, but just in case
   RB_GC_GUARD(instance);
@@ -668,7 +674,7 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 static void *run_sampling_trigger_loop(void *state_ptr) {
   cpu_and_wall_time_worker_state *state = (cpu_and_wall_time_worker_state *) state_ptr;
 
-  uint64_t minimum_time_between_signals = MILLIS_AS_NS(10);
+  uint64_t minimum_time_between_signals = MILLIS_AS_NS(state->cpu_sampling_interval_ms);
 
   while (atomic_load(&state->should_run)) {
     state->stats.trigger_sample_attempts++;
@@ -1469,6 +1475,11 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
 
     return state->gvl_profiling_hook != NULL ? Qtrue : Qfalse;
   }
+
+  static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception) {
+    stop(self_instance, exception, "rescued_after_gvl_running_from_postponed_job");
+    return Qnil;
+  }
 #else
   static VALUE _native_gvl_profiling_hook_active(DDTRACE_UNUSED VALUE self, DDTRACE_UNUSED VALUE instance) {
     return Qfalse;
@@ -1495,11 +1506,6 @@ static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instanc
   return Qnil;
 }
 
-static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception) {
-  stop(self_instance, exception, "rescued_after_gvl_running_from_postponed_job");
-  return Qnil;
-}
-
 static VALUE rescued_after_allocation(VALUE self_instance) {
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
@@ -1513,6 +1519,8 @@ static VALUE rescued_after_allocation(VALUE self_instance) {
 // This postponed job callback is used to finalize heap allocation recordings on Ruby 4+.
 // During on_newobj_event, calling rb_obj_id() is unsafe because it mutates the object.
 // So we defer getting the object_id until after the event completes.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function" // This is only used for some Rubies, but we want to build on all to make it easier to dev
 static void after_allocation_from_postponed_job(DDTRACE_UNUSED void *_unused) {
   cpu_and_wall_time_worker_state *state = active_sampler_instance_state;
 
@@ -1535,6 +1543,7 @@ static void after_allocation_from_postponed_job(DDTRACE_UNUSED void *_unused) {
 
   during_sample_exit(state);
 }
+#pragma GCC diagnostic pop
 
 static inline void during_sample_enter(cpu_and_wall_time_worker_state* state) {
   // Tell the compiler it's not allowed to reorder the `during_sample` flag with anything that happens after.

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -290,11 +290,13 @@ static bool handle_gvl_waiting(
   sampling_buffer* sampling_buffer,
   long current_cpu_time_ns
 );
-static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_on_gvl_running(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception);
-static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE delta_ns);
+#ifndef NO_GVL_INSTRUMENTATION
+  static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_on_gvl_running(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception);
+  static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE delta_ns);
+#endif
 static void otel_without_ddtrace_trace_identifiers_for(
   thread_context_collector_state *state,
   VALUE thread,
@@ -1818,7 +1820,7 @@ static void otel_without_ddtrace_trace_identifiers_for(
   VALUE otel_current_span_key = get_otel_current_span_key(state, is_safe_to_allocate_objects);
   if (otel_current_span_key == Qnil) return;
 
-  int active_context_index = RARRAY_LEN(context_storage) - 1;
+  long active_context_index = RARRAY_LEN(context_storage) - 1;
   if (active_context_index < 0) return;
 
   otel_span active_span = otel_span_from(rb_ary_entry(context_storage, active_context_index), otel_current_span_key);
@@ -1827,7 +1829,7 @@ static void otel_without_ddtrace_trace_identifiers_for(
   otel_span local_root_span = active_span;
 
   // Now find the oldest span starting from the active span that still has the same trace id as the active span
-  for (int i = active_context_index - 1; i >= 0; i--) {
+  for (long i = active_context_index - 1; i >= 0; i--) {
     otel_span checking_span = otel_span_from(rb_ary_entry(context_storage, i), otel_current_span_key);
     if (checking_span.span == Qnil) return;
 

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -82,7 +82,8 @@ append_cflags "-Werror" if ENV["DATADOG_GEM_CI"] == "true"
 # * by upstream Ruby -- search for gnu99 in the codebase
 # * by msgpack, another datadog gem dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
-append_cflags "-std=gnu99"
+# @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
+append_cflags RUBY_PLATFORM.include?('darwin') ? '-std=gnu11' : '-std=gnu99'
 
 # Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 append_cflags "-Wno-unused-function"
@@ -210,37 +211,16 @@ $defs << "-DNO_GVL_OWNER" if RUBY_VERSION < "2.6"
 $defs << "-DNO_THREAD_INVOKE_ARG" if RUBY_VERSION < "2.6"
 
 # If we got here, libdatadog is available and loaded
-ENV["PKG_CONFIG_PATH"] = "#{ENV["PKG_CONFIG_PATH"]}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV["PKG_CONFIG_PATH"].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config("datadog_profiling_with_rpath")
-  Logging.message("[datadog] Ruby detected the pkg-config command is #{$PKGCONFIG.inspect}\n")
-
-  skip_building_extension!(
-    if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
-      Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
-    else
-      # Less specific error message
-      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG
-    end
-  )
+unless Datadog::LibdatadogExtconfHelpers.configure_libdatadog(extconf_folder: __dir__)
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG)
 end
 
 unless have_type("atomic_int", ["stdatomic.h"])
   skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
 end
 
-# See comments on the helper methods being used for why we need to additionally set this.
-# The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
-# experimentation. We need to get these special characters across a lot of tools untouched...
-extra_relative_rpaths = [
-  Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_native_lib_folder(current_folder: __dir__),
-  *Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
-]
-extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
-Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
-
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -693,7 +693,7 @@ VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder) {
 
 typedef struct {
   heap_recorder *recorder;
-  VALUE debug_str;
+  VALUE debug_ary;
 } debug_context;
 
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
@@ -701,12 +701,12 @@ VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
     raise_error(rb_eArgError, "heap_recorder is NULL");
   }
 
-  VALUE debug_str = rb_str_new2("");
-  debug_context context = (debug_context) {.recorder = heap_recorder, .debug_str = debug_str};
+  VALUE debug_ary = rb_ary_new();
+  debug_context context = (debug_context) {.recorder = heap_recorder, .debug_ary = debug_ary};
   st_foreach(heap_recorder->object_records, st_object_records_debug, (st_data_t) &context);
 
   return rb_ary_new_from_args(2,
-    rb_ary_new_from_args(2, ID2SYM(rb_intern("records")), debug_str),
+    rb_ary_new_from_args(2, ID2SYM(rb_intern("records")), debug_ary),
     rb_ary_new_from_args(2, ID2SYM(rb_intern("state")), heap_recorder_state_snapshot(heap_recorder))
   );
 }
@@ -828,11 +828,10 @@ static int st_object_records_iterate(DDTRACE_UNUSED st_data_t key, st_data_t val
 
 static int st_object_records_debug(DDTRACE_UNUSED st_data_t key, st_data_t value, st_data_t extra) {
   debug_context *context = (debug_context*) extra;
-  VALUE debug_str = context->debug_str;
 
   object_record *record = (object_record*) value;
 
-  rb_str_catf(debug_str, "%"PRIsVALUE"\n", object_record_inspect(context->recorder, record));
+  rb_ary_push(context->debug_ary, object_record_inspect(context->recorder, record));
 
   return ST_CONTINUE;
 }

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -16,7 +16,11 @@ static VALUE library_version_string = Qnil;
 
 typedef struct {
   ddog_prof_ProfileExporter *exporter;
-  ddog_prof_Request_Result *build_result;
+  ddog_prof_EncodedProfile *profile;
+  ddog_prof_Exporter_Slice_File files_to_compress_and_export;
+  ddog_CharSlice internal_metadata;
+  ddog_CharSlice info;
+  ddog_CharSlice *process_tags;
   ddog_CancellationToken *cancel_token;
   ddog_prof_Result_HttpStatus result;
   bool send_ran;
@@ -29,7 +33,6 @@ static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_r
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
   VALUE flush
 );
 static void *call_exporter_without_gvl(void *call_args);
@@ -39,7 +42,7 @@ void http_transport_init(VALUE profiling_module) {
   VALUE http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
 
   rb_define_singleton_method(http_transport_class, "_native_validate_exporter",  _native_validate_exporter, 1);
-  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 3);
+  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 2);
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
@@ -75,15 +78,31 @@ static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
   ID working_mode = SYM2ID(exporter_working_mode);
 
-  if (working_mode == rb_intern("agentless")) {
-    VALUE site = rb_ary_entry(exporter_configuration, 1);
-    VALUE api_key = rb_ary_entry(exporter_configuration, 2);
+  VALUE timeout_milliseconds_value = rb_ary_entry(exporter_configuration, 1);
+  ENFORCE_TYPE(timeout_milliseconds_value, T_FIXNUM);
+  uint64_t timeout_milliseconds = NUM2ULONG(timeout_milliseconds_value);
+
+  VALUE use_system_dns = rb_ary_entry(exporter_configuration, 2);
+  ENFORCE_BOOLEAN(use_system_dns);
 
-    return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+  if (working_mode == rb_intern("agentless")) {
+    VALUE site = rb_ary_entry(exporter_configuration, 3);
+    VALUE api_key = rb_ary_entry(exporter_configuration, 4);
+
+    return ddog_prof_Endpoint_agentless(
+      char_slice_from_ruby_string(site),
+      char_slice_from_ruby_string(api_key),
+      timeout_milliseconds,
+      use_system_dns == Qtrue
+    );
   } else if (working_mode == rb_intern("agent")) {
-    VALUE base_url = rb_ary_entry(exporter_configuration, 1);
+    VALUE base_url = rb_ary_entry(exporter_configuration, 3);
 
-    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+    return ddog_prof_Endpoint_agent(
+      char_slice_from_ruby_string(base_url),
+      timeout_milliseconds,
+      use_system_dns == Qtrue
+    );
   } else {
     raise_error(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
   }
@@ -123,41 +142,18 @@ static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_r
 
 // Note: This function handles a bunch of libdatadog dynamically-allocated objects, so it MUST not use any Ruby APIs
 // which can raise exceptions, otherwise the objects will be leaked.
-static VALUE perform_export(
-  ddog_prof_ProfileExporter *exporter,
-  ddog_prof_EncodedProfile *profile,
-  ddog_prof_Exporter_Slice_File files_to_compress_and_export,
-  ddog_CharSlice internal_metadata,
-  ddog_CharSlice info,
-  ddog_CharSlice *process_tags
-) {
-  ddog_prof_Request_Result build_result = ddog_prof_Exporter_Request_build(
-    exporter,
-    profile,
-    files_to_compress_and_export,
-    /* files_to_export_unmodified: */ ddog_prof_Exporter_Slice_File_empty(),
-    /* optional_additional_tags: */ NULL,
-    /* optional_process_tags: */ process_tags,
-    &internal_metadata,
-    &info
-  );
-
-  if (build_result.tag == DDOG_PROF_REQUEST_RESULT_ERR_HANDLE_REQUEST) {
-    ddog_prof_Exporter_drop(exporter);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
-  }
-
+static VALUE perform_export(call_exporter_without_gvl_arguments args) {
   ddog_CancellationToken cancel_token_request = ddog_CancellationToken_new();
   ddog_CancellationToken cancel_token_interrupt = ddog_CancellationToken_clone(&cancel_token_request);
 
   validate_token(cancel_token_request, __FILE__, __LINE__);
   validate_token(cancel_token_interrupt, __FILE__, __LINE__);
 
+  args.cancel_token = &cancel_token_request;
+  args.send_ran = false;
+
   // We'll release the Global VM Lock while we're calling send, so that the Ruby VM can continue to work while this
   // is pending
-  call_exporter_without_gvl_arguments args =
-    {.exporter = exporter, .build_result = &build_result, .cancel_token = &cancel_token_request, .send_ran = false};
-
   // We use rb_thread_call_without_gvl2 instead of rb_thread_call_without_gvl as the gvl2 variant never raises any
   // exceptions.
   //
@@ -182,18 +178,13 @@ static VALUE perform_export(
   // Cleanup exporter and token, no longer needed
   ddog_CancellationToken_drop(&cancel_token_request);
   ddog_CancellationToken_drop(&cancel_token_interrupt);
-  ddog_prof_Exporter_drop(exporter);
+  ddog_prof_Exporter_drop(args.exporter);
 
   if (pending_exception) {
-    // If we got here send did not run, so we need to explicitly dispose of the request
-    ddog_prof_Exporter_Request_drop(&build_result.ok);
-
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  // The request itself does not need to be freed as libdatadog takes ownership of it as part of sending.
-
   ddog_prof_Result_HttpStatus result = args.result;
 
   return result.tag == DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS ?
@@ -204,7 +195,6 @@ static VALUE perform_export(
 static VALUE _native_do_export(
   DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
   VALUE flush
 ) {
   VALUE encoded_profile = rb_funcall(flush, rb_intern("encoded_profile"), 0);
@@ -215,7 +205,6 @@ static VALUE _native_do_export(
   VALUE info_json = rb_funcall(flush, rb_intern("info_json"), 0);
   VALUE process_tags = rb_funcall(flush, rb_intern("process_tags"), 0);
 
-  ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
   enforce_encoded_profile_instance(encoded_profile);
   ENFORCE_TYPE(code_provenance_file_name, T_STRING);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
@@ -227,8 +216,6 @@ static VALUE _native_do_export(
   bool have_code_provenance = !NIL_P(code_provenance_data);
   if (have_code_provenance) ENFORCE_TYPE(code_provenance_data, T_STRING);
 
-  uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
-
   int to_compress_length = have_code_provenance ? 1 : 0;
   ddog_prof_Exporter_File to_compress[to_compress_length];
   ddog_prof_Exporter_Slice_File files_to_compress_and_export = {.ptr = to_compress, .len = to_compress_length};
@@ -250,29 +237,29 @@ static VALUE _native_do_export(
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
-  ddog_VoidResult timeout_result = ddog_prof_Exporter_set_timeout(&exporter_result.ok, timeout_milliseconds);
-  if (timeout_result.tag == DDOG_VOID_RESULT_ERR) {
-    // NOTE: Seems a bit harsh to fail the upload if we can't set a timeout. OTOH, this is only expected to fail
-    // if the exporter is not well built. Because such a situation should already be caught above I think it's
-    // preferable to leave this here as a virtually unreachable exception rather than ignoring it.
-    ddog_prof_Exporter_drop(&exporter_result.ok);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&timeout_result.err));
-  }
-
-  return perform_export(
-    &exporter_result.ok,
-    to_ddog_prof_EncodedProfile(encoded_profile),
-    files_to_compress_and_export,
-    internal_metadata,
-    info,
-    &process_tags_slice
-  );
+  return perform_export((call_exporter_without_gvl_arguments) {
+    .exporter = &exporter_result.ok,
+    .profile = to_ddog_prof_EncodedProfile(encoded_profile),
+    .files_to_compress_and_export = files_to_compress_and_export,
+    .internal_metadata = internal_metadata,
+    .info = info,
+    .process_tags = &process_tags_slice
+  });
 }
 
 static void *call_exporter_without_gvl(void *call_args) {
   call_exporter_without_gvl_arguments *args = (call_exporter_without_gvl_arguments*) call_args;
 
-  args->result = ddog_prof_Exporter_send(args->exporter, &args->build_result->ok, args->cancel_token);
+  args->result = ddog_prof_Exporter_send_blocking(
+    args->exporter,
+    args->profile,
+    args->files_to_compress_and_export,
+    /* optional_additional_tags: */ NULL,
+    /* optional_process_tags: */ args->process_tags,
+    &args->internal_metadata,
+    &args->info,
+    args->cancel_token
+  );
   args->send_ran = true;
 
   return NULL; // Unused

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -104,19 +104,6 @@ module Datadog
           suggested: CONTACT_SUPPORT,
         )
 
-        # Validation for this check is done in extconf.rb because it relies on mkmf
-        PKG_CONFIG_IS_MISSING = explain_issue(
-          # ----------------------------------------------------------------------------+
-          "the `pkg-config` system tool is missing.",
-          "This issue can usually be fixed by installing one of the following:",
-          "the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;",
-          "the `pkgconf` package on Arch and Alpine-based Linux;",
-          "the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.",
-          "(Tip: When fixing this, ensure `pkg-config` is installed **before**",
-          "running `bundle install`, and remember to clear any installed gems cache).",
-          suggested: CONTACT_SUPPORT,
-        )
-
         # Validation for this check is done in extconf.rb because it relies on mkmf
         COMPILER_ATOMIC_MISSING = explain_issue(
           "your C compiler is missing support for the <stdatomic.h> header.",

data/ext/datadog_profiling_native_extension/profiling.c

@@ -25,6 +25,7 @@ void encoded_profile_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 void crashtracking_runtime_stacks_init(void);
+void setup_signal_handler_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
 static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
@@ -62,6 +63,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_funcall(native_extension_module, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("native_working?")));
 
   ruby_helpers_init();
+  setup_signal_handler_init(profiling_module);
   collectors_cpu_and_wall_time_worker_init(profiling_module);
   collectors_discrete_dynamic_sampler_init(profiling_module);
   collectors_dynamic_sampling_rate_init(profiling_module);
@@ -251,7 +253,7 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 
   ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex));
 
-  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
+  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler, true);
 
   if (holding_the_gvl_signal_handler_result[0] == Qfalse) raise_error(rb_eRuntimeError, "Could not signal background_thread");