ddtrace 1.0.0 → 1.10.1

data/ext/ddtrace_profiling_native_extension/collectors_thread_context.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ruby.h>
+
+void thread_context_collector_sample(
+  VALUE self_instance,
+  long current_monotonic_wall_time_ns,
+  VALUE profiler_overhead_stack_thread
+);
+void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight);
+VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
+void thread_context_collector_on_gc_start(VALUE self_instance);
+void thread_context_collector_on_gc_finish(VALUE self_instance);
+VALUE enforce_thread_context_collector_instance(VALUE object);

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -1,105 +1,95 @@
-# typed: ignore
-
 # rubocop:disable Style/StderrPuts
-
-# Older Rubies don't have the MJIT header, used by the JIT compiler, so we need to use a different approach
-CAN_USE_MJIT_HEADER = RUBY_VERSION >= '2.6'
-
-def on_jruby?
-  # We don't support JRuby for profiling, and JRuby doesn't support native extensions, so let's just skip this entire
-  # thing so that JRuby users of dd-trace-rb aren't impacted.
-  RUBY_ENGINE == 'jruby'
-end
-
-def on_truffleruby?
-  # We don't officially support TruffleRuby for dd-trace-rb at all BUT let's not break adventurous customers that
-  # want to give it a try.
-  RUBY_ENGINE == 'truffleruby'
-end
-
-def on_windows?
-  # Microsoft Windows is unsupported, so let's not build the extension there.
-  Gem.win_platform?
-end
-
-def expected_to_use_mjit_but_mjit_is_disabled?
-  # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
-  # building the extension.
-  mjit_disabled = CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
-
-  if mjit_disabled
-    $stderr.puts(%(
-+------------------------------------------------------------------------------+
-| Your Ruby has been compiled without JIT support (--disable-jit-support).     |
-| The profiling native extension requires a Ruby compiled with JIT support,    |
-| even if the JIT is not in use by the application itself.                     |
-|                                                                              |
-| WARNING: Without the profiling native extension, some profiling features     |
-| will not be available.                                                       |
-+------------------------------------------------------------------------------+
-
-))
+# rubocop:disable Style/GlobalVars
+
+require_relative 'native_extension_helpers'
+
+SKIPPED_REASON_FILE = "#{__dir__}/skipped_reason.txt".freeze
+# Not a problem if the file doesn't exist or we can't delete it
+File.delete(SKIPPED_REASON_FILE) rescue nil
+
+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(
+      '[ddtrace] 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
 
-  mjit_disabled
-end
-
-def disabled_via_env?
-  # Experimental toggle to disable building the extension.
-  # Disabling the extension will lead to the profiler not working in future releases.
-  # If you needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.
-  ENV['DD_PROFILING_NO_EXTENSION'].to_s.downcase == 'true'
-end
-
-def skip_building_extension?
-  disabled_via_env? || on_jruby? || on_truffleruby? || on_windows? || expected_to_use_mjit_but_mjit_is_disabled?
-end
-
-# IMPORTANT: When adding flags, remember that our customers compile with a wide range of gcc/clang versions, so
-# doublecheck that what you're adding can be reasonably expected to work on their systems.
-def add_compiler_flag(flag)
-  $CFLAGS << ' ' << flag
-end
-
-def skip_building_extension!
-  File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
   exit
 end
 
-if skip_building_extension?
-  $stderr.puts(%(
-+------------------------------------------------------------------------------+
-| Skipping build of profiling native extension and replacing it with a no-op   |
-| Makefile                                                                     |
-+------------------------------------------------------------------------------+
-
-))
-  skip_building_extension!
+unless Datadog::Profiling::NativeExtensionHelpers::Supported.supported?
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported.unsupported_reason)
 end
 
-$stderr.puts(%(
+$stderr.puts(
+  %(
 +------------------------------------------------------------------------------+
-| ** Preparing to build the ddtrace native extension... **                     |
+| ** Preparing to build the ddtrace 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.         |
 |                                                                              |
-| Disabling the extension will lead to the ddtrace profiling features not      |
-| working in future releases.                                                  |
+| If you disable this extension, the Datadog Continuous Profiler will          |
+| not be available, but all other ddtrace 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 ddtrace! 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'
 
-# Gets really noisy when we include the MJIT header, let's omit it
+Logging.message("[ddtrace] Using compiler:\n")
+xsystem("#{CONFIG['CC']} -v")
+Logging.message("[ddtrace] End of compiler information\n")
+
+# mkmf on modern Rubies actually has an append_cflags that does something similar
+# (see https://github.com/ruby/ruby/pull/5760), but as usual we need a bit more boilerplate to deal with legacy Rubies
+def add_compiler_flag(flag)
+  if try_cflags(flag)
+    $CFLAGS << ' ' << flag
+  else
+    $stderr.puts("WARNING: '#{flag}' not accepted by compiler, skipping it")
+  end
+end
+
+# 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.
+add_compiler_flag '-Werror' if ENV['DDTRACE_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 ddtrace dependency
+#   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
+add_compiler_flag '-std=gnu99'
+
+# Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 add_compiler_flag '-Wno-unused-function'
 
 # Allow defining variables at any point in a function
@@ -109,6 +99,9 @@ add_compiler_flag '-Wno-declaration-after-statement'
 # cause a segfault later. Let's ensure that never happens.
 add_compiler_flag '-Werror-implicit-function-declaration'
 
+# Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+add_compiler_flag '-Wunused-parameter'
+
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
 # the sole exception being `Init_ddtrace_profiling_native_extension` which needs to be visible for Ruby to call it when
 # it `dlopen`s the library.
@@ -117,24 +110,91 @@ add_compiler_flag '-Werror-implicit-function-declaration'
 # For more details see https://gcc.gnu.org/wiki/Visibility
 add_compiler_flag '-fvisibility=hidden'
 
+# Avoid legacy C definitions
+add_compiler_flag '-Wold-style-definition'
+
+# Enable all other compiler warnings
+add_compiler_flag '-Wall'
+add_compiler_flag '-Wextra'
+
 if RUBY_PLATFORM.include?('linux')
   # Supposedly, the correct way to do this is
   # ```
   # have_library 'pthread'
   # have_func 'pthread_getcpuclockid'
   # ```
-  # but it broke the build on Windows and on older Ruby versions (2.1 and 2.2)
+  # but a) it broke the build on Windows, b) on older Ruby versions (2.2 and below) and c) 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'
 end
 
+# 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, there was no tid member in the internal thread structure
+$defs << '-DNO_THREAD_TID' if RUBY_VERSION < '3.1'
+
+# On older Rubies, we need to use a backported version of this function. See private_vm_api_access.h for details.
+$defs << '-DUSE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME' if RUBY_VERSION < '3'
+
+# On older Rubies, there are no Ractors
+$defs << '-DNO_RACTORS' if RUBY_VERSION < '3'
+
+# 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, we need to use rb_thread_t instead of rb_execution_context_t
+$defs << '-DUSE_THREAD_INSTEAD_OF_EXECUTION_CONTEXT' if RUBY_VERSION < '2.5'
+
+# On older Rubies, extensions can't use GET_VM()
+$defs << '-DNO_GET_VM' if RUBY_VERSION < '2.5'
+
+# On older Rubies...
+if RUBY_VERSION < '2.4'
+  # ...we need to use RUBY_VM_NORMAL_ISEQ_P instead of VM_FRAME_RUBYFRAME_P
+  $defs << '-DUSE_ISEQ_P_INSTEAD_OF_RUBYFRAME_P'
+  # ...we use a legacy copy of rb_vm_frame_method_entry
+  $defs << '-DUSE_LEGACY_RB_VM_FRAME_METHOD_ENTRY'
+end
+
+# If we got here, libdatadog is available and loaded
+ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
+Logging.message("[ddtrace] 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')
+  skip_building_extension!(
+    if Datadog::Profiling::NativeExtensionHelpers::Supported.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 method 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...
+$LDFLAGS += \
+  ' -Wl,-rpath,$$$\\\\{ORIGIN\\}/' \
+  "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
+Logging.message("[ddtrace] 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 = "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
 
-if CAN_USE_MJIT_HEADER
+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
@@ -146,61 +206,32 @@ if CAN_USE_MJIT_HEADER
   original_common_headers = MakeMakefile::COMMON_HEADERS
   MakeMakefile::COMMON_HEADERS = ''.freeze
   unless have_macro('RUBY_MJIT_H', mjit_header_file_name)
-    $stderr.puts(%(
-+------------------------------------------------------------------------------+
-| WARNING: Unable to compile a needed component for ddtrace native extension.  |
-| Your C compiler or Ruby VM just-in-time compiler seems to be broken.         |
-|                                                                              |
-| You will be NOT be able to use ddtrace profiling features,                   |
-| but all other features will work fine!                                       |
-|                                                                              |
-| For help solving this issue, please contact Datadog support at               |
-| <https://docs.datadoghq.com/help/>.                                          |
-+------------------------------------------------------------------------------+
-
-))
-    skip_building_extension!
+    skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILATION_BROKEN)
   end
   MakeMakefile::COMMON_HEADERS = original_common_headers
 
-  $defs << '-DUSE_MJIT_HEADER'
+  $defs << "-DRUBY_MJIT_HEADER='\"#{mjit_header_file_name}\"'"
 
   # NOTE: This needs to come after all changes to $defs
   create_header
 
-  # The MJIT header is always (afaik?) suffixed with the exact Ruby VM version,
-  # including patch (e.g. 2.7.2). Thus, we add to the header file a definition
-  # containing the exact file, so that it can be used in a #include in the C code.
-  header_contents =
-    File.read($extconf_h)
-        .sub('#endif',
-             <<-EXTCONF_H.strip
-#define RUBY_MJIT_HEADER "#{mjit_header_file_name}"
-
-#endif
-             EXTCONF_H
-            )
-  File.open($extconf_h, 'w') { |file| file.puts(header_contents) }
-
   create_makefile EXTENSION_NAME
 else
   # On older Rubies, we use the debase-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/ruby-debug/debase-ruby_core_source for details
 
-  thread_native_for_ruby_2_1 = proc { true }
-  if RUBY_VERSION < '2.2'
-    # This header became public in Ruby 2.2, but we need to pull it from the private headers folder for 2.1
-    thread_native_for_ruby_2_1 = proc { have_header('thread_native.h') }
-    $defs << '-DRUBY_2_1_WORKAROUND'
-  end
-
   create_header
 
   require 'debase/ruby_core_source'
   dir_config('ruby') # allow user to pass in non-standard core include directory
 
   Debase::RubyCoreSource
-    .create_makefile_with_core(proc { have_header('vm_core.h') && thread_native_for_ruby_2_1.call }, EXTENSION_NAME)
+    .create_makefile_with_core(
+      proc { have_header('vm_core.h') && have_header('iseq.h') },
+      EXTENSION_NAME,
+    )
 end
+
+# rubocop:enable Style/GlobalVars
 # rubocop:enable Style/StderrPuts

data/ext/ddtrace_profiling_native_extension/helpers.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// 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
+
+// @ivoanjo: After trying to read through https://stackoverflow.com/questions/3437404/min-and-max-in-c I decided I
+// don't like C and I just implemented this as a function.
+inline static uint64_t uint64_max_of(uint64_t a, uint64_t b) { return a > b ? a : b; }
+inline static uint64_t uint64_min_of(uint64_t a, uint64_t b) { return a > b ? b : a; }