ddtrace 0.8.2 → 0.9.0

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

@@ -0,0 +1,50 @@
+module Datadog
+  module Contrib
+    module SuckerPunch
+      SERVICE = 'sucker_punch'.freeze
+      COMPATIBLE_WITH = Gem::Version.new('2.0.0')
+
+      # Responsible for hooking the instrumentation into `sucker_punch`
+      module Patcher
+        @patched = false
+
+        module_function
+
+        def patch
+          return @patched if patched? || !compatible?
+
+          require 'ddtrace/ext/app_types'
+          require_relative 'exception_handler'
+          require_relative 'instrumentation'
+
+          add_pin!
+          ExceptionHandler.patch!
+          Instrumentation.patch!
+
+          @patched = true
+        rescue => e
+          Datadog::Tracer.log.error("Unable to apply SuckerPunch integration: #{e}")
+          @patched
+        end
+
+        def patched?
+          @patched
+        end
+
+        def compatible?
+          return unless defined?(::SuckerPunch::VERSION)
+
+          Gem::Version.new(::SuckerPunch::VERSION) >= COMPATIBLE_WITH
+        end
+
+        def add_pin!
+          Pin.new(SERVICE, app_type: Ext::AppTypes::WORKER).tap do |pin|
+            pin.onto(::SuckerPunch)
+          end
+        end
+
+        private_class_method :compatible?, :add_pin!
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/http.rb

@@ -6,6 +6,7 @@ module Datadog
       URL = 'http.url'.freeze
       METHOD = 'http.method'.freeze
       STATUS_CODE = 'http.status_code'.freeze
+      ERROR_RANGE = 500...600
     end
   end
 end

data/lib/ddtrace/ext/mongo.rb

@@ -0,0 +1,12 @@
+module Datadog
+  module Ext
+    module Mongo
+      DB = 'mongodb.db'.freeze
+      TYPE = 'mongodb'.freeze
+      ROWS = 'mongodb.rows'.freeze
+      QUERY = 'mongodb.query'.freeze
+      OPERATION = 'mongodb.operation'.freeze
+      COLLECTION = 'mongodb.collection'.freeze
+    end
+  end
+end

data/lib/ddtrace/monkey.rb

@@ -5,9 +5,15 @@ require 'thread'
 # patching code, which is required on demand, when patching.
 require 'ddtrace/contrib/active_record/patcher'
 require 'ddtrace/contrib/elasticsearch/patcher'
+require 'ddtrace/contrib/faraday/patcher'
 require 'ddtrace/contrib/grape/patcher'
 require 'ddtrace/contrib/redis/patcher'
 require 'ddtrace/contrib/http/patcher'
+require 'ddtrace/contrib/aws/patcher'
+require 'ddtrace/contrib/sucker_punch/patcher'
+require 'ddtrace/contrib/mongodb/patcher'
+require 'ddtrace/contrib/dalli/patcher'
+require 'ddtrace/contrib/resque/patcher'
 
 module Datadog
   # Monkey is used for monkey-patching 3rd party libs.
@@ -18,6 +24,12 @@ module Datadog
       http: true,
       redis: true,
       grape: true,
+      faraday: true,
+      aws: true,
+      sucker_punch: true,
+      mongo: true,
+      dalli: true,
+      resque: true,
       active_record: false
     }
     # Patchers should expose 2 methods:
@@ -29,6 +41,12 @@ module Datadog
                   http: Datadog::Contrib::HTTP::Patcher,
                   redis: Datadog::Contrib::Redis::Patcher,
                   grape: Datadog::Contrib::Grape::Patcher,
+                  faraday: Datadog::Contrib::Faraday::Patcher,
+                  aws: Datadog::Contrib::Aws::Patcher,
+                  sucker_punch: Datadog::Contrib::SuckerPunch::Patcher,
+                  mongo: Datadog::Contrib::MongoDB::Patcher,
+                  dalli: Datadog::Contrib::Dalli::Patcher,
+                  resque: Datadog::Contrib::Resque::Patcher,
                   active_record: Datadog::Contrib::ActiveRecord::Patcher }
     @mutex = Mutex.new
 

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::Tracer.log.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
+
+      def call(trace)
+        black_list = trace.select(&method(:drop_it?))
+
+        clean_trace(black_list, trace) while black_list.any?
+
+        trace
+      end
+
+      private
+
+      def drop_it?(span)
+        @criteria.call(span) rescue false
+      end
+
+      def clean_trace(black_list, trace)
+        current = black_list.shift
+
+        trace.delete(current)
+
+        trace.each do |span|
+          black_list << span if span.parent == current
+        end
+      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/tracer.rb

@@ -57,6 +57,23 @@ module Datadog
       log.level == Logger::DEBUG
     end
 
+    # Shorthand that calls the `shutdown!` method of a registered worker.
+    # It's useful to ensure that the Trace Buffer is properly flushed before
+    # shutting down the application.
+    #
+    # For instance:
+    #
+    #   tracer.trace('operation_name', service='rake_tasks') do |span|
+    #     span.set_tag('task.name', 'script')
+    #   end
+    #
+    #   tracer.shutdown!
+    #
+    def shutdown!
+      return if !@enabled || @writer.worker.nil?
+      @writer.worker.shutdown!
+    end
+
     # Return the current active \Context for this traced execution. This method is
     # automatically called when calling Tracer.trace or Tracer.start_span,
     # but it can be used in the application code during manual instrumentation.
@@ -303,6 +320,7 @@ module Datadog
       end
 
       @writer.write(trace, @services)
+      @services = {}
     end
 
     private :write, :guess_context_and_parent

data/lib/ddtrace/utils.rb

@@ -1,16 +1,36 @@
-require 'thread'
-
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
   module Utils
     # We use a custom random number generator because we want no interference
     # with the default one. Using the default prng, we could break code that
     # would rely on srand/rand sequences.
-    @rnd = Random.new
 
     # Return a span id
     def self.next_id
+      reset! if was_forked?
+
       @rnd.rand(Datadog::Span::MAX_ID)
     end
+
+    def self.reset!
+      @pid = Process.pid
+      @rnd = Random.new
+    end
+
+    def self.was_forked?
+      Process.pid != @pid
+    end
+
+    def self.truncate(value, size, omission = '...')
+      string = value.to_s
+
+      return string if string.size <= size
+
+      string.slice(0, size - omission.size) + omission
+    end
+
+    private_class_method :reset!, :was_forked?
+
+    reset!
   end
 end

data/lib/ddtrace/version.rb

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

data/lib/ddtrace/workers.rb

@@ -9,14 +9,18 @@ module Datadog
     # will perform a task at regular intervals. The thread can be stopped
     # with the +stop()+ method and can start with the +start()+ method.
     class AsyncTransport
-      def initialize(span_interval, service_interval, transport, buff_size, trace_task, service_task)
+      DEFAULT_TIMEOUT = 5
+
+      attr_reader :trace_buffer, :service_buffer, :shutting_down
+
+      def initialize(transport, buff_size, trace_task, service_task, interval)
         @trace_task = trace_task
         @service_task = service_task
-        @span_interval = span_interval
-        @service_interval = service_interval
+        @flush_interval = interval
         @trace_buffer = TraceBuffer.new(buff_size)
         @service_buffer = TraceBuffer.new(buff_size)
         @transport = transport
+        @shutting_down = false
 
         @worker = nil
         @run = false
@@ -28,6 +32,7 @@ module Datadog
 
         begin
           traces = @trace_buffer.pop()
+          traces = Pipeline.process!(traces)
           @trace_task.call(traces, @transport)
         rescue StandardError => e
           # ensures that the thread will not die because of an exception.
@@ -43,16 +48,7 @@ module Datadog
 
         begin
           services = @service_buffer.pop()
-          # pick up the latest services hash (this is a FIFO list)
-          # that is different from what we sent before.
-          different = services.inject(false) { |acc, elem| elem != @last_flushed_services ? elem : acc }
-          if different
-            if @service_task.call(different, @transport)
-              @last_flushed_services = different.clone
-            end
-          else
-            Datadog::Tracer.log.debug('No new different services, skipping flush.')
-          end
+          @service_task.call(services[0], @transport)
         rescue StandardError => e
           # ensures that the thread will not die because of an exception.
           # TODO[manu]: findout the reason and reschedule the send if it's not
@@ -67,17 +63,11 @@ module Datadog
         @run = true
         @worker = Thread.new() do
           Datadog::Tracer.log.debug("Starting thread in the process: #{Process.pid}")
-          @last_flushed_services = nil
-          next_send_services = Time.now
 
-          # this loop assumes spans are flushed more often than services
           while @run
             callback_traces
-            if Time.now >= next_send_services
-              next_send_services = Time.now + @service_interval
-              callback_services
-            end
-            sleep(@span_interval)
+            callback_services
+            sleep(@flush_interval) if @run
           end
         end
       end
@@ -87,9 +77,27 @@ module Datadog
         @run = false
       end
 
+      # Closes all available queues and waits for the trace and service buffer to flush
+      def shutdown!
+        return false if @shutting_down
+        @shutting_down = true
+        @trace_buffer.close
+        @service_buffer.close
+        sleep(0.1)
+        timeout_time = Time.now + DEFAULT_TIMEOUT
+        while (!@trace_buffer.empty? || !@service_buffer.empty?) && Time.now <= timeout_time
+          sleep(0.05)
+          Datadog::Tracer.log.debug('Waiting for the buffers to clear before exiting')
+        end
+        stop
+        join
+        @shutting_down = false
+        true
+      end
+
       # Block until executor shutdown is complete or until timeout seconds have passed.
       def join
-        @worker.join(10)
+        @worker.join(5)
       end
 
       # Enqueue an item in the trace internal buffer. This operation is thread-safe

data/lib/ddtrace/writer.rb

@@ -5,7 +5,7 @@ require 'ddtrace/workers'
 module Datadog
   # Traces and services writer that periodically sends data to the trace-agent
   class Writer
-    attr_reader :transport
+    attr_reader :transport, :worker
 
     HOSTNAME = 'localhost'.freeze
     PORT = '8126'.freeze
@@ -13,8 +13,7 @@ module Datadog
     def initialize(options = {})
       # writer and transport parameters
       @buff_size = options.fetch(:buffer_size, 100)
-      @span_interval = options.fetch(:spans_interval, 1)
-      @service_interval = options.fetch(:services_interval, 120)
+      @flush_interval = options.fetch(:flush_interval, 1)
 
       # transport and buffers
       @transport = options.fetch(:transport, Datadog::HTTPTransport.new(HOSTNAME, PORT))
@@ -36,12 +35,11 @@ module Datadog
     def start
       @trace_handler = ->(items, transport) { send_spans(items, transport) }
       @service_handler = ->(items, transport) { send_services(items, transport) }
-      @worker = Datadog::Workers::AsyncTransport.new(@span_interval,
-                                                     @service_interval,
-                                                     @transport,
+      @worker = Datadog::Workers::AsyncTransport.new(@transport,
                                                      @buff_size,
                                                      @trace_handler,
-                                                     @service_handler)
+                                                     @service_handler,
+                                                     @flush_interval)
 
       @worker.start()
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-08 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -42,16 +42,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: 0.49.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: 0.49.1
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -137,11 +137,23 @@ files:
 - lib/ddtrace/buffer.rb
 - lib/ddtrace/context.rb
 - lib/ddtrace/contrib/active_record/patcher.rb
+- lib/ddtrace/contrib/aws/instrumentation.rb
+- lib/ddtrace/contrib/aws/parsed_context.rb
+- lib/ddtrace/contrib/aws/patcher.rb
+- lib/ddtrace/contrib/aws/services.rb
+- lib/ddtrace/contrib/dalli/instrumentation.rb
+- lib/ddtrace/contrib/dalli/patcher.rb
+- lib/ddtrace/contrib/dalli/quantize.rb
 - lib/ddtrace/contrib/elasticsearch/patcher.rb
 - lib/ddtrace/contrib/elasticsearch/quantize.rb
+- lib/ddtrace/contrib/faraday/middleware.rb
+- lib/ddtrace/contrib/faraday/patcher.rb
 - lib/ddtrace/contrib/grape/endpoint.rb
 - lib/ddtrace/contrib/grape/patcher.rb
 - lib/ddtrace/contrib/http/patcher.rb
+- lib/ddtrace/contrib/mongodb/parsers.rb
+- lib/ddtrace/contrib/mongodb/patcher.rb
+- lib/ddtrace/contrib/mongodb/subscribers.rb
 - lib/ddtrace/contrib/rack/middlewares.rb
 - lib/ddtrace/contrib/rails/action_controller.rb
 - lib/ddtrace/contrib/rails/action_view.rb
@@ -154,8 +166,13 @@ files:
 - lib/ddtrace/contrib/redis/patcher.rb
 - lib/ddtrace/contrib/redis/quantize.rb
 - lib/ddtrace/contrib/redis/tags.rb
+- lib/ddtrace/contrib/resque/patcher.rb
+- lib/ddtrace/contrib/resque/resque_job.rb
 - lib/ddtrace/contrib/sidekiq/tracer.rb
 - lib/ddtrace/contrib/sinatra/tracer.rb
+- lib/ddtrace/contrib/sucker_punch/exception_handler.rb
+- lib/ddtrace/contrib/sucker_punch/instrumentation.rb
+- lib/ddtrace/contrib/sucker_punch/patcher.rb
 - lib/ddtrace/distributed.rb
 - lib/ddtrace/encoding.rb
 - lib/ddtrace/error.rb
@@ -164,12 +181,16 @@ files:
 - lib/ddtrace/ext/distributed.rb
 - lib/ddtrace/ext/errors.rb
 - lib/ddtrace/ext/http.rb
+- lib/ddtrace/ext/mongo.rb
 - lib/ddtrace/ext/net.rb
 - lib/ddtrace/ext/redis.rb
 - lib/ddtrace/ext/sql.rb
 - lib/ddtrace/logger.rb
 - lib/ddtrace/monkey.rb
 - lib/ddtrace/pin.rb
+- lib/ddtrace/pipeline.rb
+- lib/ddtrace/pipeline/span_filter.rb
+- lib/ddtrace/pipeline/span_processor.rb
 - lib/ddtrace/provider.rb
 - lib/ddtrace/sampler.rb
 - lib/ddtrace/span.rb
@@ -200,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 2.6.9
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications