datadog 2.2.0 → 2.4.0

data/ext/{datadog_profiling_native_extension → libdatadog_api}/crashtracker.c

@@ -1,15 +1,25 @@
 #include <ruby.h>
-#include <datadog/common.h>
-#include <libdatadog_helpers.h>
+#include <datadog/crashtracker.h>
+
+#include "datadog_ruby_common.h"
 
 static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self);
+static void crashtracker_init(VALUE crashtracking_module);
 
 // Used to report Ruby VM crashes.
 // Once initialized, segfaults will be reported automatically using libdatadog.
 
-void crashtracker_init(VALUE profiling_module) {
-  VALUE crashtracker_class = rb_define_class_under(profiling_module, "Crashtracker", rb_cObject);
+void DDTRACE_EXPORT Init_libdatadog_api(void) {
+  VALUE datadog_module = rb_define_module("Datadog");
+  VALUE core_module = rb_define_module_under(datadog_module, "Core");
+  VALUE crashtracking_module = rb_define_module_under(core_module, "Crashtracking");
+
+  crashtracker_init(crashtracking_module);
+}
+
+void crashtracker_init(VALUE crashtracking_module) {
+  VALUE crashtracker_class = rb_define_class_under(crashtracking_module, "Component", rb_cObject);
 
   rb_define_singleton_method(crashtracker_class, "_native_start_or_update_on_fork", _native_start_or_update_on_fork, -1);
   rb_define_singleton_method(crashtracker_class, "_native_stop", _native_stop, 0);
@@ -18,8 +28,9 @@ void crashtracker_init(VALUE profiling_module) {
 static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
   VALUE options;
   rb_scan_args(argc, argv, "0:", &options);
+  if (options == Qnil) options = rb_hash_new();
 
-  VALUE exporter_configuration = rb_hash_fetch(options, ID2SYM(rb_intern("exporter_configuration")));
+  VALUE agent_base_url = rb_hash_fetch(options, ID2SYM(rb_intern("agent_base_url")));
   VALUE path_to_crashtracking_receiver_binary = rb_hash_fetch(options, ID2SYM(rb_intern("path_to_crashtracking_receiver_binary")));
   VALUE ld_library_path = rb_hash_fetch(options, ID2SYM(rb_intern("ld_library_path")));
   VALUE tags_as_array = rb_hash_fetch(options, ID2SYM(rb_intern("tags_as_array")));
@@ -29,7 +40,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
   VALUE start_action = ID2SYM(rb_intern("start"));
   VALUE update_on_fork_action = ID2SYM(rb_intern("update_on_fork"));
 
-  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
+  ENFORCE_TYPE(agent_base_url, T_STRING);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
   ENFORCE_TYPE(path_to_crashtracking_receiver_binary, T_STRING);
   ENFORCE_TYPE(ld_library_path, T_STRING);
@@ -38,14 +49,14 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   if (action != start_action && action != update_on_fork_action) rb_raise(rb_eArgError, "Unexpected action: %+"PRIsVALUE, action);
 
-  VALUE version = ddtrace_version();
-  ddog_prof_Endpoint endpoint = endpoint_from(exporter_configuration);
+  VALUE version = datadog_gem_version();
 
-  // Tags are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
+  // Tags and endpoint are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
   // Start of exception-free zone to prevent leaks {{
+  ddog_Endpoint *endpoint = ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
-  ddog_prof_CrashtrackerConfiguration config = {
+  ddog_crasht_Config config = {
     .additional_files = {},
     // The Ruby VM already uses an alt stack to detect stack overflows so the crash handler must not overwrite it.
     //
@@ -57,23 +68,26 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     // "Process.kill('SEGV', Process.pid)" gets run.
     .create_alt_stack = false,
     .endpoint = endpoint,
-    .resolve_frames = DDOG_PROF_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
+    .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
     .timeout_secs = FIX2INT(upload_timeout_seconds),
+    // Waits for crash tracker to finish reporting the issue before letting the Ruby process die; see
+    // https://github.com/DataDog/libdatadog/pull/477 for details
+    .wait_for_receiver = true,
   };
 
-  ddog_prof_CrashtrackerMetadata metadata = {
-    .profiling_library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
-    .profiling_library_version = char_slice_from_ruby_string(version),
+  ddog_crasht_Metadata metadata = {
+    .library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
+    .library_version = char_slice_from_ruby_string(version),
     .family = DDOG_CHARSLICE_C("ruby"),
     .tags = &tags,
   };
 
-  ddog_prof_EnvVar ld_library_path_env = {
+  ddog_crasht_EnvVar ld_library_path_env = {
     .key = DDOG_CHARSLICE_C("LD_LIBRARY_PATH"),
     .val = char_slice_from_ruby_string(ld_library_path),
   };
 
-  ddog_prof_CrashtrackerReceiverConfig receiver_config = {
+  ddog_crasht_ReceiverConfig receiver_config = {
     .args = {},
     .env = {.ptr = &ld_library_path_env, .len = 1},
     .path_to_receiver_binary = char_slice_from_ruby_string(path_to_crashtracking_receiver_binary),
@@ -81,16 +95,17 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     .optional_stdout_filename = {},
   };
 
-  ddog_prof_CrashtrackerResult result =
+  ddog_crasht_Result result =
     action == start_action ?
-      ddog_prof_Crashtracker_init(config, receiver_config, metadata) :
-      ddog_prof_Crashtracker_update_on_fork(config, receiver_config, metadata);
+      ddog_crasht_init_with_receiver(config, receiver_config, metadata) :
+      ddog_crasht_update_on_fork(config, receiver_config, metadata);
 
   // Clean up before potentially raising any exceptions
   ddog_Vec_Tag_drop(tags);
+  ddog_endpoint_drop(endpoint);
   // }} End of exception-free zone to prevent leaks
 
-  if (result.tag == DDOG_PROF_CRASHTRACKER_RESULT_ERR) {
+  if (result.tag == DDOG_CRASHT_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to start/update the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
@@ -98,9 +113,9 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 }
 
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
-  ddog_prof_CrashtrackerResult result = ddog_prof_Crashtracker_shutdown();
+  ddog_crasht_Result result = ddog_crasht_shutdown();
 
-  if (result.tag == DDOG_PROF_CRASHTRACKER_RESULT_ERR) {
+  if (result.tag == DDOG_CRASHT_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to stop the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -0,0 +1,83 @@
+#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) {
+  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, 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/libdatadog_api/datadog_ruby_common.h

@@ -0,0 +1,53 @@
+#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/profiling.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__); }
+
+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;
+}
+
+__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/libdatadog_api/extconf.rb

@@ -0,0 +1,108 @@
+# rubocop:disable Style/StderrPuts
+# rubocop:disable Style/GlobalVars
+
+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'
+
+  if fail_install_if_missing_extension
+    require 'mkmf'
+    Logging.message("[datadog] Failure cause: #{reason}")
+  else
+    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')
+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!('issue setting up `libdatadog` gem') if Datadog::LibdatadogExtconfHelpers.libdatadog_issue?
+
+require 'mkmf'
+
+# 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'
+
+# 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'
+
+# Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+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
+# 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 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")
+
+  if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
+    skip_building_extension!('the `pkg-config` system tool is missing')
+  else
+    skip_building_extension!('there was a problem in setting up the `libdatadog` dependency')
+  end
+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 = "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}".freeze
+
+create_makefile(EXTENSION_NAME)
+
+# rubocop:enable Style/GlobalVars
+# rubocop:enable Style/StderrPuts

data/ext/libdatadog_api/macos_development.md

@@ -0,0 +1,26 @@
+# Developing on macOS
+
+As of this writing (August 2024), the libdatadog builds on rubygems.org only support Linux.
+
+We don't officially support using libdatadog for Ruby on other platforms yet, but it is possible to use it for local development on macOS.
+(**Note that you don't need these instructions if you develop inside docker.**)
+
+Here's how you can do so:
+
+1. [Install rust](https://www.rust-lang.org/tools/install)
+2. Install `cbindgen`: `cargo install cbindgen`
+3. Clone [libdatadog](https://github.com/datadog/libdatadog)
+4. Create a folder for building into based on your ruby platform:
+
+```
+export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
+mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
+```
+
+5. Build libdatadog into this folder: `./build-profiling-ffi.sh my-libdatadog-build/$DD_RUBY_PLATFORM`
+6. Tell the Ruby where to find libdatadog: `export LIBDATADOG_VENDOR_OVERRIDE=/full/path/to/my-libdatadog-build/` (Notice no platform here)
+7. Run `bundle exec rake clean compile`
+
+If you additionally want to run the profiler test suite, also remember to `export DD_PROFILING_MACOS_TESTING=true` and re-run `rake clean compile`.
+
+These instructions can quickly get outdated, so feel free to open an issue if they're not working (and/or ping @ivoanjo).

data/ext/libdatadog_extconf_helpers.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'pathname'
+
+module Datadog
+  # Contains a bunch of shared helpers that get used during building of extensions that link to libdatadog
+  module LibdatadogExtconfHelpers
+    # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
+    # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
+    LIBDATADOG_VERSION = '~> 12.0.0.1.0'
+
+    # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
+    # libdatadog are moved after the extension gets compiled.
+    #
+    # Because the libdatadog 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
+    # native extensions), 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 datadog_profiling_native_extension.2.7.3_x86_64-linux.so`.
+    #
+    # In older versions of the datadog gem, 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 datadog gem 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 libdatadog could not be found.
+    #
+    # To workaround this issue, this method computes the **relative** path between the folder where
+    # native extensions are 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 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
+    # weird moves don't happen.
+    #
+    # As a curiosity, `LD_LIBRARY_PATH` can be used to influence the folders that get searched but **CANNOT BE
+    # 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.libdatadog_folder_relative_to_native_lib_folder(
+      current_folder:,
+      libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
+    )
+      return unless libdatadog_pkgconfig_folder
+
+      native_lib_folder = "#{current_folder}/../../lib/"
+      libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
+
+      Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(native_lib_folder)).to_s
+    end
+
+    # In https://github.com/DataDog/dd-trace-rb/pull/3582 we got a report of a customer for which the native extension
+    # only got installed into the extensions folder.
+    #
+    # But then this fix was not enough to fully get them moving because then they started to see the issue from
+    # https://github.com/DataDog/dd-trace-rb/issues/2067 / https://github.com/DataDog/dd-trace-rb/pull/2125 :
+    #
+    # > Profiling was requested but is not supported, profiling disabled: There was an error loading the profiling
+    # > native extension due to 'RuntimeError Failure to load datadog_profiling_native_extension.3.2.2_x86_64-linux
+    # > due to libdatadog_profiling.so: cannot open shared object file: No such file or directory
+    #
+    # The problem is that when loading the native extension from the extensions directory, the relative rpath we add
+    # with the #libdatadog_folder_relative_to_native_lib_folder helper above is not correct, we need to add a relative
+    # rpath to the extensions directory.
+    #
+    # So how do we find the full path where the native extension is placed?
+    # * From https://github.com/ruby/ruby/blob/83f02d42e0a3c39661dc99c049ab9a70ff227d5b/lib/bundler/runtime.rb#L166
+    #   `extension_dirs = Dir["#{Gem.dir}/extensions/*/*/*"] + Dir["#{Gem.dir}/bundler/gems/extensions/*/*/*"]`
+    #   we get that's in one of two fixed subdirectories of `Gem.dir`
+    # * From https://github.com/ruby/ruby/blob/83f02d42e0a3c39661dc99c049ab9a70ff227d5b/lib/rubygems/basic_specification.rb#L111-L115
+    #   we get the structure of the subdirectory (platform/extension_api_version/gem_and_version)
+    #
+    # Thus, `Gem.dir` of `/var/app/current/vendor/bundle/ruby/3.2.0` becomes (for instance)
+    # `/var/app/current/vendor/bundle/ruby/3.2.0/extensions/x86_64-linux/3.2.0/datadog-2.0.0/` or
+    # `/var/app/current/vendor/bundle/ruby/3.2.0/bundler/gems/extensions/x86_64-linux/3.2.0/datadog-2.0.0/`
+    #
+    # We then compute the relative path between these folders and the libdatadog folder, and use that as a relative path.
+    def self.libdatadog_folder_relative_to_ruby_extensions_folders(
+      gem_dir: Gem.dir,
+      libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
+    )
+      return unless libdatadog_pkgconfig_folder
+
+      # For the purposes of calculating a folder relative to the other, we don't actually NEED to fill in the
+      # platform, extension_api_version and gem version. We're basically just after how many folders it is deep from
+      # the Gem.dir.
+      expected_ruby_extensions_folders = [
+        "#{gem_dir}/extensions/platform/extension_api_version/datadog_version/",
+        "#{gem_dir}/bundler/gems/extensions/platform/extension_api_version/datadog_version/",
+      ]
+      libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
+
+      expected_ruby_extensions_folders.map do |folder|
+        Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(folder)).to_s
+      end
+    end
+
+    # mkmf sets $PKGCONFIG after the `pkg_config` gets used in extconf.rb. When `pkg_config` is unsuccessful, we use
+    # this helper to decide if we can show more specific error message vs a generic "something went wrong".
+    def self.pkg_config_missing?(command: $PKGCONFIG) # rubocop:disable Style/GlobalVars
+      pkg_config_available = command && xsystem("#{command} --version")
+
+      pkg_config_available != true
+    end
+
+    def self.try_loading_libdatadog
+      gem 'libdatadog', LIBDATADOG_VERSION
+      require 'libdatadog'
+      nil
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      if block_given?
+        yield e
+      else
+        e
+      end
+    end
+
+    def self.libdatadog_issue?
+      try_loading_libdatadog { |_exception| return true }
+      Libdatadog.pkgconfig_folder.nil?
+    end
+  end
+end