ddtrace 0.54.0 → 1.0.0

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