datadog 2.45.0 → 2.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ec6218e3a5ff1d1a8e18c9c12e665dd21d88d0e281eb1ff7690958433b7734a
-  data.tar.gz: 6bc2e56d66439425d29b7a9f7c843da914d6d7e4fb7509b0d52cd52b5c3e7dba
+  metadata.gz: f4a11a75d5b532014ee82ed0628621a2586ca9b05ab6b00c7136357b7b0a5445
+  data.tar.gz: d51c04201a7f931546374be3adc2c6445e523e98713b60c3e7167398da2dede2
 SHA512:
-  metadata.gz: 323a79d901180e0174cc4052a39cfd52637e7cb496ae8aef6813dfcbca21e943757516a7663acab009e286f74ab8d0306a7fe833d562814f1a78cb47f6f4af6f
-  data.tar.gz: fc1a980e41d7f6872acdd1addf5bbcaa91e2609fa69283ca1fd3bdc9cd91e6593c225946bc6e3007fd0069fe5c8e32a6b42311ba69912742f96f504b4b42c0b1
+  metadata.gz: 344ce6f6622f0c6879f598917bab789aef9345a0498d3164b7481df27fdd916b8a4b65b69893fda1527db16ad01da921340441e35a880df4207ae6806966c31a
+  data.tar.gz: 2a77c07e5af10203211755104d3b4e117a70ef64d673d04330769b01a350d2bc8de024b5f7fad2954d95c50a99fa3526c1a473f169653437ad73cb51cea7e542

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [2.47.0] - 2026-10-26
+
+### Added
+
+* Tracing: Add quantized request paths to outbound HTTP client resource names, such as `GET /users/*`; enable with `DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE=true`. ([#6298][])
+* Open Feature: Let evaluations opt out of flag evaluation events, metrics, and span tags with `dd_evaluation_telemetry_opt_out: true` in the evaluation context; enable it with `DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED=true`. ([#6486][])
+
+### Changed
+
+* AppSec: Update `libddwaf` to 1.30.0.1.0. ([#6548][])
+
+### Fixed
+
+* Core: Fix forked processes, such as Puma and Unicorn workers, reporting no runtime metrics when the parent process traced before forking. ([#6500][]) ([@dduugg][])
+* Profiling: Fix the "no signals" workaround being enabled when `mysql2` uses MariaDB Connector/C 3.x. ([#6543][])
+* AppSec: Fix ruleset updates with Remote Configuration. ([#6547][])
+* AppSec: Fix duplicate JSON serialization of Rails and Sinatra response objects when application security is enabled. ([#6548][])
+
+## [2.46.0] - 2026-10-19
+
+### Added
+
+* Tracing: Add OpenTelemetry Thread Context support on Linux so that compatible agents can correlate Workload Protection events with application traces. ([#6454][])
+* Open Feature: Start Feature Flags delivery during provider initialization, including for applications that never receive traced requests. ([#6418][])
+
+### Changed
+
+* SSI: Reduce the single-step injection init image by about 35 MB, lowering download size and disk use when installing the library. ([#6469][], [#6474][], [#6481][], [#6485][], [#6488][])
+* Profiling: Upgrade `datadog-ruby_core_source` to support Ruby 4.1.0-preview1. ([#6470][])
+* Dynamic Instrumentation: Bound snapshot captures by the `DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS` budget (default `150`). `DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE` is deprecated. ([#6205][])
+
 ## [2.45.0] - 2026-10-13
 
 ### Changed
@@ -3838,7 +3869,9 @@ 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.45.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.47.0...master
+[2.47.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.46.0...v2.47.0
+[2.46.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.45.0...v2.46.0
 [2.45.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.44.0...v2.45.0
 [2.44.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...v2.44.0
 [2.43.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.42.0...v2.43.0
@@ -5669,6 +5702,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6142]: https://github.com/DataDog/dd-trace-rb/issues/6142
 [#6173]: https://github.com/DataDog/dd-trace-rb/issues/6173
 [#6176]: https://github.com/DataDog/dd-trace-rb/issues/6176
+[#6205]: https://github.com/DataDog/dd-trace-rb/issues/6205
 [#6213]: https://github.com/DataDog/dd-trace-rb/issues/6213
 [#6219]: https://github.com/DataDog/dd-trace-rb/issues/6219
 [#6220]: https://github.com/DataDog/dd-trace-rb/issues/6220
@@ -5679,6 +5713,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6261]: https://github.com/DataDog/dd-trace-rb/issues/6261
 [#6286]: https://github.com/DataDog/dd-trace-rb/issues/6286
 [#6291]: https://github.com/DataDog/dd-trace-rb/issues/6291
+[#6298]: https://github.com/DataDog/dd-trace-rb/issues/6298
 [#6316]: https://github.com/DataDog/dd-trace-rb/issues/6316
 [#6320]: https://github.com/DataDog/dd-trace-rb/issues/6320
 [#6339]: https://github.com/DataDog/dd-trace-rb/issues/6339
@@ -5695,10 +5730,23 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6401]: https://github.com/DataDog/dd-trace-rb/issues/6401
 [#6407]: https://github.com/DataDog/dd-trace-rb/issues/6407
 [#6412]: https://github.com/DataDog/dd-trace-rb/issues/6412
+[#6418]: https://github.com/DataDog/dd-trace-rb/issues/6418
 [#6419]: https://github.com/DataDog/dd-trace-rb/issues/6419
 [#6427]: https://github.com/DataDog/dd-trace-rb/issues/6427
 [#6433]: https://github.com/DataDog/dd-trace-rb/issues/6433
 [#6441]: https://github.com/DataDog/dd-trace-rb/issues/6441
+[#6454]: https://github.com/DataDog/dd-trace-rb/issues/6454
+[#6469]: https://github.com/DataDog/dd-trace-rb/issues/6469
+[#6470]: https://github.com/DataDog/dd-trace-rb/issues/6470
+[#6474]: https://github.com/DataDog/dd-trace-rb/issues/6474
+[#6481]: https://github.com/DataDog/dd-trace-rb/issues/6481
+[#6485]: https://github.com/DataDog/dd-trace-rb/issues/6485
+[#6486]: https://github.com/DataDog/dd-trace-rb/issues/6486
+[#6488]: https://github.com/DataDog/dd-trace-rb/issues/6488
+[#6500]: https://github.com/DataDog/dd-trace-rb/issues/6500
+[#6543]: https://github.com/DataDog/dd-trace-rb/issues/6543
+[#6547]: https://github.com/DataDog/dd-trace-rb/issues/6547
+[#6548]: https://github.com/DataDog/dd-trace-rb/issues/6548
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -41,7 +41,7 @@ static const char *get_or_compute_native_filename(void *function, st_table *nati
 static void initialize_static_ruby_actual_filename(VALUE profiling_module);
 static void add_truncated_frames_placeholder(ddog_prof_Location *locations);
 static void record_placeholder_stack_in_native_code(VALUE recorder_instance, sample_values values, sample_labels labels);
-static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_CharSlice *filename_slice);
+static void maybe_trim_template_random_ids(ddog_CharSlice *frame_name, ddog_CharSlice method_name, ddog_CharSlice filename);
 
 // NULL if we weren't able to get the native filename for the Ruby VM.
 // On a static Ruby without libruby.so, `get_or_compute_native_filename` returns `ruby_native_filename` but
@@ -438,7 +438,7 @@ void sample_thread(
       frame_name = name_slice;
     }
 
-    maybe_trim_template_random_ids(&frame_name, &filename_slice);
+    maybe_trim_template_random_ids(&frame_name, name_slice, filename_slice);
 
     int libdatadog_stores_stacks_flipped_from_rb_profile_frames_index = top_of_stack_position - i;
 
@@ -548,33 +548,50 @@ static const char *get_or_compute_native_filename(void *function, st_table *nati
 //  the extra "_".)
 //
 // This method trims these suffixes, so that we keep less data + the names correctly aggregate together.
-static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_CharSlice *filename_slice) {
+//
+// We match on `method_name` because it always ends with the ids, while `frame_name` can have DDTRACE_BLOCK_SUFFIX
+// after them ("Foo#_app_views_articles_index_html_erb__123_456 (block)"); in that case we move the suffix left over
+// the ids. A `frame_name` that is a Ruby String ends with the ids we just matched, so that write only ever lands on
+// a name we composed in the sample's own buffer.
+static void maybe_trim_template_random_ids(ddog_CharSlice *frame_name, ddog_CharSlice method_name, ddog_CharSlice filename) {
   // Check filename doesn't end with ".rb"; templates are usually along the lines of .html.erb/.html.haml/...
-  if (filename_slice->len < 3 || memcmp(filename_slice->ptr + filename_slice->len - 3, ".rb", 3) == 0) return;
+  if (filename.len < 3 || memcmp(filename.ptr + filename.len - 3, ".rb", 3) == 0) return;
 
-  if (name_slice->len > 1024) return;
-  if (name_slice->len == 0) return;
+  if (method_name.len > 1024) return;
+  if (method_name.len == 0) return;
 
-  int pos = ((int) name_slice->len) - 1;
+  int pos = ((int) method_name.len) - 1;
 
   // Let's match on something__number_number:
   // Find start of id suffix from the end...
-  if (name_slice->ptr[pos] < '0' || name_slice->ptr[pos] > '9') return;
+  if (method_name.ptr[pos] < '0' || method_name.ptr[pos] > '9') return;
 
   // ...now match a bunch of numbers and interspersed underscores
   for (int underscores = 0; pos >= 0 && underscores < 2; pos--) {
-    if (name_slice->ptr[pos] == '_') underscores++;
-    else if (name_slice->ptr[pos] < '0' || name_slice->ptr[pos] > '9') return;
+    if (method_name.ptr[pos] == '_') underscores++;
+    else if (method_name.ptr[pos] < '0' || method_name.ptr[pos] > '9') return;
   }
 
   // Make sure there's something left before the underscores (hence the <= instead of <) + match the last underscore
-  if (pos <= 0 || name_slice->ptr[pos] != '_') return;
+  if (pos <= 0 || method_name.ptr[pos] != '_') return;
 
   // Does it have the optional third underscore? If so, remove it as well
-  if (pos > 1 && name_slice->ptr[pos-1] == '_') pos--;
+  if (pos > 1 && method_name.ptr[pos-1] == '_') pos--;
+
+  // If we got here, we matched on our pattern. Let's remove the ids from the end of the frame name.
+  size_t random_ids_len = method_name.len - pos;
+
+  static const char block_suffix[] = DDTRACE_BLOCK_SUFFIX;
+  size_t block_suffix_len = sizeof(block_suffix) - 1;
+
+  if (
+    frame_name->len >= random_ids_len + block_suffix_len &&
+    memcmp(frame_name->ptr + frame_name->len - block_suffix_len, block_suffix, block_suffix_len) == 0
+  ) {
+    memcpy((char *) frame_name->ptr + frame_name->len - block_suffix_len - random_ids_len, block_suffix, block_suffix_len);
+  }
 
-  // If we got here, we matched on our pattern. Let's slice the length of the string to exclude it.
-  name_slice->len = pos;
+  frame_name->len -= random_ids_len;
 }
 
 static void add_truncated_frames_placeholder(ddog_prof_Location *locations) {

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -893,6 +893,10 @@ const char *imemo_kind(__attribute__((unused)) VALUE imemo) {
 }
 #endif
 
+int imemo_mask(void) {
+  return IMEMO_MASK;
+}
+
 // This is used to workaround a VM bug. See "handle_sampling_signal" in "collectors_cpu_and_wall_time_worker" for details.
 #ifdef NO_POSTPONED_TRIGGER
 void *objspace_ptr_for_gc_finalize_deferred_workaround(void) {
@@ -1132,7 +1136,7 @@ static ssize_t calculate_iseq_label(VALUE owner, const rb_iseq_t *iseq, char *bu
       // We use "Foo#bar (block)" because it's much faster and looks better in the UI.
       const rb_iseq_t* method_iseq = ISEQ_BODY(iseq)->local_iseq;
 
-      static const char suffix[] = " (block)";
+      static const char suffix[] = DDTRACE_BLOCK_SUFFIX;
       size_t suffix_len = sizeof(suffix) - 1;
 
       // Only use the result if there is enough space for both parts

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -75,6 +75,8 @@ void self_test_mn_enabled(void);
 // Provides more specific information on what kind an imemo is
 const char *imemo_kind(VALUE imemo);
 
+int imemo_mask(void);
+
 #ifdef NO_POSTPONED_TRIGGER
   void *objspace_ptr_for_gc_finalize_deferred_workaround(void);
 #endif
@@ -100,6 +102,9 @@ VALUE ddtrace_alloc_free_rb_mod_name(VALUE mod);
 // if the module does not have a permanent name (e.g. `#<Module:0x0123>::Foo`).
 VALUE ddtrace_permanent_mod_name(VALUE mod);
 
+// Suffix ddtrace_location_label() adds to blocks, e.g. "Foo#bar (block)"
+#define DDTRACE_BLOCK_SUFFIX " (block)"
+
 ssize_t ddtrace_location_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq, char *buf, size_t buf_size);
 VALUE ddtrace_location_base_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq);
 void* ddtrace_cme_cfunc_func(const rb_callable_method_entry_t *cme);

data/ext/datadog_profiling_native_extension/profiling.c

@@ -47,6 +47,7 @@ static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_er
 static void *trigger_enforce_success(void *trigger_args);
 static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self);
 static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj);
+static VALUE _native_imemo_mask(DDTRACE_UNUSED VALUE _self);
 
 void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   // The profiler still has a lot of limitations around being used in Ractors BUT for now we're choosing to take care of those
@@ -101,6 +102,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_define_singleton_method(testing_module, "_native_enforce_success", _native_enforce_success, 2);
   rb_define_singleton_method(testing_module, "_native_malloc_stats", _native_malloc_stats, 0);
   rb_define_singleton_method(testing_module, "_native_safe_object_info", _native_safe_object_info, 1);
+  rb_define_singleton_method(testing_module, "_native_imemo_mask", _native_imemo_mask, 0);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
@@ -329,3 +331,7 @@ static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self) {
 static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj) {
   return rb_str_new_cstr(safe_object_info(obj));
 }
+
+static VALUE _native_imemo_mask(DDTRACE_UNUSED VALUE _self) {
+  return INT2NUM(imemo_mask());
+}

data/ext/libdatadog_api/di.c

@@ -1,4 +1,5 @@
 #include <stdbool.h>
+#include <string.h>
 
 #include "datadog_ruby_common.h"
 
@@ -12,15 +13,19 @@ VALUE rb_iseqw_new(const void *iseq);
 // rb_iseqw_to_iseq unwraps a RubyVM::InstructionSequence object back
 // to its internal iseq pointer.
 const void *rb_iseqw_to_iseq(VALUE iseqw);
+#ifdef HAVE_RB_IMEMO_NAME
+const char *rb_imemo_name(int imemo_type);
+#endif
 int rb_objspace_internal_object_p(VALUE obj);
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
     void *data);
 
-// The mask is unchanged between Ruby 2.5 and 4.1-dev, but the `enum imemo_type` values do get
-// renumbered from time to time (e.g. Ruby 4.0 moved imemo_callinfo from 11 to 10), and 4.1-dev already uses all
-// 16 values the mask allows. Thus IMEMO_TYPE_ISEQ must be re-checked when adding support for a new Ruby.
-#define IMEMO_MASK 0x0f
+#ifdef HAVE_SHIFTED_IMEMO_MASK // Ruby 4.1+
+  #define IMEMO_MASK (FL_USER0 | FL_USER1 | FL_USER2 | FL_USER3 | FL_USER4)
+#else
+  #define IMEMO_MASK 0x0f
+#endif
 #define IMEMO_TYPE_ISEQ 7
 
 // The ID value of the string "mesg" which is used in Ruby source as
@@ -37,7 +42,11 @@ static ID id_datadog_di_in_probe;
 // Returns the imemo type of an imemo object, that is `imemo_type()` from CRuby's internal/imemo.h.
 // The caller must have already checked the object is a T_IMEMO, otherwise the result is meaningless.
 static inline int ddtrace_imemo_type(VALUE imemo) {
-  return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
+  #ifdef HAVE_SHIFTED_IMEMO_MASK // Ruby 4.1+
+    return (RBASIC(imemo)->flags & IMEMO_MASK) >> FL_USHIFT;
+  #else
+    return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
+  #endif
 }
 
 // Returns whether the argument is an IMEMO of type ISEQ.
@@ -199,7 +208,20 @@ static VALUE iseq_type(DDTRACE_UNUSED VALUE _self, VALUE iseq_val) {
 }
 #endif
 
+static VALUE _native_imemo_mask(DDTRACE_UNUSED VALUE _self) {
+  return INT2NUM(IMEMO_MASK);
+}
+
 void di_init(VALUE datadog_module) {
+  #ifdef HAVE_RB_IMEMO_NAME
+    const char *iseq_name = rb_imemo_name(IMEMO_TYPE_ISEQ);
+    if (strcmp(iseq_name, "iseq") != 0) {
+      rb_raise(rb_eRuntimeError,
+        "IMEMO_TYPE_ISEQ self-test failed: rb_imemo_name(%d) returned '%s' instead of 'iseq'",
+        IMEMO_TYPE_ISEQ, iseq_name);
+    }
+  #endif
+
   id_mesg = rb_intern("mesg");
   id_datadog_di_in_probe = rb_intern("datadog_di_in_probe");
 
@@ -213,6 +235,9 @@ void di_init(VALUE datadog_module) {
   #ifdef HAVE_RB_ISEQ_TYPE
     rb_define_singleton_method(di_module, "iseq_type", iseq_type, 1);
   #endif
+
+  VALUE testing_module = rb_define_module_under(di_module, "Testing");
+  rb_define_singleton_method(testing_module, "_native_imemo_mask", _native_imemo_mask, 0);
 }
 
 #endif // TRUFFLERUBY

data/ext/libdatadog_api/extconf.rb

@@ -98,6 +98,8 @@ EXTENSION_NAME = "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}".fr
 
 have_func("rb_iseq_type")
 
+$defs << "-DHAVE_RB_IMEMO_NAME" if RUBY_VERSION >= "3.0"
+$defs << "-DHAVE_SHIFTED_IMEMO_MASK" if RUBY_VERSION >= "4.1"
 $defs << "-DHAVE_RUBY_THREAD_STORAGE_API" if RUBY_VERSION >= "3.3"
 $defs << "-DHAVE_RUBY_THREAD_HAS_GVL_P" if have_func("ruby_thread_has_gvl_p")
 

data/ext/libdatadog_api/otel_thread_context.c

@@ -30,7 +30,6 @@ DDTRACE_UNUSED static bool otel_context_enabled = false;
 
 static VALUE native_set(VALUE _self, VALUE trace_id, VALUE span_id, VALUE local_root_span_id);
 static VALUE native_clear(VALUE _self);
-static VALUE native_supported_p(VALUE _self);
 static VALUE native_enable(VALUE _self);
 static VALUE native_read(VALUE _self);
 
@@ -42,7 +41,6 @@ void otel_thread_context_init(VALUE tracing_module) {
   rb_define_method(otel_thread_context_class, "_native_enable", native_enable, 0);
   rb_define_method(otel_thread_context_class, "_native_set", native_set, 3);
   rb_define_method(otel_thread_context_class, "_native_clear", native_clear, 0);
-  rb_define_method(otel_thread_context_class, "_native_supported?", native_supported_p, 0);
 
   VALUE testing_module = rb_define_module_under(otel_thread_context_class, "Testing");
   rb_define_singleton_method(testing_module, "_native_read", native_read, 0);
@@ -100,6 +98,19 @@ void otel_thread_context_init(VALUE tracing_module) {
     ) {
       ddog_otel_thread_ctx_detach();
     }
+
+    // CRuby fires RUBY_EVENT_THREAD_END only after the thread body returns,
+    // and Thread#kill unwinds the body via EC_JUMP_TAG(TAG_FATAL):
+    // https://github.com/ruby/ruby/blob/v3_1_4/thread.c#L744-L775
+    static void on_thread_begin(
+      DDTRACE_UNUSED rb_event_flag_t evflag,
+      DDTRACE_UNUSED VALUE data,
+      DDTRACE_UNUSED VALUE self,
+      DDTRACE_UNUSED ID mid,
+      DDTRACE_UNUSED VALUE klass
+    ) {
+      ddog_otel_thread_ctx_detach();
+    }
   #endif
 
   #ifdef HAVE_RUBY_THREAD_STORAGE_API
@@ -166,6 +177,11 @@ static VALUE native_enable(DDTRACE_UNUSED VALUE _self) {
       rb_internal_thread_add_event_hook(on_thread_exited, RUBY_INTERNAL_THREAD_EVENT_EXITED, NULL);
     #else
       rb_add_event_hook(on_thread_end, RUBY_EVENT_THREAD_END, Qnil);
+      // RUBY_EVENT_THREAD_END does not fire for threads terminated via Thread#kill
+      // on Ruby < 3.2, so a killed thread's otel_thread_ctx_v1 TLS stays attached
+      // on a native thread CRuby may recycle for a later Ruby thread. Detach on
+      // thread begin to drop that stale record before the new thread runs.
+      rb_add_event_hook(on_thread_begin, RUBY_EVENT_THREAD_BEGIN, Qnil);
     #endif
 
     // These hooks only matter under the M:N thread scheduler (Ruby 3.3+),
@@ -179,15 +195,7 @@ static VALUE native_enable(DDTRACE_UNUSED VALUE _self) {
 
     return Qtrue;
   #else
-    return Qfalse;
-  #endif
-}
-
-static VALUE native_supported_p(DDTRACE_UNUSED VALUE _self) {
-  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
-    return Qtrue;
-  #else
-    return Qfalse;
+    raise_error(rb_eRuntimeError, "OTel thread context is not supported on this platform");
   #endif
 }
 
@@ -216,9 +224,7 @@ static VALUE native_set(
       store_current_fiber_handle(handle);
       ddog_otel_thread_ctx_attach(handle);
     } else {
-      // FIXME: add a method to libdatadog to update the context record before attaching it
-      ddog_otel_thread_ctx_attach(handle);
-      ddog_otel_thread_ctx_update(&trace_id_bytes, &span_id_bytes, 0, &local_root_span_id_bytes);
+      ddog_otel_thread_ctx_update_and_attach(handle, &trace_id_bytes, &span_id_bytes, 0, &local_root_span_id_bytes);
     }
 
     return Qtrue;

data/ext/libdatadog_api/process_discovery.c

@@ -4,6 +4,7 @@
 #include <datadog/library-config.h>
 
 #include "datadog_ruby_common.h"
+#include "helpers.h"
 
 static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_to_rb_int(DDTRACE_UNUSED VALUE _self, VALUE tracer_memfd);
@@ -38,8 +39,9 @@ void process_discovery_init(VALUE core_module) {
 
 static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   VALUE logger;
+  VALUE otel_thread_context_enabled;
   VALUE options;
-  rb_scan_args(argc, argv, "1:", &logger, &options);
+  rb_scan_args(argc, argv, "2:", &logger, &otel_thread_context_enabled, &options);
   if (options == Qnil) options = rb_hash_new();
 
   VALUE runtime_id = rb_hash_fetch(options, ID2SYM(rb_intern("runtime_id")));
@@ -61,6 +63,7 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   ENFORCE_TYPE(service_version, T_STRING);
   ENFORCE_TYPE(process_tags, T_STRING);
   ENFORCE_TYPE(container_id, T_STRING);
+  ENFORCE_BOOLEAN(otel_thread_context_enabled);
 
   void* builder = ddog_tracer_metadata_new();
 
@@ -74,6 +77,16 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_PROCESS_TAGS, StringValueCStr(process_tags));
   ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_CONTAINER_ID, StringValueCStr(container_id));
 
+  if (RTEST(otel_thread_context_enabled)) {
+    ddog_VoidResult include_result = ddog_tracer_metadata_include_otel_thread_context(builder);
+
+    if (include_result.tag == DDOG_VOID_RESULT_ERR) {
+      ddog_tracer_metadata_free(builder);
+    }
+
+    CHECK_VOID_RESULT("Failed to include OTel thread context metadata", include_result);
+  }
+
   ddog_Result_TracerMemfdHandle result = ddog_tracer_metadata_store(builder);
   ddog_tracer_metadata_free(builder);
 
@@ -89,6 +102,7 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   *fd = result.ok.fd;
   VALUE tracer_memfd_class = rb_const_get(self, rb_intern("TracerMemfd"));
   VALUE tracer_memfd = TypedData_Wrap_Struct(tracer_memfd_class, &tracer_memfd_type, fd);
+
   return tracer_memfd;
 }
 

data/ext/libdatadog_api/trace_exporter.c

@@ -104,6 +104,8 @@ static VALUE serializable_backtrace_class = Qnil;
 /* Response class (loaded from Ruby) */
 static VALUE response_class       = Qnil;
 static ID id_new;
+static ID id_handle_interrupt;
+static VALUE observation_interrupt_mask = Qnil;
 
 /* Response keyword-argument IDs, cached to avoid re-interning per send */
 static ID kw_ok;
@@ -1464,6 +1466,11 @@ static VALUE _native_exporter_new(
   /* Phase 2: configure before creating the separately-owned runtime. */
   ddog_TraceExporterConfig *config = NULL;
   ddog_trace_exporter_config_new(&config);
+  ddog_TraceExporterError *observation_error = ddog_trace_exporter_config_enable_observations(config);
+  if (observation_error != NULL) {
+    ddog_trace_exporter_config_free(config);
+    check_exporter_error("Failed to select exporter observations", observation_error);
+  }
 
   set_config_field(config, ddog_trace_exporter_config_set_url,               rb_url,                   "url");
   set_config_field(config, ddog_trace_exporter_config_set_tracer_version,    rb_tracer_version,        "tracer_version");
@@ -1621,6 +1628,7 @@ typedef struct {
   const ddog_TraceExporter       *exporter;
   ddog_TracerTraceChunks         *chunks;
   ddog_TraceExporterResponse     *response;
+  ddog_TraceExporterObservations  observations;
   ddog_TraceExporterCancelToken  *cancel_token;  /* borrowed, not owned */
   ddog_TraceExporterErrorCode     error_code;
   bool                            failed;
@@ -1629,8 +1637,8 @@ typedef struct {
 
 static void *send_chunks_without_gvl(void *data) {
   send_chunks_args_t *args = (send_chunks_args_t *)data;
-  ddog_TraceExporterError *err = ddog_trace_exporter_send_trace_chunks(
-      args->exporter, args->chunks, &args->response, args->cancel_token);
+  ddog_TraceExporterError *err = ddog_trace_exporter_send_trace_chunks_observed(
+      args->exporter, args->chunks, &args->response, &args->observations, args->cancel_token);
   if (err != NULL) {
     args->error_code = err->code;
     args->failed = true;
@@ -1698,8 +1706,73 @@ typedef struct {
   long                      trace_count;
   raw_span_owner            span_owner;
   ddog_TracerTraceChunks   *chunks;  /* NULL after send consumes it */
+  ddog_TraceExporterResponse *response;
 } send_traces_ctx;
 
+typedef struct {
+  const ddog_TraceExporterObservations *report;
+  VALUE block;
+} observations_callback_args;
+
+static VALUE yield_observations(VALUE arg) {
+  observations_callback_args *callback = (observations_callback_args *)arg;
+  const ddog_TraceExporterObservations *report = callback->report;
+  VALUE values = rb_hash_new();
+#define ADD_OBSERVATION(field) if (report->field > 0) rb_hash_aset(values, ID2SYM(rb_intern_const(#field)), ULL2NUM(report->field))
+  ADD_OBSERVATION(requests_count);
+  ADD_OBSERVATION(errors_network);
+  ADD_OBSERVATION(errors_timeout);
+  ADD_OBSERVATION(errors_status_code);
+  ADD_OBSERVATION(bytes_sent);
+  ADD_OBSERVATION(chunks_sent);
+  ADD_OBSERVATION(chunks_dropped_serialization_error);
+  ADD_OBSERVATION(chunks_dropped_send_failure);
+  ADD_OBSERVATION(spans_enqueued_for_serialization);
+  ADD_OBSERVATION(spans_dropped_serialization_error);
+  ADD_OBSERVATION(spans_dropped_api_error);
+  ADD_OBSERVATION(responses_count);
+  ADD_OBSERVATION(status_code);
+#undef ADD_OBSERVATION
+  return rb_proc_call_with_block(callback->block, 1, &values, Qnil);
+}
+
+static VALUE ignore_observation_error(DDTRACE_UNUSED VALUE arg, DDTRACE_UNUSED VALUE error) {
+  return Qnil;
+}
+
+static VALUE protected_observations(RB_BLOCK_CALL_FUNC_ARGLIST(yielded, arg)) {
+  (void)yielded;
+  (void)argc;
+  (void)argv;
+  (void)blockarg;
+  return rb_rescue2(yield_observations, arg, ignore_observation_error, Qnil,
+      rb_eStandardError, (VALUE)0);
+}
+
+static VALUE forward_observations(VALUE arg) {
+  observations_callback_args callback = {
+    .report = (const ddog_TraceExporterObservations *)arg,
+    .block = rb_block_proc(),
+  };
+  /* Deliver fresh interrupts after the callback's StandardError rescue has ended. */
+  VALUE result = rb_block_call(rb_cThread, id_handle_interrupt, 1, &observation_interrupt_mask,
+      protected_observations, (VALUE)&callback);
+  RB_GC_GUARD(callback.block);
+  return result;
+}
+
+static VALUE ensure_observations(VALUE arg) {
+  int ignored_state = 0;
+  /* The original interruption wins over any callback failure or non-local exit. */
+  rb_protect(forward_observations, arg, &ignored_state);
+  return Qnil;
+}
+
+static VALUE rethrow_interrupt(VALUE tag) {
+  rb_jump_tag(FIX2INT(tag));
+  return Qnil;
+}
+
 /*
  * Body: build trace chunks from Ruby spans, then send them.
  * Passed to rb_ensure as the "try" block.
@@ -1777,40 +1850,37 @@ static VALUE build_and_send_traces(VALUE arg) {
   if (args.send_ran) {
     ctx->chunks = NULL;
   }
+  ctx->response = args.response;
+
+  /* A completed send can race with cancellation; retain its report while unwinding. */
+  if (!pending_exception) {
+    pending_exception = check_if_pending_exception();
+  }
+  if (args.send_ran && rb_block_given_p()) {
+    if (pending_exception) {
+      /* rb_ensure preserves Thread#kill's fatal sentinel, which rb_set_errinfo cannot restore. */
+      rb_ensure(rethrow_interrupt, INT2FIX(pending_exception),
+          ensure_observations, (VALUE)&args.observations);
+    } else {
+      forward_observations((VALUE)&args.observations);
+    }
+  }
+  if (pending_exception) {
+    rb_jump_tag(pending_exception);
+  }
 
   /* Extract the response body as a Ruby string before freeing. */
   VALUE payload = Qnil;
   if (args.response != NULL) {
-    ddog_ByteSlice body =
-        ddog_trace_exporter_response_get_body(args.response);
+    ddog_ByteSlice body = ddog_trace_exporter_response_get_body(args.response);
     if (body.len > 0) {
       payload = rb_str_new((const char *)body.ptr, (long)body.len);
     }
     ddog_trace_exporter_response_free(args.response);
+    ctx->response = NULL;
     args.response = NULL;
   }
 
-  /*
-   * Re-check for a pending interrupt unconditionally before deciding the
-   * outcome.  In a race, the unblock function (interrupt_exporter_call) can
-   * fire -- cancelling the token -- while the send still completes, so
-   * rb_thread_call_without_gvl2 returns with args.send_ran == true.  In that
-   * case the loop above exits without ever calling check_if_pending_exception(),
-   * leaving the interrupt pending.  If we did not check here, the cancelled
-   * send would fall through and be reported as an ordinary transport error
-   * response, swallowing the interrupt (e.g. Thread#kill / shutdown).
-   *
-   * This runs after the response has already been extracted and freed and
-   * after chunks have been handed off to the ensure handler, so re-raising
-   * here leaks nothing.
-   */
-  if (!pending_exception) {
-    pending_exception = check_if_pending_exception();
-  }
-  if (pending_exception) {
-    rb_jump_tag(pending_exception);
-  }
-
   if (args.failed) {
     VALUE err_resp = create_error_response(args.error_code, ctx->trace_count);
     return rb_ary_new_from_args(1, err_resp);
@@ -1827,6 +1897,10 @@ static VALUE build_and_send_traces(VALUE arg) {
 static VALUE free_send_resources(VALUE arg) {
   send_traces_ctx *ctx = (send_traces_ctx *)arg;
   free_raw_span((VALUE)&ctx->span_owner);
+  if (ctx->response != NULL) {
+    ddog_trace_exporter_response_free(ctx->response);
+    ctx->response = NULL;
+  }
   if (ctx->chunks != NULL) {
     ddog_tracer_trace_chunks_free(ctx->chunks);
     ctx->chunks = NULL;
@@ -1883,6 +1957,12 @@ static VALUE _native_send_traces(VALUE self, VALUE traces, VALUE native_events_s
  * ======================================================================== */
 
 void trace_exporter_init(VALUE tracing_module) {
+  id_handle_interrupt = rb_intern("handle_interrupt");
+  observation_interrupt_mask = rb_hash_new();
+  rb_hash_aset(observation_interrupt_mask, rb_cObject, ID2SYM(rb_intern("never")));
+  rb_obj_freeze(observation_interrupt_mask);
+  rb_global_variable(&observation_interrupt_mask);
+
   /* -- Module hierarchy -- */
   VALUE transport_module = rb_define_module_under(tracing_module, "Transport");
   VALUE native_module =

data/ext/libdatadog_extconf_helpers.rb

@@ -11,7 +11,7 @@ module Datadog
   module LibdatadogExtconfHelpers
     # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
     # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
-    LIBDATADOG_VERSION = "~> 45.0.0.1.0"
+    LIBDATADOG_VERSION = "~> 46.1.0.1.1"
 
     # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
     # libdatadog are moved after the extension gets compiled.