datadog 2.36.0 → 2.40.0

data/ext/datadog_profiling_native_extension/setup_signal_handler.c

@@ -36,6 +36,8 @@ static void install_sigprof_signal_handler_internal(
 ) {
   struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
   struct sigaction signal_handler_config = {
+    // NOTE: Deliberately not SA_ONSTACK. `handle_sampling_signal` uses "am I running on the alternate signal stack?"
+    // to detect that if it interrupted another signal handler from the Ruby VM, see `is_running_on_alternate_signal_stack` for details.
     .sa_flags = SA_RESTART | SA_SIGINFO,
     .sa_sigaction = signal_handler_function
   };

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -4,7 +4,7 @@
 #include <errno.h>
 #include <time.h>
 
-#include "extconf.h" // Needed for HAVE_CLOCK_MONOTONIC_COARSE
+#include "extconf.h"
 #include "ruby_helpers.h"
 
 #define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
@@ -33,7 +33,16 @@ static inline long retrieve_clock_as_ns(clockid_t clock_id, raise_on_failure_set
   return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
 }
 
-static inline long monotonic_wall_time_now_ns(raise_on_failure_setting raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC, raise_on_failure); }
+// CLOCK_MONOTONIC on macOS only has microsecond precision, CLOCK_MONOTONIC_RAW has nanosecond precision
+#ifdef __APPLE__
+  #define CLOCK_MONOTONIC_FOR_PROFILING CLOCK_MONOTONIC_RAW
+  #define CLOCK_MONOTONIC_COARSE_FOR_PROFILING CLOCK_MONOTONIC_RAW_APPROX
+#else
+  #define CLOCK_MONOTONIC_FOR_PROFILING CLOCK_MONOTONIC
+  #define CLOCK_MONOTONIC_COARSE_FOR_PROFILING CLOCK_MONOTONIC_COARSE
+#endif
+
+static inline long monotonic_wall_time_now_ns(raise_on_failure_setting raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC_FOR_PROFILING, raise_on_failure); }
 static inline long system_epoch_time_now_ns(raise_on_failure_setting raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
 
 // Coarse instants use CLOCK_MONOTONIC_COARSE on Linux which is expected to provide resolution in the millisecond range:
@@ -47,11 +56,7 @@ typedef struct {
 static inline coarse_instant to_coarse_instant(long timestamp_ns) { return (coarse_instant) {.timestamp_ns = timestamp_ns}; }
 
 static inline coarse_instant monotonic_coarse_wall_time_now_ns(void) {
- #ifdef HAVE_CLOCK_MONOTONIC_COARSE // Linux
-    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE, DO_NOT_RAISE_ON_FAILURE));
-  #else // macOS
-    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC, DO_NOT_RAISE_ON_FAILURE));
-  #endif
+  return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE_FOR_PROFILING, DO_NOT_RAISE_ON_FAILURE));
 }
 
 long monotonic_to_system_epoch_ns(monotonic_to_system_epoch_state *state, long monotonic_wall_time_ns);

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.

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);
 

data/ext/libdatadog_api/di.c

@@ -21,6 +21,12 @@ void rb_objspace_each_objects(
 // 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 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;
@@ -75,6 +81,71 @@ 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
@@ -117,10 +188,15 @@ static VALUE iseq_type(DDTRACE_UNUSED VALUE _self, VALUE iseq_val) {
 
 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

data/ext/libdatadog_api/extconf.rb

@@ -1,36 +1,36 @@
 # 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") if RUBY_ENGINE != "ruby"
+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,
@@ -39,24 +39,30 @@ Datadog::LibdatadogExtconfHelpers.dump_mkmf_log_on_failure!
 
 # 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
@@ -64,22 +70,22 @@ 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'
+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
@@ -90,7 +96,7 @@ Datadog::LibdatadogExtconfHelpers.add_libdatadog_version_define
 # 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')
+have_func("rb_iseq_type")
 
 create_makefile(EXTENSION_NAME)
 

data/ext/libdatadog_api/feature_flags.c

@@ -21,6 +21,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);
@@ -101,6 +102,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);
@@ -421,6 +423,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

@@ -6,6 +6,7 @@
 #include "feature_flags.h"
 #include "library_config.h"
 #include "process_discovery.h"
+#include "trace_exporter.h"
 
 void ddsketch_init(VALUE core_module);
 void di_init(VALUE datadog_module);
@@ -24,4 +25,7 @@ void DDTRACE_EXPORT Init_libdatadog_api(void) {
   ddsketch_init(core_module);
   feature_flags_init(core_module);
   di_init(datadog_module);
+
+  VALUE tracing_module = rb_define_module_under(datadog_module, "Tracing");
+  trace_exporter_init(tracing_module);
 }