ddtrace 0.53.0 → 1.9.0

data/lib/ddtrace/profiling.rb

@@ -1,151 +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/cpu'
-      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

data/lib/ddtrace/runtime/metrics.rb

@@ -1,135 +0,0 @@
-# typed: true
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/runtime'
-
-require 'ddtrace/metrics'
-require 'datadog/core/environment/class_count'
-require 'datadog/core/environment/gc'
-require 'datadog/core/environment/identity'
-require 'datadog/core/environment/thread_count'
-require 'datadog/core/environment/vm_cache'
-
-module Datadog
-  module Runtime
-    # For generating runtime metrics
-    class Metrics < Datadog::Metrics
-      def initialize(**options)
-        super
-
-        # Initialize service list
-        @services = Set.new(options.fetch(:services, []))
-        @service_tags = nil
-        compile_service_tags!
-      end
-
-      def associate_with_span(span)
-        return if !enabled? || span.nil?
-
-        # Register service as associated with metrics
-        register_service(span.service) unless span.service.nil?
-
-        # Tag span with language and runtime ID for association with metrics.
-        # We only tag spans that performed internal application work.
-        unless span.get_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE)
-          span.set_tag(Ext::Runtime::TAG_LANG, Core::Environment::Identity.lang)
-        end
-      end
-
-      # Associate service with runtime metrics
-      def register_service(service)
-        return if !enabled? || service.nil?
-
-        service = service.to_s
-
-        unless @services.include?(service)
-          # Add service to list and update services tag
-          services << service
-
-          # Recompile the service tags
-          compile_service_tags!
-        end
-      end
-
-      # Flush all runtime metrics to Statsd client
-      def flush
-        return unless enabled?
-
-        try_flush do
-          if Core::Environment::ClassCount.available?
-            gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
-          end
-        end
-
-        try_flush do
-          if Core::Environment::ThreadCount.available?
-            gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
-          end
-        end
-
-        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
-
-        try_flush do
-          if Core::Environment::VMCache.available?
-            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_CONSTANT_STATE, Core::Environment::VMCache.global_constant_state)
-
-            # global_method_state is not available since Ruby >= 3.0,
-            # as method caching was moved to a per-class basis.
-            global_method_state = Core::Environment::VMCache.global_method_state
-            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
-          end
-        end
-      end
-
-      def gc_metrics
-        Core::Environment::GC.stat.flat_map do |k, v|
-          nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
-        end.to_h
-      end
-
-      def try_flush
-        yield
-      rescue StandardError => e
-        Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
-      end
-
-      def default_metric_options
-        # Return dupes, so that the constant isn't modified,
-        # and defaults are unfrozen for mutation in Statsd.
-        super.tap do |options|
-          options[:tags] = options[:tags].dup
-
-          # Add services dynamically because they might change during runtime.
-          options[:tags].concat(service_tags) unless service_tags.nil?
-        end
-      end
-
-      private
-
-      attr_reader \
-        :service_tags,
-        :services
-
-      def compile_service_tags!
-        @service_tags = services.to_a.collect do |service|
-          "#{Ext::Runtime::Metrics::TAG_SERVICE}:#{service}".freeze
-        end
-      end
-
-      def nested_gc_metric(prefix, k, v)
-        path = "#{prefix}.#{k}"
-
-        if v.is_a?(Hash)
-          v.flat_map do |key, value|
-            nested_gc_metric(path, key, value)
-          end
-        else
-          [[to_metric_name(path), v]]
-        end
-      end
-
-      def to_metric_name(str)
-        str.downcase.gsub(/[-\s]/, '_')
-      end
-    end
-  end
-end