ddtrace 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3896d5d634a6a65d95f815955b5e62108562a55c
-  data.tar.gz: a4d606173f9f92749e757bccc17a8524a91a916e
+  metadata.gz: b0875d09844d2557b344cda645c3a378d0b33a1b
+  data.tar.gz: dd0bfd29b724ae66809b769512d971379cc56853
 SHA512:
-  metadata.gz: 9ef525976240577dd0d39692749416765ace3b5542202d6b9db4674c8467c2d76c3bcfa8a4755e62b79fc31d4478c49960b10aba4607d3963d71754518fac240
-  data.tar.gz: 9eaf559a0c2d59798e8441c45342f3d3084358955e318677e42c506a95f548ad5b688eee4b0edf649e7f638befa6ee621337e6dd591fc9d12ebe011de30d8283
+  metadata.gz: cf0a24f6e5dc2198f8108fbb6f477295d73db47bd439d1f9b10b4b8b01e9aa006e9922180976b7a851b5bb6474558ccd950543944e343e332c00e77de7a503b3
+  data.tar.gz: 48410c488ae9fdaec44b519e702badf58ccc651bfb4204988b11e078598b6c4f6bc61c607a97ee313fcc708d562e9bf035045c13beb463fae6e1beb94cb46cea

data/Rakefile

@@ -92,6 +92,8 @@ end
 
 YARD::Rake::YardocTask.new(:docs) do |t|
   t.options += ['--title', "ddtrace #{Datadog::VERSION::STRING} documentation"]
+  t.options += ['--markup', 'markdown']
+  t.options += ['--markup-provider', 'redcarpet']
 end
 
 # Deploy tasks

data/ddtrace.gemspec

@@ -39,4 +39,5 @@ EOS
   spec.add_development_dependency 'minitest', '= 5.10.1'
   spec.add_development_dependency 'appraisal', '~> 2.2'
   spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'redcarpet', '~> 3.4' if RUBY_PLATFORM != 'java'
 end

data/docs/GettingStarted.md

@@ -24,17 +24,18 @@ The easiest way to get started with the tracing client is to instrument your web
 provides auto instrumentation for the following web frameworks and libraries:
 
 * [Ruby on Rails](#Ruby_on_Rails)
-* [Sidekiq](#Sidekiq)
 * [Sinatra](#Sinatra)
 * [Rack](#Rack)
 * [Grape](#Grape)
 * [Active Record](#Active_Record)
 * [Elastic Search](#Elastic_Search)
 * [MongoDB](#MongoDB)
-* [Dalli](#Dalli)
-* [Faraday](#Faraday)
+* [Sidekiq](#Sidekiq)
+* [Resque](#Resque)
 * [SuckerPunch](#SuckerPunch)
 * [Net/HTTP](#Net_HTTP)
+* [Faraday](#Faraday)
+* [Dalli](#Dalli)
 * [Redis](#Redis)
 
 ## Web Frameworks
@@ -365,6 +366,23 @@ The `faraday` integration is available through the `ddtrace` middleware:
 
     connection.get('/foo')
 
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Type | Default | Description |
+| --- | --- | --- | --- |
+| `split_by_domain` | Boolean | `false` | Uses the request domain as the service name when set to `true`. |
+| `distributed_tracing` | Boolean | `false` | Propagates tracing context along the HTTP request when set to `true`. |
+| `error_handler` | Callable | ``5xx`` evaluated as errors | A callable object that receives a single argument – the request environment. If it evaluates to a *truthy* value, the trace span is marked as an error. |
+
+It's worth mentioning that `ddtrace` also supports instrumentation for the
+`net/http` library, so if you're using it as farady's backend you might see
+instrumentation both on `faraday` and `net/http` levels. If you want to avoid
+multiple levels of instrumentation for your HTTP requests, remember that you can
+always fine tune which libraries are patched by calling:
+
+    Datadog::Monkey.patch([:faraday, :redis])
+    # instead of using Datadog::Monkey.patch_all
+
 ### AWS
 
 The AWS integration will trace every interaction (e.g. API calls) with AWS
@@ -422,21 +440,6 @@ executions. It can be added as any other Sidekiq middleware:
       end
     end
 
-### SuckerPunch
-
-The `sucker_punch` integration traces all scheduled jobs:
-
-    require 'ddtrace'
-
-    Datadog::Monkey.patch_module(:sucker_punch)
-
-    # the execution of this job is traced
-    LogJob.perform_async('login')
-
-    # to change SuckerPunch service name, use the Pin class
-    pin = Datadog::Pin.get_from(::SuckerPunch)
-    pin.service = 'deploy-queues'
-
 #### Configure the tracer middleware
 
 To modify the default configuration, simply pass arguments to the middleware.
@@ -475,22 +478,41 @@ giving precedence to the middleware settings. Inherited configurations are:
 * ``trace_agent_hostname``
 * ``trace_agent_port``
 
-Where `options` is an optional `Hash` that accepts the following parameters:
+### Resque
 
-| Key | Type | Default | Description |
-| --- | --- | --- | --- |
-| `split_by_domain` | Boolean | `false` | Uses the request domain as the service name when set to `true`. |
-| `distributed_tracing` | Boolean | `false` | Propagates tracing context along the HTTP request when set to `true`. |
-| `error_handler` | Callable | [Click Here](https://github.com/DataDog/dd-trace-rb/blob/4fe3bc9df032eac3cd294b0bebcc866080dbe04f/lib/ddtrace/contrib/faraday/middleware.rb#L11-L13) | A callable object that receives a single argument – the request environment. If it evaluates to a *truthy* value, the trace span is marked as an error. By default, only server-side errors (e.g. `5xx`) are flagged as errors. |
+The Resque integration uses Resque hooks that wraps the ``perform`` method.
+To add tracing to a Resque job, extend your base class with the provided
+one:
 
-It's worth mentioning that `ddtrace` also supports instrumentation for the
-`net/http` library, so if you're using it as farady's backend you might see
-instrumentation both on `faraday` and `net/http` levels. If you want to avoid
-multiple levels of instrumentation for your HTTP requests, remember that you can
-always fine tune witch libraries are patched by calling:
+    require 'ddtrace'
+    require 'ddtrace/contrib/resque/resque_job'
+
+    # patch Resque
+    Datadog::Monkey.patch_module(:resque)
+
+    class MyJob
+      # extend MyJob with integration hooks
+      extend Datadog::Contrib::Resque::ResqueJob
+
+      def self.perform(*args)
+        # do_something
+      end
+    end
+
+### SuckerPunch
+
+The `sucker_punch` integration traces all scheduled jobs:
+
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:sucker_punch)
+
+    # the execution of this job is traced
+    LogJob.perform_async('login')
 
-    Datadog::Monkey.patch([:foo, :bar])
-    # instead of Datadog::Monkey.patch_all
+    # to change SuckerPunch service name, use the Pin class
+    pin = Datadog::Pin.get_from(::SuckerPunch)
+    pin.service = 'deploy-queues'
 
 ## Advanced usage
 
@@ -771,8 +793,11 @@ sent upstream.  To achieve that, you can hook custom *processors* into the
 pipeline using the method `Datadog::Pipeline.before_flush`:
 
     Datadog::Pipeline.before_flush(
+      # filter the Span if the given block evaluates true
       Datadog::Pipeline::SpanFilter.new { |span| span.resource =~ /PingController/ },
       Datadog::Pipeline::SpanFilter.new { |span| span.get_tag('host') == 'localhost' }
+
+      # alter the Span updating fields or tags
       Datadog::Pipeline::SpanProcessor.new { |span| span.resource.gsub!(/password=.*/, '') }
     )
 
@@ -844,11 +869,6 @@ Currently we are supporting Sinatra >= 1.4.0.
 
 Currently we are supporting Sidekiq >= 4.0.0.
 
-### Glossary
+### Terminology
 
-* ``Service``: The name of a set of processes that do the same job. Some examples are ``datadog-web-app`` or ``datadog-metrics-db``.
-* ``Resource``: A particular query to a service. For a web application, some examples might be a URL stem like ``/user/home`` or a
-handler function like ``web.user.home``. For a SQL database, a resource would be the SQL of the query itself like ``select * from users where id = ?``.
-You can track thousands (not millions or billions) of unique resources per services, so prefer resources like ``/user/home`` rather than ``/user/home?id=123456789``.
-* ``Span``: A span tracks a unit of work in a service, like querying a database or rendering a template. Spans are associated
-with a service and optionally a resource. Spans have names, start times, durations and optional tags.
+If you need more context about the terminology used in the APM, take a look at the [official documentation](https://docs.datadoghq.com/tracing/terminology/).

data/lib/ddtrace/contrib/rails/action_controller.rb

@@ -9,19 +9,9 @@ module Datadog
         def self.instrument
           # patch Rails core components
           Datadog::RailsActionPatcher.patch_action_controller
-
-          # subscribe when the request processing starts
-          ::ActiveSupport::Notifications.subscribe('!datadog.start_processing.action_controller') do |*args|
-            start_processing(*args)
-          end
-
-          # subscribe when the request processing has been completed
-          ::ActiveSupport::Notifications.subscribe('!datadog.finish_processing.action_controller') do |*args|
-            finish_processing(*args)
-          end
         end
 
-        def self.start_processing(_name, _start, _finish, _id, payload)
+        def self.start_processing(payload)
           # trace the execution
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
           service = ::Rails.configuration.datadog_trace.fetch(:default_controller_service)
@@ -35,7 +25,7 @@ module Datadog
           Datadog::Tracer.log.error(e.message)
         end
 
-        def self.finish_processing(_name, start, finish, _id, payload)
+        def self.finish_processing(payload)
           # retrieve the tracing context and the latest active span
           tracing_context = payload.fetch(:tracing_context)
           span = tracing_context[:dd_request_span]

data/lib/ddtrace/contrib/rails/action_view.rb

@@ -7,30 +7,10 @@ module Datadog
       module ActionView
         def self.instrument
           # patch Rails core components
-          Datadog::RailsRendererPatcher.patch_renderer()
-
-          # subscribe when the template rendering starts
-          ::ActiveSupport::Notifications.subscribe('!datadog.start_render_template.action_view') do |*args|
-            start_render_template(*args)
-          end
-
-          # subscribe when the template rendering has been processed
-          ::ActiveSupport::Notifications.subscribe('!datadog.finish_render_template.action_view') do |*args|
-            finish_render_template(*args)
-          end
-
-          # subscribe when the partial rendering starts
-          ::ActiveSupport::Notifications.subscribe('!datadog.start_render_partial.action_view') do |*args|
-            start_render_partial(*args)
-          end
-
-          # subscribe when the partial rendering has been processed
-          ::ActiveSupport::Notifications.subscribe('!datadog.finish_render_partial.action_view') do |*args|
-            finish_render_partial(*args)
-          end
+          Datadog::RailsRendererPatcher.patch_renderer
         end
 
-        def self.start_render_template(_name, _start, _finish, _id, payload)
+        def self.start_render_template(payload)
           # retrieve the tracing context
           tracing_context = payload.fetch(:tracing_context)
 
@@ -42,7 +22,7 @@ module Datadog
           Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.finish_render_template(_name, _start, _finish, _id, payload)
+        def self.finish_render_template(payload)
           # retrieve the tracing context and the latest active span
           tracing_context = payload.fetch(:tracing_context)
           span = tracing_context[:dd_rails_template_span]
@@ -64,7 +44,7 @@ module Datadog
           Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.start_render_partial(_name, _start, _finish, _id, payload)
+        def self.start_render_partial(payload)
           # retrieve the tracing context
           tracing_context = payload.fetch(:tracing_context)
 
@@ -75,7 +55,7 @@ module Datadog
           Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.finish_render_partial(_name, start, finish, _id, payload)
+        def self.finish_render_partial(payload)
           # retrieve the tracing context and the latest active span
           tracing_context = payload.fetch(:tracing_context)
           span = tracing_context[:dd_rails_partial_span]

data/lib/ddtrace/contrib/rails/active_support.rb

@@ -8,20 +8,10 @@ module Datadog
       module ActiveSupport
         def self.instrument
           # patch Rails core components
-          Datadog::RailsCachePatcher.patch_cache_store()
-
-          # subscribe when a cache read starts being processed
-          ::ActiveSupport::Notifications.subscribe('!datadog.start_cache_tracing.active_support') do |*args|
-            start_trace_cache(*args)
-          end
-
-          # subscribe when a cache read has been processed
-          ::ActiveSupport::Notifications.subscribe('!datadog.finish_cache_tracing.active_support') do |*args|
-            finish_trace_cache(*args)
-          end
+          Datadog::RailsCachePatcher.patch_cache_store
         end
 
-        def self.start_trace_cache(_name, _start, _finish, _id, payload)
+        def self.start_trace_cache(payload)
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
           tracing_context = payload.fetch(:tracing_context)
 
@@ -45,7 +35,7 @@ module Datadog
           Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.finish_trace_cache(_name, _start, _finish, _id, payload)
+        def self.finish_trace_cache(payload)
           # retrieve the tracing context and continue the trace
           tracing_context = payload.fetch(:tracing_context)
           span = tracing_context[:dd_cache_span]

data/lib/ddtrace/contrib/rails/core_extensions.rb

@@ -2,7 +2,7 @@ module Datadog
   # RailsRendererPatcher contains function to patch Rails rendering libraries.
   # rubocop:disable Lint/RescueException
   # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/ModuleLength
   module RailsRendererPatcher
     module_function
 
@@ -27,11 +27,9 @@ module Datadog
           # context when a partial is rendered
           @tracing_context ||= {}
           if @tracing_context.empty?
-            ::ActiveSupport::Notifications.instrument(
-              '!datadog.start_render_template.action_view',
-              tracing_context: @tracing_context
-            )
+            Datadog::Contrib::Rails::ActionView.start_render_template(tracing_context: @tracing_context)
           end
+
           render_without_datadog(*args)
         rescue Exception => e
           # attach the exception to the tracing context if any
@@ -39,10 +37,7 @@ module Datadog
           raise e
         ensure
           # ensure that the template `Span` is finished even during exceptions
-          ::ActiveSupport::Notifications.instrument(
-            '!datadog.finish_render_template.action_view',
-            tracing_context: @tracing_context
-          )
+          Datadog::Contrib::Rails::ActionView.finish_render_template(tracing_context: @tracing_context)
         end
 
         def render_template_with_datadog(*args)
@@ -90,10 +85,7 @@ module Datadog
         def render_with_datadog(*args, &block)
           # create a tracing context and start the rendering span
           @tracing_context = {}
-          ::ActiveSupport::Notifications.instrument(
-            '!datadog.start_render_partial.action_view',
-            tracing_context: @tracing_context
-          )
+          Datadog::Contrib::Rails::ActionView.start_render_partial(tracing_context: @tracing_context)
           render_without_datadog(*args)
         rescue Exception => e
           # attach the exception to the tracing context if any
@@ -101,10 +93,7 @@ module Datadog
           raise e
         ensure
           # ensure that the template `Span` is finished even during exceptions
-          ::ActiveSupport::Notifications.instrument(
-            '!datadog.finish_render_partial.action_view',
-            tracing_context: @tracing_context
-          )
+          Datadog::Contrib::Rails::ActionView.finish_render_partial(tracing_context: @tracing_context)
         end
 
         def render_partial_with_datadog(*args)
@@ -143,24 +132,25 @@ module Datadog
           # mutable payload with a tracing context that is used in two different
           # signals; it propagates the request span so that it can be finished
           # no matter what
-          raw_payload = {
+          payload = {
             controller: self.class.name,
             action: action_name,
             tracing_context: {}
           }
 
-          # emits two different signals that start and finish the trace; this approach
-          # mimics the original behavior that is available since Rails 3.0:
-          # - https://github.com/rails/rails/blob/3-0-stable/actionpack/lib/action_controller/metal/instrumentation.rb#L17-L35
-          # - https://github.com/rails/rails/blob/5-1-stable/actionpack/lib/action_controller/metal/instrumentation.rb#L17-L39
-          ActiveSupport::Notifications.instrument('!datadog.start_processing.action_controller', raw_payload)
-
-          # process the request and finish the trace
-          ActiveSupport::Notifications.instrument('!datadog.finish_processing.action_controller', raw_payload) do |payload|
+          begin
+            # process and catch request exceptions
+            Datadog::Contrib::Rails::ActionController.start_processing(payload)
             result = process_action_without_datadog(*args)
             payload[:status] = response.status
             result
+          rescue Exception => e
+            payload[:exception] = [e.class.name, e.message]
+            payload[:exception_object] = e
+            raise e
           end
+        ensure
+          Datadog::Contrib::Rails::ActionController.finish_processing(payload)
         end
 
         alias_method :process_action_without_datadog, :process_action
@@ -206,11 +196,17 @@ module Datadog
             tracing_context: {}
           }
 
-          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
-
-          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+          begin
+            # process and catch cache exceptions
+            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(raw_payload)
             read_without_datadog(*args, &block)
+          rescue Exception => e
+            payload[:exception] = [e.class.name, e.message]
+            payload[:exception_object] = e
+            raise e
           end
+        ensure
+          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(raw_payload)
         end
       end
     end
@@ -225,11 +221,17 @@ module Datadog
             tracing_context: {}
           }
 
-          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
-
-          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+          begin
+            # process and catch cache exceptions
+            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(raw_payload)
             fetch_without_datadog(*args, &block)
+          rescue Exception => e
+            payload[:exception] = [e.class.name, e.message]
+            payload[:exception_object] = e
+            raise e
           end
+        ensure
+          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(raw_payload)
         end
       end
     end
@@ -244,11 +246,17 @@ module Datadog
             tracing_context: {}
           }
 
-          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
-
-          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+          begin
+            # process and catch cache exceptions
+            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(raw_payload)
             write_without_datadog(*args, &block)
+          rescue Exception => e
+            payload[:exception] = [e.class.name, e.message]
+            payload[:exception_object] = e
+            raise e
           end
+        ensure
+          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(raw_payload)
         end
       end
     end
@@ -263,11 +271,17 @@ module Datadog
             tracing_context: {}
           }
 
-          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
-
-          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+          begin
+            # process and catch cache exceptions
+            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(raw_payload)
             delete_without_datadog(*args, &block)
+          rescue Exception => e
+            payload[:exception] = [e.class.name, e.message]
+            payload[:exception_object] = e
+            raise e
           end
+        ensure
+          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(raw_payload)
         end
       end
     end

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -8,6 +8,7 @@ module Datadog
       module ResqueJob
         def around_perform(*args)
           pin = Pin.get_from(::Resque)
+          return yield unless pin && pin.tracer
           pin.tracer.trace('resque.job', service: pin.service) do |span|
             span.resource = name
             span.span_type = pin.app_type
@@ -18,7 +19,7 @@ module Datadog
 
         def after_perform(*args)
           pin = Pin.get_from(::Resque)
-          pin.tracer.shutdown!
+          pin.tracer.shutdown! if pin && pin.tracer
         end
       end
     end
@@ -27,5 +28,15 @@ end
 
 Resque.before_first_fork do
   pin = Datadog::Pin.get_from(Resque)
+  next unless pin && pin.tracer
   pin.tracer.set_service_info(pin.service, 'resque', Datadog::Ext::AppTypes::WORKER)
 end
+
+Resque.after_fork do
+  # get the current tracer
+  pin = Datadog::Pin.get_from(Resque)
+  next unless pin && pin.tracer
+  # clean the state so no CoW happens
+  pin.tracer.provider.context = nil
+  pin.tracer.writer.start
+end

data/lib/ddtrace/pin.rb

@@ -34,11 +34,11 @@ module Datadog
       false
     end
 
+    # rubocop:disable Style/TrivialAccessors
     def onto(obj)
       unless obj.respond_to? :datadog_pin=
         obj.instance_exec do
           def datadog_pin=(pin)
-            Datadog::Tracer.log.debug("Set pin #{pin.service} on #{self.class}.")
             @datadog_pin = pin
           end
         end
@@ -47,7 +47,6 @@ module Datadog
       unless obj.respond_to? :datadog_pin
         obj.instance_exec do
           def datadog_pin
-            Datadog::Tracer.log.debug("Get pin from #{self.class}.")
             @datadog_pin
           end
         end

data/lib/ddtrace/tracer.rb

@@ -259,13 +259,8 @@ module Datadog
     # * +span_type+: the type of the span (such as \http, \db and so on)
     # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
-      opts = options.select do |k, _v|
-        # Filter options, we want no side effects with unexpected args.
-        # Plus, this documents the code (Ruby 2 named args would be better but we're Ruby 1.9 compatible)
-        [:service, :resource, :span_type, :tags].include?(k)
-      end
-      opts[:child_of] = call_context
-      span = start_span(name, opts)
+      options[:child_of] = call_context
+      span = start_span(name, options)
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns

data/lib/ddtrace/version.rb

@@ -2,7 +2,7 @@ module Datadog
   module VERSION
     MAJOR = 0
     MINOR = 9
-    PATCH = 0
+    PATCH = 1
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/ddtrace/workers.rb

@@ -10,6 +10,8 @@ module Datadog
     # with the +stop()+ method and can start with the +start()+ method.
     class AsyncTransport
       DEFAULT_TIMEOUT = 5
+      BACK_OFF_RATIO = 1.2
+      BACK_OFF_MAX = 5
 
       attr_reader :trace_buffer, :service_buffer, :shutting_down
 
@@ -17,6 +19,7 @@ module Datadog
         @trace_task = trace_task
         @service_task = service_task
         @flush_interval = interval
+        @back_off = interval
         @trace_buffer = TraceBuffer.new(buff_size)
         @service_buffer = TraceBuffer.new(buff_size)
         @transport = transport
@@ -28,7 +31,7 @@ module Datadog
 
       # Callback function that process traces and executes the +send_traces()+ method.
       def callback_traces
-        return if @trace_buffer.empty?
+        return true if @trace_buffer.empty?
 
         begin
           traces = @trace_buffer.pop()
@@ -44,7 +47,7 @@ module Datadog
 
       # Callback function that process traces and executes the +send_services()+ method.
       def callback_services
-        return if @service_buffer.empty?
+        return true if @service_buffer.empty?
 
         begin
           services = @service_buffer.pop()
@@ -65,9 +68,11 @@ module Datadog
           Datadog::Tracer.log.debug("Starting thread in the process: #{Process.pid}")
 
           while @run
-            callback_traces
+            @back_off = callback_traces ? @flush_interval : [@back_off * BACK_OFF_RATIO, BACK_OFF_MAX].min
+
             callback_services
-            sleep(@flush_interval) if @run
+
+            sleep(@back_off) if @run
           end
         end
       end

data/lib/ddtrace/writer.rb

@@ -33,6 +33,7 @@ module Datadog
     # spawns two different workers for spans and services;
     # they share the same transport which is thread-safe
     def start
+      @pid = Process.pid
       @trace_handler = ->(items, transport) { send_spans(items, transport) }
       @service_handler = ->(items, transport) { send_services(items, transport) }
       @worker = Datadog::Workers::AsyncTransport.new(@transport,
@@ -55,16 +56,10 @@ module Datadog
       return true if traces.empty?
 
       code = transport.send(:traces, traces)
+      status = !transport.server_error?(code)
+      @traces_flushed += traces.length if status
 
-      if transport.server_error? code # requeue on server error, skip on success or client error
-        traces[0..@buff_size].each do |trace|
-          @worker.enqueue_trace trace
-        end
-        return false
-      end
-
-      @traces_flushed += traces.length()
-      true
+      status
     end
 
     # flush services to the trace-agent, handles services only
@@ -72,13 +67,10 @@ module Datadog
       return true if services.empty?
 
       code = transport.send(:services, services)
-      if transport.server_error? code # requeue on server error, skip on success or client error
-        @worker.enqueue_service services
-        return false
-      end
+      status = !transport.server_error?(code)
+      @services_flushed += 1 if status
 
-      @services_flushed += 1
-      true
+      status
     end
 
     # enqueue the trace for submission to the API
@@ -94,7 +86,6 @@ module Datadog
       pid = Process.pid
       @mutex_after_fork.synchronize do
         if pid != @pid
-          @pid = pid
           # we should start threads because the worker doesn't own this
           start()
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-06 00:00:00.000000000 Z
+date: 2017-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description: |
   ddtrace is Datadog’s tracing client for Ruby. It is used to trace requests
   as they flow across web servers, databases and microservices so that developers