ddtrace 0.54.2 → 1.0.0.beta1

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/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

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

@@ -1,37 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/api/instance'
-require 'ddtrace/profiling/transport/http/api/spec'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # API instance for profiling
-          class Instance < Datadog::Transport::HTTP::API::Instance
-            def send_profiling_flush(env)
-              raise ProfilesNotSupportedError, spec unless spec.is_a?(Spec)
-
-              spec.send_profiling_flush(env) do |request_env|
-                call(request_env)
-              end
-            end
-
-            # Raised when profiles sent to API that does not support profiles
-            class ProfilesNotSupportedError < StandardError
-              attr_reader :spec
-
-              def initialize(spec)
-                @spec = spec
-              end
-
-              def message
-                'Profiles not supported for this API!'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/api/map'
-require 'ddtrace/profiling/encoding/profile'
-require 'ddtrace/profiling/transport/http/api/spec'
-require 'ddtrace/profiling/transport/http/api/instance'
-require 'ddtrace/profiling/transport/http/api/endpoint'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Extensions for HTTP API Spec
-        module API
-          # Default API versions
-          V1 = 'v1'.freeze
-
-          module_function
-
-          def agent_defaults
-            @agent_defaults ||= Datadog::Transport::HTTP::API::Map[
-              V1 => Spec.new do |s|
-                s.profiles = Endpoint.new(
-                  '/profiling/v1/input'.freeze,
-                  Profiling::Encoding::Profile::Protobuf
-                )
-              end
-            ]
-          end
-
-          def api_defaults
-            @api_defaults ||= Datadog::Transport::HTTP::API::Map[
-              V1 => Spec.new do |s|
-                s.profiles = Endpoint.new(
-                  '/v1/input'.freeze,
-                  Profiling::Encoding::Profile::Protobuf
-                )
-              end
-            ]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/transport/http/builder.rb

@@ -1,29 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/builder'
-
-require 'ddtrace/profiling/transport/http/api'
-require 'ddtrace/profiling/transport/http/client'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Builds new instances of Transport::HTTP::Client
-        class Builder < Datadog::Transport::HTTP::Builder
-          def api_instance_class
-            API::Instance
-          end
-
-          def to_transport
-            raise Datadog::Transport::HTTP::Builder::NoDefaultApiError if @default_api.nil?
-
-            # TODO: Profiling doesn't have multiple APIs yet.
-            #       When it does, we should build it out with these APIs.
-            #       Just use :default_api for now.
-            Client.new(to_api_instances[@default_api])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/client'
-require 'ddtrace/profiling/transport/client'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
-        class Client < Datadog::Transport::HTTP::Client
-          include Transport::Client
-
-          def send_profiling_flush(flush)
-            # Build a request
-            request = Profiling::Transport::Request.new(flush)
-            send_payload(request).tap do |response|
-              if response.ok?
-                Datadog.logger.debug('Successfully reported profiling data')
-              else
-                Datadog.logger.debug { "Failed to report profiling data -- #{response.inspect}" }
-              end
-            end
-          end
-
-          def send_payload(request)
-            send_request(request) do |api, env|
-              api.send_profiling_flush(env)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/profiling/transport/http/response.rb

@@ -1,22 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/response'
-require 'ddtrace/profiling/transport/response'
-
-module Datadog
-  module Profiling
-    module Transport
-      # HTTP transport behavior for profiling
-      module HTTP
-        # Response from HTTP transport for profiling
-        class Response
-          include Datadog::Transport::HTTP::Response
-          include Profiling::Transport::Response
-
-          def initialize(http_response, options = {})
-            super(http_response)
-          end
-        end
-      end
-    end
-  end
-end