ddtrace 0.54.2 → 1.18.0

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

@@ -1,31 +0,0 @@
-# typed: true
-require 'ddtrace/profiling/transport/io/client'
-require 'ddtrace/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/ddtrace/profiling/transport/parcel.rb

@@ -1,18 +0,0 @@
-# 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/ddtrace/profiling/transport/request.rb

@@ -1,16 +0,0 @@
-# typed: true
-require 'ddtrace/transport/request'
-require 'ddtrace/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/ddtrace/profiling/transport/response.rb

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

data/lib/ddtrace/profiling.rb

@@ -1,149 +0,0 @@
-# typed: true
-require 'datadog/core/environment/variable_helpers'
-require 'ddtrace/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
-
-    SKIPPED_NATIVE_EXTENSION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :SKIPPED_NATIVE_EXTENSION_ONLY_ONCE
-
-    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
-
-      ruby_engine_unsupported? ||
-        native_library_failed_to_load? ||
-        protobuf_gem_unavailable? ||
-        protobuf_version_unsupported? ||
-        protobuf_failed_to_load?
-    end
-
-    private_class_method def self.ruby_engine_unsupported?
-      'JRuby is not supported' if RUBY_ENGINE == 'jruby'
-    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.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 support via <https://docs.datadoghq.com/help/> or ' \
-          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
-        )
-        @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.message}' at '#{exception.backtrace.first}'"
-        else
-          'The profiling native extension did not load correctly. ' \
-          'If the error persists, please contact support via <https://docs.datadoghq.com/help/> or ' \
-          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
-        end
-      end
-    end
-
-    private_class_method def self.try_loading_native_library
-      if Datadog::Core::Environment::VariableHelpers.env_to_bool('DD_PROFILING_NO_EXTENSION', false)
-        SKIPPED_NATIVE_EXTENSION_ONLY_ONCE.run do
-          Kernel.warn(
-            '[DDTRACE] Skipped loading of profiling native extension due to DD_PROFILING_NO_EXTENSION environment ' \
-            'variable being set. ' \
-            'This option is experimental and will lead to the profiler not working in future releases. ' \
-            'If you needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.'
-          )
-        end
-
-        return [true, nil]
-      end
-
-      begin
-        require "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-        success =
-          defined?(Datadog::Profiling::NativeExtension) && Datadog::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 'ddtrace/profiling/ext/forking'
-      require 'ddtrace/profiling/collectors/stack'
-      require 'ddtrace/profiling/exporter'
-      require 'ddtrace/profiling/recorder'
-      require 'ddtrace/profiling/scheduler'
-      require 'ddtrace/profiling/tasks/setup'
-      require 'ddtrace/profiling/transport/io'
-      require 'ddtrace/profiling/transport/http'
-      require 'ddtrace/profiling/profiler'
-      require 'ddtrace/profiling/native_extension'
-      require 'ddtrace/profiling/trace_identifiers/helper'
-      require 'ddtrace/profiling/pprof/pprof_pb'
-
-      true
-    end
-
-    load_profiling if supported?
-  end
-end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -1,75 +0,0 @@
-# typed: true
-require 'ddtrace/context'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  # opentracing.io compliant methods for distributing trace context
-  # between two or more distributed services. Note this is very close
-  # to the HTTPPropagator; the key difference is the way gRPC handles
-  # header information (called "metadata") as it operates over HTTP2
-  module GRPCPropagator
-    include Ext::DistributedTracing
-
-    def self.inject!(context, metadata)
-      metadata[GRPC_METADATA_TRACE_ID] = context.trace_id.to_s
-      metadata[GRPC_METADATA_PARENT_ID] = context.span_id.to_s
-      metadata[GRPC_METADATA_SAMPLING_PRIORITY] = context.sampling_priority.to_s if context.sampling_priority
-      metadata[GRPC_METADATA_ORIGIN] = context.origin.to_s if context.origin
-    end
-
-    def self.extract(metadata)
-      metadata = Carrier.new(metadata)
-      return Datadog::Context.new unless metadata.valid?
-
-      Datadog::Context.new(trace_id: metadata.trace_id,
-                           span_id: metadata.parent_id,
-                           sampling_priority: metadata.sampling_priority,
-                           origin: metadata.origin)
-    end
-
-    # opentracing.io compliant carrier object
-    class Carrier
-      include Ext::DistributedTracing
-
-      def initialize(metadata = {})
-        @metadata = metadata || {}
-      end
-
-      def valid?
-        trace_id && parent_id
-      end
-
-      def trace_id
-        value = metadata_for_key(GRPC_METADATA_TRACE_ID).to_i
-        value if (1..Span::EXTERNAL_MAX_ID).cover? value
-      end
-
-      def parent_id
-        value = metadata_for_key(GRPC_METADATA_PARENT_ID).to_i
-        value if (1..Span::EXTERNAL_MAX_ID).cover? value
-      end
-
-      def sampling_priority
-        value = metadata_for_key(GRPC_METADATA_SAMPLING_PRIORITY)
-        value && value.to_i
-      end
-
-      def origin
-        value = metadata_for_key(GRPC_METADATA_ORIGIN)
-        value if value != ''
-      end
-
-      private
-
-      def metadata_for_key(key)
-        # metadata values can be arrays (multiple headers with the same key)
-        value = @metadata[key]
-        if value.is_a?(Array)
-          value.first
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/propagation/http_propagator.rb

@@ -1,91 +0,0 @@
-# typed: false
-require 'ddtrace/configuration'
-require 'ddtrace/context'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/priority'
-require 'ddtrace/distributed_tracing/headers/b3'
-require 'ddtrace/distributed_tracing/headers/b3_single'
-require 'ddtrace/distributed_tracing/headers/datadog'
-
-module Datadog
-  # HTTPPropagator helps extracting and injecting HTTP headers.
-  module HTTPPropagator
-    include Ext::DistributedTracing
-
-    PROPAGATION_STYLES = { PROPAGATION_STYLE_B3 => DistributedTracing::Headers::B3,
-                           PROPAGATION_STYLE_B3_SINGLE_HEADER => DistributedTracing::Headers::B3Single,
-                           PROPAGATION_STYLE_DATADOG => DistributedTracing::Headers::Datadog }.freeze
-
-    # inject! popolates the env with span ID, trace ID and sampling priority
-    def self.inject!(context, env)
-      # Prevent propagation from being attempted if context provided is nil.
-      if context.nil?
-        ::Datadog.logger.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
-        return
-      end
-
-      # Inject all configured propagation styles
-      ::Datadog.configuration.distributed_tracing.propagation_inject_style.each do |style|
-        propagator = PROPAGATION_STYLES[style]
-        begin
-          propagator.inject!(context, env) unless propagator.nil?
-        rescue => e
-          Datadog.logger.error(
-            'Error injecting propagated context into the environment. ' \
-            "Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-      end
-    end
-
-    # extract returns a context containing the span ID, trace ID and
-    # sampling priority defined in env.
-    def self.extract(env)
-      context = nil
-      dd_context = nil
-
-      ::Datadog.configuration.distributed_tracing.propagation_extract_style.each do |style|
-        propagator = PROPAGATION_STYLES[style]
-        next if propagator.nil?
-
-        # Extract context
-        # DEV: `propagator.extract` will return `nil`, where `HTTPPropagator#extract` will not
-        begin
-          extracted_context = propagator.extract(env)
-        rescue => e
-          Datadog.logger.error(
-            'Error extracting propagated context from the environment. ' \
-            "Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-
-        # Skip this style if no valid headers were found
-        next if extracted_context.nil?
-
-        # Keep track of the Datadog extract context, we want to return
-        #   this one if we have one
-        dd_context = extracted_context if extracted_context && style == PROPAGATION_STYLE_DATADOG
-
-        # No previously extracted context, use the one we just extracted
-        if context.nil?
-          context = extracted_context
-        else
-          unless context.trace_id == extracted_context.trace_id && context.span_id == extracted_context.span_id
-            # Return an empty/new context if we have a mismatch in values extracted
-            msg = "#{context.trace_id} != #{extracted_context.trace_id} && " \
-                  "#{context.span_id} != #{extracted_context.span_id}"
-            ::Datadog.logger.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
-            # DEV: This will return from `self.extract` not this `each` block
-            return ::Datadog::Context.new
-          end
-        end
-      end
-
-      # Return the extracted context if we found one or else a new empty context
-      # Always return the Datadog context if one exists since it has more
-      #   information than the B3 headers e.g. origin, expanded priority
-      #   sampling values, etc
-      dd_context || context || ::Datadog::Context.new
-    end
-  end
-end

data/lib/ddtrace/quantization/hash.rb

@@ -1,104 +0,0 @@
-# typed: true
-module Datadog
-  module Quantization
-    # Quantization for HTTP resources
-    module Hash
-      PLACEHOLDER = '?'.freeze
-      EXCLUDE_KEYS = [].freeze
-      SHOW_KEYS = [].freeze
-      DEFAULT_OPTIONS = {
-        exclude: EXCLUDE_KEYS,
-        show: SHOW_KEYS,
-        placeholder: PLACEHOLDER
-      }.freeze
-
-      module_function
-
-      def format(hash_obj, options = {})
-        options ||= {}
-        format!(hash_obj, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def format!(hash_obj, options = {})
-        options ||= {}
-        options = merge_options(DEFAULT_OPTIONS, options)
-        format_hash(hash_obj, options)
-      end
-
-      def format_hash(hash_obj, options = {})
-        case hash_obj
-        when ::Hash
-          return {} if options[:exclude] == :all
-          return hash_obj if options[:show] == :all
-
-          hash_obj.each_with_object({}) do |(key, value), quantized|
-            if options[:show].any?(&indifferent_equals(key))
-              quantized[key] = value
-            elsif options[:exclude].none?(&indifferent_equals(key))
-              quantized[key] = format_value(value, options)
-            end
-          end
-        else
-          format_value(hash_obj, options)
-        end
-      end
-
-      def format_value(value, options = {})
-        return value if options[:show] == :all
-
-        case value
-        when ::Hash
-          format_hash(value, options)
-        when Array
-          # If any are objects, format them.
-          format_array(value, options)
-        else
-          options[:placeholder]
-        end
-      end
-
-      def format_array(value, options)
-        if value.any? { |v| v.class <= ::Hash || v.class <= Array }
-          first_entry = format_value(value.first, options)
-          value.size > 1 ? [first_entry, options[:placeholder]] : [first_entry]
-          # Otherwise short-circuit and return single placeholder
-        else
-          [options[:placeholder]]
-        end
-      end
-
-      def merge_options(original, additional)
-        {}.tap do |options|
-          # Show
-          # If either is :all, value becomes :all
-          options[:show] = if original[:show] == :all || additional[:show] == :all
-                             :all
-                           else
-                             (original[:show] || []).dup.concat(additional[:show] || []).uniq
-                           end
-
-          # Exclude
-          # If either is :all, value becomes :all
-          options[:exclude] = if original[:exclude] == :all || additional[:exclude] == :all
-                                :all
-                              else
-                                (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
-                              end
-
-          options[:placeholder] = additional[:placeholder] || original[:placeholder]
-        end
-      end
-
-      def indifferent_equals(value)
-        value = convert_value(value)
-        ->(compared_value) { value == convert_value(compared_value) }
-      end
-
-      def convert_value(value)
-        value.is_a?(Symbol) ? value.to_s : value
-      end
-    end
-  end
-end

data/lib/ddtrace/quantization/http.rb

@@ -1,90 +0,0 @@
-# typed: true
-require 'uri'
-require 'set'
-
-module Datadog
-  module Quantization
-    # Quantization for HTTP resources
-    module HTTP
-      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
-      PLACEHOLDER = '?'.freeze
-
-      module_function
-
-      def url(url, options = {})
-        url!(url, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def url!(url, options = {})
-        options ||= {}
-
-        URI.parse(url).tap do |uri|
-          # Format the query string
-          if uri.query
-            query = query(uri.query, options[:query])
-            uri.query = (!query.nil? && query.empty? ? nil : query)
-          end
-
-          # Remove any URI framents
-          uri.fragment = nil unless options[:fragment] == :show
-        end.to_s
-      end
-
-      def query(query, options = {})
-        query!(query, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def query!(query, options = {})
-        options ||= {}
-        options[:show] = options[:show] || []
-        options[:exclude] = options[:exclude] || []
-
-        # Short circuit if query string is meant to exclude everything
-        # or if the query string is meant to include everything
-        return '' if options[:exclude] == :all
-        return query if options[:show] == :all
-
-        collect_query(query, uniq: true) do |key, value|
-          if options[:exclude].include?(key)
-            [nil, nil]
-          else
-            value = options[:show].include?(key) ? value : nil
-            [key, value]
-          end
-        end
-      end
-
-      # Iterate over each key value pair, yielding to the block given.
-      # Accepts :uniq option, which keeps uniq copies of keys without values.
-      # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
-      def collect_query(query, options = {})
-        return query unless block_given?
-
-        uniq = options[:uniq].nil? ? false : options[:uniq]
-        keys = Set.new
-
-        delims = query.scan(/(^|&|;)/).flatten
-        query.split(/[&;]/).collect.with_index do |pairs, i|
-          key, value = pairs.split('=', 2)
-          key, value = yield(key, value, delims[i])
-          if uniq && keys.include?(key)
-            ''
-          elsif key && value
-            "#{delims[i]}#{key}=#{value}"
-          elsif key
-            "#{delims[i]}#{key}".tap { keys << key }
-          else
-            ''
-          end
-        end.join.sub(/^[&;]/, '')
-      end
-
-      private_class_method :collect_query
-    end
-  end
-end