datadog 2.45.0 → 2.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ec6218e3a5ff1d1a8e18c9c12e665dd21d88d0e281eb1ff7690958433b7734a
-  data.tar.gz: 6bc2e56d66439425d29b7a9f7c843da914d6d7e4fb7509b0d52cd52b5c3e7dba
+  metadata.gz: 90e55c02331cafb4d96cd0dedf6edb09fc5a6c7f993ffd611d8ca13f12d42cdb
+  data.tar.gz: a99ea41f5975708838075815674c78e47a46ef8368188186d2e20653a8372b19
 SHA512:
-  metadata.gz: 323a79d901180e0174cc4052a39cfd52637e7cb496ae8aef6813dfcbca21e943757516a7663acab009e286f74ab8d0306a7fe833d562814f1a78cb47f6f4af6f
-  data.tar.gz: fc1a980e41d7f6872acdd1addf5bbcaa91e2609fa69283ca1fd3bdc9cd91e6593c225946bc6e3007fd0069fe5c8e32a6b42311ba69912742f96f504b4b42c0b1
+  metadata.gz: 4061492c8bba7bf1238b6442d9275bbd7172978ecdbe4d4a92b53f0c67c2ca2d7b20947aaa42247fdc37ccbe81502710b4d69733e420e18fcd1e13d6e27b9864
+  data.tar.gz: 6fe366c5fcb305780a575c830bc77967be48605478071c1d16975242a95cb5c178b81dac776306f5b082b27770140174d29ad0c4dd7df3c9522b4a048883303f

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [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 +3851,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.45.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.46.0...master
+[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 +5683,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
@@ -5695,10 +5710,18 @@ 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
+[#6488]: https://github.com/DataDog/dd-trace-rb/issues/6488
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5855,4 +5878,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/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) {

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

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.0.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.

data/lib/datadog/core/configuration/components.rb

@@ -21,7 +21,7 @@ require_relative "../../ai_guard/component"
 require_relative "../../di/component"
 require_relative "../../symbol_database"
 require_relative "../../symbol_database/component"
-require_relative "../../open_feature/component"
+require_relative "../../open_feature/activation"
 require_relative "../../error_tracking/component"
 require_relative "../crashtracking/component"
 require_relative "../environment/agent_info"
@@ -154,8 +154,7 @@ module Datadog
           :ai_guard,
           :agent_info,
           :data_streams,
-          :symbol_database,
-          :open_feature
+          :symbol_database
 
         def initialize(settings)
           @settings = settings
@@ -188,15 +187,14 @@ module Datadog
 
           @telemetry = self.class.build_telemetry(settings, agent_settings, @logger)
 
-          # Bind Remote Configuration dispatch to this tree, which starts before it becomes the global Components instance.
           @remote = Remote::Component.build(
             settings,
             agent_settings,
             logger: @logger,
             telemetry: telemetry,
-            open_feature_component_provider: -> { @open_feature },
           )
           @tracer = Datadog::Tracing::Component.build_tracer(settings, agent_settings, logger: @logger)
+          Datadog::Tracing::Component.bind_transport_telemetry(@tracer, telemetry)
           @crashtracker = self.class.build_crashtracker(settings, agent_settings, logger: @logger)
 
           @profiler, profiler_logger_extra = Datadog::Profiling::Component.build_profiler_component(
@@ -211,7 +209,13 @@ module Datadog
           @health_metrics = self.class.build_health_metrics(settings, @logger, telemetry)
           @appsec = Datadog::AppSec::Component.build_appsec_component(settings, telemetry: telemetry)
           @ai_guard = Datadog::AIGuard::Component.build(settings, logger: @logger, telemetry: telemetry)
-          @open_feature = OpenFeature::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
+          @open_feature_activation = OpenFeature::Activation.new(
+            settings,
+            agent_settings,
+            remote,
+            logger: @logger,
+            telemetry: telemetry,
+          )
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           # Only build symbol database when enabled, so a disabled component is
           # never constructed.
@@ -257,6 +261,7 @@ module Datadog
           ProcessDiscovery.after_fork
           symbol_database&.after_fork!
           data_streams&.restart_flush_thread
+          @open_feature_activation.after_fork
         end
 
         # Hot-swaps with a new sampler.
@@ -271,6 +276,8 @@ module Datadog
         def startup!(settings, old_state: nil)
           telemetry.start(old_state&.telemetry_enabled?, components: self)
 
+          @open_feature_activation.startup!
+
           if settings.profiling.enabled
             if profiler
               profiler.start
@@ -329,8 +336,14 @@ module Datadog
           # Shutdown Symbol Database
           symbol_database&.shutdown!
 
-          # Shutdown OpenFeature component
-          open_feature&.shutdown!
+          begin
+            @open_feature_activation.shutdown!
+          rescue => e
+            # Feature Flags is optional and must never interrupt library shutdown.
+            description = "Feature Flags delivery failed to shut down"
+            logger.error("#{description}: #{e.class}: #{e.message}")
+            telemetry.report(e, description: description)
+          end
 
           # Decommission AppSec
           appsec&.shutdown!
@@ -407,6 +420,14 @@ module Datadog
             di_implicitly_enabled: di_implicit || false,
           )
         end
+
+        def open_feature
+          @open_feature_activation.component
+        end
+
+        private
+
+        attr_reader :open_feature_activation
       end
     end
   end

data/lib/datadog/core/configuration/supported_configurations.rb

@@ -51,6 +51,7 @@ module Datadog
           "DD_DBM_INJECT_SQL_BASEHASH",
           "DD_DBM_PROPAGATION_MODE",
           "DD_DISABLE_DATADOG_RAILS",
+          "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS",
           "DD_DYNAMIC_INSTRUMENTATION_ENABLED",
           "DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE",
           "DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE",
@@ -399,6 +400,7 @@ module Datadog
 
       ALIASES =
         {"DD_DISABLE_DATADOG_RAILS" => ["DISABLE_DATADOG_RAILS"],
+         "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS" => ["DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT"],
          "DD_PROFILING_GVL_ENABLED" => ["DD_PROFILING_PREVIEW_GVL_ENABLED"],
          "DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED" => ["DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED"],
          "DD_SERVICE" => ["OTEL_SERVICE_NAME"],
@@ -409,10 +411,11 @@ module Datadog
          "DD_TRACE_SAMPLE_RATE" => ["OTEL_TRACES_SAMPLER"]}.freeze
 
       DEPRECATIONS =
-        Set["DD_PROFILING_PREVIEW_GVL_ENABLED", "DISABLE_DATADOG_RAILS"]
+        Set["DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT", "DD_PROFILING_PREVIEW_GVL_ENABLED", "DISABLE_DATADOG_RAILS"]
 
       ALIAS_TO_CANONICAL =
-        {"DD_PROFILING_PREVIEW_GVL_ENABLED" => "DD_PROFILING_GVL_ENABLED",
+        {"DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT" => "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS",
+         "DD_PROFILING_PREVIEW_GVL_ENABLED" => "DD_PROFILING_GVL_ENABLED",
          "DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED" => "DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED",
          "DISABLE_DATADOG_RAILS" => "DD_DISABLE_DATADOG_RAILS",
          "OTEL_LOG_LEVEL" => "DD_TRACE_DEBUG",