datadog 2.8.0 → 2.39.0

data/ext/libdatadog_api/di.c

@@ -0,0 +1,203 @@
+#include <stdbool.h>
+
+#include "datadog_ruby_common.h"
+
+// 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);
+
+#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 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
+}

data/ext/libdatadog_api/extconf.rb

@@ -1,54 +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!('issue setting up `libdatadog` gem') if Datadog::LibdatadogExtconfHelpers.libdatadog_issue?
+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?
 
-require 'mkmf'
+libdatadog_issue = Datadog::LibdatadogExtconfHelpers.load_libdatadog_or_get_issue
+skip_building_extension!("issue setting up `libdatadog` gem: #{libdatadog_issue}") if libdatadog_issue
+
+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)
-append_cflags '-std=gnu99'
+# @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
+append_cflags RUBY_PLATFORM.include?("darwin") ? "-std=gnu11" : "-std=gnu99"
 
 # 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
@@ -56,45 +70,25 @@ 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
-ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config('datadog_profiling_with_rpath')
-  Logging.message("[datadog] Ruby detected the pkg-config command is #{$PKGCONFIG.inspect}\n")
-
-  if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
-    skip_building_extension!('the `pkg-config` system tool is missing')
-  else
-    skip_building_extension!('there was a problem in setting up the `libdatadog` dependency')
-  end
+unless Datadog::LibdatadogExtconfHelpers.configure_libdatadog(extconf_folder: __dir__)
+  skip_building_extension!("there was a problem in setting up the `libdatadog` dependency")
 end
 
-# See comments on the helper methods being used for why we need to additionally set this.
-# The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
-# experimentation. We need to get these special characters across a lot of tools untouched...
-extra_relative_rpaths = [
-  Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_native_lib_folder(current_folder: __dir__),
-  *Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
-]
-extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
-Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+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
@@ -102,6 +96,8 @@ Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.ins
 # 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")
+
 create_makefile(EXTENSION_NAME)
 
 # rubocop:enable Style/GlobalVars