ddtrace 1.2.0 → 1.10.1

data/ext/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <datadog/profiling.h>
+#include "ruby_helpers.h"
+
+inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
+  ENFORCE_TYPE(string, T_STRING);
+  ddog_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
+  return char_slice;
+}
+
+inline static VALUE ruby_string_from_vec_u8(ddog_Vec_U8 string) {
+  return rb_str_new((char *) string.ptr, string.len);
+}
+
+inline static 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);
+}
+
+inline static VALUE get_error_details_and_drop(ddog_Error *error) {
+  VALUE result = ruby_string_from_error(error);
+  ddog_Error_drop(error);
+  return result;
+}

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# typed: ignore
-
-require 'libddprof'
+require 'rubygems'
 require 'pathname'
 
 module Datadog
@@ -17,34 +15,37 @@ module Datadog
       # 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'
 
+      LIBDATADOG_VERSION = '~> 2.0.0.1.0'
+
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
       end
 
       # Used as an workaround for a limitation with how dynamic linking works in environments where ddtrace and
-      # libddprof are moved after the extension gets compiled.
+      # libdatadog are moved after the extension gets compiled.
       #
       # Because the libddpprof native library is installed on a non-standard system path, in order for it to be
       # found by the system dynamic linker (e.g. what takes care of dlopen(), which is used to load the profiling
-      # native extension), we need to add a "runpath" -- a list of folders to search for libddprof.
+      # native extension), we need to add a "runpath" -- a list of folders to search for libdatadog.
       #
       # This runpath gets hardcoded at native library linking time. You can look at it using the `readelf` tool in
       # Linux: e.g. `readelf -d ddtrace_profiling_native_extension.2.7.3_x86_64-linux.so`.
       #
-      # In ddtrace 1.1.0, we only set as runpath an absolute path to libddprof. (This gets set automatically by the call
-      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libddprof was **NOT**
+      # In older versions of ddtrace, we only set as runpath an absolute path to libdatadog.
+      # (This gets set automatically by the call
+      # to `pkg_config('datadog_profiling_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog was **NOT**
       # moved from the folder it was present at ddtrace installation/linking time.
       #
       # Unfortunately, environments such as Heroku and AWS Elastic Beanstalk move gems around in the filesystem after
       # installation. Thus, the profiling native extension could not be loaded in these environments
-      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libddprof could not be found.
+      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libdatadog could not be found.
       #
       # To workaround this issue, this method computes the **relative** path between the folder where the profiling
-      # native extension is going to be installed and the folder where libddprof is installed, and returns it
+      # native extension is going to be installed and the folder where libdatadog is installed, and returns it
       # to be set as an additional runpath. (Yes, you can set multiple runpath folders to be searched).
       #
       # This way, if both gems are moved together (and it turns out that they are in these environments),
-      # the relative path can still be traversed to find libddprof.
+      # the relative path can still be traversed to find libdatadog.
       #
       # This is incredibly awful, and it's kinda bizarre how it's not possible to just find these paths at runtime
       # and set them correctly; rather than needing to set stuff at linking-time and then praying to $deity that
@@ -54,21 +55,20 @@ module Datadog
       # SET DYNAMICALLY**, e.g. it needs to be set at the start of the process (Ruby VM) and thus it's not something
       # we could setup when doing a `require`.
       #
-      def self.libddprof_folder_relative_to_native_lib_folder(
+      def self.libdatadog_folder_relative_to_native_lib_folder(
         current_folder: __dir__,
-        libddprof_pkgconfig_folder: Libddprof.pkgconfig_folder
+        libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
       )
-        return unless libddprof_pkgconfig_folder
+        return unless libdatadog_pkgconfig_folder
 
         profiling_native_lib_folder = "#{current_folder}/../../lib/"
-        libddprof_lib_folder = "#{libddprof_pkgconfig_folder}/../"
+        libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
 
-        Pathname.new(libddprof_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
+        Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
       end
 
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
       # system may not be supported.
-      # rubocop:disable Metrics/ModuleLength
       module Supported
         private_class_method def self.explain_issue(*reason, suggested:)
           { reason: reason, suggested: suggested }
@@ -85,9 +85,11 @@ module Datadog
             on_windows? ||
             on_macos? ||
             on_unknown_os? ||
-            not_on_amd64_or_arm64? ||
+            on_unsupported_cpu_arch? ||
+            on_unsupported_ruby_version? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
-            libddprof_not_usable?
+            libdatadog_not_available? ||
+            libdatadog_not_usable?
         end
 
         # This banner will show up in the logs/terminal while compiling the native extension
@@ -137,20 +139,21 @@ module Datadog
         CONTACT_SUPPORT = [
           'For help solving this issue, please contact Datadog support at',
           '<https://docs.datadoghq.com/help/>.',
-        ].freeze
-
-        REPORT_ISSUE = [
-          '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 :)',
+          'You can also check out the Continuous Profiler troubleshooting page at',
+          '<https://dtdg.co/ruby-profiler-troubleshooting>.'
         ].freeze
 
         GET_IN_TOUCH = [
           "Get in touch with us if you're interested in profiling your app!"
         ].freeze
 
+        UPGRADE_RUBY = [
+          'Upgrade to a modern Ruby to enable profiling for your app.'
+        ].freeze
+
         # Validation for this check is done in extconf.rb because it relies on mkmf
-        FAILED_TO_CONFIGURE_LIBDDPROF = explain_issue(
-          'there was a problem in setting up the `libddprof` dependency.',
+        FAILED_TO_CONFIGURE_LIBDATADOG = explain_issue(
+          'there was a problem in setting up the `libdatadog` dependency.',
           suggested: CONTACT_SUPPORT,
         )
 
@@ -165,18 +168,33 @@ module Datadog
         PKG_CONFIG_IS_MISSING = explain_issue(
           #+-----------------------------------------------------------------------------+
           'the `pkg-config` system tool is missing.',
-          'This issue can usually be fixed by installing:',
-          '1. the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;',
-          '2. the `pkgconf` package on Arch and Alpine-based Linux;',
-          '3. the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.',
+          'This issue can usually be fixed by installing one of the following:',
+          'the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;',
+          'the `pkgconf` package on Arch and Alpine-based Linux;',
+          'the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.',
+          '(Tip: When fixing this, ensure `pkg-config` is installed **before**',
+          'running `bundle install`, and remember to clear any installed gems cache).',
+          suggested: CONTACT_SUPPORT,
+        )
+
+        # Validation for this check is done in extconf.rb because it relies on mkmf
+        COMPILER_ATOMIC_MISSING = explain_issue(
+          'your C compiler is missing support for the <stdatomic.h> header.',
+          'This issue can usually be fixed by upgrading to a later version of your',
+          'operating system image or compiler.',
           suggested: CONTACT_SUPPORT,
         )
 
         private_class_method def self.disabled_via_env?
+          report_disabled = [
+            '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 :)',
+          ].freeze
+
           disabled_via_env = explain_issue(
             'the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to',
             '`true` during installation.',
-            suggested: REPORT_ISSUE,
+            suggested: report_disabled,
           )
 
           return unless ENV[ENV_NO_EXTENSION].to_s.strip.downcase == 'true'
@@ -233,13 +251,22 @@ module Datadog
           unknown_os_not_supported unless RUBY_PLATFORM.include?('darwin') || RUBY_PLATFORM.include?('linux')
         end
 
-        private_class_method def self.not_on_amd64_or_arm64?
+        private_class_method def self.on_unsupported_cpu_arch?
           architecture_not_supported = explain_issue(
             'your CPU architecture is not supported by the Datadog Continuous Profiler.',
             suggested: GET_IN_TOUCH,
           )
 
-          architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64')
+          architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64', 'arm64')
+        end
+
+        private_class_method def self.on_unsupported_ruby_version?
+          ruby_version_not_supported = explain_issue(
+            'the profiler only supports Ruby 2.3 or newer.',
+            suggested: UPGRADE_RUBY,
+          )
+
+          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.', '2.2.')
         end
 
         # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
@@ -255,20 +282,38 @@ module Datadog
           ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
         end
 
-        private_class_method def self.libddprof_not_usable?
+        private_class_method def self.libdatadog_not_available?
+          begin
+            gem 'libdatadog', LIBDATADOG_VERSION
+            require 'libdatadog'
+            nil
+          # rubocop:disable Lint/RescueException
+          rescue Exception => e
+            explain_issue(
+              'there was an exception during loading of the `libdatadog` gem:',
+              e.class.name,
+              *e.message.split("\n"),
+              *Array(e.backtrace),
+              '.',
+              suggested: CONTACT_SUPPORT,
+            )
+          end
+          # rubocop:enable Lint/RescueException
+        end
+
+        private_class_method def self.libdatadog_not_usable?
           no_binaries_for_current_platform = explain_issue(
-            'the `libddprof` gem installed on your system is missing binaries for your',
+            'the `libdatadog` gem installed on your system is missing binaries for your',
             'platform variant.',
             "(Your platform: `#{Gem::Platform.local}`)",
             '(Available binaries: ',
-            "`#{Libddprof.available_binaries.join('`, `')}`)",
+            "`#{Libdatadog.available_binaries.join('`, `')}`)",
             suggested: CONTACT_SUPPORT,
           )
 
-          no_binaries_for_current_platform unless Libddprof.pkgconfig_folder
+          no_binaries_for_current_platform unless Libdatadog.pkgconfig_folder
         end
       end
-      # rubocop:enable Metrics/ModuleLength
     end
   end
 end