ddtrace 0.54.2 → 1.0.0.beta1

data/lib/datadog/profiling/recorder.rb

@@ -0,0 +1,116 @@
+# typed: true
+require 'datadog/profiling/buffer'
+require 'datadog/profiling/flush'
+
+module Datadog
+  module Profiling
+    # Stores profiling events gathered by `Collector`s
+    class Recorder
+      attr_reader :max_size
+
+      # TODO: Why does the Recorder directly reference the `code_provenance_collector`?
+      #
+      # For starters, this is weird/a problem because the relationship is supposed to go in the other direction:
+      # collectors are supposed to record their results in the `Recorder`, rather than the `Recorder` having to know
+      # about individual collectors.
+      #
+      # But the `code_provenance_collector` is different from other existing and potential collectors because it is not
+      # asynchronous. It does not gather data over time and record it as it goes. Instead, you call it once per profile,
+      # synchronously, and just use what it spits out.
+      #
+      # The current design of the `Recorder` is quite tied to the asynchronous model. Modifying our current design
+      # to support synchronous collectors is non-trivial, and I decided not to go through with it because we're
+      # soon going to replace the `Recorder` and many other existing classes with a
+      # [libddprof](https://github.com/datadog/libddprof)-based implementation, and thus I don't think massive refactors
+      # are worth it before moving to libddprof.
+
+      def initialize(event_classes, max_size, code_provenance_collector:, last_flush_time: Time.now.utc)
+        @buffers = {}
+        @last_flush_time = last_flush_time
+        @max_size = max_size
+        @code_provenance_collector = code_provenance_collector
+
+        # 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
+
+        code_provenance = @code_provenance_collector.refresh.generate_json if @code_provenance_collector
+
+        Flush.new(
+          start: start,
+          finish: finish,
+          event_groups: event_groups,
+          event_count: event_count,
+          code_provenance: code_provenance,
+        )
+      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/datadog/profiling/scheduler.rb

@@ -0,0 +1,150 @@
+# typed: false
+require 'datadog/core/utils/time'
+
+require 'datadog/core/worker'
+require 'datadog/core/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 < Core::Worker
+      include Core::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: Core::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 = 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
+        # 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/datadog/profiling/tasks/exec.rb

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

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

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

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

@@ -0,0 +1,90 @@
+# typed: false
+require 'datadog/core/utils/only_once'
+require 'datadog/profiling'
+require 'datadog/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 = Core::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
+                Profiling.start_if_enabled
+              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/datadog/profiling/trace_identifiers/ddtrace.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+
+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?(:active_trace))
+        end
+
+        def trace_identifiers_for(thread)
+          return unless @tracer
+
+          trace = @tracer.active_trace(thread)
+          return unless trace
+
+          root_span = trace.send(:root_span)
+          span = trace.active_span
+          return unless span && root_span
+
+          root_span_id = root_span.id || 0
+          span_id = span.id || 0
+
+          [root_span_id, span_id, maybe_extract_resource(trace, 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(trace, root_span)
+          trace.resource if root_span.span_type == Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'datadog/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 = [
+          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/datadog/profiling/transport/http/api/endpoint.rb

@@ -0,0 +1,106 @@
+# typed: true
+require 'datadog/core/utils/compression'
+require 'datadog/core/vendor/multipart-post/multipart/post/composite_read_io'
+require 'datadog/profiling/ext'
+require 'datadog/profiling/transport/http/response'
+require 'ddtrace/transport/http/api/endpoint'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        module API
+          # Datadog API endpoint for profiling
+          class Endpoint < Datadog::Transport::HTTP::API::Endpoint
+            include Profiling::Ext::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?
+
+              # May not be available/enabled
+              form[FORM_FIELD_CODE_PROVENANCE_DATA] = build_code_provenance(flush) if flush.code_provenance
+
+              form
+            end
+
+            def build_pprof(flush)
+              pprof = encoder.encode(flush)
+
+              gzipped_pprof_data = Core::Utils::Compression.gzip(pprof.data)
+
+              Core::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_pprof_data),
+                HEADER_CONTENT_TYPE_OCTET_STREAM,
+                PPROF_DEFAULT_FILENAME
+              )
+            end
+
+            def build_code_provenance(flush)
+              gzipped_code_provenance = Core::Utils::Compression.gzip(flush.code_provenance)
+
+              Core::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_code_provenance),
+                HEADER_CONTENT_TYPE_OCTET_STREAM,
+                CODE_PROVENANCE_FILENAME,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# typed: true
+require 'ddtrace/transport/http/api/instance'
+require 'datadog/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