ddtrace 0.38.0

data/lib/ddtrace/pipeline.rb

@@ -0,0 +1,46 @@
+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/pipeline/span_filter.rb

@@ -0,0 +1,38 @@
+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
+
+      # Note: this SpanFilter implementation only handles traces in which child spans appear
+      # after parent spans in the trace array. If in the future child spans can be before
+      # parent spans, then the code below will need to be updated.
+      def call(trace)
+        deleted = Set.new
+
+        trace.delete_if do |span|
+          if deleted.include?(span.parent)
+            deleted << span
+            true
+          else
+            drop = drop_it?(span)
+            deleted << span if drop
+            drop
+          end
+        end
+      end
+
+      private
+
+      def drop_it?(span)
+        @criteria.call(span) rescue false
+      end
+    end
+  end
+end

data/lib/ddtrace/pipeline/span_processor.rb

@@ -0,0 +1,20 @@
+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/propagation/grpc_propagator.rb

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,44 @@
+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