Move into prof extension

Author: gyuheon0h

Rakefile

@@ -64,8 +64,8 @@ namespace :test do
         command = "bundle check || bundle install && bundle exec rake #{spec_task}"
         command += "'[#{spec_arguments}]'" if spec_arguments
 
-        total_executors = ENV.key?('CIRCLE_NODE_TOTAL') ? ENV['CIRCLE_NODE_TOTAL'].to_i : nil
-        current_executor = ENV.key?('CIRCLE_NODE_INDEX') ? ENV['CIRCLE_NODE_INDEX'].to_i : nil
+        total_executors = Datadog::DATADOG_ENV.key?('CIRCLE_NODE_TOTAL') ? Datadog::DATADOG_ENV['CIRCLE_NODE_TOTAL'].to_i : nil
+        current_executor = Datadog::DATADOG_ENV.key?('CIRCLE_NODE_INDEX') ? Datadog::DATADOG_ENV['CIRCLE_NODE_INDEX'].to_i : nil
 
         if total_executors && current_executor && total_executors > 1
           @execution_count ||= 0
@@ -232,7 +232,7 @@ namespace :spec do
     Rake::Task[t.name].enhance(
       [
         "compile:libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}",
-        "compile:datadog_runtime_stacks.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}"
+        "compile:datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
       ]
     )
   end
@@ -467,11 +467,11 @@ namespace :coverage do
   task :report do
     require 'simplecov'
 
-    resultset_files = Dir["#{ENV.fetch("COVERAGE_DIR", "coverage")}/.resultset.json"] +
-      Dir["#{ENV.fetch("COVERAGE_DIR", "coverage")}/versions/**/.resultset.json"]
+    resultset_files = Dir["#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/.resultset.json"] +
+      Dir["#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/versions/**/.resultset.json"]
 
     SimpleCov.collate resultset_files do
-      coverage_dir "#{ENV.fetch("COVERAGE_DIR", "coverage")}/report"
+      coverage_dir "#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/report"
       formatter SimpleCov::Formatter::HTMLFormatter
     end
   end
@@ -481,11 +481,11 @@ namespace :coverage do
     require 'simplecov'
     require_relative 'spec/support/simplecov_fix'
 
-    versions = Dir["#{ENV.fetch("COVERAGE_DIR", "coverage")}/versions/*"].map { |f| File.basename(f) }
+    versions = Dir["#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/versions/*"].map { |f| File.basename(f) }
     versions.map do |version|
       puts "Generating report for: #{version}"
-      SimpleCov.collate Dir["#{ENV.fetch("COVERAGE_DIR", "coverage")}/versions/#{version}/**/.resultset.json"] do
-        coverage_dir "#{ENV.fetch("COVERAGE_DIR", "coverage")}/report/versions/#{version}"
+      SimpleCov.collate Dir["#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/versions/#{version}/**/.resultset.json"] do
+        coverage_dir "#{Datadog::DATADOG_ENV.fetch("COVERAGE_DIR", "coverage")}/report/versions/#{version}"
         formatter SimpleCov::Formatter::HTMLFormatter
       end
     end
@@ -505,10 +505,6 @@ NATIVE_EXTS = [
     ext.ext_dir = 'ext/libdatadog_api'
   end,
 
-  Rake::ExtensionTask.new("datadog_runtime_stacks.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}") do |ext|
-    ext.ext_dir = 'ext/datadog_runtime_stacks'
-  end,
-
   Rake::ExtensionTask.new("datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}") do |ext|
     ext.ext_dir = 'ext/datadog_profiling_native_extension'
   end,

datadog.gemspec

@@ -83,7 +83,6 @@ Gem::Specification.new do |spec|
 
   spec.extensions = [
     'ext/datadog_profiling_native_extension/extconf.rb',
-    'ext/datadog_runtime_stacks/extconf.rb',
     'ext/libdatadog_api/extconf.rb'
   ]
 end

ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -6,14 +6,19 @@ module Profiling
     module NativeExtensionHelpers
       # Can be set when customers want to skip compiling the native extension entirely
       ENV_NO_EXTENSION = "DD_PROFILING_NO_EXTENSION"
+      LEGACY_ENV_NO_EXTENSION = "DD_NO_EXTENSION"
       # Can be set to force rubygems to fail gem installation when profiling extension could not be built
       ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = "DD_PROFILING_FAIL_INSTALL_IF_MISSING_EXTENSION"
+      LEGACY_ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = "DD_FAIL_INSTALL_IF_MISSING_EXTENSION"
 
       # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on datadog-ruby_core_source
       CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?("2.6", "2.7", "3.0.", "3.1.", "3.2.")
 
       def self.fail_install_if_missing_extension?
-        ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == "true"
+        [
+          ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION],
+          ENV[LEGACY_ENV_FAIL_INSTALL_IF_MISSING_EXTENSION],
+        ].any? { |value| value.to_s.strip.downcase == "true" }
       end
 
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
@@ -131,15 +136,19 @@ def self.render_skipped_reason_file(reason:, suggested:)
             "<https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :)",
           ].freeze
 
-          disabled_via_env = explain_issue(
-            "the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to",
+          env_var =
+            [
+              ENV_NO_EXTENSION,
+              LEGACY_ENV_NO_EXTENSION,
+            ].find { |var| ENV[var].to_s.strip.downcase == "true" }
+
+          return unless env_var
+
+          explain_issue(
+            "the `#{env_var}` environment variable is/was set to",
             "`true` during installation.",
             suggested: report_disabled,
           )
-
-          return unless ENV[ENV_NO_EXTENSION].to_s.strip.downcase == "true"
-
-          disabled_via_env
         end
 
         private_class_method def self.on_jruby?

ext/datadog_profiling_native_extension/profiling.c

@@ -9,6 +9,7 @@
 #include "helpers.h"
 #include "private_vm_api_access.h"
 #include "ruby_helpers.h"
+#include "runtime_stacks.h"
 #include "setup_signal_handler.h"
 #include "time_helpers.h"
 #include "unsafe_api_calls_check.h"
@@ -65,6 +66,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   encoded_profile_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
+  runtime_stacks_init(datadog_module);
   unsafe_api_calls_check_init();
 
   // Hosts methods used for testing the native code using RSpec

ext/datadog_runtime_stacks/runtime_stacks.c renamed to ext/datadog_profiling_native_extension/runtime_stacks.c

@@ -32,9 +32,10 @@
   #endif
 #endif
 
-#include <datadog/crashtracker.h>
 #include "runtime_stacks.h"
+#include <datadog/crashtracker.h>
 #include "datadog_ruby_common.h"
+#include "private_vm_api_access.h"
 #include <sys/mman.h>
 #include <unistd.h>
 #include <errno.h>
@@ -310,58 +311,7 @@ static void ruby_runtime_stack_callback(
       const char *function_name = "<C method>";
       const char *file_name = "<C extension>";
 
-#ifdef RUBY_MJIT_HEADER
-      // Only attempt method entry resolution on Ruby versions with MJIT header
-      // where rb_vm_frame_method_entry is guaranteed to be available
-      const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
-      if (me && is_pointer_readable(me, sizeof(rb_callable_method_entry_t))) {
-        if (me->def && is_pointer_readable(me->def, sizeof(*me->def))) {
-          if (me->def->original_id) {
-            const char *method_name = rb_id2name(me->def->original_id);
-            if (method_name && is_pointer_readable(method_name, strlen(method_name))) {
-              size_t method_name_len = strlen(method_name);
-              if (method_name_len > 0 && method_name_len < 256) {
-                function_name = method_name;
-              }
-            }
-          }
-
-          if (me->def->type == VM_METHOD_TYPE_CFUNC && me->owner) {
-            // Try to get the full class/module path
-            VALUE owner_name = Qnil;
-            VALUE actual_owner = me->owner;
-
-            // If this is a singleton class (like Fiddle's singleton class for module methods),
-            // try to get the attached object which should be the actual module or else we will
-            // just get `Module` which is not that useful to us
-            if (RB_TYPE_P(me->owner, T_CLASS) && FL_TEST(me->owner, FL_SINGLETON)) {
-              VALUE attached = rb_ivar_get(me->owner, rb_intern("__attached__"));
-              if (attached != Qnil) {
-                actual_owner = attached;
-              }
-            }
-
-            // Get the class/module path
-            if (RB_TYPE_P(actual_owner, T_CLASS) || RB_TYPE_P(actual_owner, T_MODULE)) {
-              owner_name = rb_class_path(actual_owner);
-            }
-
-            // Fallback to rb_class_name if rb_class_path fails
-            if (owner_name == Qnil) {
-              owner_name = rb_class_name(actual_owner);
-            }
-
-            if (owner_name != Qnil) {
-              const char *owner_str = safe_string_ptr(owner_name);
-              static char file_buffer[256];
-              snprintf(file_buffer, sizeof(file_buffer), "<%s (C extension)>", owner_str);
-              file_name = file_buffer;
-            }
-          }
-        }
-      }
-#else
-      // For Ruby versions without MJIT header, use our own rb_vm_frame_method_entry implementation
+      // Resolve Ruby C frames via rb_vm_frame_method_entry (Ruby or our fallback depending on version)
       const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
       if (me && is_pointer_readable(me, sizeof(rb_callable_method_entry_t))) {
         if (me->def && is_pointer_readable(me->def, sizeof(*me->def))) {
@@ -408,7 +358,6 @@ static void ruby_runtime_stack_callback(
           }
         }
       }
-#endif
 
       ddog_crasht_RuntimeStackFrame frame = {
         .type_name = char_slice_from_cstr(NULL),
@@ -424,58 +373,6 @@ static void ruby_runtime_stack_callback(
   }
 }
 
-// Support code for Ruby versions without MJIT header (copied from private_vm_api_access.c)
-#ifndef RUBY_MJIT_HEADER
-
-#define MJIT_STATIC // No-op on older Rubies
-
-#ifndef FALSE
-# define FALSE false
-#elif FALSE
-# error FALSE must be false
-#endif
-
-#ifndef TRUE
-# define TRUE true
-#elif ! TRUE
-# error TRUE must be true
-#endif
-
-static rb_callable_method_entry_t *
-check_method_entry(VALUE obj, int can_be_svar)
-{
-    if (obj == Qfalse) return NULL;
-
-    switch (imemo_type(obj)) {
-      case imemo_ment:
-        return (rb_callable_method_entry_t *)obj;
-      case imemo_cref:
-        return NULL;
-      case imemo_svar:
-        if (can_be_svar) {
-            return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
-        }
-        // fallthrough
-      default:
-        return NULL;
-    }
-}
-
-MJIT_STATIC const rb_callable_method_entry_t *
-rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
-{
-    const VALUE *ep = cfp->ep;
-    rb_callable_method_entry_t *me;
-
-    while (!VM_ENV_LOCAL_P(ep)) {
-        if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
-        ep = VM_ENV_PREV_EP(ep);
-    }
-
-    return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
-}
-#endif // RUBY_MJIT_HEADER
-
 static VALUE _native_register_runtime_stack_callback(DDTRACE_UNUSED VALUE _self) {
   enum ddog_crasht_CallbackResult result = ddog_crasht_register_runtime_frame_callback(
     ruby_runtime_stack_callback
@@ -495,10 +392,20 @@ static VALUE _native_is_runtime_callback_registered(DDTRACE_UNUSED VALUE _self)
   return ddog_crasht_is_runtime_callback_registered() ? Qtrue : Qfalse;
 }
 
-void DDTRACE_EXPORT Init_datadog_runtime_stacks(void) {
-  VALUE datadog_module = rb_define_module("Datadog");
+void runtime_stacks_init(VALUE datadog_module) {
   VALUE runtime_stacks_class = rb_define_class_under(datadog_module, "RuntimeStacks", rb_cObject);
 
-  rb_define_singleton_method(runtime_stacks_class, "_native_register_runtime_stack_callback", _native_register_runtime_stack_callback, 0);
-  rb_define_singleton_method(runtime_stacks_class, "_native_is_runtime_callback_registered", _native_is_runtime_callback_registered, 0);
+  rb_define_singleton_method(
+    runtime_stacks_class,
+    "_native_register_runtime_stack_callback",
+    _native_register_runtime_stack_callback,
+    0
+  );
+  rb_define_singleton_method(
+    runtime_stacks_class,
+    "_native_is_runtime_callback_registered",
+    _native_is_runtime_callback_registered,
+    0
+  );
 }
+

ext/datadog_profiling_native_extension/runtime_stacks.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void runtime_stacks_init(VALUE datadog_module);
+