ddtrace 0.35.2 → 1.1.0

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

@@ -0,0 +1,112 @@
+# typed: true
+
+require 'datadog/core/environment/ext'
+require 'ddtrace/transport/ext'
+
+require 'datadog/core/environment/container'
+require 'datadog/core/environment/variable_helpers'
+
+require 'datadog/profiling/transport/http/builder'
+require 'datadog/profiling/transport/http/api'
+
+require 'ddtrace/transport/http/adapters/net'
+require 'ddtrace/transport/http/adapters/test'
+require 'ddtrace/transport/http/adapters/unix_socket'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        # Builds a new Transport::HTTP::Client
+        def self.new(&block)
+          Builder.new(&block).to_transport
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        def self.default(
+          profiling_upload_timeout_seconds:,
+          agent_settings:,
+          site: nil,
+          api_key: nil,
+          agentless_allowed: agentless_allowed?
+        )
+          new do |transport|
+            transport.headers default_headers
+
+            # Configure adapter & API
+            if site && api_key && agentless_allowed
+              configure_for_agentless(
+                transport,
+                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
+                site: site,
+                api_key: api_key
+              )
+            else
+              configure_for_agent(
+                transport,
+                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
+                agent_settings: agent_settings
+              )
+            end
+          end
+        end
+
+        def self.default_headers
+          {
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER => Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Core::Environment::Container.container_id
+            headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
+          apis = API.agent_defaults
+
+          transport.adapter(agent_settings.merge(timeout_seconds: profiling_upload_timeout_seconds))
+          transport.api(API::V1, apis[API::V1], default: true)
+
+          # NOTE: This proc, when it exists, usually overrides the transport specified above
+          if agent_settings.deprecated_for_removal_transport_configuration_proc
+            agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+          end
+        end
+
+        private_class_method def self.configure_for_agentless(transport, profiling_upload_timeout_seconds:, site:, api_key:)
+          apis = API.api_defaults
+
+          site_uri = URI(format(Profiling::Ext::Transport::HTTP::URI_TEMPLATE_DD_API, site))
+          hostname = site_uri.host
+          port = site_uri.port
+
+          transport.adapter(
+            Datadog::Transport::Ext::HTTP::ADAPTER,
+            hostname,
+            port,
+            timeout: profiling_upload_timeout_seconds,
+            ssl: site_uri.scheme == 'https'
+          )
+          transport.api(API::V1, apis[API::V1], default: true)
+          transport.headers(Datadog::Transport::Ext::HTTP::HEADER_DD_API_KEY => api_key)
+        end
+
+        private_class_method def self.agentless_allowed?
+          Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
+        end
+
+        # Add adapters to registry
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net,
+                                                        Datadog::Transport::Ext::HTTP::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test,
+                                                        Datadog::Transport::Ext::Test::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket,
+                                                        Datadog::Transport::Ext::UnixSocket::ADAPTER)
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/io/client.rb

@@ -0,0 +1,29 @@
+# typed: true
+
+require 'ddtrace/transport/io/client'
+require 'datadog/profiling/transport/client'
+require 'datadog/profiling/transport/request'
+require 'datadog/profiling/transport/io/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      module IO
+        # IO transport for profiling
+        class Client < Datadog::Transport::IO::Client
+          include Transport::Client
+
+          def send_profiling_flush(flush)
+            # Build a request
+            request = Profiling::Transport::Request.new(flush)
+            send_request(request)
+          end
+
+          def build_response(_request, _data, result)
+            Profiling::Transport::IO::Response.new(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/io/response.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+require 'ddtrace/transport/io/response'
+require 'datadog/profiling/transport/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      # IO transport behavior for profiling
+      module IO
+        # Response from IO transport for profiling
+        class Response < Datadog::Transport::IO::Response
+          include Profiling::Transport::Response
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/io.rb

@@ -0,0 +1,32 @@
+# typed: true
+
+require 'datadog/profiling/transport/io/client'
+require 'datadog/profiling/encoding/profile'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Namespace for profiling IO transport components
+      module IO
+        module_function
+
+        # Builds a new Profiling::Transport::IO::Client
+        def new(out, encoder, options = {})
+          Client.new(out, encoder, options)
+        end
+
+        # Builds a new Profiling::Transport::IO::Client with default settings
+        # Pass options to override any settings.
+        def default(options = {})
+          options = options.dup
+
+          new(
+            options.delete(:out) || $stdout,
+            options.delete(:encoder) || Profiling::Encoding::Profile::Protobuf,
+            options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/parcel.rb

@@ -0,0 +1,19 @@
+# typed: true
+
+require 'ddtrace/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Data transfer object for profiling data
+      class Parcel
+        include Datadog::Transport::Parcel
+
+        def encode_with(encoder)
+          # TODO: Determine encoding behavior
+          encoder.encode(data)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/request.rb

@@ -0,0 +1,17 @@
+# typed: true
+
+require 'ddtrace/transport/request'
+require 'datadog/profiling/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling request
+      class Request < Datadog::Transport::Request
+        def initialize(flush)
+          super(Parcel.new(flush))
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/transport/response.rb

@@ -0,0 +1,10 @@
+# typed: strict
+
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling response
+      module Response; end
+    end
+  end
+end

data/lib/datadog/profiling.rb

@@ -0,0 +1,170 @@
+# typed: true
+
+require 'datadog/core'
+require 'datadog/core/environment/variable_helpers'
+require 'datadog/core/utils/only_once'
+
+module Datadog
+  # Contains profiler for generating stack profiles, etc.
+  module Profiling # rubocop:disable Metrics/ModuleLength
+    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
+    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
+
+    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 they are missing protobuf
+
+      native_library_compilation_skipped? ||
+        native_library_failed_to_load? ||
+        protobuf_gem_unavailable? ||
+        protobuf_version_unsupported? ||
+        protobuf_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
+
+    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/ddtrace_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.protobuf_gem_unavailable?
+      # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
+      # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
+      # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
+      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].nil?
+        "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
+      end
+    end
+
+    private_class_method def self.protobuf_version_unsupported?
+      # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
+      # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
+      # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
+      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
+        'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
+        "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
+      end
+    end
+
+    private_class_method def self.protobuf_failed_to_load?
+      unless protobuf_loaded_successfully?
+        'There was an error loading the google-protobuf library; see previous warning message for details'
+      end
+    end
+
+    # The `google-protobuf` gem depends on a native component, and its creators helpfully tried to provide precompiled
+    # versions of this extension on rubygems.org.
+    #
+    # Unfortunately, for a long time, the supported Ruby versions metadata on these precompiled versions of the extension
+    # was not correctly set. (This is fixed in newer versions -- but not all Ruby versions we want to support can use
+    # these.)
+    #
+    # Thus, the gem can still be installed, but can be in a broken state. To avoid breaking customer applications, we
+    # use this helper to load it and gracefully handle failures.
+    private_class_method def self.protobuf_loaded_successfully?
+      return @protobuf_loaded if defined?(@protobuf_loaded)
+
+      begin
+        require 'google/protobuf'
+        @protobuf_loaded = true
+      rescue LoadError => e
+        # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
+        # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
+        Kernel.warn(
+          '[DDTRACE] Error while loading google-protobuf gem. ' \
+          "Cause: '#{e.class.name} #{e.message}' Location: '#{Array(e.backtrace).first}'. " \
+          'This can happen when google-protobuf is missing its native components. ' \
+          'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
+          '`gem uninstall google-protobuf -a; BUNDLE_FORCE_RUBY_PLATFORM=true bundle install`. ' \
+          'If the error persists, please contact Datadog support at <https://docs.datadoghq.com/help/>.'
+        )
+        @protobuf_loaded = false
+      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 '#{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 'datadog/profiling/load_native_extension'
+
+        success =
+          defined?(Profiling::NativeExtension) && Profiling::NativeExtension.send(:native_working?)
+        [success, nil]
+      rescue StandardError, LoadError => e
+        [false, e]
+      end
+    end
+
+    private_class_method def self.load_profiling
+      return false unless supported?
+
+      require 'datadog/profiling/ext/forking'
+      require 'datadog/profiling/collectors/code_provenance'
+      require 'datadog/profiling/collectors/old_stack'
+      require 'datadog/profiling/collectors/stack'
+      require 'datadog/profiling/stack_recorder'
+      require 'datadog/profiling/exporter'
+      require 'datadog/profiling/recorder'
+      require 'datadog/profiling/scheduler'
+      require 'datadog/profiling/tasks/setup'
+      require 'datadog/profiling/transport/io'
+      require 'datadog/profiling/transport/http'
+      require 'datadog/profiling/profiler'
+      require 'datadog/profiling/native_extension'
+      require 'datadog/profiling/trace_identifiers/helper'
+      require 'datadog/profiling/pprof/pprof_pb'
+      require 'datadog/profiling/tag_builder'
+
+      true
+    end
+
+    load_profiling
+  end
+end

data/lib/datadog/tracing/analytics.rb

@@ -0,0 +1,25 @@
+# typed: true
+
+require 'datadog/tracing/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,132 @@
+# typed: true
+
+require 'datadog/core'
+require 'datadog/core/environment/ext'
+require 'datadog/core/buffer/thread_safe'
+require 'datadog/core/buffer/cruby'
+require 'datadog/core/diagnostics/health'
+
+module Datadog
+  module Tracing
+    # Health metrics for trace buffers.
+    module MeasuredBuffer
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+      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/configuration/ext.rb

@@ -0,0 +1,51 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Configuration
+      module Ext
+        # @public_api
+        module Analytics
+          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+        end
+
+        # @public_api
+        module Correlation
+          ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
+        end
+
+        # @public_api
+        module Distributed
+          PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+          PROPAGATION_STYLE_B3 = 'B3'.freeze
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
+          ENV_PROPAGATION_STYLE_INJECT = 'DD_PROPAGATION_STYLE_INJECT'.freeze
+          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+        end
+
+        # @public_api
+        module NET
+          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+        end
+
+        # @public_api
+        module Sampling
+          ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
+          ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+        end
+
+        # @public_api
+        module Test
+          ENV_MODE_ENABLED = 'DD_TRACE_TEST_MODE_ENABLED'.freeze
+        end
+
+        # @public_api
+        module Transport
+          ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
+          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
+          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/context.rb

@@ -0,0 +1,68 @@
+# typed: true
+
+require 'datadog/core/utils/forking'
+
+module Datadog
+  module Tracing
+    # {Datadog::Tracing::Context} is used to keep track of a the active trace for the current
+    # execution flow. During each logical execution, the same {Datadog::Tracing::Context} is
+    # used to represent a single logical trace, even if the trace is built
+    # asynchronously.
+    #
+    # A single code execution may use multiple {Datadog::Tracing::Context} if part of the execution
+    # must not be related to the current tracing. As example, a delayed job may
+    # compose a standalone trace instead of being related to the same trace that
+    # generates the job itself. On the other hand, if it's part of the same
+    # {Datadog::Tracing::Context}, it will be related to the original trace.
+    class Context
+      include Core::Utils::Forking
+
+      attr_reader \
+        :active_trace
+
+      def initialize(
+        trace: nil
+      )
+        activate!(trace)
+      end
+
+      # Handles trace activation.
+      #
+      # Permits nil, allowing traces to be deactivated.
+      #
+      # If given a block, it will reset to the original
+      # trace after the block completes.
+      #
+      # When restoring the original trace, if it is finished,
+      # it will deactivate it. This prevents the context from
+      # holding references to completed traces thereby releasing
+      # its memory.
+      def activate!(trace)
+        if block_given?
+          begin
+            original_trace = @active_trace
+            set_active_trace!(trace)
+            yield
+          ensure
+            set_active_trace!(original_trace)
+          end
+        else
+          set_active_trace!(trace)
+        end
+      end
+
+      # Creates a copy of the context, when forked.
+      def fork_clone
+        forked_trace = @active_trace && @active_trace.fork_clone
+        self.class.new(trace: forked_trace)
+      end
+
+      private
+
+      def set_active_trace!(trace)
+        # Don't retain finished traces
+        @active_trace = trace && !trace.finished? ? trace : nil
+      end
+    end
+  end
+end