ddtrace 0.34.1 → 1.23.1

data/lib/datadog/profiling/stack_recorder.rb

@@ -0,0 +1,71 @@
+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:
+      )
+        # 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,
+          heap_samples_enabled,
+          heap_size_enabled,
+          heap_sample_every,
+          timeline_enabled,
+        )
+      end
+
+      def serialize
+        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          start, finish, encoded_pprof, profile_stats = result
+
+          Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
+
+          [start, finish, encoded_pprof, profile_stats]
+        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
+
+      def stats
+        self.class._native_stats(self)
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tag_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils'
+require_relative '../core/environment/git'
+
+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,
+        git_repository_url: Core::Environment::Git.git_repository_url,
+        git_commit_sha: Core::Environment::Git.git_commit_sha,
+        # 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
+        tags[TAG_GIT_REPOSITORY_URL] = git_repository_url if git_repository_url
+        tags[TAG_GIT_COMMIT_SHA] = git_commit_sha if git_commit_sha
+
+        # 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 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']
+
+          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 "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,16 @@
+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,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,161 @@
+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
+
+    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
+      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/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 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/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/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

data/lib/datadog/tracing/buffer.rb

@@ -0,0 +1,127 @@
+require_relative '../core/environment/ext'
+require_relative '../core/buffer/thread_safe'
+require_relative '../core/buffer/cruby'
+require_relative '../core/diagnostics/health'
+
+module Datadog
+  module Tracing
+    # Health metrics for trace buffers.
+    module MeasuredBuffer
+      def initialize(*_)
+        super
+
+        @buffer_accepted = 0
+        @buffer_accepted_lengths = 0
+        @buffer_dropped = 0
+        @buffer_spans = 0
+      end
+
+      def add!(trace)
+        super
+
+        # Emit health metrics
+        measure_accept(trace)
+      end
+
+      def add_all!(traces)
+        super
+
+        # Emit health metrics
+        traces.each { |trace| measure_accept(trace) }
+      end
+
+      def replace!(trace)
+        discarded_trace = super
+
+        # Emit health metrics
+        measure_accept(trace)
+        measure_drop(discarded_trace) if discarded_trace
+
+        discarded_trace
+      end
+
+      # Stored traces are returned and the local buffer is reset.
+      def drain!
+        traces = super
+        measure_pop(traces)
+        traces
+      end
+
+      def measure_accept(trace)
+        @buffer_accepted += 1
+        @buffer_accepted_lengths += trace.length
+
+        @buffer_spans += trace.length
+      rescue StandardError => e
+        Datadog.logger.debug(
+          "Failed to measure queue accept. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+
+      def measure_drop(trace)
+        @buffer_dropped += 1
+
+        @buffer_spans -= trace.length
+      rescue StandardError => e
+        Datadog.logger.debug(
+          "Failed to measure queue drop. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+
+      def measure_pop(traces)
+        # Accepted, cumulative totals
+        Datadog.health_metrics.queue_accepted(@buffer_accepted)
+        Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+        # Dropped, cumulative totals
+        Datadog.health_metrics.queue_dropped(@buffer_dropped)
+        # TODO: are we missing a +queue_dropped_lengths+ metric?
+
+        # Queue gauges, current values
+        Datadog.health_metrics.queue_max_length(@max_size)
+        Datadog.health_metrics.queue_spans(@buffer_spans)
+        Datadog.health_metrics.queue_length(traces.length)
+
+        # Reset aggregated metrics
+        @buffer_accepted = 0
+        @buffer_accepted_lengths = 0
+        @buffer_dropped = 0
+        @buffer_spans = 0
+      rescue StandardError => e
+        Datadog.logger.debug(
+          "Failed to measure queue. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+    end
+
+    # Trace buffer that stores application traces, has a maximum size, and
+    # can be safely used concurrently on any environment.
+    #
+    # @see Datadog::Core::Buffer::ThreadSafe
+    class ThreadSafeTraceBuffer < Core::Buffer::ThreadSafe
+      prepend MeasuredBuffer
+    end
+
+    # Trace buffer that stores application traces, has a maximum size, and
+    # can be safely used concurrently with CRuby.
+    #
+    # @see Datadog::Core::Buffer::CRuby
+    class CRubyTraceBuffer < Core::Buffer::CRuby
+      prepend MeasuredBuffer
+    end
+
+    # Trace buffer that stores application traces. The buffer has a maximum size and when
+    # the buffer is full, a random trace is discarded. This class is thread-safe and is used
+    # automatically by the ``Tracer`` instance when a ``Span`` is finished.
+    #
+    # We choose the default TraceBuffer implementation for current platform dynamically here.
+    #
+    # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
+    # TODO Making such a change is potentially breaking for users manually configuring the tracer.
+    TraceBuffer = if Core::Environment::Ext::RUBY_ENGINE == 'ruby'
+                    CRubyTraceBuffer
+                  else
+                    ThreadSafeTraceBuffer
+                  end
+  end
+end

data/lib/datadog/tracing/client_ip.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration'
+require_relative '../core/utils/network'
+require_relative 'metadata/ext'
+require_relative 'span'
+
+module Datadog
+  module Tracing
+    # Common functions for supporting the `http.client_ip` span attribute.
+    module ClientIp
+      class << self
+        # Sets the `http.client_ip` tag on the given span.
+        #
+        # This function respects the user's settings: if they disable the client IP tagging,
+        #   or provide a different IP header name.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag(span, headers: nil, remote_ip: nil)
+          return unless configuration.enabled
+
+          set_client_ip_tag!(span, headers: headers, remote_ip: remote_ip)
+        end
+
+        # Forcefully sets the `http.client_ip` tag on the given span.
+        #
+        # This function ignores the user's `enabled` setting.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag!(span, headers: nil, remote_ip: nil)
+          ip = extract_client_ip(headers, remote_ip)
+
+          span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP, ip) if ip
+        end
+
+        def extract_client_ip(headers, remote_ip)
+          if headers && configuration.header_name
+            return Datadog::Core::Utils::Network.stripped_ip_from_request_headers(
+              headers,
+              ip_headers_to_check: Array(configuration.header_name)
+            )
+          end
+
+          ip_from_headers = Datadog::Core::Utils::Network.stripped_ip_from_request_headers(headers) if headers
+
+          ip_from_headers || Datadog::Core::Utils::Network.stripped_ip(remote_ip)
+        end
+
+        private
+
+        def configuration
+          Datadog.configuration.tracing.client_ip
+        end
+      end
+    end
+  end
+end