datadog 2.30.0 → 2.45.0

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -6,19 +6,27 @@
 static ID telemetry_message_id;
 
 void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char *function_name) {
-  rb_exc_raise(
-    rb_exc_new_str(
-      rb_eTypeError,
-      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
-        rb_inspect(value),
-        value_name,
-        type_name,
-        file,
-        line,
-        function_name
-      )
+  // All of the below come from `ENFORCE_TYPE` and are constant for their call-site
+  VALUE simple_message = rb_sprintf("wrong argument for '%s' (expected a %s) at %s:%d:in `%s'",
+    value_name,
+    type_name,
+    file,
+    line,
+    function_name
+  );
+  VALUE exception = rb_exc_new_str(
+    rb_eTypeError,
+    rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+      rb_inspect(value),
+      value_name,
+      type_name,
+      file,
+      line,
+      function_name
     )
   );
+  rb_ivar_set(exception, telemetry_message_id, simple_message);
+  rb_exc_raise(exception);
 }
 
 // Raises an exception with separate telemetry-safe and detailed messages.
@@ -29,16 +37,15 @@ void private_raise_exception(VALUE exception, const char *static_message) {
   rb_exc_raise(exception);
 }
 
-// Helper for raising pre-formatted exceptions
-void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message) {
-  VALUE exception = rb_exc_new_cstr(exception_class, detailed_message);
-  private_raise_exception(exception, static_message);
-}
-
 // Use `raise_error` the macro instead, as it provides additional argument checks.
 void private_raise_error(VALUE exception_class, const char *fmt, ...) {
-  FORMAT_VA_ERROR_MESSAGE(detailed_message, fmt);
-  private_raise_error_formatted(exception_class, detailed_message, fmt);
+  va_list args;
+  va_start(args, fmt);
+  VALUE detailed_message = rb_vsprintf(fmt, args);
+  va_end(args);
+
+  VALUE exception = rb_exc_new_str(exception_class, detailed_message);
+  private_raise_exception(exception, fmt);
 }
 
 VALUE datadog_gem_version(void) {
@@ -122,6 +129,24 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
   return error_msg_size;
 }
 
+static void verify_libdatadog_version(void) {
+  rb_eval_string(
+    "require 'libdatadog';"
+    "expected = '" EXPECTED_LIBDATADOG_VERSION "';"
+    "if expected != Libdatadog::VERSION;"
+      "raise(LoadError, <<MSG\n"
+        "The `datadog` gem needs to be reinstalled whenever the `libdatadog` gem version is changed. "
+        "The currently-installed version of `datadog` was built to work with `libdatadog` gem version #{expected} "
+        "but the currently-loaded version of `libdatadog` is #{Libdatadog::VERSION}. "
+        "To fix this, reinstall the `datadog` gem (e.g. `bundle exec gem pristine datadog`) "
+        "or contact Datadog support for help at <https://docs.datadoghq.com/help/>.\n"
+        "MSG\n"
+      ");"
+    "end"
+  );
+}
+
 void datadog_ruby_common_init(void) {
   telemetry_message_id = rb_intern("@telemetry_message");
+  verify_libdatadog_version();
 }

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -5,6 +5,13 @@
 #include <ruby.h>
 #include <datadog/common.h>
 
+// All recommended backward compatible macros for keyword argument functions can be found here:
+// https://github.com/ruby/ruby/blob/master/doc/extension.rdoc#defining-backward-compatible-macros-for-keyword-argument-functions
+#ifndef RB_PASS_KEYWORDS
+/* Only define macros on Ruby <2.7 */
+#define rb_funcallv_kw(o, m, c, v, kw) rb_funcallv(o, m, c, v)
+#endif
+
 // Must be called once during initialization
 void datadog_ruby_common_init(void);
 
@@ -47,11 +54,6 @@ NORETURN(
   __attribute__ ((format (printf, 2, 3)));
 );
 
-// Internal helper for raising pre-formatted exceptions
-NORETURN(
-  void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message)
-);
-
 // Raises an exception with separate telemetry-safe and detailed messages.
 // NOTE: Raising an exception always invokes Ruby code so it requires the GVL and is not compatible with "debug_enter_unsafe_context".
 // @see debug_enter_unsafe_context
@@ -61,13 +63,6 @@ NORETURN(
 
 #define MAX_RAISE_MESSAGE_SIZE 256
 
-#define FORMAT_VA_ERROR_MESSAGE(buf, fmt) \
-  char buf[MAX_RAISE_MESSAGE_SIZE]; \
-  va_list buf##_args; \
-  va_start(buf##_args, fmt); \
-  vsnprintf(buf, MAX_RAISE_MESSAGE_SIZE, fmt, buf##_args); \
-  va_end(buf##_args);
-
 // Helper to retrieve Datadog::VERSION::STRING
 VALUE datadog_gem_version(void);
 

data/ext/libdatadog_api/di.c

@@ -0,0 +1,218 @@
+#include <stdbool.h>
+
+#include "datadog_ruby_common.h"
+
+// rb_iseq is CRuby-specific
+#ifndef TRUFFLERUBY
+
+// Prototypes for Ruby functions declared in internal Ruby headers.
+// rb_iseqw_new wraps an internal iseq pointer into a Ruby-visible
+// RubyVM::InstructionSequence object.
+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);
+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
+#define IMEMO_TYPE_ISEQ 7
+
+// The ID value of the string "mesg" which is used in Ruby source as
+// id_mesg or idMesg, and is used to set and retrieve the exception message
+// from standard library exception classes like NameError.
+static ID id_mesg;
+
+// ID for the fiber-local key that backs the method-probe re-entrancy guard.
+// Storage is the same hashtable that backs Thread#[] / Thread#[]=, but accessed
+// directly via rb_thread_local_aref / rb_thread_local_aset so that user-installed
+// method probes on Thread#[] / Thread#[]= cannot intercept guard reads/writes.
+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;
+}
+
+// Returns whether the argument is an IMEMO of type ISEQ.
+static bool ddtrace_imemo_iseq_p(VALUE v) {
+  return rb_objspace_internal_object_p(v) && RB_TYPE_P(v, T_IMEMO) && ddtrace_imemo_type(v) == IMEMO_TYPE_ISEQ;
+}
+
+static int ddtrace_di_os_obj_of_i(void *vstart, void *vend, size_t stride, void *data)
+{
+  VALUE *array = (VALUE *)data;
+
+  VALUE v = (VALUE)vstart;
+  for (; v != (VALUE)vend; v += stride) {
+    if (ddtrace_imemo_iseq_p(v)) {
+      VALUE iseq = rb_iseqw_new((void *) v);
+      rb_ary_push(*array, iseq);
+    }
+  }
+
+  return 0;
+}
+
+/*
+Returns all RubyVM::InstructionSequence objects existing in the current process.
+
+This uses the same approach as ruby/debug's iseq_collector.c:
+https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+*/
+static VALUE all_iseqs(DDTRACE_UNUSED VALUE _self) {
+  VALUE array = rb_ary_new();
+  rb_objspace_each_objects(ddtrace_di_os_obj_of_i, &array);
+  return array;
+}
+
+/*
+ * call-seq:
+ *   DI.exception_message(exception) -> String | Object
+ *
+ * Returns the exception message associated with the exception via the
+ * exception's constructor.
+ *
+ * This method does not invoke Ruby code and as such will not call
+ * the +message+ method, if one is defined on the exception object.
+ *
+ * Normally, the exception message is a string, however there is no
+ * type enforcement done by Ruby for the messages and objects of arbitrary
+ * classes can be passed to exception constructors and will, subsequently,
+ * be returned by this method.
+ *
+ * @param exception [Exception] The exception object
+ * @return [String | Object] The exception message
+ */
+static VALUE exception_message(DDTRACE_UNUSED VALUE _self, VALUE exception) {
+  return rb_ivar_get(exception, id_mesg);
+}
+
+/*
+ * call-seq:
+ *   DI.in_probe? -> true | false
+ *
+ * Returns whether the current fiber is currently inside DI probe processing.
+ * Reads the same fiber-local storage as Thread.current[:datadog_di_in_probe]
+ * but bypasses Thread#[] method dispatch — a user method probe on Thread#[]
+ * cannot observe or intercept this call.
+ *
+ * @api private
+ */
+static VALUE in_probe_p(DDTRACE_UNUSED VALUE _self) {
+  VALUE v = rb_thread_local_aref(rb_thread_current(), id_datadog_di_in_probe);
+  return RTEST(v) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   DI.enter_probe -> nil
+ *
+ * Marks the current fiber as inside DI probe processing. Writes to the same
+ * fiber-local storage as Thread.current[:datadog_di_in_probe] = true, but
+ * bypasses Thread#[]= method dispatch — a user method probe on Thread#[]=
+ * cannot observe or intercept this call.
+ *
+ * @api private
+ */
+static VALUE enter_probe(DDTRACE_UNUSED VALUE _self) {
+  rb_thread_local_aset(rb_thread_current(), id_datadog_di_in_probe, Qtrue);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DI.leave_probe -> nil
+ *
+ * Marks the current fiber as no longer inside DI probe processing. Writes to
+ * the same fiber-local storage as Thread.current[:datadog_di_in_probe] = nil,
+ * but bypasses Thread#[]= method dispatch — a user method probe on Thread#[]=
+ * cannot observe or intercept this call.
+ *
+ * @api private
+ */
+static VALUE leave_probe(DDTRACE_UNUSED VALUE _self) {
+  rb_thread_local_aset(rb_thread_current(), id_datadog_di_in_probe, Qnil);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DI.hash?(obj) -> true | false
+ *
+ * Returns whether the given object is a Hash via a direct type check
+ * (RB_TYPE_P), bypassing Kernel#is_a? method dispatch. Used in the method
+ * probe wrapper (the Ruby < 3 argument-serialization split) to test whether
+ * the trailing argument is a hash without giving a user-installed method
+ * probe on Kernel#is_a? a chance to recurse. Matches Hash and its
+ * subclasses, like is_a?(Hash), since their instances are still T_HASH.
+ *
+ * @api private
+ */
+static VALUE is_hash(DDTRACE_UNUSED VALUE _self, VALUE obj) {
+  return RB_TYPE_P(obj, T_HASH) ? Qtrue : Qfalse;
+}
+
+// rb_iseq_type was added in Ruby 3.1 (commit 89a02d89 by Koichi Sasada,
+// 2021-12-19). It returns the iseq type as a Symbol. On Ruby < 3.1 this
+// function does not exist, so have_func('rb_iseq_type') in extconf.rb
+// gates compilation. When unavailable, backfill_registry falls back to
+// the first_lineno == 0 heuristic.
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const void *iseq);
+
+/*
+ * call-seq:
+ *   DI.iseq_type(iseq) -> Symbol
+ *
+ * Returns the type of an InstructionSequence as a symbol by calling
+ * the internal rb_iseq_type() function (available since Ruby 3.1).
+ *
+ * This method is only defined when rb_iseq_type is detected at compile
+ * time via have_func in extconf.rb. On Ruby < 3.1 it is not available
+ * and callers must use an alternative (e.g. first_lineno heuristic).
+ *
+ * Possible return values: :top, :method, :block, :class, :rescue,
+ * :ensure, :eval, :main, :plain.
+ *
+ * :top and :main represent whole-file iseqs (from require/load and the
+ * entry point script respectively). Other types represent sub-file
+ * constructs (method definitions, class bodies, blocks, etc.).
+ *
+ * Used by CodeTracker#backfill_registry to distinguish whole-file iseqs
+ * from per-method/block/class iseqs when populating the registry from
+ * the object space.
+ *
+ * @param iseq [RubyVM::InstructionSequence] The instruction sequence
+ * @return [Symbol] The iseq type
+ */
+static VALUE iseq_type(DDTRACE_UNUSED VALUE _self, VALUE iseq_val) {
+  const void *iseq = rb_iseqw_to_iseq(iseq_val);
+  if (!iseq) return Qnil;
+  return rb_iseq_type(iseq);
+}
+#endif
+
+void di_init(VALUE datadog_module) {
+  id_mesg = rb_intern("mesg");
+  id_datadog_di_in_probe = rb_intern("datadog_di_in_probe");
+
+  VALUE di_module = rb_define_module_under(datadog_module, "DI");
+  rb_define_singleton_method(di_module, "all_iseqs", all_iseqs, 0);
+  rb_define_singleton_method(di_module, "exception_message", exception_message, 1);
+  rb_define_singleton_method(di_module, "in_probe?", in_probe_p, 0);
+  rb_define_singleton_method(di_module, "enter_probe", enter_probe, 0);
+  rb_define_singleton_method(di_module, "leave_probe", leave_probe, 0);
+  rb_define_singleton_method(di_module, "hash?", is_hash, 1);
+  #ifdef HAVE_RB_ISEQ_TYPE
+    rb_define_singleton_method(di_module, "iseq_type", iseq_type, 1);
+  #endif
+}
+
+#endif // TRUFFLERUBY

data/ext/libdatadog_api/extconf.rb

@@ -1,57 +1,68 @@
 # rubocop:disable Style/StderrPuts
 # rubocop:disable Style/GlobalVars
 
-require 'rubygems'
-require_relative '../libdatadog_extconf_helpers'
+require "rubygems"
+require_relative "../libdatadog_extconf_helpers"
 
 def skip_building_extension!(reason)
   $stderr.puts(
     "WARN: Skipping build of libdatadog_api (#{reason}). Some functionality will not be available."
   )
 
-  fail_install_if_missing_extension = ENV['DD_FAIL_INSTALL_IF_MISSING_EXTENSION'].to_s.strip.downcase == 'true'
+  fail_install_if_missing_extension = ENV["DD_FAIL_INSTALL_IF_MISSING_EXTENSION"].to_s.strip.downcase == "true"
 
   if fail_install_if_missing_extension
-    require 'mkmf'
+    require "mkmf"
     Logging.message("[datadog] Failure cause: #{reason}")
   else
-    File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+    File.write("Makefile", "all install clean: # dummy makefile that does nothing")
   end
 
   exit
 end
 
-if ENV['DD_NO_EXTENSION'].to_s.strip.downcase == 'true'
-  skip_building_extension!('the `DD_NO_EXTENSION` environment variable is/was set to `true` during installation')
+if ENV["DD_NO_EXTENSION"].to_s.strip.downcase == "true"
+  skip_building_extension!("the `DD_NO_EXTENSION` environment variable is/was set to `true` during installation")
 end
-skip_building_extension!('current Ruby VM is not supported') if RUBY_ENGINE != 'ruby'
-skip_building_extension!('Microsoft Windows is not supported') if Gem.win_platform?
+skip_building_extension!("current Ruby VM is not supported") unless %w[ruby truffleruby].include?(RUBY_ENGINE)
+skip_building_extension!("Microsoft Windows is not supported") if Gem.win_platform?
 
 libdatadog_issue = Datadog::LibdatadogExtconfHelpers.load_libdatadog_or_get_issue
 skip_building_extension!("issue setting up `libdatadog` gem: #{libdatadog_issue}") if libdatadog_issue
 
-require 'mkmf'
+require "mkmf"
+Datadog::LibdatadogExtconfHelpers.dump_mkmf_log_on_failure!
+
+# We must *never* `append_cflags "-Wall"` or `append_cflags "-Wextra"`, because those add the flag at the end,
+# which then overrides earlier -Wno-* flags from RbConfig::CONFIG["warnflags"], and causes errors if -Werror is added.
+# There is no need to add them anyway, Ruby since 1.9 has RbConfig::CONFIG["warnflags"] starting with "-Wall -Wextra ".
 
 # Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
 # But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
-append_cflags '-Werror' if ENV['DATADOG_GEM_CI'] == 'true'
+append_cflags "-Werror" if ENV["DATADOG_GEM_CI"] == "true"
+
+# TEMPORARY STOPGAP: libdatadog v36's vendored `common.h` ships duplicate typedefs
+# (a header-dedup regression), which `-Werror` turns into fatal
+# `-Wtypedef-redefinition` errors under C11/gnu11. Keep it a warning until a fixed
+# header lands upstream in libdatadog/libdatadog-rb. Remove this once that ships.
+append_cflags "-Wno-error=typedef-redefinition" if ENV["DATADOG_GEM_CI"] == "true"
 
 # Older gcc releases may not default to C99 and we need to ask for this. This is also used:
 # * 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)
 # @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'
+append_cflags RUBY_PLATFORM.include?("darwin") ? "-std=gnu11" : "-std=gnu99"
 
 # Allow defining variables at any point in a function
-append_cflags '-Wno-declaration-after-statement'
+append_cflags "-Wno-declaration-after-statement"
 
 # If we forget to include a Ruby header, the function call may still appear to work, but then
 # cause a segfault later. Let's ensure that never happens.
-append_cflags '-Werror-implicit-function-declaration'
+append_cflags "-Werror-implicit-function-declaration"
 
 # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
-append_cflags '-Wunused-parameter'
+append_cflags "-Wunused-parameter"
 
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
 # the sole exception being `Init_libdatadog_api` which needs to be visible for Ruby to call it when
@@ -59,34 +70,37 @@ append_cflags '-Wunused-parameter'
 #
 # By setting this compiler flag, we tell it to assume that everything is private unless explicitly stated.
 # For more details see https://gcc.gnu.org/wiki/Visibility
-append_cflags '-fvisibility=hidden'
+append_cflags "-fvisibility=hidden"
 
 # Avoid legacy C definitions
-append_cflags '-Wold-style-definition'
-
-# Enable all other compiler warnings
-append_cflags '-Wall'
-append_cflags '-Wextra'
+append_cflags "-Wold-style-definition"
 
-if ENV['DDTRACE_DEBUG'] == 'true'
-  $defs << '-DDD_DEBUG'
-  CONFIG['optflags'] = '-O0'
-  CONFIG['debugflags'] = '-ggdb3'
+if ENV["DDTRACE_DEBUG"] == "true"
+  $defs << "-DDD_DEBUG"
+  CONFIG["optflags"] = "-O0"
+  CONFIG["debugflags"] = "-ggdb3"
 end
 
 # If we got here, libdatadog is available and loaded
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
 unless Datadog::LibdatadogExtconfHelpers.configure_libdatadog(extconf_folder: __dir__)
-  skip_building_extension!('there was a problem in setting up the `libdatadog` dependency')
+  skip_building_extension!("there was a problem in setting up the `libdatadog` dependency")
 end
 
+Datadog::LibdatadogExtconfHelpers.add_libdatadog_version_define
+
 # 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.
 # When requiring, we need to use the exact same string, including the version and the platform.
 EXTENSION_NAME = "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}".freeze
 
+have_func("rb_iseq_type")
+
+$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")
+
 create_makefile(EXTENSION_NAME)
 
 # rubocop:enable Style/GlobalVars

data/ext/libdatadog_api/feature_flags.c

@@ -13,6 +13,7 @@
 // Forward declarations
 static VALUE configuration_new(VALUE klass, VALUE json_str);
 static void configuration_free(void *ptr);
+static VALUE configuration_get_observe_full_evaluation_data(VALUE self);
 static VALUE configuration_get_assignment(
   VALUE self, VALUE flag_key, VALUE expected_type, VALUE context);
 
@@ -21,6 +22,7 @@ static VALUE resolution_details_get_raw_value(VALUE self);
 static VALUE resolution_details_get_flag_type(VALUE self);
 static VALUE resolution_details_get_variant(VALUE self);
 static VALUE resolution_details_get_allocation_key(VALUE self);
+static VALUE resolution_details_get_serial_id(VALUE self);
 static VALUE resolution_details_get_reason(VALUE self);
 static VALUE resolution_details_get_error_code(VALUE self);
 static VALUE resolution_details_get_error_message(VALUE self);
@@ -93,6 +95,7 @@ void feature_flags_init(VALUE core_module) {
   rb_undef_alloc_func(configuration_class);
   rb_define_singleton_method(configuration_class, "new", configuration_new, 1);
   rb_define_method(configuration_class, "get_assignment", configuration_get_assignment, 3);
+  rb_define_method(configuration_class, "observe_full_evaluation_data", configuration_get_observe_full_evaluation_data, 0);
 
   rb_gc_register_address(&resolution_details_class);
   resolution_details_class = rb_define_class_under(feature_flags_module, "ResolutionDetails", rb_cObject);
@@ -101,6 +104,7 @@ void feature_flags_init(VALUE core_module) {
   rb_define_method(resolution_details_class, "flag_type", resolution_details_get_flag_type, 0);
   rb_define_method(resolution_details_class, "variant", resolution_details_get_variant, 0);
   rb_define_method(resolution_details_class, "allocation_key", resolution_details_get_allocation_key, 0);
+  rb_define_method(resolution_details_class, "serial_id", resolution_details_get_serial_id, 0);
   rb_define_method(resolution_details_class, "reason", resolution_details_get_reason, 0);
   rb_define_method(resolution_details_class, "error_code", resolution_details_get_error_code, 0);
   rb_define_method(resolution_details_class, "error_message", resolution_details_get_error_message, 0);
@@ -135,6 +139,12 @@ static VALUE configuration_new(VALUE klass, VALUE json_str) {
   return TypedData_Wrap_Struct(klass, &configuration_data_type, result.ok);
 }
 
+static VALUE configuration_get_observe_full_evaluation_data(VALUE self) {
+  ddog_ffe_Handle_Configuration configuration =
+    (ddog_ffe_Handle_Configuration)rb_check_typeddata(self, &configuration_data_type);
+  return ddog_ffe_configuration_get_observe_full_evaluation_data(configuration) ? Qtrue : Qfalse;
+}
+
 static void configuration_free(void *ptr) {
   ddog_ffe_Handle_Configuration config = (ddog_ffe_Handle_Configuration)ptr;
   ddog_ffe_configuration_drop(&config);
@@ -421,6 +431,30 @@ static VALUE resolution_details_get_allocation_key(VALUE self) {
   return str_from_borrow(allocation_key);
 }
 
+/*
+ * call-seq:
+ *   resolution_details.serial_id() -> Integer or nil
+ *
+ * Get the split serial id assigned for this evaluation.
+ *
+ * libdatadog returns an optional 32-bit integer (`ddog_Option_I32`, a tagged
+ * union). When the assignment carries a serial id the tag is
+ * DDOG_OPTION_I32_SOME_I32 and the value is in the `.some` field; otherwise the
+ * tag is DDOG_OPTION_I32_NONE_I32 and we return nil. This is consumed by the
+ * APM span-enrichment hook as `__dd_split_serial_id`.
+ *
+ * @return [Integer, nil] The split serial id or nil when absent
+ */
+static VALUE resolution_details_get_serial_id(VALUE self) {
+  ddog_ffe_Handle_ResolutionDetails resolution_details =
+    (ddog_ffe_Handle_ResolutionDetails)rb_check_typeddata(self, &resolution_details_typed_data);
+  struct ddog_Option_I32 serial_id = ddog_ffe_assignment_get_serial_id(resolution_details);
+  if (serial_id.tag == DDOG_OPTION_I32_SOME_I32) {
+    return INT2NUM(serial_id.some);
+  }
+  return Qnil;
+}
+
 /*
  * call-seq:
  *   resolution_details.reason() -> String

data/ext/libdatadog_api/init.c

@@ -1,12 +1,16 @@
 #include <ruby.h>
 
 #include "datadog_ruby_common.h"
+
 #include "crashtracker.h"
-#include "process_discovery.h"
-#include "library_config.h"
 #include "feature_flags.h"
+#include "library_config.h"
+#include "otel_thread_context.h"
+#include "process_discovery.h"
+#include "trace_exporter.h"
 
 void ddsketch_init(VALUE core_module);
+void di_init(VALUE datadog_module);
 
 void DDTRACE_EXPORT Init_libdatadog_api(void) {
   VALUE datadog_module = rb_define_module("Datadog");
@@ -21,4 +25,11 @@ void DDTRACE_EXPORT Init_libdatadog_api(void) {
   library_config_init(core_module);
   ddsketch_init(core_module);
   feature_flags_init(core_module);
+  #ifndef TRUFFLERUBY
+    di_init(datadog_module);
+  #endif
+
+  VALUE tracing_module = rb_define_module_under(datadog_module, "Tracing");
+  trace_exporter_init(tracing_module);
+  otel_thread_context_init(tracing_module);
 }