cw-datadog 2.23.0.2

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#include "gvl_profiling_helper.h"
+
+void thread_context_collector_sample(
+  VALUE self_instance,
+  long current_monotonic_wall_time_ns,
+  VALUE profiler_overhead_stack_thread
+);
+__attribute__((warn_unused_result)) bool thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance);
+void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object);
+void thread_context_collector_sample_skipped_allocation_samples(VALUE self_instance, unsigned int skipped_samples);
+VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
+void thread_context_collector_on_gc_start(VALUE self_instance);
+__attribute__((warn_unused_result)) bool thread_context_collector_on_gc_finish(VALUE self_instance);
+VALUE enforce_thread_context_collector_instance(VALUE object);
+
+#ifndef NO_GVL_INSTRUMENTATION
+  typedef enum {
+    ON_GVL_RUNNING_UNKNOWN, // Thread is not known, it may not even be from the current Ractor
+    ON_GVL_RUNNING_DONT_SAMPLE, // Thread is known, but "Waiting for GVL" period was too small to be sampled
+    ON_GVL_RUNNING_SAMPLE, // Thread is known, and "Waiting for GVL" period should be sampled
+  } on_gvl_running_result;
+
+  void thread_context_collector_on_gvl_waiting(gvl_profiling_thread thread);
+  __attribute__((warn_unused_result)) on_gvl_running_result thread_context_collector_on_gvl_running(gvl_profiling_thread thread);
+  VALUE thread_context_collector_sample_after_gvl_running(VALUE self_instance, VALUE current_thread, long current_monotonic_wall_time_ns);
+#endif

data/ext/datadog_profiling_native_extension/datadog_ruby_common.c

@@ -0,0 +1,80 @@
+#include "datadog_ruby_common.h"
+
+// IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
+
+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
+      )
+    )
+  );
+}
+
+VALUE datadog_gem_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  ENFORCE_TYPE(ddtrace_module, T_MODULE);
+  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
+  ENFORCE_TYPE(version_module, T_MODULE);
+  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
+  ENFORCE_TYPE(version_string, T_STRING);
+  return version_string;
+}
+
+static VALUE log_failure_to_process_tag(VALUE err_details) {
+  return log_warning(rb_sprintf("Failed to convert tag: %"PRIsVALUE, err_details));
+}
+
+__attribute__((warn_unused_result))
+ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
+  ENFORCE_TYPE(tags_as_array, T_ARRAY);
+
+  long tags_count = RARRAY_LEN(tags_as_array);
+  ddog_Vec_Tag tags = ddog_Vec_Tag_new();
+
+  for (long i = 0; i < tags_count; i++) {
+    VALUE name_value_pair = rb_ary_entry(tags_as_array, i);
+
+    if (!RB_TYPE_P(name_value_pair, T_ARRAY)) {
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(name_value_pair, T_ARRAY);
+    }
+
+    // Note: We can index the array without checking its size first because rb_ary_entry returns Qnil if out of bounds
+    VALUE tag_name = rb_ary_entry(name_value_pair, 0);
+    VALUE tag_value = rb_ary_entry(name_value_pair, 1);
+
+    if (!(RB_TYPE_P(tag_name, T_STRING) && RB_TYPE_P(tag_value, T_STRING))) {
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(tag_name, T_STRING);
+      ENFORCE_TYPE(tag_value, T_STRING);
+    }
+
+    ddog_Vec_Tag_PushResult push_result =
+      ddog_Vec_Tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
+
+    if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
+      // libdatadog validates tags and may catch invalid tags that ddtrace didn't actually catch.
+      // We warn users about such tags, and then just ignore them.
+
+      int exception_state;
+      rb_protect(log_failure_to_process_tag, get_error_details_and_drop(&push_result.err), &exception_state);
+
+      // Since we are calling into Ruby code, it may raise an exception. Ensure that dynamically-allocated tags
+      // get cleaned before propagating the exception.
+      if (exception_state) {
+        ddog_Vec_Tag_drop(tags);
+        rb_jump_tag(exception_state);  // "Re-raise" exception
+      }
+    }
+  }
+
+  return tags;
+}

data/ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -0,0 +1,63 @@
+#pragma once
+
+// IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
+
+#include <ruby.h>
+#include <datadog/common.h>
+
+// Used to mark symbols to be exported to the outside of the extension.
+// Consider very carefully before tagging a function with this.
+#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
+
+// Used to mark function arguments that are deliberately left unused
+#ifdef __GNUC__
+  #define DDTRACE_UNUSED  __attribute__((unused))
+#else
+  #define DDTRACE_UNUSED
+#endif
+
+#define ADD_QUOTES_HELPER(x) #x
+#define ADD_QUOTES(x) ADD_QUOTES_HELPER(x)
+
+// Ruby has a Check_Type(value, type) that is roughly equivalent to this BUT Ruby's version is rather cryptic when it fails
+// e.g. "wrong argument type nil (expected String)". This is a replacement that prints more information to help debugging.
+#define ENFORCE_TYPE(value, type) \
+  { if (RB_UNLIKELY(!RB_TYPE_P(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
+#define ENFORCE_BOOLEAN(value) \
+  { if (RB_UNLIKELY(value != Qtrue && value != Qfalse)) raise_unexpected_type(value, ADD_QUOTES(value), "true or false", __FILE__, __LINE__, __func__); }
+
+#define ENFORCE_TYPED_DATA(value, type) \
+  { if (RB_UNLIKELY(!rb_typeddata_is_kind_of(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), "TypedData of type " ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
+NORETURN(void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char* function_name));
+
+// Helper to retrieve Datadog::VERSION::STRING
+VALUE datadog_gem_version(void);
+
+static inline ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
+  ENFORCE_TYPE(string, T_STRING);
+  ddog_CharSlice char_slice = {.ptr = RSTRING_PTR(string), .len = RSTRING_LEN(string)};
+  return char_slice;
+}
+
+static inline VALUE log_warning(VALUE warning) {
+  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  VALUE logger = rb_funcall(datadog_module, rb_intern("logger"), 0);
+
+  return rb_funcall(logger, rb_intern("warn"), 1, warning);
+}
+
+__attribute__((warn_unused_result))
+ddog_Vec_Tag convert_tags(VALUE tags_as_array);
+
+static inline VALUE ruby_string_from_error(const ddog_Error *error) {
+  ddog_CharSlice char_slice = ddog_Error_message(error);
+  return rb_str_new(char_slice.ptr, char_slice.len);
+}
+
+static inline VALUE get_error_details_and_drop(ddog_Error *error) {
+  VALUE result = ruby_string_from_error(error);
+  ddog_Error_drop(error);
+  return result;
+}

data/ext/datadog_profiling_native_extension/encoded_profile.c

@@ -0,0 +1,79 @@
+#include "encoded_profile.h"
+#include "datadog_ruby_common.h"
+#include "libdatadog_helpers.h"
+
+// This class exists to wrap a ddog_prof_EncodedProfile into a Ruby object
+// This file implements the native bits of the Datadog::Profiling::EncodedProfile class
+
+static void encoded_profile_typed_data_free(void *state_ptr);
+static VALUE _native_bytes(VALUE self);
+
+static VALUE encoded_profile_class = Qnil;
+
+void encoded_profile_init(VALUE profiling_module) {
+  encoded_profile_class = rb_define_class_under(profiling_module, "EncodedProfile", rb_cObject);
+
+  rb_undef_alloc_func(encoded_profile_class); // Class cannot be created from Ruby code
+  rb_global_variable(&encoded_profile_class);
+
+  rb_define_method(encoded_profile_class, "_native_bytes", _native_bytes, 0);
+}
+
+// This structure is used to define a Ruby object that stores a `ddog_prof_EncodedProfile`
+// See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
+static const rb_data_type_t encoded_profile_typed_data = {
+  .wrap_struct_name = "Datadog::Profiling::EncodedProfile",
+  .function = {
+    .dmark = NULL, // We don't store references to Ruby objects so we don't need to mark any of them
+    .dfree = encoded_profile_typed_data_free,
+    .dsize = NULL, // We don't track memory usage (although it'd be cool if we did!)
+    //.dcompact = NULL, // Not needed -- we don't store references to Ruby objects
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile) {
+  ddog_prof_EncodedProfile *state = ruby_xcalloc(1, sizeof(ddog_prof_EncodedProfile));
+  *state = profile;
+  return TypedData_Wrap_Struct(encoded_profile_class, &encoded_profile_typed_data, state);
+}
+
+static ddog_ByteSlice get_bytes(ddog_prof_EncodedProfile *state) {
+  ddog_prof_Result_ByteSlice raw_bytes = ddog_prof_EncodedProfile_bytes(state);
+  if (raw_bytes.tag == DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE) {
+    rb_raise(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
+  }
+  return raw_bytes.ok;
+}
+
+static ddog_prof_EncodedProfile *internal_to_ddog_prof_EncodedProfile(VALUE object) {
+  ddog_prof_EncodedProfile *state;
+  TypedData_Get_Struct(object, ddog_prof_EncodedProfile, &encoded_profile_typed_data, state);
+  return state;
+}
+
+ddog_prof_EncodedProfile *to_ddog_prof_EncodedProfile(VALUE object) {
+  ddog_prof_EncodedProfile *state = internal_to_ddog_prof_EncodedProfile(object);
+  get_bytes(state); // Validate profile is still usable -- if it's not, this will raise an exception
+  return state;
+}
+
+static void encoded_profile_typed_data_free(void *state_ptr) {
+  ddog_prof_EncodedProfile *state = (ddog_prof_EncodedProfile *) state_ptr;
+
+  // This drops the profile itself
+  ddog_prof_EncodedProfile_drop(state);
+
+  // This drops the tiny bit of memory we allocated to contain the ` ddog_prof_EncodedProfile` struct
+  ruby_xfree(state);
+}
+
+static VALUE _native_bytes(VALUE self) {
+  ddog_ByteSlice bytes = get_bytes(internal_to_ddog_prof_EncodedProfile(self));
+  return rb_str_new((const char *) bytes.ptr, bytes.len);
+}
+
+VALUE enforce_encoded_profile_instance(VALUE object) {
+  ENFORCE_TYPED_DATA(object, &encoded_profile_typed_data);
+  return object;
+}

data/ext/datadog_profiling_native_extension/encoded_profile.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <ruby.h>
+#include <datadog/profiling.h>
+
+VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile);
+VALUE enforce_encoded_profile_instance(VALUE object);
+ddog_prof_EncodedProfile *to_ddog_prof_EncodedProfile(VALUE object);

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -0,0 +1,321 @@
+# rubocop:disable Style/StderrPuts
+# rubocop:disable Style/GlobalVars
+
+require_relative "native_extension_helpers"
+require_relative "../libdatadog_extconf_helpers"
+
+SKIPPED_REASON_FILE = "#{__dir__}/skipped_reason.txt".freeze
+# Not a problem if the file doesn't exist or we can't delete it
+begin
+  File.delete(SKIPPED_REASON_FILE)
+rescue
+  nil
+end
+
+def skip_building_extension!(reason)
+  fail_install_if_missing_extension =
+    Datadog::Profiling::NativeExtensionHelpers.fail_install_if_missing_extension?
+
+  $stderr.puts(
+    Datadog::Profiling::NativeExtensionHelpers::Supported.failure_banner_for(
+      **reason,
+      fail_install: fail_install_if_missing_extension,
+    )
+  )
+
+  File.write(
+    SKIPPED_REASON_FILE,
+    Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason),
+  )
+
+  if fail_install_if_missing_extension
+    require "mkmf"
+    Logging.message(
+      "[datadog] Failure cause: " \
+      "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
+    )
+  else
+    File.write("Makefile", "all install clean: # dummy makefile that does nothing")
+  end
+
+  exit
+end
+
+unless Datadog::Profiling::NativeExtensionHelpers::Supported.supported?
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported.unsupported_reason)
+end
+
+$stderr.puts(
+  %(
++------------------------------------------------------------------------------+
+| ** Preparing to build the datadog profiling native extension... **           |
+|                                                                              |
+| If you run into any failures during this step, you can set the               |
+| `DD_PROFILING_NO_EXTENSION` environment variable to `true` e.g.              |
+| `$ DD_PROFILING_NO_EXTENSION=true bundle install` to skip this step.         |
+|                                                                              |
+| If you disable this extension, the Datadog Continuous Profiler will          |
+| not be available, but all other datadog features will work fine!             |
+|                                                                              |
+| If you needed to use this, please tell us why on                             |
+| <https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :\)      |
+|                                                                              |
+| Thanks for using datadog! You rock!                                          |
++------------------------------------------------------------------------------+
+
+)
+)
+
+# NOTE: we MUST NOT require 'mkmf' before we check the #skip_building_extension? because the require triggers checks
+# that may fail on an environment not properly setup for building Ruby extensions.
+require "mkmf"
+
+Logging.message("[datadog] Using compiler:\n")
+xsystem("#{CONFIG["CC"]} -v")
+Logging.message("[datadog] End of compiler information\n")
+
+# 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"
+
+# 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"
+
+# Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
+append_cflags "-Wno-unused-function"
+
+# Allow defining variables at any point in a function
+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"
+
+# The native extension is not intended to expose any symbols/functions for other native libraries to use;
+# the sole exception being `Init_datadog_profiling_native_extension` which needs to be visible for Ruby to call it when
+# it `dlopen`s the library.
+#
+# 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"
+
+# Avoid legacy C definitions
+append_cflags "-Wold-style-definition"
+
+# Enable all other compiler warnings
+append_cflags "-Wall"
+append_cflags "-Wextra"
+
+if ENV["DDTRACE_DEBUG"] == "true"
+  $defs << "-DDD_DEBUG"
+  CONFIG["optflags"] = "-O0"
+  CONFIG["debugflags"] = "-ggdb3"
+end
+
+if RUBY_PLATFORM.include?("linux")
+  # Supposedly, the correct way to do this is
+  # ```
+  # have_library 'pthread'
+  # have_func 'pthread_getcpuclockid'
+  # ```
+  # but it's slower to build
+  # so instead we just assume that we have the function we need on Linux, and nowhere else
+  $defs << "-DHAVE_PTHREAD_GETCPUCLOCKID"
+
+  # Not available on macOS
+  $defs << "-DHAVE_CLOCK_MONOTONIC_COARSE"
+end
+
+have_func "malloc_stats"
+
+# Used to get native filenames (dladdr1 is preferred, so we only check for the other if not available)
+# Note it's possible none are available
+if have_header("dlfcn.h")
+  (have_struct_member("struct link_map", "l_name", "link.h") && have_func("dladdr1")) ||
+    have_func("dladdr")
+end
+
+# On Ruby 3.5, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
+$defs << "-DNO_IMEMO_OBJECT_ID" unless RUBY_VERSION < "3.5"
+
+# On Ruby 2.5 and 3.3, this symbol was not visible. It is on 2.6 to 3.2, as well as 3.4+
+$defs << "-DNO_RB_OBJ_INFO" if RUBY_VERSION.start_with?("2.5", "3.3")
+
+# On older Rubies, rb_postponed_job_preregister/rb_postponed_job_trigger did not exist
+$defs << "-DNO_POSTPONED_TRIGGER" if RUBY_VERSION < "3.3"
+
+# On older Rubies, M:N threads were not available
+$defs << "-DNO_MN_THREADS_AVAILABLE" if RUBY_VERSION < "3.3"
+
+# On older Rubies, we did not need to include the ractor header (this was built into the MJIT header)
+$defs << "-DNO_RACTOR_HEADER_INCLUDE" if RUBY_VERSION < "3.3"
+
+# On older Rubies, some of the Ractor internal APIs were directly accessible
+$defs << "-DUSE_RACTOR_INTERNAL_APIS_DIRECTLY" if RUBY_VERSION < "3.3"
+
+# On older Rubies, there was no GVL instrumentation API and APIs created to support it
+$defs << "-DNO_GVL_INSTRUMENTATION" if RUBY_VERSION < "3.2"
+
+# Supporting GVL instrumentation on 3.2 needs some workarounds
+$defs << "-DUSE_GVL_PROFILING_3_2_WORKAROUNDS" if RUBY_VERSION.start_with?("3.2")
+
+# On older Rubies, there was no struct rb_native_thread. See private_vm_api_acccess.c for details.
+$defs << "-DNO_RB_NATIVE_THREAD" if RUBY_VERSION < "3.2"
+
+# On older Rubies, there was no struct rb_thread_sched (it was struct rb_global_vm_lock_struct)
+$defs << "-DNO_RB_THREAD_SCHED" if RUBY_VERSION < "3.2"
+
+# On older Rubies, the first_lineno inside a location was a VALUE and not a int (https://github.com/ruby/ruby/pull/6430)
+$defs << "-DNO_INT_FIRST_LINENO" if RUBY_VERSION < "3.2"
+
+# On older Rubies, "pop" was not a primitive operation
+$defs << "-DNO_PRIMITIVE_POP" if RUBY_VERSION < "3.2"
+
+# We could support this for older Rubies, but since this only gets used by the OTEL context extraction, and that
+# use-case is only for 3.1+, we didn't bother supporting it farther back yet.
+$defs << "-DNO_CURRENT_FIBER_FOR" if RUBY_VERSION < "3.1"
+
+# On older Rubies, there was no tid member in the internal thread structure
+$defs << "-DNO_THREAD_TID" if RUBY_VERSION < "3.1"
+
+# On older Rubies, there was no jit_return member on the rb_control_frame_t struct
+$defs << "-DNO_JIT_RETURN" if RUBY_VERSION < "3.1"
+
+# On older Rubies, there are no Ractors
+$defs << "-DNO_RACTORS" if RUBY_VERSION < "3"
+
+# On older Rubies, rb_imemo_name did not exist
+$defs << "-DNO_IMEMO_NAME" if RUBY_VERSION < "3"
+
+# On older Rubies, objects would not move
+$defs << "-DNO_T_MOVED" if RUBY_VERSION < "2.7"
+
+# On older Rubies, rb_global_vm_lock_struct did not include the owner field
+$defs << "-DNO_GVL_OWNER" if RUBY_VERSION < "2.6"
+
+# On older Rubies, there was no thread->invoke_arg
+$defs << "-DNO_THREAD_INVOKE_ARG" if RUBY_VERSION < "2.6"
+
+# 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")
+
+  skip_building_extension!(
+    if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
+      Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
+    else
+      # Less specific error message
+      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG
+    end
+  )
+end
+
+unless have_type("atomic_int", ["stdatomic.h"])
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
+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")
+
+# 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 = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
+
+if Datadog::Profiling::NativeExtensionHelpers::CAN_USE_MJIT_HEADER
+  mjit_header_file_name = "rb_mjit_min_header-#{RUBY_VERSION}.h"
+
+  # Validate that the mjit header can actually be compiled on this system. We learned via
+  # https://github.com/DataDog/dd-trace-rb/issues/1799 and https://github.com/DataDog/dd-trace-rb/issues/1792
+  # that even if the header seems to exist, it may not even compile.
+  # `have_macro` actually tries to compile a file that mentions the given macro, so if this passes, we should be good to
+  # use the MJIT header.
+  # Finally, the `COMMON_HEADERS` conflict with the MJIT header so we need to temporarily disable them for this check.
+  original_common_headers = MakeMakefile::COMMON_HEADERS
+  MakeMakefile::COMMON_HEADERS = "".freeze
+  unless have_macro("RUBY_MJIT_H", mjit_header_file_name)
+    skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILATION_BROKEN)
+  end
+  MakeMakefile::COMMON_HEADERS = original_common_headers
+
+  $defs << "-DRUBY_MJIT_HEADER='\"#{mjit_header_file_name}\"'"
+
+  # NOTE: This needs to come after all changes to $defs
+  create_header
+
+  # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+  # See the comment on the same flag below for why this is done last.
+  append_cflags "-Wunused-parameter"
+
+  create_makefile EXTENSION_NAME
+else
+  # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on
+  # the datadog-ruby_core_source gem to get access to private VM headers.
+  # This gem ships source code copies of these VM headers for the different Ruby VM versions;
+  # see https://github.com/DataDog/datadog-ruby_core_source for details
+
+  create_header
+
+  require "datadog/ruby_core_source"
+  dir_config("ruby") # allow user to pass in non-standard core include directory
+
+  # This is a workaround for a weird issue...
+  #
+  # The mkmf tool defines a `with_cppflags` helper that datadog-ruby_core_source uses. This helper temporarily
+  # replaces `$CPPFLAGS` (aka the C pre-processor [not c++!] flags) with a different set when doing something.
+  #
+  # The datadog-ruby_core_source gem uses `with_cppflags` during makefile generation to inject extra headers into the
+  # path. But because `with_cppflags` replaces `$CPPFLAGS`, well, the default `$CPPFLAGS` are not included in the
+  # makefile.
+  #
+  # This is a problem because the default `$CPPFLAGS` carries configuration that was set when Ruby was being built.
+  # Thus, if we ignore it, we don't compile the profiler with the exact same configuration as Ruby.
+  # In practice, this can generate crashes and weird bugs if the Ruby configuration is tweaked in a manner that
+  # changes some of the internal structures that the profiler relies on. Concretely, setting for instance
+  # `VM_CHECK_MODE=1` when building Ruby will trigger this issue (because somethings in structures the profiler reads
+  # are ifdef'd out using this setting).
+  #
+  # To workaround this issue, we override `with_cppflags` for datadog-ruby_core_source to still include `$CPPFLAGS`.
+  Datadog::RubyCoreSource.define_singleton_method(:with_cppflags) do |newflags, &block|
+    super("#{newflags} #{$CPPFLAGS}", &block)
+  end
+
+  Datadog::RubyCoreSource
+    .create_makefile_with_core(
+      proc do
+        headers_available =
+          have_header("vm_core.h") &&
+          have_header("iseq.h") &&
+          (RUBY_VERSION < "3.3" || have_header("ractor_core.h"))
+
+        if headers_available
+          # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+          # This is added as late as possible because in some Rubies we support (e.g. 3.3), adding this flag before
+          # checking if internal VM headers are available causes those checks to fail because of this warning (and not
+          # because the headers are not available.)
+          append_cflags "-Wunused-parameter"
+        end
+
+        headers_available
+      end,
+      EXTENSION_NAME,
+    )
+end
+
+# rubocop:enable Style/GlobalVars
+# rubocop:enable Style/StderrPuts

data/ext/datadog_profiling_native_extension/gvl_profiling_helper.c

@@ -0,0 +1,52 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+
+#include "datadog_ruby_common.h"
+#include "gvl_profiling_helper.h"
+
+#if !defined(NO_GVL_INSTRUMENTATION) && !defined(USE_GVL_PROFILING_3_2_WORKAROUNDS) // Ruby 3.3+
+  rb_internal_thread_specific_key_t gvl_waiting_tls_key;
+
+  void gvl_profiling_init(void) {
+    gvl_waiting_tls_key = rb_internal_thread_specific_key_create();
+  }
+
+#endif
+
+#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
+  __thread gvl_profiling_thread gvl_waiting_tls;
+  static bool gvl_profiling_state_thread_tracking_workaround_installed = false;
+
+  static void on_thread_start(
+    DDTRACE_UNUSED rb_event_flag_t _unused1,
+    DDTRACE_UNUSED const rb_internal_thread_event_data_t *_unused2,
+    DDTRACE_UNUSED void *_unused3
+  ) {
+    gvl_waiting_tls = (gvl_profiling_thread) {.thread = NULL};
+  }
+
+  // Hack: We're using the gvl_waiting_tls native thread-local to store per-thread information. Unfortunately, Ruby puts a big hole
+  // in our plan because it reuses native threads -- specifically, in Ruby 3.2, native threads are still 1:1 to Ruby
+  // threads (M:N wasn't a thing yet) BUT once a Ruby thread dies, the VM will keep the native thread around for a
+  // bit, and if another Ruby thread starts right after, Ruby will reuse the native thread, rather than create a new one.
+  //
+  // This will mean that the new Ruby thread will still have the same native thread-local data that we set on the
+  // old thread. For the purposes of our tracking, where we're keeping a pointer to the current thread object in
+  // thread-local storage **this is disastrous** since it means we'll be pointing at the wrong thread (and its
+  // memory may have been freed or reused since!)
+  //
+  // To work around this issue, once GVL profiling is enabled, we install an event hook on thread start
+  // events that clears the thread-local data. This guarantees that there will be no stale data -- any existing
+  // data will be cleared at thread start.
+  //
+  // Note that once installed, this event hook becomes permanent -- stopping the profiler does not stop this event
+  // hook, unlike all others. This is because we can't afford to miss any thread start events while the
+  // profiler is stopped (e.g. during reconfiguration) as that would mean stale data once the profiler starts again.
+  void gvl_profiling_state_thread_tracking_workaround(void) {
+    if (gvl_profiling_state_thread_tracking_workaround_installed) return;
+
+    rb_internal_thread_add_event_hook(on_thread_start, RUBY_INTERNAL_THREAD_EVENT_STARTED, NULL);
+
+    gvl_profiling_state_thread_tracking_workaround_installed = true;
+  }
+#endif