ddtrace 0.15.0.beta1 → 0.15.0.internaltracinfeature1

data/lib/ddtrace/context.rb

@@ -13,14 +13,16 @@ module Datadog
   # \Context, it will be related to the original trace.
   #
   # This data structure is thread-safe.
+  # rubocop:disable Metrics/ClassLength
   class Context
     # 100k spans is about a 100Mb footprint
     DEFAULT_MAX_LENGTH = 100_000
 
     attr_reader :max_length
 
-    # Initialize a new \Context.
+    # Initialize a new thread-safe \Context.
     def initialize(options = {})
+      @mutex = Mutex.new
       # max_length is the amount of spans above which, for a given trace,
       # the context will simply drop and ignore spans, avoiding high memory usage.
       @max_length = options.fetch(:max_length, DEFAULT_MAX_LENGTH)
@@ -28,56 +30,82 @@ module Datadog
     end
 
     def trace_id
-      @parent_trace_id
+      @mutex.synchronize do
+        @parent_trace_id
+      end
     end
 
     def span_id
-      @parent_span_id
+      @mutex.synchronize do
+        @parent_span_id
+      end
     end
 
-    attr_reader :sampling_priority
+    def sampling_priority
+      @mutex.synchronize do
+        @sampling_priority
+      end
+    end
 
-    attr_writer :sampling_priority
+    def sampling_priority=(priority)
+      @mutex.synchronize do
+        @sampling_priority = priority
+      end
+    end
 
     # Return the last active span that corresponds to the last inserted
     # item in the trace list. This cannot be considered as the current active
     # span in asynchronous environments, because some spans can be closed
     # earlier while child spans still need to finish their traced execution.
-    attr_reader :current_span, :current_root_span
+    def current_span
+      @mutex.synchronize do
+        return @current_span
+      end
+    end
+
+    def current_root_span
+      @mutex.synchronize do
+        return @current_root_span
+      end
+    end
 
     # Add a span to the context trace list, keeping it as the last active span.
     def add_span(span)
-      # If hitting the hard limit, just drop spans. This is really a rare case
-      # as it means despite the soft limit, the hard limit is reached, so the trace
-      # by default has 10000 spans, all of which belong to unfinished parts of a
-      # larger trace. This is a catch-all to reduce global memory usage.
-      if @max_length > 0 && @trace.length >= @max_length
-        Datadog::Tracer.log.debug("context full, ignoring span #{span.name}")
-        # Detach the span from any context, it's being dropped and ignored.
-        span.context = nil
-        return
-      end
-      set_current_span(span)
-      @current_root_span = span if @trace.empty?
-      @trace << span
-      span.context = self
+      @mutex.synchronize do
+        # If hitting the hard limit, just drop spans. This is really a rare case
+        # as it means despite the soft limit, the hard limit is reached, so the trace
+        # by default has 10000 spans, all of which belong to unfinished parts of a
+        # larger trace. This is a catch-all to reduce global memory usage.
+        if @max_length > 0 && @trace.length >= @max_length
+          Datadog::Tracer.log.debug("context full, ignoring span #{span.name}")
+          # Detach the span from any context, it's being dropped and ignored.
+          span.context = nil
+          return
+        end
+        set_current_span(span)
+        @current_root_span = span if @trace.empty?
+        @trace << span
+        span.context = self
+      end
     end
 
     # Mark a span as a finished, increasing the internal counter to prevent
     # cycles inside _trace list.
     def close_span(span)
-      @finished_spans += 1
-      # Current span is only meaningful for linear tree-like traces,
-      # in other cases, this is just broken and one should rely
-      # on per-instrumentation code to retrieve handle parent/child relations.
-      set_current_span(span.parent)
-      return if span.tracer.nil?
-      return unless Datadog::Tracer.debug_logging
-      if span.parent.nil? && !check_finished_spans
-        opened_spans = @trace.length - @finished_spans
-        Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
-        @trace.each do |s|
-          Datadog::Tracer.log.debug("unfinished span: #{s}") unless s.finished?
+      @mutex.synchronize do
+        @finished_spans += 1
+        # Current span is only meaningful for linear tree-like traces,
+        # in other cases, this is just broken and one should rely
+        # on per-instrumentation code to retrieve handle parent/child relations.
+        set_current_span(span.parent)
+        return if span.tracer.nil?
+        return unless Datadog::Tracer.debug_logging
+        if span.parent.nil? && !check_finished_spans
+          opened_spans = @trace.length - @finished_spans
+          Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
+          @trace.each do |s|
+            Datadog::Tracer.log.debug("unfinished span: #{s}") unless s.finished?
+          end
         end
       end
     end
@@ -85,13 +113,17 @@ module Datadog
     # Returns if the trace for the current Context is finished or not. A \Context
     # is considered finished if all spans in this context are finished.
     def finished?
-      check_finished_spans
+      @mutex.synchronize do
+        return check_finished_spans
+      end
     end
 
     # Returns true if the context is sampled, that is, if it should be kept
     # and sent to the trace agent.
     def sampled?
-      @sampled
+      @mutex.synchronize do
+        return @sampled
+      end
     end
 
     # Returns both the trace list generated in the current context and
@@ -101,22 +133,26 @@ module Datadog
     #
     # This operation is thread-safe.
     def get
-      trace = @trace
-      sampled = @sampled
+      @mutex.synchronize do
+        trace = @trace
+        sampled = @sampled
 
-      attach_sampling_priority if sampled && @sampling_priority
+        attach_sampling_priority if sampled && @sampling_priority
 
-      # still return sampled attribute, even if context is not finished
-      return nil, sampled unless check_finished_spans()
+        # still return sampled attribute, even if context is not finished
+        return nil, sampled unless check_finished_spans()
 
-      reset
-      [trace, sampled]
+        reset
+        [trace, sampled]
+      end
     end
 
     # Return a string representation of the context.
     def to_s
-      # rubocop:disable Metrics/LineLength
-      "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
+      @mutex.synchronize do
+        # rubocop:disable Metrics/LineLength
+        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
+      end
     end
 
     private
@@ -158,37 +194,45 @@ module Datadog
 
     # Return the start time of the root span, or nil if there are no spans or this is undefined.
     def start_time
-      return nil if @trace.empty?
-      @trace[0].start_time
+      @mutex.synchronize do
+        return nil if @trace.empty?
+        @trace[0].start_time
+      end
     end
 
     # Return the length of the current trace held by this context.
     def length
-      @trace.length
+      @mutex.synchronize do
+        @trace.length
+      end
     end
 
     # Iterate on each span within the trace. This is thread safe.
     def each_span
-      @trace.each do |span|
-        yield span
+      @mutex.synchronize do
+        @trace.each do |span|
+          yield span
+        end
       end
     end
 
     # Delete any span matching the condition. This is thread safe.
     def delete_span_if
-      @trace.delete_if do |span|
-        finished = span.finished?
-        delete_span = yield span
-        if delete_span
-          # We need to detach the span from the context, else, some code
-          # finishing it afterwards would mess up with the number of
-          # finished_spans and possibly cause other side effects.
-          span.context = nil
-          # Acknowledge there's one span less to finish, if needed.
-          # It's very important to keep this balanced.
-          @finished_spans -= 1 if finished
+      @mutex.synchronize do
+        @trace.delete_if do |span|
+          finished = span.finished?
+          delete_span = yield span
+          if delete_span
+            # We need to detach the span from the context, else, some code
+            # finishing it afterwards would mess up with the number of
+            # finished_spans and possibly cause other side effects.
+            span.context = nil
+            # Acknowledge there's one span less to finish, if needed.
+            # It's very important to keep this balanced.
+            @finished_spans -= 1 if finished
+          end
+          delete_span
         end
-        delete_span
       end
     end
   end

data/lib/ddtrace/contrib/concurrent_ruby/configuration/settings.rb

@@ -0,0 +1,13 @@
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      module Configuration
+        class Settings < Contrib::Configuration::Settings
+          # Add any custom ConcurrentRuby configuration or behavior here.
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/context_composite_executor_service.rb

@@ -0,0 +1,35 @@
+require 'concurrent/executor/executor_service'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # wraps existing executor to carry over trace context
+      class ContextCompositeExecutorService
+        extend Forwardable
+        include Concurrent::ExecutorService
+
+        attr_accessor :composited_executor
+
+        def initialize(composited_executor)
+          @composited_executor = composited_executor
+        end
+
+        # post method runs the task within composited executor - in a different thread
+        def post(*args, &task)
+          context = datadog_configuration.tracer.provider.context
+
+          @composited_executor.post(*args) do
+            datadog_configuration.tracer.provider.context = context
+            yield
+          end
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:concurrent_ruby]
+        end
+
+        delegate [:can_overflow?, :serialized?] => :composited_executor
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/future_patch.rb

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/concurrent_ruby/context_composite_executor_service'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+      module FuturePatch
+        def self.included(base)
+          base.class_eval do
+            alias_method :ns_initialize_without_datadog, :ns_initialize
+            remove_method(:ns_initialize)
+
+            def ns_initialize(value, opts)
+              ns_initialize_without_datadog(value, opts)
+
+              @executor = ContextCompositeExecutorService.new(@executor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/integration.rb

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/concurrent_ruby/patcher'
+require 'ddtrace/contrib/concurrent_ruby/configuration/settings'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # Propagate Tracing context in Concurrent::Future
+      class Integration
+        include Contrib::Integration
+
+        register_as :concurrent_ruby
+
+        def self.compatible?
+          defined?(::Concurrent::Future)
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/patcher.rb

@@ -0,0 +1,34 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # Patcher enables patching of 'Future' class.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:concurrent_ruby)
+        end
+
+        def patch
+          do_once(:concurrent_ruby) do
+            begin
+              require 'ddtrace/contrib/concurrent_ruby/future_patch'
+
+              patch_future
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Future integration: #{e}")
+            end
+          end
+        end
+
+        def patch_future
+          ::Concurrent::Future.send(:include, FuturePatch)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -1,5 +1,6 @@
 require 'ddtrace/ext/http'
 require 'ddtrace/ext/errors'
+require 'ddtrace/contrib/rack/middlewares'
 
 module Datadog
   module Contrib

data/lib/ddtrace/contrib/graphql/patcher.rb

@@ -29,12 +29,20 @@ module Datadog
             tracer = get_option(:tracer)
             service_name = get_option(:service_name)
 
-            schema.define do
-              use(
+            if schema.respond_to?(:use)
+              schema.use(
                 ::GraphQL::Tracing::DataDogTracing,
                 tracer: tracer,
                 service: service_name
               )
+            else
+              schema.define do
+                use(
+                  ::GraphQL::Tracing::DataDogTracing,
+                  tracer: tracer,
+                  service: service_name
+                )
+              end
             end
           end
 

data/lib/ddtrace/contrib/http/patcher.rb

@@ -14,27 +14,37 @@ module Datadog
 
       module_function
 
-      def should_skip_tracing?(req, address, port, transport, pin)
+      def tracing_transport?(req, address, port, transport)
         # we don't want to trace our own call to the API (they use net/http)
         # when we know the host & port (from the URI) we use it, else (most-likely
         # called with a block) rely on the URL at the end.
         if req.respond_to?(:uri) && req.uri
           if req.uri.host.to_s == transport.hostname.to_s &&
              req.uri.port.to_i == transport.port.to_i
-            return true
+            true
           end
         elsif address && port &&
               address.to_s == transport.hostname.to_s &&
               port.to_i == transport.port.to_i
-          return true
+          true
         end
+      end
+
+      def tracing_recursive_request?(tracer)
         # we don't want a "shotgun" effect with two nested traces for one
         # logical get, and request is likely to call itself recursively
-        active = pin.tracer.active_span()
+        active = tracer.active_span
         return true if active && (active.name == NAME)
         false
       end
 
+      # @deprecated This method will be removed in 1.0
+      def should_skip_tracing?(req, address, port, transport, pin)
+        Datadog::Tracer.log.error('should_skip_tracing? will be deprecated in 1.0')
+
+        tracing_transport?(req, address, port, transport) || tracing_recursive_request?(pin.tracer)
+      end
+
       def should_skip_distributed_tracing?(pin)
         if pin.config && pin.config.key?(:distributed_tracing)
           return !pin.config[:distributed_tracing]
@@ -99,12 +109,15 @@ module Datadog
             end
 
             def request(req, body = nil, &block) # :yield: +response+
+              transport = Datadog.configuration[:http][:tracer].writer.transport
+              if Datadog::Contrib::HTTP.tracing_transport?(req, @address, @port, transport)
+                return request_without_datadog(req, body, &block)
+              end
+
               pin = datadog_pin
               return request_without_datadog(req, body, &block) unless pin && pin.tracer
 
-              transport = pin.tracer.writer.transport
-
-              if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
+              if Datadog::Contrib::HTTP.tracing_recursive_request?(pin.tracer)
                 return request_without_datadog(req, body, &block)
               end