ddtrace 0.35.2 → 1.1.0

data/lib/ddtrace/opentracer.rb

@@ -1,40 +0,0 @@
-module Datadog
-  # Namespace for ddtrace OpenTracing implementation
-  module OpenTracer
-    module_function
-
-    def supported?
-      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1')
-    end
-
-    def load_opentracer
-      require 'opentracing'
-      require 'opentracing/carrier'
-      require 'ddtrace'
-      require 'ddtrace/opentracer/carrier'
-      require 'ddtrace/opentracer/tracer'
-      require 'ddtrace/opentracer/span'
-      require 'ddtrace/opentracer/span_context'
-      require 'ddtrace/opentracer/span_context_factory'
-      require 'ddtrace/opentracer/scope'
-      require 'ddtrace/opentracer/scope_manager'
-      require 'ddtrace/opentracer/thread_local_scope'
-      require 'ddtrace/opentracer/thread_local_scope_manager'
-      require 'ddtrace/opentracer/distributed_headers'
-      require 'ddtrace/opentracer/propagator'
-      require 'ddtrace/opentracer/text_map_propagator'
-      require 'ddtrace/opentracer/binary_propagator'
-      require 'ddtrace/opentracer/rack_propagator'
-      require 'ddtrace/opentracer/global_tracer'
-
-      # Modify the OpenTracing module functions
-      OpenTracing.module_eval do
-        class << self
-          prepend Datadog::OpenTracer::GlobalTracer
-        end
-      end
-    end
-
-    load_opentracer if supported?
-  end
-end

data/lib/ddtrace/patcher.rb

@@ -1,47 +0,0 @@
-module Datadog
-  # Defines some useful patching methods for integrations
-  module Patcher
-    def self.included(base)
-      base.send(:extend, CommonMethods)
-      base.send(:include, CommonMethods)
-    end
-
-    # Defines some common methods for patching, that can be used
-    # at the instance, class, or module level.
-    module CommonMethods
-      def without_warnings
-        # This is typically used when monkey patching functions such as
-        # intialize, which Ruby advices you not to. Use cautiously.
-        v = $VERBOSE
-        $VERBOSE = nil
-        begin
-          yield
-        ensure
-          $VERBOSE = v
-        end
-      end
-
-      def do_once(key = nil, options = {})
-        # If already done, don't do again
-        @done_once ||= Hash.new { |h, k| h[k] = {} }
-        if @done_once.key?(key) && @done_once[key].key?(options[:for])
-          return @done_once[key][options[:for]]
-        end
-
-        # Otherwise 'do'
-        yield.tap do
-          # Then add the key so we don't do again.
-          @done_once[key][options[:for]] = true
-        end
-      end
-
-      def done?(key, options = {})
-        return false unless instance_variable_defined?(:@done_once)
-        !@done_once.nil? && @done_once.key?(key) && @done_once[key].key?(options[:for])
-      end
-    end
-
-    # Extend the common methods so they're available as a module function.
-    extend(CommonMethods)
-  end
-end

data/lib/ddtrace/pin.rb

@@ -1,114 +0,0 @@
-require 'ddtrace/patcher'
-
-# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
-module Datadog
-  # A \Pin (a.k.a Patch INfo) is a small class which is used to
-  # set tracing metadata on a particular traced object.
-  # This is useful if you wanted to, say, trace two different
-  # database clusters.
-  class Pin
-    def self.get_from(obj)
-      return nil unless obj.respond_to? :datadog_pin
-      obj.datadog_pin
-    end
-
-    attr_reader :service_name
-    attr_accessor :app
-    attr_accessor :tags
-    attr_accessor :app_type
-    attr_accessor :name
-    attr_accessor :tracer
-    attr_accessor :config
-
-    def initialize(service_name, options = {})
-      @app = options[:app]
-      @tags = options[:tags]
-      @app_type = options[:app_type]
-      @name = nil # this would rarely be overriden as it's really span-specific
-      @tracer = options[:tracer] || Datadog.tracer
-      @config = options[:config]
-      self.service_name = service_name
-    end
-
-    def enabled?
-      return @tracer.enabled if @tracer
-      false
-    end
-
-    # rubocop:disable Style/TrivialAccessors
-    def onto(obj)
-      unless obj.respond_to? :datadog_pin=
-        obj.instance_exec do
-          def datadog_pin=(pin)
-            @datadog_pin = pin
-          end
-        end
-      end
-
-      unless obj.respond_to? :datadog_pin
-        obj.instance_exec do
-          def datadog_pin
-            @datadog_pin
-          end
-        end
-      end
-
-      obj.datadog_pin = self
-    end
-
-    def service_name=(name)
-      @service_name = name
-    end
-
-    alias service= service_name=
-    alias service service_name
-
-    def to_s
-      "Pin(service:#{service},app:#{app},app_type:#{app_type},name:#{name})"
-    end
-  end
-
-  # Modification to Pin which logs deprecation warnings if accessed.
-  # Will be used by integrations which are phasing out the direct use of #datadog_pin.
-  module DeprecatedPin
-    include Datadog::Patcher
-
-    DEPRECATION_WARNING = %(
-      Use of Datadog::Pin is DEPRECATED.
-      Upgrade to the configuration API using the migration guide here:
-      https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-    # Raise a deprecation warning when #datadog_pin or #datadog_pin= is accessed.
-    def onto(obj)
-      obj.instance_exec(self) do |pin|
-        @datadog_deprecated_pin = pin
-
-        unless respond_to? :datadog_pin=
-          def datadog_pin=(pin)
-            @datadog_deprecated_pin.log_deprecation_warning('#datadog_pin=')
-            @datadog_pin = pin
-          end
-        end
-
-        unless respond_to? :datadog_pin
-          def datadog_pin
-            @datadog_deprecated_pin.log_deprecation_warning('#datadog_pin')
-            @datadog_pin
-          end
-        end
-
-        # Set instance variable to avoid deprecation warnings
-        @datadog_pin = @datadog_deprecated_pin
-      end
-
-      self
-    end
-
-    def log_deprecation_warning(method_name)
-      # Only log each deprecation warning once (safeguard against log spam)
-      do_once(method_name) do
-        Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
-      end
-    end
-  end
-end

data/lib/ddtrace/pipeline/span_filter.rb

@@ -1,38 +0,0 @@
-module Datadog
-  module Pipeline
-    # SpanFilter implements a processor that filters entire span subtrees
-    class SpanFilter
-      def initialize(filter = nil, &block)
-        callable = filter || block
-
-        raise(ArgumentError) unless callable.respond_to?(:call)
-
-        @criteria = filter || block
-      end
-
-      def call(trace)
-        black_list = trace.select(&method(:drop_it?))
-
-        clean_trace(black_list, trace) while black_list.any?
-
-        trace
-      end
-
-      private
-
-      def drop_it?(span)
-        @criteria.call(span) rescue false
-      end
-
-      def clean_trace(black_list, trace)
-        current = black_list.shift
-
-        trace.delete(current)
-
-        trace.each do |span|
-          black_list << span if span.parent == current
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/pipeline/span_processor.rb

@@ -1,20 +0,0 @@
-module Datadog
-  module Pipeline
-    # SpanProcessor
-    class SpanProcessor
-      def initialize(operation = nil, &block)
-        callable = operation || block
-
-        raise(ArgumentError) unless callable.respond_to?(:call)
-
-        @operation = operation || block
-      end
-
-      def call(trace)
-        trace.each do |span|
-          @operation.call(span) rescue next
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/pipeline.rb

@@ -1,46 +0,0 @@
-module Datadog
-  # Pipeline
-  module Pipeline
-    require_relative 'pipeline/span_filter'
-    require_relative 'pipeline/span_processor'
-
-    @mutex = Mutex.new
-    @processors = []
-
-    def self.before_flush(*processors, &processor_block)
-      processors = [processor_block] if processors.empty?
-
-      @mutex.synchronize do
-        @processors.concat(processors)
-      end
-    end
-
-    def self.process!(traces)
-      @mutex.synchronize do
-        traces
-          .map(&method(:apply_processors!))
-          .select(&:any?)
-      end
-    end
-
-    def self.processors=(value)
-      @processors = value
-    end
-
-    def self.apply_processors!(trace)
-      result = @processors.inject(trace) do |current_trace, processor|
-        processor.call(current_trace)
-      end
-
-      result || []
-    rescue => e
-      Datadog.logger.debug(
-        "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
-      )
-
-      []
-    end
-
-    private_class_method :apply_processors!
-  end
-end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -1,61 +0,0 @@
-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[GRPC_METADATA_TRACE_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
-      end
-
-      def parent_id
-        value = @metadata[GRPC_METADATA_PARENT_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
-      end
-
-      def sampling_priority
-        value = @metadata[GRPC_METADATA_SAMPLING_PRIORITY]
-        value && value.to_i
-      end
-
-      def origin
-        value = @metadata[GRPC_METADATA_ORIGIN]
-        value if value != ''
-      end
-    end
-  end
-end

data/lib/ddtrace/propagation/http_propagator.rb

@@ -1,75 +0,0 @@
-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]
-        propagator.inject!(context, env) unless propagator.nil?
-      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
-        extracted_context = propagator.extract(env)
-        # 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,103 +0,0 @@
-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,86 +0,0 @@
-require 'uri'
-require 'set'
-
-module Datadog
-  module Quantization
-    # Quantization for HTTP resources
-    module HTTP
-      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/cgroup.rb

@@ -1,44 +0,0 @@
-require 'ddtrace/ext/runtime'
-
-module Datadog
-  module Runtime
-    # For control groups
-    module Cgroup
-      LINE_REGEX = /^(\d+):([^:]*):(.+)$/
-
-      Descriptor = Struct.new(
-        :id,
-        :groups,
-        :path,
-        :controllers
-      )
-
-      module_function
-
-      def descriptors(process = 'self')
-        [].tap do |descriptors|
-          begin
-            filepath = "/proc/#{process}/cgroup"
-
-            if File.exist?(filepath)
-              File.open("/proc/#{process}/cgroup").each do |line|
-                line = line.strip
-                descriptors << parse(line) unless line.empty?
-              end
-            end
-          rescue StandardError => e
-            Datadog.logger.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
-          end
-        end
-      end
-
-      def parse(line)
-        id, groups, path = line.scan(LINE_REGEX).first
-
-        Descriptor.new(id, groups, path).tap do |descriptor|
-          descriptor.controllers = groups.split(',') unless groups.nil?
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/runtime/class_count.rb

@@ -1,17 +0,0 @@
-module Datadog
-  module Runtime
-    # Retrieves number of classes from runtime
-    module ClassCount
-      module_function
-
-      def value
-        ::ObjectSpace.count_objects[:T_CLASS]
-      end
-
-      def available?
-        ::ObjectSpace.respond_to?(:count_objects) \
-          && ::ObjectSpace.count_objects.key?(:T_CLASS)
-      end
-    end
-  end
-end