ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -13,14 +13,17 @@ module Datadog
       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)
+                           sampling_priority: metadata.sampling_priority,
+                           origin: metadata.origin)
     end
 
     # opentracing.io compliant carrier object
@@ -36,19 +39,36 @@ module Datadog
       end
 
       def trace_id
-        value = @metadata[GRPC_METADATA_TRACE_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        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[GRPC_METADATA_PARENT_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        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[GRPC_METADATA_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,28 +1,90 @@
+require 'ddtrace/configuration'
 require 'ddtrace/context'
 require 'ddtrace/ext/distributed'
-require 'ddtrace/propagation/distributed_headers'
+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)
-      env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
-      env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
-      env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s
-      env.delete(HTTP_HEADER_SAMPLING_PRIORITY) unless context.sampling_priority
+      # 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: #{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)
-      headers = DistributedHeaders.new(env)
-      return Datadog::Context.new unless headers.valid?
-      Datadog::Context.new(trace_id: headers.trace_id,
-                           span_id: headers.parent_id,
-                           sampling_priority: headers.sampling_priority)
+      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: #{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/http.rb

@@ -61,6 +61,7 @@ module Datadog
       # 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
 

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+):([^:]*):(.+)$/.freeze
+
+      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.foreach("/proc/#{process}/cgroup") 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

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

data/lib/ddtrace/runtime/container.rb

@@ -0,0 +1,71 @@
+require 'ddtrace/ext/runtime'
+require 'ddtrace/runtime/cgroup'
+
+module Datadog
+  module Runtime
+    # For container environments
+    module Container
+      UUID_PATTERN = '[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}'.freeze
+      CONTAINER_PATTERN = '[0-9a-f]{64}'.freeze
+
+      POD_REGEX = /(pod)?(#{UUID_PATTERN})(?:.slice)?$/.freeze
+      CONTAINER_REGEX = /(#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/.freeze
+
+      Descriptor = Struct.new(
+        :platform,
+        :container_id,
+        :task_uid
+      )
+
+      module_function
+
+      def platform
+        descriptor.platform
+      end
+
+      def container_id
+        descriptor.container_id
+      end
+
+      def task_uid
+        descriptor.task_uid
+      end
+
+      def descriptor
+        @descriptor ||= Descriptor.new.tap do |descriptor|
+          begin
+            Cgroup.descriptors.each do |cgroup_descriptor|
+              # Parse container data from cgroup descriptor
+              path = cgroup_descriptor.path
+              next if path.nil?
+
+              # Split path into parts
+              parts = path.split('/')
+              parts.shift # Remove leading empty part
+              next if parts.length < 2
+
+              # Read info from path
+              platform = parts[0]
+              container_id = parts[-1][CONTAINER_REGEX]
+              task_uid = parts[-2][POD_REGEX]
+
+              # If container ID wasn't found, ignore.
+              # Path might describe a non-container environment.
+              next if container_id.nil?
+
+              descriptor.platform = platform
+              descriptor.container_id = container_id
+              descriptor.task_uid = task_uid
+
+              break
+            end
+          rescue StandardError => e
+            Datadog.logger.error(
+              "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/gc.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Runtime
+    # Retrieves garbage collection statistics
+    module GC
+      module_function
+
+      def stat
+        ::GC.stat
+      end
+
+      def available?
+        defined?(::GC) && ::GC.respond_to?(:stat)
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/identity.rb

@@ -0,0 +1,48 @@
+require 'securerandom'
+require 'ddtrace/ext/runtime'
+require 'ddtrace/utils/forking'
+
+module Datadog
+  module Runtime
+    # For runtime identity
+    module Identity
+      extend Datadog::Utils::Forking
+
+      module_function
+
+      # Retrieves number of classes from runtime
+      def id
+        @id ||= SecureRandom.uuid
+
+        # Check if runtime has changed, e.g. forked.
+        after_fork! { @id = SecureRandom.uuid }
+
+        @id
+      end
+
+      def lang
+        Ext::Runtime::LANG
+      end
+
+      def lang_engine
+        Ext::Runtime::LANG_ENGINE
+      end
+
+      def lang_interpreter
+        Ext::Runtime::LANG_INTERPRETER
+      end
+
+      def lang_platform
+        Ext::Runtime::LANG_PLATFORM
+      end
+
+      def lang_version
+        Ext::Runtime::LANG_VERSION
+      end
+
+      def tracer_version
+        Ext::Runtime::TRACER_VERSION
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/metrics.rb

@@ -0,0 +1,114 @@
+require 'ddtrace/ext/integration'
+require 'ddtrace/ext/runtime'
+
+require 'ddtrace/metrics'
+require 'ddtrace/runtime/class_count'
+require 'ddtrace/runtime/gc'
+require 'ddtrace/runtime/identity'
+require 'ddtrace/runtime/thread_count'
+
+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, Runtime::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 { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
+        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
+        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+      end
+
+      def gc_metrics
+        Hash[
+          GC.stat.flat_map do |k, v|
+            nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
+          end
+        ]
+      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