cw-datadog 2.23.0.2

data/lib/datadog/profiling/scheduler.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "../core/utils/time"
+
+require_relative "../core/worker"
+require_relative "../core/workers/polling"
+require_relative "../core/telemetry/logger"
+
+module Datadog
+  module Profiling
+    # Periodically (every interval, 60 seconds by default) 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
+
+      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,
+        :profiler_failed
+
+      public
+
+      def initialize(
+        exporter:,
+        transport:,
+        interval:, fork_policy: Core::Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default, # seconds
+        enabled: true
+      )
+        @exporter = exporter
+        @transport = transport
+        @profiler_failed = false
+        @stop_requested = false
+
+        # 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)
+        # 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
+        Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
+        raise
+      ensure
+        Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
+      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
+
+      # This is called by the Profiler class whenever an issue happened in the profiler. This makes sure that even
+      # if there is data to be flushed, we don't try to flush it.
+      def mark_profiler_failed
+        @profiler_failed = true
+      end
+
+      def work_pending?
+        !profiler_failed && exporter.can_flush? && (run_loop? || !stop_requested?)
+      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 interval + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual interval seconds.
+        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 => e
+          Datadog.logger.warn(
+            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
+        end
+
+        @stop_requested = !run_loop?
+
+        true
+      end
+
+      def stop_requested?
+        @stop_requested
+      end
+    end
+  end
+end

data/lib/datadog/profiling/sequence_tracker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils/forking'
+
+module Datadog
+  module Profiling
+    # Used to generate the `profile_seq` tag, which effectively counts how many profiles we've attempted to report
+    # from a given runtime-id.
+    #
+    # Note that the above implies a few things:
+    # 1. The sequence number only gets incremented when we decide to report a profile and create a `Flush` for it
+    # 2. The `SequenceTracker` must live across profiler reconfigurations and resets, since no matter how many
+    #    profiler instances get created due to reconfiguration, the runtime-id is still the same, so the sequence number
+    #    should be kept and not restarted from 0
+    # 3. The `SequenceTracker` must be reset after a fork, since the runtime-id will change, and we want to start
+    #    counting from 0 again
+    #
+    # This is why this module is implemented as a singleton that we reuse, not as an instance that we recreate.
+    #
+    # Note that this module is not thread-safe, so it's up to the callers to make sure
+    # it's only used by a single thread at a time (which is what the `Profiling::Exporter`)
+    # is doing.
+    module SequenceTracker
+      class << self
+        include Core::Utils::Forking
+
+        def get_next
+          reset! unless defined?(@sequence_number)
+          after_fork! { reset! }
+
+          next_seq = @sequence_number
+          @sequence_number += 1
+          next_seq
+        end
+
+        private
+
+        def reset!
+          @sequence_number = 0
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/stack_recorder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../core/telemetry/logger"
+
+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:,
+        heap_samples_enabled:,
+        heap_size_enabled:,
+        heap_sample_every:,
+        timeline_enabled:,
+        heap_clean_after_gc_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_serialize_mutex = Mutex.new
+
+        self.class._native_initialize(
+          self_instance: self,
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+        )
+      end
+
+      def self.for_testing(
+        cpu_time_enabled: true,
+        alloc_samples_enabled: false,
+        heap_samples_enabled: false,
+        heap_size_enabled: false,
+        heap_sample_every: 1,
+        timeline_enabled: false,
+        heap_clean_after_gc_enabled: true,
+        **options
+      )
+        new(
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+          **options,
+        )
+      end
+
+      def serialize
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          start, finish, encoded_profile, profile_stats = result
+
+          Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
+
+          [start, finish, encoded_profile, profile_stats]
+        else
+          error_message = result
+
+          Datadog.logger.warn("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data (#{error_message})")
+
+          nil
+        end
+      end
+
+      def serialize!
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          _start, _finish, encoded_profile = result
+
+          encoded_profile
+        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
+
+      def stats
+        self.class._native_stats(self)
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tag_builder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../core/tag_builder'
+require_relative '../core/utils'
+
+require 'set'
+
+module Datadog
+  module Profiling
+    # Builds a hash of default plus user tags to be included in a profile
+    #
+    # @api private
+    module TagBuilder
+      include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
+
+      # When changing or adding profiling-related tags, make sure they are
+      # kept in sync with
+      # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
+      # (Datadog internal link).
+      #
+      # For consistency between the different profilers, every tag should be
+      # vetted before it gets reported with a profile, as otherwise it's too
+      # easy to end up with different tags in different languages.
+      ALLOWED_TAGS = Set.new(
+        [
+          'env',
+          'service',
+          'version',
+          'git.commit.sha',
+          'git.repository_url',
+          'host',
+          'language',
+          'runtime',
+          'runtime_engine',
+          'runtime_platform',
+          'runtime_version',
+          'runtime-id',
+          'process_id',
+          'profiler_version',
+          'profile_seq',
+        ]
+      ).freeze
+
+      def self.call(
+        settings:,
+        profile_seq:,
+        profiler_version: Core::Environment::Identity.gem_datadog_version
+      )
+        hash = Core::TagBuilder.tags(settings).merge(
+          FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
+          'profile_seq' => profile_seq.to_s,
+        )
+        user_tag_keys = settings.tags.keys
+        hash.keep_if { |tag| user_tag_keys.include?(tag) || ALLOWED_TAGS.include?(tag) }
+        Core::Utils.encode_tags(hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Wraps command with Datadog profiling
+      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"] # rubocop:disable CustomCops/EnvUsageCop
+
+          ENV["RUBYOPT"] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(" ")}" : rubyopts.join(" ") # rubocop:disable CustomCops/EnvUsageCop
+        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 "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.exit 127
+        rescue Errno::EACCES, Errno::ENOEXEC => e
+          Kernel.warn "ddprofrb 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,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Prints help message for usage of `ddprofrb`
+      class Help
+        def run
+          puts %(
+  Usage: ddprofrb [command] [arguments]
+    exec [command]: Executes command with profiling preloaded.
+    help:           Prints this help message.
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../core/utils/only_once"
+require_relative "../../core/utils/at_fork_monkey_patch"
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Takes care of restarting the profiler when the process forks
+      class Setup
+        ACTIVATE_EXTENSIONS_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
+        def run
+          ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
+            Datadog::Core::Utils::AtForkMonkeyPatch.apply!
+            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
+            Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
+          end
+        end
+
+        private
+
+        def setup_at_fork_hooks
+          Datadog::Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
+            # Restart profiler, if enabled
+            Profiling.start_if_enabled
+          rescue => e
+            Datadog.logger.warn do
+              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
+            end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+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
+      !!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.
+    # Note 3: This counter is not accurate when using the M:N scheduler.
+    #
+    # 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?
+    end
+
+    def self.wait_until_running(timeout_seconds: 5)
+      profiler = Datadog.send(:components).profiler
+      if profiler
+        # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+        worker = profiler.send(:worker)
+        worker.wait_until_running(timeout_seconds: timeout_seconds)
+      else
+        raise 'Profiler not enabled or available'
+      end
+    end
+
+    private_class_method def self.replace_noop_allocation_count
+      class << self
+        remove_method :allocation_count
+        def allocation_count
+          Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+        end
+      end
+    end
+
+    private_class_method def self.native_library_compilation_skipped?
+      skipped_reason = try_reading_skipped_reason_file
+
+      "Your datadog 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/datadog_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
+        # 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
+      require_relative 'profiling/load_native_extension'
+
+      success =
+        defined?(Profiling::NativeExtension) && Profiling::NativeExtension.send(:native_working?)
+      [success, nil]
+    rescue StandardError, LoadError => e
+      [false, e]
+    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/dir_monkey_patches'
+      require_relative 'profiling/collectors/info'
+      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/stack_recorder'
+      require_relative 'profiling/exporter'
+      require_relative 'profiling/encoded_profile'
+      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'
+      require_relative 'profiling/sequence_tracker'
+
+      replace_noop_allocation_count
+
+      true
+    end
+
+    load_profiling
+  end
+end

data/lib/datadog/single_step_instrument.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#
+# Entrypoint file for single step instrumentation.
+#
+# This file's path is private. Do not reference this file.
+#
+
+module Datadog
+  # This module handles conditional loading of single step auto-instrumentation,
+  # which enables Datadog tracing and profiling features when available.
+  module SingleStepInstrument
+  end
+end
+
+begin
+  require_relative 'auto_instrument'
+  Datadog::SingleStepInstrument::LOADED = true
+rescue StandardError, LoadError => e
+  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+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
+          span_op.set_metric(Metadata::Ext::Analytics::TAG_MEASURED, value)
+        end
+      end
+    end
+  end
+end