ddtrace 0.54.2 → 1.2.0

data/lib/ddtrace/profiling/pprof/template.rb

@@ -1,119 +0,0 @@
-# typed: false
-require 'ddtrace/profiling/pprof/payload'
-require 'ddtrace/profiling/pprof/message_set'
-require 'ddtrace/profiling/pprof/builder'
-
-require 'ddtrace/profiling/events/stack'
-require 'ddtrace/profiling/pprof/stack_sample'
-
-module Datadog
-  module Profiling
-    module Pprof
-      # Converts a collection of profiling events into a Perftools::Profiles::Profile
-      class Template
-        DEFAULT_MAPPINGS = {
-          Events::StackSample => Pprof::StackSample
-        }.freeze
-
-        attr_reader \
-          :builder,
-          :converters,
-          :sample_type_mappings
-
-        def self.for_event_classes(event_classes)
-          # Build a map of event class --> converter class
-          mappings = event_classes.each_with_object({}) do |event_class, m|
-            converter_class = DEFAULT_MAPPINGS[event_class]
-            raise NoProfilingEventConversionError, event_class unless converter_class
-
-            m[event_class] = converter_class
-          end
-
-          new(mappings)
-        end
-
-        def initialize(mappings)
-          @builder = Builder.new
-          @converters = Hash.new { |_h, event_class| raise NoProfilingEventConversionError, event_class }
-          @sample_type_mappings = Hash.new { |_h, type| raise UnknownSampleTypeMappingError, type }
-
-          # Add default mapping
-          builder.mappings.fetch($PROGRAM_NAME, &builder.method(:build_mapping))
-
-          # Combine all sample types from each converter class
-          types = mappings.values.each_with_object({}) do |converter_class, t|
-            t.merge!(converter_class.sample_value_types)
-          end
-
-          # Build the sample types into sample type objects
-          types.each do |type_name, type_args|
-            index = nil
-
-            sample_type = builder.sample_types.fetch(*type_args) do |id, type, unit|
-              index = id
-              builder.build_value_type(type, unit)
-            end
-
-            # Create mapping between the type and index to which its assigned.
-            # Do this for faster lookup while building profile sample values.
-            sample_type_mappings[type_name] = index || builder.sample_types.messages.index(sample_type)
-          end
-
-          # Freeze them so they can't be modified.
-          # We don't want the number of sample types to vary between samples within the same profile.
-          builder.sample_types.freeze
-          sample_type_mappings.freeze
-
-          # Add converters
-          mappings.each do |event_class, converter_class|
-            converters[event_class] = converter_class.new(builder, sample_type_mappings)
-          end
-
-          converters.freeze
-        end
-
-        def add_events!(event_class, events)
-          converters[event_class].add_events!(events)
-        end
-
-        def debug_statistics
-          converters.values.map(&:debug_statistics).join(', ')
-        end
-
-        def to_pprof(start:, finish:)
-          profile = builder.build_profile(start: start, finish: finish)
-          data = builder.encode_profile(profile)
-          types = sample_type_mappings.keys
-
-          Payload.new(data, types)
-        end
-
-        # Error when an unknown event type is given to be converted
-        class NoProfilingEventConversionError < ArgumentError
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-
-          def message
-            "Profiling event type '#{type}' cannot be converted to pprof."
-          end
-        end
-
-        # Error when the mapping of a sample type to value index is unknown
-        class UnknownSampleTypeMappingError < ArgumentError
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-
-          def message
-            "Mapping for sample value type '#{type}' is unknown."
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/profiler.rb

@@ -1,31 +0,0 @@
-# typed: true
-module Datadog
-  # Profiling entry point, which coordinates collectors and a scheduler
-  class Profiler
-    attr_reader \
-      :collectors,
-      :scheduler
-
-    def initialize(collectors, scheduler)
-      @collectors = collectors
-      @scheduler = scheduler
-    end
-
-    def start
-      collectors.each(&:start)
-      scheduler.start
-    end
-
-    def shutdown!
-      Datadog.logger.debug('Shutting down profiler')
-
-      collectors.each do |collector|
-        collector.enabled = false
-        collector.stop(true)
-      end
-
-      scheduler.enabled = false
-      scheduler.stop(true)
-    end
-  end
-end

data/lib/ddtrace/profiling/recorder.rb

@@ -1,96 +0,0 @@
-# typed: true
-require 'ddtrace/profiling/buffer'
-require 'ddtrace/profiling/flush'
-
-module Datadog
-  module Profiling
-    # Stores profiling events gathered by `Collector`s
-    class Recorder
-      attr_reader :max_size
-
-      def initialize(event_classes, max_size, last_flush_time: Time.now.utc)
-        @buffers = {}
-        @last_flush_time = last_flush_time
-        @max_size = max_size
-
-        # Add a buffer for each class
-        event_classes.each do |event_class|
-          @buffers[event_class] = Profiling::Buffer.new(max_size)
-        end
-
-        # Event classes can only be added ahead of time
-        @buffers.freeze
-      end
-
-      def [](event_class)
-        @buffers[event_class]
-      end
-
-      def push(events)
-        if events.is_a?(Array)
-          # Push multiple events
-          event_class = events.first.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].concat(events)
-        else
-          # Push single event
-          event_class = events.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].push(events)
-        end
-      end
-
-      def flush
-        event_count = 0
-
-        event_groups, start, finish = update_time do
-          @buffers.collect do |event_class, buffer|
-            events = buffer.pop
-            next if events.empty?
-
-            event_count += events.length
-            EventGroup.new(event_class, events)
-          end.compact
-        end
-
-        Flush.new(
-          start,
-          finish,
-          event_groups,
-          event_count
-        )
-      end
-
-      # NOTE: Remember that if the recorder is being accessed by multiple threads, this is an inherently racy operation.
-      def empty?
-        @buffers.values.all?(&:empty?)
-      end
-
-      # Error when event of an unknown type is used with the Recorder
-      class UnknownEventError < StandardError
-        attr_reader :event_class
-
-        def initialize(event_class)
-          @event_class = event_class
-        end
-
-        def message
-          @message ||= "Unknown event class '#{event_class}' for profiling recorder."
-        end
-      end
-
-      private
-
-      def update_time
-        start = @last_flush_time
-        result = yield
-        @last_flush_time = Time.now.utc
-
-        # Return event groups, start time, finish time
-        [result, start, @last_flush_time]
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/scheduler.rb

@@ -1,150 +0,0 @@
-# typed: true
-require 'ddtrace/utils/time'
-
-require 'ddtrace/worker'
-require 'ddtrace/workers/polling'
-
-module Datadog
-  module Profiling
-    # Periodically (every DEFAULT_INTERVAL_SECONDS) takes data from the `Recorder` and pushes them to all configured
-    # `Exporter`s. Runs on its own background thread.
-    class Scheduler < Worker
-      include Workers::Polling
-
-      DEFAULT_INTERVAL_SECONDS = 60
-      MINIMUM_INTERVAL_SECONDS = 0
-
-      # Profiles with duration less than this will not be reported
-      PROFILE_DURATION_THRESHOLD_SECONDS = 1
-
-      # 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_constant :DEFAULT_INTERVAL_SECONDS, :MINIMUM_INTERVAL_SECONDS, :PROFILE_DURATION_THRESHOLD_SECONDS
-
-      attr_reader \
-        :exporters,
-        :recorder
-
-      def initialize(
-        recorder,
-        exporters,
-        fork_policy: Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default
-        interval: DEFAULT_INTERVAL_SECONDS,
-        enabled: true
-      )
-        @recorder = recorder
-        @exporters = [exporters].flatten
-
-        # 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
-        perform
-      end
-
-      def perform
-        # 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
-
-        begin
-          flush_and_wait
-          interrupted = false
-        ensure
-          Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
-        end
-      end
-
-      def after_fork
-        # Clear recorder's buffers by flushing events.
-        # Objects from parent process will copy-on-write,
-        # and we don't want to send events for the wrong process.
-        recorder.flush
-      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 samples in the recorder.
-      def loop_wait_before_first_iteration?
-        true
-      end
-
-      def work_pending?
-        !recorder.empty?
-      end
-
-      private
-
-      def flush_and_wait
-        run_time = Datadog::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
-        # Get events from recorder
-        flush = recorder.flush
-
-        if duration_below_threshold?(flush)
-          Datadog.logger.debug do
-            "Skipped exporting profiling events as profile duration is below minimum (#{flush.event_count} events skipped)"
-          end
-
-          return flush
-        end
-
-        # 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 shutting 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
-
-        # Send events to each exporter
-        if flush.event_count > 0
-          exporters.each do |exporter|
-            begin
-              exporter.export(flush)
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Unable to export #{flush.event_count} profiling events. Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-          end
-        end
-
-        flush
-      end
-
-      def duration_below_threshold?(flush)
-        (flush.finish - flush.start) < PROFILE_DURATION_THRESHOLD_SECONDS
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-# typed: false
-require 'ddtrace/utils/only_once'
-require 'ddtrace/profiling'
-require 'ddtrace/profiling/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 = Datadog::Utils::OnlyOnce.new
-
-        def run
-          ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
-            begin
-              check_if_cpu_time_profiling_is_supported
-              activate_forking_extensions
-              setup_at_fork_hooks
-            rescue StandardError, ScriptError => e
-              Datadog.logger.warn do
-                "Profiler extensions unavailable. Cause: #{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.message} Location: #{Array(e.backtrace).first}"
-          end
-        end
-
-        def check_if_cpu_time_profiling_is_supported
-          unsupported = cpu_time_profiling_unsupported_reason
-
-          if unsupported
-            Datadog.logger.info do
-              'CPU time profiling skipped because native CPU time is not supported: ' \
-              "#{unsupported}. Profiles containing 'Wall time' data will still be reported."
-            end
-          end
-        end
-
-        def setup_at_fork_hooks
-          if Process.respond_to?(:at_fork)
-            Process.at_fork(:child) do
-              begin
-                # When Ruby forks, clock IDs for each of the threads
-                # will change. We can only update these IDs from the
-                # execution context of the thread that owns it.
-                # This hook will update the IDs for the main thread
-                # after a fork occurs.
-                Thread.current.send(:update_native_ids) if Thread.current.respond_to?(:update_native_ids, true)
-
-                # Restart profiler, if enabled
-                Datadog.profiler.start if Datadog.profiler
-              rescue StandardError => e
-                Datadog.logger.warn do
-                  "Error during post-fork hooks. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
-                end
-              end
-            end
-          end
-        end
-
-        def cpu_time_profiling_unsupported_reason
-          # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons
-
-          if RUBY_ENGINE == 'jruby'
-            'JRuby is not supported'
-          elsif RUBY_PLATFORM.include?('darwin')
-            'Feature requires Linux; macOS is not supported'
-          elsif RUBY_PLATFORM =~ /(mswin|mingw)/
-            'Feature requires Linux; Windows is not supported'
-          elsif !RUBY_PLATFORM.include?('linux')
-            "Feature requires Linux; #{RUBY_PLATFORM} is not supported"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/trace_identifiers/ddtrace.rb

@@ -1,42 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'ddtrace/ext/http'
-
-module Datadog
-  module Profiling
-    module TraceIdentifiers
-      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (root span id and span id)
-      # for a given thread, if there is an active trace for that thread in the supplied tracer object.
-      class Ddtrace
-        def initialize(tracer:)
-          @tracer = (tracer if tracer.respond_to?(:call_context))
-        end
-
-        def trace_identifiers_for(thread)
-          return unless @tracer
-
-          context = @tracer.call_context(thread)
-          return unless context
-
-          span, root_span = context.current_span_and_root_span
-          return unless span && root_span
-
-          root_span_id = root_span.span_id || 0
-          span_id = span.span_id || 0
-
-          [root_span_id, span_id, maybe_extract_resource(root_span)] if root_span_id != 0 && span_id != 0
-        end
-
-        private
-
-        # NOTE: Currently we're only interested in HTTP service endpoints. Over time, this list may be expanded.
-        # Resources MUST NOT include personal identifiable information (PII); this should not be the case with
-        # ddtrace integrations, but worth mentioning just in case :)
-        def maybe_extract_resource(root_span)
-          root_span.resource if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/trace_identifiers/helper.rb

@@ -1,46 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'ddtrace/profiling/trace_identifiers/ddtrace'
-
-module Datadog
-  module Profiling
-    module TraceIdentifiers
-      # Helper used to retrieve the trace identifiers (root span id and span id) for a given thread,
-      # if there is an active trace for that thread for the supported tracing APIs.
-      #
-      # This data is used to connect profiles to the traces -- samples in a profile will be tagged with this data and
-      # the profile can be filtered down to look at only the samples for a given trace.
-      class Helper
-        DEFAULT_SUPPORTED_APIS = [
-          ::Datadog::Profiling::TraceIdentifiers::Ddtrace
-        ].freeze
-        private_constant :DEFAULT_SUPPORTED_APIS
-
-        def initialize(
-          tracer:,
-          # If this is disabled, the helper will strip the optional trace_resource_container even if provided by the api
-          endpoint_collection_enabled:,
-          supported_apis: DEFAULT_SUPPORTED_APIS.map { |api| api.new(tracer: tracer) }
-        )
-          @endpoint_collection_enabled = endpoint_collection_enabled
-          @supported_apis = supported_apis
-        end
-
-        # Expected output of the #trace_identifiers_for
-        # duck type is [root_span_id, span_id, (optional trace_resource_container)]
-        def trace_identifiers_for(thread)
-          @supported_apis.each do |api|
-            trace_identifiers = api.trace_identifiers_for(thread)
-
-            if trace_identifiers
-              return @endpoint_collection_enabled ? trace_identifiers : trace_identifiers[0..1]
-            end
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/transport/client.rb

@@ -1,15 +0,0 @@
-# typed: true
-module Datadog
-  module Profiling
-    module Transport
-      # Generic interface for profiling transports
-      module Client
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
-        def send_profiling_flush(flush)
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/transport/http/api/endpoint.rb

@@ -1,94 +0,0 @@
-# typed: true
-require 'ddtrace/ext/profiling'
-require 'ddtrace/utils/compression'
-require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
-
-require 'ddtrace/transport/http/api/endpoint'
-require 'ddtrace/profiling/transport/http/response'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # Datadog API endpoint for profiling
-          class Endpoint < Datadog::Transport::HTTP::API::Endpoint
-            include Datadog::Ext::Profiling::Transport::HTTP
-
-            # These tags are read from the flush object (see below) directly and so we ignore any extra copies that
-            # may come in the tags hash to avoid duplicates.
-            TAGS_TO_IGNORE_IN_TAGS_HASH = %w[service env version].freeze
-            private_constant :TAGS_TO_IGNORE_IN_TAGS_HASH
-
-            attr_reader \
-              :encoder
-
-            def initialize(path, encoder)
-              super(:post, path)
-              @encoder = encoder
-            end
-
-            def call(env, &block)
-              # Build request
-              env.form = build_form(env)
-
-              # Send request
-              http_response = super(env, &block)
-
-              # Build response
-              Profiling::Transport::HTTP::Response.new(http_response)
-            end
-
-            def build_form(env)
-              flush = env.request.parcel.data
-              pprof_file = build_pprof(flush)
-
-              form = {
-                FORM_FIELD_INTAKE_VERSION => '3', # Aka 1.3 intake format
-                FORM_FIELD_RECORDING_START => flush.start.utc.iso8601,
-                FORM_FIELD_RECORDING_END => flush.finish.utc.iso8601,
-                FORM_FIELD_TAGS => [
-                  "#{FORM_FIELD_TAG_RUNTIME}:#{flush.language}",
-                  "#{FORM_FIELD_TAG_RUNTIME_ID}:#{flush.runtime_id}",
-                  "#{FORM_FIELD_TAG_RUNTIME_ENGINE}:#{flush.runtime_engine}",
-                  "#{FORM_FIELD_TAG_RUNTIME_PLATFORM}:#{flush.runtime_platform}",
-                  "#{FORM_FIELD_TAG_RUNTIME_VERSION}:#{flush.runtime_version}",
-                  "#{FORM_FIELD_TAG_PID}:#{Process.pid}",
-                  "#{FORM_FIELD_TAG_PROFILER_VERSION}:#{flush.profiler_version}",
-                  # NOTE: Redundant w/ 'runtime'; may want to remove this later.
-                  "#{FORM_FIELD_TAG_LANGUAGE}:#{flush.language}",
-                  "#{FORM_FIELD_TAG_HOST}:#{flush.host}",
-                  *flush
-                    .tags
-                    .reject { |tag_key| TAGS_TO_IGNORE_IN_TAGS_HASH.include?(tag_key) }
-                    .map { |tag_key, tag_value| "#{tag_key}:#{tag_value}" }
-                ],
-                FORM_FIELD_PPROF_DATA => pprof_file,
-                FORM_FIELD_FAMILY => flush.language,
-              }
-
-              # Optional fields
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_SERVICE}:#{flush.service}" unless flush.service.nil?
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_ENV}:#{flush.env}" unless flush.env.nil?
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_VERSION}:#{flush.version}" unless flush.version.nil?
-
-              form
-            end
-
-            def build_pprof(flush)
-              pprof = encoder.encode(flush)
-
-              gzipped_pprof_data = Datadog::Utils::Compression.gzip(pprof.data)
-
-              Datadog::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_pprof_data),
-                HEADER_CONTENT_TYPE_OCTET_STREAM,
-                PPROF_DEFAULT_FILENAME
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end