ddtrace 1.4.2 → 1.19.0

data/ext/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -1,14 +1,42 @@
 #pragma once
 
-#include <ddprof/ffi.h>
+#include <datadog/profiling.h>
 #include "ruby_helpers.h"
 
-inline static ddprof_ffi_CharSlice char_slice_from_ruby_string(VALUE string) {
+inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
   ENFORCE_TYPE(string, T_STRING);
-  ddprof_ffi_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
+  ddog_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
   return char_slice;
 }
 
-inline static VALUE ruby_string_from_vec_u8(ddprof_ffi_Vec_u8 string) {
+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;
+}
+
+// Utility function to be able to extract an error cstring from a ddog_Error.
+// Returns the amount of characters written to string (which are necessarily
+// bounded by capacity - 1 since the string will be null-terminated).
+size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capacity);
+
+// Used for pretty printing this Ruby enum. Returns "T_UNKNOWN_OR_MISSING_RUBY_VALUE_TYPE_ENTRY" for unknown elements.
+// In practice, there's a few types that the profiler will probably never encounter, but I've added all entries of
+// ruby_value_type that Ruby uses so that we can also use this for debugging.
+const char *ruby_value_type_to_string(enum ruby_value_type type);
+ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type);
+
+// Returns a dynamically allocated string from the provided char slice.
+// WARN: The returned string must be explicitly freed with ruby_xfree.
+inline static char* string_from_char_slice(ddog_CharSlice slice) {
+  return ruby_strndup(slice.ptr, slice.len);
+}

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# typed: ignore
-
-require 'libdatadog'
+require 'rubygems'
 require 'pathname'
 
 module Datadog
@@ -14,8 +12,10 @@ module Datadog
       # 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'
 
-      # 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'
+      # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on debase-ruby_core_source
+      CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?('2.6', '2.7', '3.0.', '3.1.', '3.2.')
+
+      LIBDATADOG_VERSION = '~> 5.0.0.1.0'
 
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
@@ -31,8 +31,9 @@ module Datadog
       # 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 libdatadog. (This gets set automatically by the call
-      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog 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
@@ -68,7 +69,6 @@ module Datadog
 
       # 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,10 @@ module Datadog
             on_windows? ||
             on_macos? ||
             on_unknown_os? ||
-            not_on_amd64_or_arm64? ||
-            on_ruby_2_1? ||
+            on_unsupported_cpu_arch? ||
+            on_unsupported_ruby_version? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
+            libdatadog_not_available? ||
             libdatadog_not_usable?
         end
 
@@ -142,11 +143,6 @@ module Datadog
           '<https://dtdg.co/ruby-profiler-troubleshooting>.'
         ].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 :)',
-        ].freeze
-
         GET_IN_TOUCH = [
           "Get in touch with us if you're interested in profiling your app!"
         ].freeze
@@ -172,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'
@@ -240,22 +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_ruby_2_1?
+        private_class_method def self.on_unsupported_ruby_version?
           ruby_version_not_supported = explain_issue(
-            'the profiler only supports Ruby 2.2 or newer.',
+            'the profiler only supports Ruby 2.3 or newer.',
             suggested: UPGRADE_RUBY,
           )
 
-          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.')
+          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
@@ -271,6 +282,25 @@ module Datadog
           ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
         end
 
+        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 `libdatadog` gem installed on your system is missing binaries for your',
@@ -284,7 +314,6 @@ module Datadog
           no_binaries_for_current_platform unless Libdatadog.pkgconfig_folder
         end
       end
-      # rubocop:enable Metrics/ModuleLength
     end
   end
 end

data/ext/ddtrace_profiling_native_extension/pid_controller.c

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2023 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Originally imported from https://github.com/DataDog/java-profiler/blob/11fe6206c31a14c6e5134e8401eaec8b22c618d7/ddprof-lib/src/main/cpp/pidController.cpp
+
+#include "pid_controller.h"
+
+#include <math.h>
+
+inline static double computeAlpha(float cutoff) {
+    if (cutoff <= 0)
+        return 1;
+    // α(fₙ) = cos(2πfₙ) - 1 + √( cos(2πfₙ)² - 4 cos(2πfₙ) + 3 )
+    const double c = cos(2 * ((double) M_PI) * cutoff);
+    return c - 1 + sqrt(c * c - 4 * c + 3);
+}
+
+void pid_controller_init(pid_controller *controller, u64 target_per_second, double proportional_gain, double integral_gain, double derivative_gain, int sampling_window, double cutoff_secs) {
+    controller->_target = target_per_second * sampling_window;
+    controller->_proportional_gain = proportional_gain;
+    controller->_integral_gain = integral_gain * sampling_window;
+    controller->_derivative_gain = derivative_gain / sampling_window;
+    controller->_alpha = computeAlpha(sampling_window / cutoff_secs);
+    controller->_avg_error= 0;
+    controller->_integral_value = 0;
+}
+
+double pid_controller_compute(pid_controller *controller, u64 input, double time_delta_coefficient) {
+    // time_delta_coefficient allows variable sampling window
+    // the values are linearly scaled using that coefficient to reinterpret the given value within the expected sampling window
+    double absolute_error = (((double) controller->_target) - ((double) input)) * time_delta_coefficient;
+
+    double avg_error = (controller->_alpha * absolute_error) + ((1 - controller->_alpha) * controller->_avg_error);
+    double derivative = avg_error - controller->_avg_error;
+
+    // PID formula:
+    // u[k] = Kp e[k] + Ki e_i[k] + Kd e_d[k], control signal
+    double signal = controller->_proportional_gain * absolute_error + controller->_integral_gain * controller->_integral_value + controller->_derivative_gain * derivative;
+
+    controller->_integral_value += absolute_error;
+    controller->_avg_error = avg_error;
+
+    return signal;
+}

data/ext/ddtrace_profiling_native_extension/pid_controller.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2023 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Originally imported from https://github.com/DataDog/java-profiler/blob/11fe6206c31a14c6e5134e8401eaec8b22c618d7/ddprof-lib/src/main/cpp/pidController.h
+
+#ifndef _PIDCONTROLLER_H
+#define _PIDCONTROLLER_H
+
+// From arch.h in java-profiler
+typedef unsigned long long u64;
+
+/*
+ * A simple implementation of a PID controller.
+ * Heavily influenced by https://tttapa.github.io/Pages/Arduino/Control-Theory/Motor-Fader/PID-Cpp-Implementation.html 
+ */
+
+typedef struct {
+        u64 _target;
+        double _proportional_gain;
+        double _derivative_gain;
+        double _integral_gain;
+        double _alpha;
+
+        double _avg_error;
+        long long _integral_value;
+} pid_controller;
+
+void pid_controller_init(pid_controller *controller, u64 target_per_second, double proportional_gain, double integral_gain, double derivative_gain, int sampling_window, double cutoff_secs);
+        
+double pid_controller_compute(pid_controller *controller, u64 input, double time_delta_seconds);
+
+#endif