ddtrace 0.14.2 → 0.15.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 25dde262eb6c5e6fc818787e0393798fca7c427fabe3fd83acfde68ae75d5e4d
-  data.tar.gz: 384fc03cba261af39f3236d7ed1308ab5a706978f5ba8a0836538cd8f207cd49
+SHA1:
+  metadata.gz: 152355917a6f63e309d2fa3c2493df04f689bae2
+  data.tar.gz: ffbb1cd4275783dce93875758383ac0df983ac72
 SHA512:
-  metadata.gz: c4f348bf0337b3d820257f91bae3c8d95d0d47d6527eee841772e2beb66b7ca0679a325dc3d4d9027a53e518d437aa1522ced5dbadb865f2404c86c18c2908b6
-  data.tar.gz: 26919c343f9ee6bed204d6b08fdd741a5bd878b11a19aba6cf970f36e7e0ee863c4708070bcf0bad4885a66d85913a4e3e87f73f9b18d54b900e02208b9b9c0c
+  metadata.gz: 7143e0ffc5d84ca3f8305840f299cd021281cc45df6cad2c78460d431f835a2483af3f4cc9b9a0c75557c837fc997e3151a4d5e4cb0f19c776bd1960509652bf
+  data.tar.gz: 4918277463d66e58a51314d268305a1529564966cdb645bd31b6e9770644ee3e0bb455cbaf05de493e9cdefacc523444ccd4680dce41994b2d59ca8fa5e2239c

data/CHANGELOG.md

@@ -4,30 +4,15 @@
 
 ## [Unreleased (beta)]
 
-## [0.14.2] - 2018-08-23
+## [0.15.0.beta1] - 2018-08-15
 
-Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.14.2
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.15.0.beta1
 
-Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.14.1...v0.14.2
-
-### Fixed
-
-- Sampling priority from request headers not being used (#521)  
-
-
-## [0.14.1] - 2018-08-21
-
-Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.14.1
-
-Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0...v0.14.1
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0...v0.15.0.beta1
 
 ### Changed
 
-- Reduce verbosity of connection errors in log (#515)
-
-### Fixed
-
-- Sequel 'not a valid integration' error (#514, #516) (@steveh)
+- Reduced locking to improve multithreaded performance (#506)
 
 ## [0.14.0] - 2018-08-14
 
@@ -485,9 +470,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
-[Unreleased (stable)]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.1...master
-[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.1...0.15-dev
-[0.14.1]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0...v0.14.1
+[Unreleased (stable)]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0...master
+[Unreleased (beta)]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0...0.15-dev
 [0.14.0]: https://github.com/DataDog/dd-trace-rb/compare/v0.13.2...v0.14.0
 [0.14.0.rc1]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0.beta2...v0.14.0.rc1
 [0.14.0.beta2]: https://github.com/DataDog/dd-trace-rb/compare/v0.14.0.beta1...v0.14.0.beta2

data/lib/ddtrace.rb

@@ -44,29 +44,29 @@ module Datadog
 end
 
 require 'ddtrace/contrib/base'
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/rack/patcher'
+require 'ddtrace/contrib/rails/patcher'
 require 'ddtrace/contrib/active_model_serializers/patcher'
 require 'ddtrace/contrib/active_record/integration'
-require 'ddtrace/contrib/aws/patcher'
-require 'ddtrace/contrib/dalli/patcher'
-require 'ddtrace/contrib/delayed_job/patcher'
+require 'ddtrace/contrib/sequel/patcher'
 require 'ddtrace/contrib/elasticsearch/patcher'
-require 'ddtrace/contrib/excon/patcher'
 require 'ddtrace/contrib/faraday/patcher'
 require 'ddtrace/contrib/grape/patcher'
 require 'ddtrace/contrib/graphql/patcher'
 require 'ddtrace/contrib/grpc/patcher'
+require 'ddtrace/contrib/redis/patcher'
 require 'ddtrace/contrib/http/patcher'
-require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/aws/patcher'
+require 'ddtrace/contrib/sucker_punch/patcher'
+require 'ddtrace/contrib/rest_client/integration'
 require 'ddtrace/contrib/mongodb/patcher'
-require 'ddtrace/contrib/mysql2/patcher'
-require 'ddtrace/contrib/racecar/patcher'
-require 'ddtrace/contrib/rack/patcher'
-require 'ddtrace/contrib/rails/patcher'
+require 'ddtrace/contrib/dalli/patcher'
 require 'ddtrace/contrib/rake/patcher'
-require 'ddtrace/contrib/redis/patcher'
 require 'ddtrace/contrib/resque/patcher'
-require 'ddtrace/contrib/rest_client/integration'
-require 'ddtrace/contrib/sequel/integration'
+require 'ddtrace/contrib/delayed_job/patcher'
+require 'ddtrace/contrib/racecar/patcher'
 require 'ddtrace/contrib/sidekiq/patcher'
-require 'ddtrace/contrib/sucker_punch/patcher'
+require 'ddtrace/contrib/excon/patcher'
+require 'ddtrace/contrib/mysql2/patcher'
 require 'ddtrace/monkey'

data/lib/ddtrace/buffer.rb

@@ -8,7 +8,7 @@ module Datadog
     def initialize(max_size)
       @max_size = max_size
 
-      @mutex = Mutex.new()
+      @mutex = Mutex.new
       @traces = []
       @closed = false
     end
@@ -16,30 +16,20 @@ module Datadog
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
     # even if the buffer is full. In that case, a random trace is discarded.
     def push(trace)
-      @mutex.synchronize do
-        return if @closed
-        len = @traces.length
-        if len < @max_size || @max_size <= 0
-          @traces << trace
-        else
-          # we should replace a random trace with the new one
-          @traces[rand(len)] = trace
-        end
-      end
+      return if @closed
+      len = @traces.length
+      @traces.delete_at(rand(len)) if len >= @max_size && @max_size > 0
+      @traces << trace
     end
 
     # Return the current number of stored traces.
     def length
-      @mutex.synchronize do
-        return @traces.length
-      end
+      @traces.length
     end
 
     # Return if the buffer is empty.
     def empty?
-      @mutex.synchronize do
-        return @traces.empty?
-      end
+      @traces.empty?
     end
 
     # Stored traces are returned and the local buffer is reset.
@@ -52,9 +42,7 @@ module Datadog
     end
 
     def close
-      @mutex.synchronize do
-        @closed = true
-      end
+      @closed = true
     end
   end
 end

data/lib/ddtrace/context.rb

@@ -13,16 +13,14 @@ 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 thread-safe \Context.
+    # Initialize a new \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)
@@ -30,82 +28,56 @@ module Datadog
     end
 
     def trace_id
-      @mutex.synchronize do
-        @parent_trace_id
-      end
+      @parent_trace_id
     end
 
     def span_id
-      @mutex.synchronize do
-        @parent_span_id
-      end
+      @parent_span_id
     end
 
-    def sampling_priority
-      @mutex.synchronize do
-        @sampling_priority
-      end
-    end
+    attr_reader :sampling_priority
 
-    def sampling_priority=(priority)
-      @mutex.synchronize do
-        @sampling_priority = priority
-      end
-    end
+    attr_writer :sampling_priority
 
     # 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.
-    def current_span
-      @mutex.synchronize do
-        return @current_span
-      end
-    end
-
-    def current_root_span
-      @mutex.synchronize do
-        return @current_root_span
-      end
-    end
+    attr_reader :current_span, :current_root_span
 
     # Add a span to the context trace list, keeping it as the last active span.
     def add_span(span)
-      @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
+      # 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
 
     # Mark a span as a finished, increasing the internal counter to prevent
     # cycles inside _trace list.
     def close_span(span)
-      @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
+      @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
@@ -113,17 +85,13 @@ 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?
-      @mutex.synchronize do
-        return check_finished_spans
-      end
+      check_finished_spans
     end
 
     # Returns true if the context is sampled, that is, if it should be kept
     # and sent to the trace agent.
     def sampled?
-      @mutex.synchronize do
-        return @sampled
-      end
+      @sampled
     end
 
     # Returns both the trace list generated in the current context and
@@ -133,26 +101,22 @@ module Datadog
     #
     # This operation is thread-safe.
     def get
-      @mutex.synchronize do
-        trace = @trace
-        sampled = @sampled
+      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]
-      end
+      reset
+      [trace, sampled]
     end
 
     # Return a string representation of the context.
     def to_s
-      @mutex.synchronize do
-        # rubocop:disable Metrics/LineLength
-        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
-      end
+      # rubocop:disable Metrics/LineLength
+      "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
     end
 
     private
@@ -194,45 +158,37 @@ module Datadog
 
     # Return the start time of the root span, or nil if there are no spans or this is undefined.
     def start_time
-      @mutex.synchronize do
-        return nil if @trace.empty?
-        @trace[0].start_time
-      end
+      return nil if @trace.empty?
+      @trace[0].start_time
     end
 
     # Return the length of the current trace held by this context.
     def length
-      @mutex.synchronize do
-        @trace.length
-      end
+      @trace.length
     end
 
     # Iterate on each span within the trace. This is thread safe.
     def each_span
-      @mutex.synchronize do
-        @trace.each do |span|
-          yield span
-        end
+      @trace.each do |span|
+        yield span
       end
     end
 
     # Delete any span matching the condition. This is thread safe.
     def delete_span_if
-      @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
+      @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
     end
   end

data/lib/ddtrace/registry.rb

@@ -25,10 +25,8 @@ module Datadog
     end
 
     def [](name)
-      @mutex.synchronize do
-        entry = @data[name]
-        entry.klass if entry
-      end
+      entry = @data[name]
+      entry.klass if entry
     end
 
     def to_h

data/lib/ddtrace/sampler.rb

@@ -98,32 +98,14 @@ module Datadog
     end
 
     def sample(span)
-      return perform_sampling(span) unless span.context
-      return sampled_by_upstream(span) if span.context.sampling_priority
-
-      perform_sampling(span).tap do |sampled|
-        span.context.sampling_priority = if sampled
-                                           Datadog::Ext::Priority::AUTO_KEEP
-                                         else
-                                           Datadog::Ext::Priority::AUTO_REJECT
-                                         end
-      end
-    end
-
-    def_delegators :@post_sampler, :update
-
-    private
-
-    def sampled_by_upstream(span)
-      span.sampled = priority_keep?(span.context.sampling_priority)
-    end
+      span.context.sampling_priority = Datadog::Ext::Priority::AUTO_REJECT if span.context
+      return unless @base_sampler.sample(span)
+      return unless @post_sampler.sample(span)
+      span.context.sampling_priority = Datadog::Ext::Priority::AUTO_KEEP if span.context
 
-    def priority_keep?(sampling_priority)
-      sampling_priority == Datadog::Ext::Priority::USER_KEEP || sampling_priority == Datadog::Ext::Priority::AUTO_KEEP
+      true
     end
 
-    def perform_sampling(span)
-      @base_sampler.sample(span) && @post_sampler.sample(span)
-    end
+    def_delegators :@post_sampler, :update
   end
 end

data/lib/ddtrace/tracer.rb

@@ -103,7 +103,6 @@ module Datadog
 
       @context_flush = options[:partial_flush] ? Datadog::ContextFlush.new(options) : nil
 
-      @mutex = Mutex.new
       @services = {}
       @tags = {}
     end

data/lib/ddtrace/transport.rb

@@ -68,7 +68,6 @@ module Datadog
       @count_client_error = 0
       @count_server_error = 0
       @count_internal_error = 0
-      @count_consecutive_errors = 0
     end
 
     # route the send to the right endpoint
@@ -110,7 +109,7 @@ module Datadog
         response = Net::HTTP.start(@hostname, @port, read_timeout: TIMEOUT) { |http| http.request(request) }
         handle_response(response)
       rescue StandardError => e
-        log_error_once(e.message)
+        Datadog::Tracer.log.error(e.message)
         500
       end.tap do
         yield(response) if block_given?
@@ -171,22 +170,21 @@ module Datadog
 
       if success?(status_code)
         Datadog::Tracer.log.debug('Payload correctly sent to the trace agent.')
-        @mutex.synchronize { @count_consecutive_errors = 0 }
         @mutex.synchronize { @count_success += 1 }
       elsif downgrade?(status_code)
         Datadog::Tracer.log.debug("calling the endpoint but received #{status_code}; downgrading the API")
       elsif client_error?(status_code)
-        log_error_once("Client error: #{response.message}")
+        Datadog::Tracer.log.error("Client error: #{response.message}")
         @mutex.synchronize { @count_client_error += 1 }
       elsif server_error?(status_code)
-        log_error_once("Server error: #{response.message}")
+        Datadog::Tracer.log.error("Server error: #{response.message}")
+        @mutex.synchronize { @count_server_error += 1 }
       end
 
       status_code
     rescue StandardError => e
-      log_error_once(e.message)
+      Datadog::Tracer.log.error(e.message)
       @mutex.synchronize { @count_internal_error += 1 }
-
       500
     end
 
@@ -203,16 +201,6 @@ module Datadog
 
     private
 
-    def log_error_once(*args)
-      if @count_consecutive_errors > 0
-        Datadog::Tracer.log.debug(*args)
-      else
-        Datadog::Tracer.log.error(*args)
-      end
-
-      @mutex.synchronize { @count_consecutive_errors += 1 }
-    end
-
     def process_callback(action, response)
       return unless @response_callback && @response_callback.respond_to?(:call)
 

data/lib/ddtrace/version.rb

@@ -1,9 +1,9 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 14
-    PATCH = 2
-    PRE = nil
+    MINOR = 15
+    PATCH = 0
+    PRE = 'beta1'.freeze
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.14.2
+  version: 0.15.0.beta1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-24 00:00:00.000000000 Z
+date: 2018-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -435,12 +435,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications