datadog 2.38.0 → 2.40.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -8,6 +8,8 @@
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
   #include <ruby/thread_native.h>
   #include <ruby/vm.h>
+  typedef struct RubyCME rb_callable_method_entry_t;
+  typedef struct RubyISEQ rb_iseq_t;
 #endif
 
 #include "extconf.h"
@@ -20,18 +22,17 @@ typedef struct {
 
 // If a sample is kept around for later use, some of its fields need marking. Remember to
 // update the marking code in `sampling_buffer_mark` if new fields are added.
+// This is very similar to rb_backtrace_location_t (cme, iseq, pc) on purpose:
+// we want to show frames like Ruby backtraces,
+// not like rb_profile_frame_qualified_method_name() which differs in some cases.
 typedef struct {
-  union {
+  const rb_callable_method_entry_t* cme; // Needs marking, kept alive by sampling_buffer
+  struct {
     struct {
-      VALUE iseq; // Needs marking if kept around
+      const rb_iseq_t* iseq; // Needs marking, kept alive by sampling_buffer
       void *caching_pc; // For caching validation/invalidation only (does not need marking)
       int line;
     } ruby_frame;
-    struct {
-      VALUE caching_cme; // For caching validation/invalidation only (does not need marking)
-      ID method_id;
-      void *function;
-    } native_frame;
   } as;
   bool is_ruby_frame : 1;
   bool same_frame : 1;
@@ -48,8 +49,9 @@ VALUE thread_name_for(VALUE thread);
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 
 size_t sizeof_rb_iseq_t(void);
-VALUE ddtrace_iseq_base_label(const void *iseq);
-VALUE ddtrace_iseq_path(const void *iseq);
+size_t sizeof_rb_callable_method_entry_t(void);
+VALUE ddtrace_iseq_base_label(const rb_iseq_t *iseq);
+VALUE ddtrace_iseq_path(const rb_iseq_t *iseq);
 
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
@@ -84,4 +86,8 @@ VALUE current_fiber_for(VALUE thread);
 
 void self_test_current_fiber_for(void);
 
-bool pathobj_is_null(VALUE iseq);
+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);
+const char *ddtrace_cme_original_method_name(const rb_callable_method_entry_t *cme);
+

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/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/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,30 +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'
+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
@@ -70,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
@@ -96,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);
 }