ddtrace 0.54.2 → 1.18.0

data/lib/datadog/profiling/load_native_extension.rb

@@ -0,0 +1,26 @@
+# This file is used to load the profiling native extension. It works in two steps:
+#
+# 1. Load the ddtrace_profiling_loader extension. This extension will be used to load the actual extension, but in
+#    a special way that avoids exposing native-level code symbols. See `ddtrace_profiling_loader.c` for more details.
+#
+# 2. Use the Datadog::Profiling::Loader exposed by the ddtrace_profiling_loader extension to load the actual
+#    profiling native extension.
+#
+# All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
+# the first time it gets required, to avoid any issues with the native extension being initialized more than once.
+
+begin
+  require "ddtrace_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+rescue LoadError => e
+  raise LoadError,
+    'Failed to load the profiling loader extension. To fix this, please remove and then reinstall ddtrace ' \
+    "(Details: #{e.message})"
+end
+
+extension_name = "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+full_file_path = "#{__dir__}/../../#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+init_function_name = "Init_#{extension_name.split('.').first}"
+
+status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
+
+raise "Failure to load #{extension_name} due to #{result}" if status == :error

data/lib/datadog/profiling/native_extension.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # This module contains classes and methods which are implemented using native code in the
+    # ext/ddtrace_profiling_native_extension folder, as well as some Ruby-level utilities that don't make sense to
+    # write using C
+    module NativeExtension
+      private_class_method def self.working?
+        native_working?
+      end
+
+      unless singleton_class.private_method_defined?(:native_working?)
+        private_class_method def self.native_working?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/preload.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../../ddtrace'
+
+Datadog::Profiling.start_if_enabled

data/lib/datadog/profiling/profiler.rb

@@ -0,0 +1,62 @@
+module Datadog
+  module Profiling
+    # Profiling entry point, which coordinates the worker and scheduler threads
+    class Profiler
+      include Datadog::Core::Utils::Forking
+
+      private
+
+      attr_reader :worker, :scheduler
+
+      public
+
+      def initialize(worker:, scheduler:)
+        @worker = worker
+        @scheduler = scheduler
+      end
+
+      def start
+        after_fork! do
+          worker.reset_after_fork
+          scheduler.reset_after_fork
+        end
+
+        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
+      end
+
+      def shutdown!
+        Datadog.logger.debug('Shutting down profiler')
+
+        stop_worker
+        stop_scheduler
+      end
+
+      private
+
+      def stop_worker
+        worker.stop
+      end
+
+      def stop_scheduler
+        scheduler.enabled = false
+        scheduler.stop(true)
+      end
+
+      def component_failed(failed_component)
+        Datadog.logger.warn(
+          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+          'See previous log messages for details.'
+        )
+
+        if failed_component == :worker
+          stop_scheduler
+        elsif failed_component == :scheduler
+          stop_worker
+        else
+          raise ArgumentError, "Unexpected failed_component: #{failed_component.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/scheduler.rb

@@ -0,0 +1,137 @@
+require_relative '../core/utils/time'
+
+require_relative '../core/worker'
+require_relative '../core/workers/polling'
+
+module Datadog
+  module Profiling
+    # Periodically (every DEFAULT_INTERVAL_SECONDS) takes a profile from the `Exporter` and reports it using the
+    # configured transport. Runs on its own background thread.
+    class Scheduler < Core::Worker
+      include Core::Workers::Polling
+
+      DEFAULT_INTERVAL_SECONDS = 60
+      MINIMUM_INTERVAL_SECONDS = 0
+
+      # We sleep for at most this duration seconds before reporting data to avoid multi-process applications all
+      # reporting profiles at the exact same time
+      DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS = 3
+
+      private
+
+      attr_reader \
+        :exporter,
+        :transport
+
+      public
+
+      def initialize(
+        exporter:,
+        transport:,
+        fork_policy: Core::Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default
+        interval: DEFAULT_INTERVAL_SECONDS,
+        enabled: true
+      )
+        @exporter = exporter
+        @transport = transport
+
+        # Workers::Async::Thread settings
+        self.fork_policy = fork_policy
+
+        # Workers::IntervalLoop settings
+        self.loop_base_interval = interval
+
+        # Workers::Polling settings
+        self.enabled = enabled
+      end
+
+      def start(on_failure_proc: nil)
+        perform(on_failure_proc)
+      end
+
+      def perform(on_failure_proc)
+        begin
+          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+          # successfully finish in the strict timeout.
+          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+          interrupted = true
+
+          flush_and_wait
+          interrupted = false
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.warn(
+            'Profiling::Scheduler thread error. ' \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          on_failure_proc&.call
+          raise
+        ensure
+          Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
+        end
+      end
+
+      # Configure Workers::IntervalLoop to not report immediately when scheduler starts
+      #
+      # When a scheduler gets created (or reset), we don't want it to immediately try to flush; we want it to wait for
+      # the loop wait time first. This avoids an issue where the scheduler reported a mostly-empty profile if the
+      # application just started but this thread took a bit longer so there's already profiling data in the exporter.
+      def loop_wait_before_first_iteration?
+        true
+      end
+
+      def work_pending?
+        exporter.can_flush?
+      end
+
+      def reset_after_fork
+        exporter.reset_after_fork
+      end
+
+      private
+
+      def flush_and_wait
+        run_time = Core::Utils::Time.measure do
+          flush_events
+        end
+
+        # Update wait time to try to wake consistently on time.
+        # Don't drop below the minimum interval.
+        self.loop_wait_time = [loop_base_interval - run_time, MINIMUM_INTERVAL_SECONDS].max
+      end
+
+      def flush_events
+        # Collect data to be exported
+        flush = exporter.flush
+
+        return false unless flush
+
+        # Sleep for a bit to cause misalignment between profilers in multi-process applications
+        #
+        # When not being run in a loop, it means the scheduler has not been started or was stopped, and thus
+        # a) it's being shut down (and is trying to report the last profile)
+        # b) it's being run as a one-shot, usually in a test
+        # ...so in those cases we don't sleep
+        #
+        # During PR review (https://github.com/DataDog/dd-trace-rb/pull/1807) we discussed the possible alternative of
+        # just sleeping before starting the scheduler loop. We ended up not going with that option to avoid the first
+        # profile containing up to DEFAULT_INTERVAL_SECONDS + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual DEFAULT_INTERVAL_SECONDS size.
+        if run_loop?
+          jitter_seconds = rand * DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS # floating point number between (0.0...maximum)
+          sleep(jitter_seconds)
+        end
+
+        begin
+          transport.export(flush)
+        rescue StandardError => e
+          Datadog.logger.error(
+            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/datadog/profiling/stack_recorder.rb

@@ -0,0 +1,56 @@
+module Datadog
+  module Profiling
+    # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
+    # Note that `record_sample` is only accessible from native code.
+    # Methods prefixed with _native_ are implemented in `stack_recorder.c`
+    class StackRecorder
+      def initialize(cpu_time_enabled:, alloc_samples_enabled:)
+        # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
+        # It prevents multiple Ruby threads calling serialize at the same time -- something like
+        # `10.times { Thread.new { stack_recorder.serialize } }`.
+        # This isn't something we expect to happen normally, but because it would break the assumptions of the
+        # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
+        # accidentally happening.
+        @no_concurrent_synchronize_mutex = Mutex.new
+
+        self.class._native_initialize(self, cpu_time_enabled, alloc_samples_enabled)
+      end
+
+      def serialize
+        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          start, finish, encoded_pprof = result
+
+          Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
+
+          [start, finish, encoded_pprof]
+        else
+          error_message = result
+
+          Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
+
+          nil
+        end
+      end
+
+      def serialize!
+        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          _start, _finish, encoded_pprof = result
+
+          encoded_pprof
+        else
+          error_message = result
+
+          raise("Failed to serialize profiling data: #{error_message}")
+        end
+      end
+
+      def reset_after_fork
+        self.class._native_reset_after_fork(self)
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tag_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils'
+
+module Datadog
+  module Profiling
+    # Builds a hash of default plus user tags to be included in a profile
+    module TagBuilder
+      include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
+
+      def self.call(
+        settings:,
+        # Unified service tagging
+        env: settings.env,
+        service: settings.service,
+        version: settings.version,
+        # Other metadata
+        host: Core::Environment::Socket.hostname,
+        language: Core::Environment::Identity.lang,
+        pid: Process.pid.to_s,
+        profiler_version: Core::Environment::Identity.tracer_version,
+        runtime_engine: Core::Environment::Identity.lang_engine,
+        runtime_id: Core::Environment::Identity.id,
+        runtime_platform: Core::Environment::Identity.lang_platform,
+        runtime_version: Core::Environment::Identity.lang_version,
+        # User-provided tags
+        user_tags: settings.tags
+      )
+        tags = {
+          # When changing or adding these, make sure they are kept in sync with
+          # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/ (Datadog internal link)
+          FORM_FIELD_TAG_HOST => host,
+          FORM_FIELD_TAG_LANGUAGE => language,
+          FORM_FIELD_TAG_PID => pid,
+          FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
+          FORM_FIELD_TAG_RUNTIME => language, # This is known to be repeated from language, above
+          FORM_FIELD_TAG_RUNTIME_ENGINE => runtime_engine,
+          FORM_FIELD_TAG_RUNTIME_ID => runtime_id,
+          FORM_FIELD_TAG_RUNTIME_PLATFORM => runtime_platform,
+          FORM_FIELD_TAG_RUNTIME_VERSION => runtime_version,
+        }
+        tags[FORM_FIELD_TAG_ENV] = env if env
+        tags[FORM_FIELD_TAG_SERVICE] = service if service
+        tags[FORM_FIELD_TAG_VERSION] = version if version
+
+        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/libddprof/further downstream
+        user_tags.merge(tags).map do |key, value|
+          [Datadog::Core::Utils.utf8_encode(key), Datadog::Core::Utils.utf8_encode(value)]
+        end.to_h
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tasks/exec.rb

@@ -0,0 +1,48 @@
+module Datadog
+  module Profiling
+    module Tasks
+      # Wraps command with Datadog tracing
+      class Exec
+        attr_reader :args
+
+        def initialize(args)
+          @args = args
+        end
+
+        def run
+          set_rubyopt!
+          exec_with_error_handling(args)
+        end
+
+        def rubyopts
+          [
+            '-rdatadog/profiling/preload'
+          ]
+        end
+
+        private
+
+        def set_rubyopt!
+          existing_rubyopt = ENV['RUBYOPT']
+
+          ENV['RUBYOPT'] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(' ')}" : rubyopts.join(' ')
+        end
+
+        # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
+        # follow the same status codes as the shell uses
+        # See also:
+        # * https://www.gnu.org/software/bash/manual/html_node/Exit-Status.html
+        # * https://github.com/rubygems/rubygems/blob/dd93966cac224532035deda533cba2685dfa30cc/bundler/lib/bundler/cli/exec.rb#L45
+        def exec_with_error_handling(args)
+          Kernel.exec(*args)
+        rescue Errno::ENOENT => e
+          Kernel.warn "ddtracerb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.exit 127
+        rescue Errno::EACCES, Errno::ENOEXEC => e
+          Kernel.warn "ddtracerb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.exit 126
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tasks/help.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Profiling
+    module Tasks
+      # Prints help message for usage of `ddtrace`
+      class Help
+        def run
+          puts %(
+  Usage: ddtracerb [command] [arguments]
+    exec [command]: Executes command with tracing & profiling preloaded.
+    help:           Prints this help message.
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tasks/setup.rb

@@ -0,0 +1,58 @@
+require_relative '../../core/utils/only_once'
+require_relative '../ext/forking'
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
+      class Setup
+        ACTIVATE_EXTENSIONS_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
+        def run
+          ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
+            begin
+              activate_forking_extensions
+              setup_at_fork_hooks
+            rescue StandardError, ScriptError => e
+              Datadog.logger.warn do
+                "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+              end
+            end
+          end
+        end
+
+        private
+
+        def activate_forking_extensions
+          if Ext::Forking.supported?
+            Ext::Forking.apply!
+          elsif Datadog.configuration.profiling.enabled
+            Datadog.logger.debug('Profiler forking extensions skipped; forking not supported.')
+          end
+        rescue StandardError, ScriptError => e
+          Datadog.logger.warn do
+            "Profiler forking extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+            "Location: #{Array(e.backtrace).first}"
+          end
+        end
+
+        def setup_at_fork_hooks
+          if Process.respond_to?(:at_fork)
+            Process.at_fork(:child) do
+              begin
+                # Restart profiler, if enabled
+                Profiling.start_if_enabled
+              rescue StandardError => e
+                Datadog.logger.warn do
+                  "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+                  "Location: #{Array(e.backtrace).first}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling.rb

@@ -0,0 +1,150 @@
+require_relative 'core'
+require_relative 'core/environment/variable_helpers'
+require_relative 'core/utils/only_once'
+
+module Datadog
+  # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
+  module Profiling
+    def self.supported?
+      unsupported_reason.nil?
+    end
+
+    def self.unsupported_reason
+      # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons -- e.g. tell users
+      # first that they can't use this on JRuby before telling them that something else failed
+
+      native_library_compilation_skipped? || native_library_failed_to_load?
+    end
+
+    # Starts the profiler, if the profiler is supported by in
+    # this runtime environment and if the profiler has been enabled
+    # in configuration.
+    #
+    # @return [Boolean] `true` if the profiler has successfully started, otherwise `false`.
+    # @public_api
+    def self.start_if_enabled
+      # If the profiler was not previously touched, getting the profiler instance triggers start as a side-effect
+      # otherwise we get nil
+      profiler = Datadog.send(:components).profiler
+      # ...but we still try to start it BECAUSE if the process forks, the profiler will exist but may
+      # not yet have been started in the fork
+      profiler.start if profiler
+      !!profiler
+    end
+
+    # Returns an ever-increasing counter of the number of allocations observed by the profiler in this thread.
+    #
+    # Note 1: This counter may not start from zero on new threads. It should only be used to measure how many
+    # allocations have happened between two calls to this API:
+    # ```
+    # allocations_before = Datadog::Profiling.allocation_count
+    # do_some_work()
+    # allocations_after = Datadog::Profiling.allocation_count
+    # puts "Allocations during do_some_work: #{allocations_after - allocations_before}"
+    # ```
+    # (This is similar to some OS-based time representations.)
+    #
+    # Note 2: All fibers in the same thread will share the same counter values.
+    #
+    # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
+    #
+    # @return [Integer] number of allocations observed in the current thread.
+    # @return [nil] when not available.
+    # @public_api
+    def self.allocation_count
+      # This no-op implementation is used when profiling failed to load.
+      # It gets replaced inside #replace_noop_allocation_count.
+      nil
+    end
+
+    def self.enabled?
+      profiler = Datadog.send(:components).profiler
+      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+      !!(profiler.send(:scheduler).running? if profiler)
+    end
+
+    private_class_method def self.replace_noop_allocation_count
+      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
+        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      end
+    end
+
+    private_class_method def self.native_library_compilation_skipped?
+      skipped_reason = try_reading_skipped_reason_file
+
+      "Your ddtrace installation is missing support for the Continuous Profiler because #{skipped_reason}" if skipped_reason
+    end
+
+    private_class_method def self.try_reading_skipped_reason_file(file_api = File)
+      # This file, if it exists, is recorded by extconf.rb during compilation of the native extension
+      skipped_reason_file = "#{__dir__}/../../ext/ddtrace_profiling_native_extension/skipped_reason.txt"
+
+      begin
+        return unless file_api.exist?(skipped_reason_file)
+
+        contents = file_api.read(skipped_reason_file).strip
+        contents unless contents.empty?
+      rescue StandardError
+        # Do nothing
+      end
+    end
+
+    private_class_method def self.native_library_failed_to_load?
+      success, exception = try_loading_native_library
+
+      unless success
+        if exception
+          'There was an error loading the profiling native extension due to ' \
+          "'#{exception.class.name} #{exception.message}' at '#{Array(exception.backtrace).first}'"
+        else
+          'The profiling native extension did not load correctly. ' \
+          'For help solving this issue, please contact Datadog support at <https://docs.datadoghq.com/help/>.' \
+        end
+      end
+    end
+
+    private_class_method def self.try_loading_native_library
+      begin
+        require_relative 'profiling/load_native_extension'
+
+        success =
+          defined?(Profiling::NativeExtension) && Profiling::NativeExtension.send(:native_working?)
+        [success, nil]
+      rescue StandardError, LoadError => e
+        [false, e]
+      end
+    end
+
+    # All requires for the profiler should be directly added here; and everything should be loaded eagerly.
+    # (Currently there's a leftovers that need to be cleaned up, but we should avoid other exceptions.)
+    #
+    # All of the profiler should be loaded and ready to go when this method returns `true`.
+    private_class_method def self.load_profiling
+      return false unless supported?
+
+      require_relative 'profiling/ext/forking'
+      require_relative 'profiling/collectors/code_provenance'
+      require_relative 'profiling/collectors/cpu_and_wall_time_worker'
+      require_relative 'profiling/collectors/dynamic_sampling_rate'
+      require_relative 'profiling/collectors/idle_sampling_helper'
+      require_relative 'profiling/collectors/stack'
+      require_relative 'profiling/collectors/thread_context'
+      require_relative 'profiling/diagnostics/environment_logger'
+      require_relative 'profiling/stack_recorder'
+      require_relative 'profiling/exporter'
+      require_relative 'profiling/flush'
+      require_relative 'profiling/scheduler'
+      require_relative 'profiling/tasks/setup'
+      require_relative 'profiling/profiler'
+      require_relative 'profiling/native_extension'
+      require_relative 'profiling/tag_builder'
+      require_relative 'profiling/http_transport'
+
+      replace_noop_allocation_count
+
+      true
+    end
+
+    load_profiling
+  end
+end

data/lib/datadog/tracing/analytics.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'metadata/ext'
+
+module Datadog
+  module Tracing
+    # Defines analytics behavior
+    module Analytics
+      class << self
+        def set_sample_rate(span_op, sample_rate)
+          return if span_op.nil? || !sample_rate.is_a?(Numeric)
+
+          span_op.set_metric(Metadata::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate)
+        end
+
+        def set_measured(span_op, value = true)
+          return if span_op.nil?
+
+          value = value == true || value == 1 ? 1 : 0 # rubocop:disable Style/MultipleComparison
+          span_op.set_metric(Metadata::Ext::Analytics::TAG_MEASURED, value)
+        end
+      end
+    end
+  end
+end