ddtrace 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3bb99f4104ccd84acde3279b412e90d531ecfea
-  data.tar.gz: 63d063737c4e830b84d24471fc1ff356ca703af6
+  metadata.gz: edcd0745f2ad784016b18e4b7e4694e4af12223a
+  data.tar.gz: '0952683e8798ee961851a881d0ea4343a121572a'
 SHA512:
-  metadata.gz: b271d08b6eae8c40116c68b21ef46c4fb110fba35b331913b902e9fc0b7ce5fa4868e997c7984eff71d8f325f98f3276c6bc11b6da69bdf877903338fb599948
-  data.tar.gz: d86ca3ce85531ea82e437f2f9495deed831ab10a2e15d35a78a1095607f99c9ef901cb6cf800f084a4f4142f200f339997b60e30fa87b80d66de3c9706f23346
+  metadata.gz: 5cae4b99e2e0170f5a7da8a320ae7235ec7cc3431c8dee355a84e921b2f7933bbc2e32058547a8bea6dcbabfe94a4b1aff3bb293d7d059f480fca84f8ca5eb62
+  data.tar.gz: b74edf57aeee710af1024f68eee73e804f3bff2cb0ee4426c384b6fc8626f36db85ea7fa95e698d4b3cc32f33ffc78d2e6fdc49368a11a4122cf2a847ebaf9f8

data/Appraisals

@@ -114,7 +114,7 @@ end
 if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
   appraise 'contrib' do
     gem 'elasticsearch-transport'
-    gem 'mongo'
+    gem 'mongo', '< 2.5'
     gem 'grape'
     gem 'rack'
     gem 'rack-test'
@@ -129,11 +129,12 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
     gem 'dalli'
     gem 'resque', '< 2.0'
     gem 'racecar', '>= 0.3.5'
+    gem 'mysql2', platform: :ruby
   end
 else
   appraise 'contrib-old' do
     gem 'elasticsearch-transport'
-    gem 'mongo'
+    gem 'mongo', '< 2.5'
     gem 'redis', '< 4.0'
     gem 'hiredis'
     gem 'rack', '1.4.7'
@@ -146,5 +147,7 @@ else
     gem 'sucker_punch'
     gem 'dalli'
     gem 'resque', '< 2.0'
+    gem 'mysql2', '0.3.21', platform: :ruby
+    gem 'activerecord-mysql-adapter', platform: :ruby
   end
 end

data/README.md

@@ -75,7 +75,10 @@ you can activate it. The example above would become:
     require 'sinatra'
     require 'active_record'
 
-    Datadog::Monkey.patch_all # monkey patch all available integrations
+    Datadog.configure do |c|
+      c.use :sinatra
+      c.use :active_record
+    end
 
     # now write your code naturally, it's traced automatically
     get '/' do

data/Rakefile

@@ -11,11 +11,11 @@ desc 'Run RSpec'
 namespace :spec do
   task all: [:main,
              :rails, :railsredis, :railssidekiq, :railsactivejob,
-             :elasticsearch, :http, :redis, :sidekiq, :sinatra, :monkey]
+             :elasticsearch, :http, :redis, :sidekiq, :sinatra]
 
   RSpec::Core::RakeTask.new(:main) do |t|
     t.pattern = 'spec/**/*_spec.rb'
-    t.exclude_pattern = 'spec/**/{contrib,benchmark,redis}/**/*_spec.rb,spec/monkey_spec.rb'
+    t.exclude_pattern = 'spec/**/{contrib,benchmark,redis}/**/*_spec.rb'
   end
 
   RSpec::Core::RakeTask.new(:rails) do |t|
@@ -53,30 +53,26 @@ namespace :spec do
     :mongodb,
     :racecar,
     :resque,
+    :active_record,
     :dalli
   ].each do |contrib|
     RSpec::Core::RakeTask.new(contrib) do |t|
       t.pattern = "spec/ddtrace/contrib/#{contrib}/*_spec.rb"
     end
   end
-
-  RSpec::Core::RakeTask.new(:monkey) do |t|
-    t.pattern = 'spec/ddtrace/monkey_spec.rb'
-  end
 end
 
 namespace :test do
   task all: [:main,
              :rails, :railsredis, :railssidekiq, :railsactivejob,
-             :elasticsearch, :http, :redis, :sidekiq, :sinatra, :monkey]
+             :elasticsearch, :http, :redis, :sidekiq, :sinatra]
 
   Rake::TestTask.new(:main) do |t|
     t.libs << %w[test lib]
     t.test_files = FileList['test/**/*_test.rb'].reject do |path|
       path.include?('contrib') ||
         path.include?('benchmark') ||
-        path.include?('redis') ||
-        path.include?('monkey_test.rb')
+        path.include?('redis')
     end
   end
 
@@ -129,11 +125,6 @@ namespace :test do
       t.test_files = FileList["test/contrib/#{contrib}/*_test.rb"]
     end
   end
-
-  Rake::TestTask.new(:monkey) do |t|
-    t.libs << %w[test lib]
-    t.test_files = FileList['test/monkey_test.rb']
-  end
 end
 
 Rake::TestTask.new(:benchmark) do |t|
@@ -219,7 +210,6 @@ task :ci do
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:mongodb'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sucker_punch'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:resque'
-    sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:monkey'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:elasticsearch'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:http'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:redis'
@@ -231,9 +221,11 @@ task :ci do
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:sucker_punch'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:resque'
     # RSpec
+    sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:active_record'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:dalli'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:racecar'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake spec:dalli'
+    sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake spec:active_record'
   when 2
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sidekiq'
     sh 'rvm $SIDEKIQ_OLD_VERSIONS --verbose do appraisal contrib-old rake test:sidekiq'

data/docs/GettingStarted.md

@@ -77,7 +77,8 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | ``service_name`` | Service name used when tracing application requests (on the `rack` level) | ``<app_name>`` (inferred from your Rails application namespace) |
 | ``controller_service`` | Service name used when tracing a Rails action controller | ``<app_name>-controller`` |
 | ``cache_service`` | Cache service name used when tracing cache activity | ``<app_name>-cache`` |
-| ``database_service`` | Database service name used when tracing database activity | ``<app_name>-<adapter_name>``. |
+| ``database_service`` | Database service name used when tracing database activity | ``<app_name>-<adapter_name>`` |
+| ``exception_controller`` | Class or Module which identifies a custom exception controller class. Tracer provides improved error behavior when it can identify custom exception controllers. By default, without this option, it 'guesses' what a custom exception controller looks like. Providing this option aids this identification. | ``nil`` |
 | ``distributed_tracing`` | Enables [distributed tracing](#Distributed_Tracing) so that this service trace is connected with a trace of another service if tracing headers are received | `false` |
 | ``template_base_path`` | Used when the template name is parsed. If you don't store your templates in the ``views/`` folder, you may need to change this value | ``views/`` |
 | ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
@@ -107,6 +108,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | --- | --- | --- |
 | ``service_name`` | Service name used for `sinatra` instrumentation | sinatra |
 | ``resource_script_names`` | Prepend resource names with script name | ``false`` |
+| ``distributed_tracing`` | Enables [distributed tracing](#Distributed_Tracing) so that this service trace is connected with a trace of another service if tracing headers are received | `false` |
 | ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
 
 ### Rack

data/gemfiles/contrib.gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
 gem "elasticsearch-transport"
-gem "mongo"
+gem "mongo", "< 2.5"
 gem "grape"
 gem "rack"
 gem "rack-test"
@@ -19,5 +19,6 @@ gem "sucker_punch"
 gem "dalli"
 gem "resque", "< 2.0"
 gem "racecar", ">= 0.3.5"
+gem "mysql2", platform: :ruby
 
 gemspec path: "../"

data/gemfiles/contrib_old.gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
 gem "elasticsearch-transport"
-gem "mongo"
+gem "mongo", "< 2.5"
 gem "redis", "< 4.0"
 gem "hiredis"
 gem "rack", "1.4.7"
@@ -17,5 +17,7 @@ gem "aws-sdk", "~> 2.0"
 gem "sucker_punch"
 gem "dalli"
 gem "resque", "< 2.0"
+gem "mysql2", "0.3.21", platform: :ruby
+gem "activerecord-mysql-adapter", platform: :ruby
 
 gemspec path: "../"

data/lib/ddtrace.rb

@@ -1,9 +1,12 @@
+require 'thread'
+
 require 'ddtrace/registry'
 require 'ddtrace/pin'
 require 'ddtrace/tracer'
 require 'ddtrace/error'
 require 'ddtrace/pipeline'
 require 'ddtrace/configuration'
+require 'ddtrace/patcher'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -49,8 +52,19 @@ module Datadog
   end
 end
 
-# Monkey currently is responsible for loading all contributions, which in turn
-# rely on the registry defined above. We should make our code less dependent on
-# the load order, by letting things be lazily loaded while keeping
-# thread-safety.
-require 'ddtrace/monkey'
+require 'ddtrace/contrib/base'
+require 'ddtrace/contrib/rack/patcher'
+require 'ddtrace/contrib/rails/patcher'
+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'
+require 'ddtrace/contrib/racecar/patcher'
+require 'ddtrace/contrib/sidekiq/patcher'

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

@@ -2,11 +2,11 @@ module Datadog
   module Contrib
     module ActiveRecord
       # Patcher enables patching of 'active_record' module.
-      # This is used in monkey.rb to manually apply patches
       module Patcher
         include Base
         register_as :active_record, auto_patch: false
         option :service_name
+        option :tracer, default: Datadog.tracer
 
         @patched = false
 
@@ -58,22 +58,18 @@ module Datadog
           @adapter_port ||= Datadog::Contrib::Rails::Utils.adapter_port
         end
 
-        def self.tracer
-          @tracer ||= Datadog.configuration[:sinatra][:tracer]
-        end
-
         def self.database_service
           return @database_service if defined?(@database_service)
 
           @database_service = get_option(:service_name) || adapter_name
-          tracer.set_service_info(@database_service, 'sinatra', Ext::AppTypes::DB)
+          get_option(:tracer).set_service_info(@database_service, 'active_record', Ext::AppTypes::DB)
           @database_service
         end
 
         def self.sql(_name, start, finish, _id, payload)
           span_type = Datadog::Ext::SQL::TYPE
 
-          span = tracer.trace(
+          span = get_option(:tracer).trace(
             "#{adapter_name}.query",
             resource: payload.fetch(:sql),
             service: database_service,

data/lib/ddtrace/contrib/base.rb

@@ -8,6 +8,7 @@ module Datadog
       def self.included(base)
         base.send(:include, Registry::Registerable)
         base.send(:include, Configurable)
+        base.send(:include, Patcher)
       end
     end
   end

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

@@ -11,7 +11,6 @@ module Datadog
       SERVICE = 'elasticsearch'.freeze
 
       # Patcher enables patching of 'elasticsearch/transport' module.
-      # This is used in monkey.rb to automatically apply patches
       module Patcher
         include Base
         register_as :elasticsearch, auto_patch: true
@@ -28,7 +27,6 @@ module Datadog
             begin
               require 'uri'
               require 'json'
-              require 'ddtrace/monkey'
               require 'ddtrace/pin'
               require 'ddtrace/ext/app_types'
               require 'ddtrace/contrib/elasticsearch/quantize'
@@ -49,7 +47,7 @@ module Datadog
           # rubocop:disable Metrics/BlockLength
           ::Elasticsearch::Transport::Client.class_eval do
             alias_method :initialize_without_datadog, :initialize
-            Datadog::Monkey.without_warnings do
+            Datadog::Patcher.without_warnings do
               remove_method :initialize
             end
 

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

@@ -44,7 +44,6 @@ module Datadog
       end
 
       # Patcher enables patching of 'net/http' module.
-      # This is used in monkey.rb to automatically apply patches
       module Patcher
         include Base
         register_as :http, auto_patch: true
@@ -60,7 +59,6 @@ module Datadog
             begin
               require 'uri'
               require 'ddtrace/pin'
-              require 'ddtrace/monkey'
               require 'ddtrace/ext/app_types'
               require 'ddtrace/ext/http'
               require 'ddtrace/ext/net'
@@ -87,7 +85,7 @@ module Datadog
         def patch_http
           ::Net::HTTP.class_eval do
             alias_method :initialize_without_datadog, :initialize
-            Datadog::Monkey.without_warnings do
+            Datadog::Patcher.without_warnings do
               remove_method :initialize
             end
 

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

@@ -8,8 +8,6 @@ module Datadog
       SERVICE = 'mongodb'.freeze
 
       # Patcher adds subscribers to the MongoDB driver so that each command is traced.
-      # Use the `Datadog::Monkey.patch_module(:mongodb)` to activate tracing for
-      # this module.
       module Patcher
         include Base
         register_as :mongo, auto_patch: true
@@ -57,7 +55,7 @@ module Datadog
         def patch_mongo_client
           ::Mongo::Client.class_eval do
             alias_method :initialize_without_datadog, :initialize
-            Datadog::Monkey.without_warnings do
+            Datadog::Patcher.without_warnings do
               remove_method :initialize
             end
 

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

@@ -16,10 +16,8 @@ module Datadog
           def patch
             return patched? if patched? || !compatible?
 
-            ::ActiveSupport::Notifications.subscribe('start_process_batch.racecar', &method(:start))
-            ::ActiveSupport::Notifications.subscribe('start_process_message.racecar', &method(:start))
-            ::ActiveSupport::Notifications.subscribe('process_batch.racecar', &method(:finish))
-            ::ActiveSupport::Notifications.subscribe('process_message.racecar', &method(:finish))
+            ::ActiveSupport::Notifications.subscribe('process_batch.racecar', self)
+            ::ActiveSupport::Notifications.subscribe('process_message.racecar', self)
 
             configuration[:tracer].set_service_info(
               configuration[:service_name],
@@ -35,17 +33,7 @@ module Datadog
             @patched = false
           end
 
-          private
-
-          def configuration
-            Datadog.configuration[:racecar]
-          end
-
-          def compatible?
-            defined?(::Racecar) && defined?(::ActiveSupport::Notifications)
-          end
-
-          def start(event, *_, payload)
+          def start(event, _, payload)
             ensure_clean_context!
 
             name = event[/message/] ? NAME_MESSAGE : NAME_BATCH
@@ -60,7 +48,7 @@ module Datadog
             span.set_tag('kafka.message_count', payload[:message_count]) if payload.key?(:message_count)
           end
 
-          def finish(*_, payload)
+          def finish(_, _, payload)
             current_span = configuration[:tracer].call_context.current_span
 
             return unless current_span
@@ -69,6 +57,16 @@ module Datadog
             current_span.finish
           end
 
+          private
+
+          def configuration
+            Datadog.configuration[:racecar]
+          end
+
+          def compatible?
+            defined?(::Racecar) && defined?(::ActiveSupport::Notifications)
+          end
+
           def ensure_clean_context!
             return unless configuration[:tracer].call_context.current_span
 

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -20,16 +20,14 @@ module Datadog
         def call(env)
           # retrieve integration settings
           tracer = Datadog.configuration[:rack][:tracer]
-          service = Datadog.configuration[:rack][:service_name]
-          distributed_tracing = Datadog.configuration[:rack][:distributed_tracing]
 
           trace_options = {
-            service: service,
+            service: Datadog.configuration[:rack][:service_name],
             resource: nil,
             span_type: Datadog::Ext::HTTP::TYPE
           }
 
-          if distributed_tracing
+          if Datadog.configuration[:rack][:distributed_tracing]
             context = HTTPPropagator.extract(env)
             tracer.provider.context = context if context.trace_id
           end
@@ -56,35 +54,13 @@ module Datadog
           request_span.set_error(e) unless request_span.nil?
           raise e
         ensure
-          # the source of truth in Rack is the PATH_INFO key that holds the
-          # URL for the current request; some framework may override that
-          # value, especially during exception handling and because of that
-          # we prefer using the `REQUEST_URI` if this is available.
-          # NOTE: `REQUEST_URI` is Rails specific and may not apply for other frameworks
-          url = env['REQUEST_URI'] || env['PATH_INFO']
-
           # Rack is a really low level interface and it doesn't provide any
           # advanced functionality like routers. Because of that, we assume that
           # the underlying framework or application has more knowledge about
           # the result for this request; `resource` and `tags` are expected to
           # be set in another level but if they're missing, reasonable defaults
           # are used.
-          request_span.resource ||= resource_name_for(env, status)
-          if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
-            request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
-          end
-          if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
-            request_span.set_tag(Datadog::Ext::HTTP::URL, url)
-          end
-          if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
-            request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
-          end
-
-          # detect if the status code is a 5xx and flag the request span as an error
-          # unless it has been already set by the underlying framework
-          if status.to_s.start_with?('5') && request_span.status.zero?
-            request_span.status = 1
-          end
+          set_request_tags!(request_span, env, status, headers, response)
 
           # ensure the request_span is finished and the context reset;
           # this assumes that the Rack middleware creates a root span
@@ -103,6 +79,44 @@ module Datadog
             "#{env['REQUEST_METHOD']} #{status}".strip
           end
         end
+
+        def set_request_tags!(request_span, env, status, headers, response)
+          # the source of truth in Rack is the PATH_INFO key that holds the
+          # URL for the current request; some framework may override that
+          # value, especially during exception handling and because of that
+          # we prefer using the `REQUEST_URI` if this is available.
+          # NOTE: `REQUEST_URI` is Rails specific and may not apply for other frameworks
+          url = env['REQUEST_URI'] || env['PATH_INFO']
+
+          request_span.resource ||= resource_name_for(env, status)
+          if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
+            request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
+          end
+          if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
+            request_span.set_tag(Datadog::Ext::HTTP::URL, url)
+          end
+          if request_span.get_tag(Datadog::Ext::HTTP::BASE_URL).nil?
+            request_obj = ::Rack::Request.new(env)
+
+            base_url = if request_obj.respond_to?(:base_url)
+                         request_obj.base_url
+                       else
+                         # Compatibility for older Rack versions
+                         request_obj.url.chomp(request_obj.fullpath)
+                       end
+
+            request_span.set_tag(Datadog::Ext::HTTP::BASE_URL, base_url)
+          end
+          if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
+            request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
+          end
+
+          # detect if the status code is a 5xx and flag the request span as an error
+          # unless it has been already set by the underlying framework
+          if status.to_s.start_with?('5') && request_span.status.zero?
+            request_span.status = 1
+          end
+        end
       end
     end
   end

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

@@ -32,12 +32,15 @@ module Datadog
           return unless span && !span.finished?
 
           begin
-            resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
-            span.resource = resource
+            # Set the resource name, if it's still the default name
+            if span.resource == span.name
+              span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+            end
 
-            # set the parent resource if it's a `rack.request` span
-            if !span.parent.nil? && span.parent.name == 'rack.request'
-              span.parent.resource = resource
+            # Set the parent resource if it's a `rack.request` span,
+            # but not if its an exception contoller.
+            if !span.parent.nil? && span.parent.name == 'rack.request' && !exception_controller?(payload)
+              span.parent.resource = span.resource
             end
 
             span.set_tag('rails.route.action', payload.fetch(:action))
@@ -64,6 +67,26 @@ module Datadog
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
         end
+
+        def self.exception_controller?(payload)
+          exception_controller_class = Datadog.configuration[:rails][:exception_controller]
+          controller = payload.fetch(:controller)
+          headers = payload.fetch(:headers)
+
+          # If no exception controller class has been set,
+          # guess whether this is an exception controller from the headers.
+          if exception_controller_class.nil?
+            !headers[:request_exception].nil?
+          # If an exception controller class has been specified,
+          # check if the controller is a kind of the exception controller class.
+          elsif exception_controller_class.is_a?(Class) || exception_controller_class.is_a?(Module)
+            controller <= exception_controller_class
+          # Otherwise if the exception controller class is some other value (like false)
+          # assume that this controller doesn't handle exceptions.
+          else
+            false
+          end
+        end
       end
     end
   end

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

@@ -150,8 +150,13 @@ module Datadog
           # signals; it propagates the request span so that it can be finished
           # no matter what
           payload = {
-            controller: self.class.name,
+            controller: self.class,
             action: action_name,
+            headers: {
+              # The exception this controller was given in the request,
+              # which is typical if the controller is configured to handle exceptions.
+              request_exception: request.headers['action_dispatch.exception']
+            },
             tracing_context: {}
           }
 

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

@@ -12,6 +12,7 @@ module Datadog
         option :database_service
         option :distributed_tracing, default: false
         option :template_base_path, default: 'views/'
+        option :exception_controller, default: nil
         option :tracer, default: Datadog.tracer
 
         @patched = false

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

@@ -7,7 +7,6 @@ module Datadog
       DRIVER = 'redis.driver'.freeze
 
       # Patcher enables patching of 'redis' module.
-      # This is used in monkey.rb to automatically apply patches
       module Patcher
         include Base
         register_as :redis, auto_patch: true
@@ -23,7 +22,6 @@ module Datadog
           if !@patched && compatible?
             begin
               # do not require these by default, but only when actually patching
-              require 'ddtrace/monkey'
               require 'ddtrace/ext/app_types'
               require 'ddtrace/contrib/redis/tags'
               require 'ddtrace/contrib/redis/quantize'
@@ -47,7 +45,7 @@ module Datadog
         def patch_redis_client
           ::Redis::Client.class_eval do
             alias_method :initialize_without_datadog, :initialize
-            Datadog::Monkey.without_warnings do
+            Datadog::Patcher.without_warnings do
               remove_method :initialize
             end
 

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -4,6 +4,7 @@ require 'sinatra/base'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/errors'
 require 'ddtrace/ext/http'
+require 'ddtrace/propagation/http_propagator'
 
 sinatra_vs = Gem::Version.new(Sinatra::VERSION)
 sinatra_min_vs = Gem::Version.new('1.4.0')
@@ -29,8 +30,8 @@ module Datadog
         end
 
         option :tracer, default: Datadog.tracer
-
         option :resource_script_names, default: false
+        option :distributed_tracing, default: false
 
         def route(verb, action, *)
           # Keep track of the route name when the app is instantiated for an
@@ -82,6 +83,12 @@ module Datadog
             end
 
             tracer = Datadog.configuration[:sinatra][:tracer]
+            distributed_tracing = Datadog.configuration[:sinatra][:distributed_tracing]
+
+            if distributed_tracing && tracer.provider.context.trace_id.nil?
+              context = HTTPPropagator.extract(request.env)
+              tracer.provider.context = context if context.trace_id
+            end
 
             span = tracer.trace('sinatra.request',
                                 service: Datadog.configuration[:sinatra][:service_name],

data/lib/ddtrace/ext/http.rb

@@ -4,6 +4,7 @@ module Datadog
       TYPE = 'http'.freeze
       TEMPLATE = 'template'.freeze
       URL = 'http.url'.freeze
+      BASE_URL = 'http.base_url'.freeze
       METHOD = 'http.method'.freeze
       STATUS_CODE = 'http.status_code'.freeze
       ERROR_RANGE = 500...600

data/lib/ddtrace/patcher.rb

@@ -0,0 +1,18 @@
+module Datadog
+  # Defines some useful patching methods for integrations
+  module Patcher
+    module_function
+
+    def without_warnings
+      # This is typically used when monkey patching functions such as
+      # intialize, which Ruby advices you not to. Use cautiously.
+      v = $VERBOSE
+      $VERBOSE = nil
+      begin
+        yield
+      ensure
+        $VERBOSE = v
+      end
+    end
+  end
+end

data/lib/ddtrace/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-17 00:00:00.000000000 Z
+date: 2018-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -310,7 +310,7 @@ files:
 - lib/ddtrace/ext/redis.rb
 - lib/ddtrace/ext/sql.rb
 - lib/ddtrace/logger.rb
-- lib/ddtrace/monkey.rb
+- lib/ddtrace/patcher.rb
 - lib/ddtrace/pin.rb
 - lib/ddtrace/pipeline.rb
 - lib/ddtrace/pipeline/span_filter.rb

data/lib/ddtrace/monkey.rb

@@ -1,88 +0,0 @@
-require 'thread'
-
-# We import all patchers for every module we support, but this is fine
-# because patchers do not include any 3rd party module nor even our
-# patching code, which is required on demand, when patching.
-require 'ddtrace/contrib/base'
-require 'ddtrace/contrib/rack/patcher'
-require 'ddtrace/contrib/rails/patcher'
-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'
-require 'ddtrace/contrib/racecar/patcher'
-require 'ddtrace/contrib/sidekiq/patcher'
-
-module Datadog
-  # Monkey is used for monkey-patching 3rd party libs.
-  module Monkey
-    # Patchers should expose 2 methods:
-    # - patch, which applies our patch if needed. Should be idempotent,
-    #   can be call twice but should just do nothing the second time.
-    # - patched?, which returns true if the module has been succesfully
-    #   patched (patching might have failed if requirements were not here)
-
-    @mutex = Mutex.new
-    @registry = Datadog.registry
-
-    module_function
-
-    attr_accessor :registry
-
-    def autopatch_modules
-      registry.to_h
-    end
-
-    def patch_all
-      patch(autopatch_modules)
-    end
-
-    def patch_module(m)
-      @mutex.synchronize do
-        patcher = registry[m]
-        raise "Unsupported module #{m}" unless patcher
-        patcher.patch if patcher.respond_to?(:patch)
-      end
-    end
-
-    def patch(modules)
-      modules.each do |k, v|
-        patch_module(k) if v
-      end
-    end
-
-    def get_patched_modules
-      @mutex.synchronize do
-        registry.each_with_object({}) do |entry, patched|
-          next unless entry.klass.respond_to?(:patched?)
-          patched[entry.name] = entry.klass.patched?
-        end
-      end
-    end
-
-    def without_warnings
-      # This is typically used when monkey patching functions such as
-      # intialize, which Ruby advices you not to. Use cautiously.
-      v = $VERBOSE
-      $VERBOSE = nil
-      begin
-        yield
-      ensure
-        $VERBOSE = v
-      end
-    end
-
-    class << self
-      attr_accessor :registry
-    end
-  end
-end
-
-Datadog::Monkey.patch_module(:rails)