ddtrace 0.11.0.beta1 → 0.11.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97a9ed205c345e9abaa1b22823662552e52c898f
-  data.tar.gz: d3373c5a892cf5685ea2e360bcc2191702a358dd
+  metadata.gz: 6258854e3f07ec379803b25748a5ca5b2d816bc0
+  data.tar.gz: 7ab966119e1ee29ce4039b55cb1e264d99116143
 SHA512:
-  metadata.gz: 9601250c89c609412e3243f26e43052b6d71c47861adb4f4dbf424d66507f39d97b95bc8ce514a6e2554d18b8fd5cf5dc98d88894d7ff0f14912a11eef5b696c
-  data.tar.gz: 663044f68bc969e7510740c88218875021aec925dbb458bb28bac7f81765d0fe0873c226301b2dbca813d097f2e7ee94e988e71eb5bbd24a381b16c4a6c71fc4
+  metadata.gz: c5e5b3c715534df2cd421239d7040ffd819a4bc0dcd5b141fba1ab5dba7f63fe2150610a432ad9028c149901cd82201899e527ba5a5d86679e89789d710d4805
+  data.tar.gz: 0cbba845ea24b2dff595843e147171b14e5ac162173c606ba3302c3e04c1056fe98f302a97f18f11b934b4b1e3872330f43be2a481e8c56dabca65ca34725104

data/Appraisals

@@ -72,6 +72,7 @@ if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
       gem 'pg', platform: :ruby
       gem 'activerecord-jdbcpostgresql-adapter', platform: :jruby
       gem 'redis-rails'
+      gem 'redis', '< 4.0'
     end
   end
 
@@ -90,6 +91,7 @@ if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
       gem 'rails', '5.0.1'
       gem 'pg', platform: :ruby
       gem 'redis-rails'
+      gem 'redis', '< 4.0'
     end
 
     appraise 'rails5-postgres-sidekiq' do
@@ -116,7 +118,7 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
     gem 'grape'
     gem 'rack'
     gem 'rack-test'
-    gem 'redis'
+    gem 'redis', '< 4.0'
     gem 'hiredis'
     gem 'sinatra'
     gem 'sqlite3'
@@ -126,6 +128,7 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
     gem 'sucker_punch'
     gem 'dalli'
     gem 'resque'
+    gem 'racecar', '>= 0.3.5'
   end
 else
   appraise 'contrib-old' do

data/Rakefile

@@ -63,6 +63,7 @@ namespace :test do
     :aws,
     :sucker_punch,
     :mongodb,
+    :racecar,
     :resque,
     :dalli
   ].each do |contrib|
@@ -147,13 +148,11 @@ task :ci do
   case ENV['CIRCLE_NODE_INDEX'].to_i
   when 0
     sh 'rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS --verbose do rake test:main'
-    sh 'rvm $LAST_STABLE --verbose do rake benchmark'
   when 1
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:elasticsearch'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:http'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:redis'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sinatra'
-    sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:sidekiq'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:rack'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:grape'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:faraday'
@@ -174,8 +173,9 @@ 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:dalli'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:resque'
-    sh 'rvm $SIDEKIQ_OLD_VERSIONS --verbose do appraisal contrib-old rake test:sidekiq'
   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'
     sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails30-postgres rake test:rails'
     sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails30-postgres rake test:railsdisableenv'
     sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails32-mysql2 rake test:rails'
@@ -196,6 +196,7 @@ task :ci do
     sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres-sidekiq rake test:railssidekiq'
     sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres-sidekiq rake test:railsactivejob'
     sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres rake test:railsdisableenv'
+    sh 'rvm $LAST_STABLE --verbose do rake benchmark'
   else
     puts 'Too many workers than parallel tasks'
   end

data/circle.yml

@@ -1,6 +1,9 @@
 machine:
   services:
     - docker
+  ruby:
+    version:
+      2.2.7
   environment:
     LAST_STABLE: 2.4.1
     EARLY_STABLE: 2.2.7
@@ -12,7 +15,7 @@ machine:
     RAILS5_VERSIONS: 2.3.4,2.2.7
     RAILS3_SIDEKIQ_VERSIONS: 2.1.10,2.0.0
     RAILS4_SIDEKIQ_VERSIONS: 2.3.4,2.2.7
-    JRUBY_VERSIONS: jruby-9.1.5.0
+    JRUBY_VERSIONS: jruby-9.1.13.0
     AGENT_BUILD_PATH: "/home/ubuntu/agent"
     TEST_DATADOG_INTEGRATION: 1
 
@@ -20,31 +23,36 @@ dependencies:
   cache_directories:
     # Cache Ruby binaries and gems
     - "/opt/circleci/.rvm/"
+    - ~/rubies_cache
   pre:
+    - mkdir -p ~/rubies_cache
+    - rsync -a -v --ignore-existing ~/rubies_cache/ /opt/circleci/.rvm/rubies
     # we should use an old docker-compose because CircleCI supports
     # only docker-engine==1.9
     - pip install docker-compose==1.7.1
     - docker-compose up -d | cat
     # installing dev dependencies
-    - gem update --system=2.6.11
-    - gem install builder
-    - gem update bundler
+    - |
+      for version in $(echo "$MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS" | tr "," "\n"); do
+        $(rvm list | grep -q $version) || rvm install $version --rubygems 2.6.11
+      done
+    - gem install bundler
+    # remove line below once `msgpack` have a consistent version for jruby
+    - bundle inject msgpack 1.1.0 && sed -i "y/\"/'/" Gemfile
     - bundle install
-    # configure Ruby interpreters
-    - rvm get head
-    - rvm install $MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS
   override:
-    - rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS --verbose do gem update --system=2.6.11
     - rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS --verbose do gem install bundler
     - rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS,$JRUBY_VERSIONS --verbose do bundle install
     # [FIXME] appraisal does not work with jruby (problem with native ext, eg sqlite3)
-    - rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS --verbose do appraisal install
+    - rvm $MRI_VERSIONS,$MRI_OLD_VERSIONS --verbose do bundle exec appraisal install || echo FIX-ME: Ignoring non-zero exit status
+  post:
+    - rsync -a -v --ignore-existing /opt/circleci/.rvm/rubies/ ~/rubies_cache
 
 test:
   override:
-    - rvm $EARLY_STABLE --verbose do rake rubocop
+    - rvm $EARLY_STABLE --verbose do bundle exec rake rubocop
     # TODO: integration tests should run with the master branch of the agent
-    - rake ci:
+    - bundle exec rake ci:
         parallel: true
 
 deployment:
@@ -52,10 +60,10 @@ deployment:
     branch: /(master)|(develop)/
     # CircleCI is configured to provide VERSION_SUFFIX=$CIRCLE_BUILD_NUM
     commands:
-      - S3_DIR=trace-dev rake release:docs
-      - S3_DIR=trace-dev rake release:gem
+      - S3_DIR=trace-dev bundle exec rake release:docs
+      - S3_DIR=trace-dev bundle exec rake release:gem
       - cp -r ./rubygems/* $CIRCLE_ARTIFACTS
   public:
     tag: /v[0-9]+(\.[0-9]+)*/
     commands:
-      - S3_DIR=trace rake release:docs
+      - S3_DIR=trace bundle exec rake release:docs

data/ddtrace.gemspec

@@ -6,7 +6,7 @@ require 'ddtrace/version'
 
 Gem::Specification.new do |spec|
   spec.name                  = 'ddtrace'
-  spec.version               = "#{Datadog::VERSION::STRING}.beta1#{ENV['VERSION_SUFFIX']}"
+  spec.version               = "#{Datadog::VERSION::STRING}.beta2#{ENV['VERSION_SUFFIX']}"
   spec.required_ruby_version = '>= 1.9.1'
   spec.authors               = ['Datadog, Inc.']
   spec.email                 = ['dev@datadoghq.com']
@@ -40,7 +40,10 @@ EOS
   spec.add_development_dependency 'appraisal', '~> 2.2'
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.add_development_dependency 'webmock', '~> 2.0'
+  spec.add_development_dependency 'builder'
   # locking transitive dependency of webmock
-  spec.add_development_dependency 'addressable',  '~> 2.4.0'
+  spec.add_development_dependency 'addressable', '~> 2.4.0'
   spec.add_development_dependency 'redcarpet', '~> 3.4' if RUBY_PLATFORM != 'java'
+  spec.add_development_dependency 'pry', '>= 0.10.4'
+  spec.add_development_dependency 'pry-stack_explorer', '>= 0.4.9.2'
 end

data/docs/GettingStarted.md

@@ -182,20 +182,22 @@ To start using the middleware in your generic Rack application, add it to your `
 
     run app
 
-Experimental distributed tracing support is available for this library.
-You need to set the ``:distributed_tracing_enabled`` option to true, for example:
+The Rack middleware can be configured using the global configuration object:
 
     # config.ru example
+    require 'ddtrace'
     require 'ddtrace/contrib/rack/middlewares'
 
-    use Datadog::Contrib::Rack::TraceMiddleware, distributed_tracing_enabled: true
+    Datadog.configure do |c|
+      c.use :rack, service_name: 'api-intake', distributed_tracing: true
+    end
 
     app = proc do |env|
-      # trace and read 'x-datadog-trace-id' and 'x-datadog-parent-id'
       [ 200, {'Content-Type' => 'text/plain'}, "OK" ]
     end
 
-See [distributed tracing](#Distributed_Tracing) for details.
+In the example above, we've activated the Distributed Tracing flag, please
+see [distributed tracing](#Distributed_Tracing) for more details.
 
 #### Configure the tracer
 

data/gemfiles/contrib.gemfile

@@ -7,7 +7,7 @@ gem "mongo"
 gem "grape"
 gem "rack"
 gem "rack-test"
-gem "redis"
+gem "redis", "< 4.0"
 gem "hiredis"
 gem "sinatra"
 gem "sqlite3"
@@ -17,5 +17,6 @@ gem "aws-sdk"
 gem "sucker_punch"
 gem "dalli"
 gem "resque"
+gem "racecar", ">= 0.3.5"
 
 gemspec path: "../"

data/gemfiles/rails4_postgres_redis.gemfile

@@ -6,5 +6,6 @@ gem "rails", "4.2.7.1"
 gem "pg", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
 gem "redis-rails"
+gem "redis", "< 4.0"
 
 gemspec path: "../"

data/gemfiles/rails5_postgres_redis.gemfile

@@ -5,5 +5,6 @@ source "https://rubygems.org"
 gem "rails", "5.0.1"
 gem "pg", platform: :ruby
 gem "redis-rails"
+gem "redis", "< 4.0"
 
 gemspec path: "../"

data/lib/ddtrace/configurable.rb

@@ -20,7 +20,7 @@ module Datadog
       def get_option(name)
         __assert_valid!(name)
 
-        return __options[name][:default] unless __options[name][:set_flag]
+        return __default_value(name) unless __options[name][:set_flag]
 
         __options[name][:value]
       end
@@ -47,6 +47,7 @@ module Datadog
         name = name.to_sym
         meta[:setter] ||= (block || IDENTITY)
         meta[:depends_on] ||= []
+        meta[:lazy] ||= false
         __options[name] = meta
       end
 
@@ -72,6 +73,11 @@ module Datadog
           graph[name] = meta[:depends_on]
         end
       end
+
+      def __default_value(name)
+        return __options[name][:default].call if __options[name][:lazy]
+        __options[name][:default]
+      end
     end
   end
 end

data/lib/ddtrace/configuration/proxy.rb

@@ -11,11 +11,7 @@ module Datadog
       end
 
       def [](param)
-        value = @integration.get_option(param)
-
-        return value.call if value.respond_to?(:call)
-
-        value
+        @integration.get_option(param)
       end
 
       def []=(param, value)

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

@@ -42,21 +42,24 @@ module Datadog
           end
         end
 
-        def self.datadog_trace
-          # TODO: Consider using patcher for Rails as well.
-          # @tracer ||= defined?(::Rails) && ::Rails.configuration.datadog_trace
-          @datadog_trace ||= defined?(::Sinatra) && Datadog.configuration[:sinatra].to_h
+        def self.adapter_name
+          @adapter_name ||= Datadog::Contrib::Rails::Utils.adapter_name
         end
 
-        def self.adapter_name
-          @adapter_name ||= Datadog::Contrib::Rails::Utils.normalize_vendor(
-            ::ActiveRecord::Base.connection_config[:adapter]
-          )
+        def self.database_name
+          @database_name ||= Datadog::Contrib::Rails::Utils.database_name
+        end
+
+        def self.adapter_host
+          @adapter_host ||= Datadog::Contrib::Rails::Utils.adapter_host
+        end
+
+        def self.adapter_port
+          @adapter_port ||= Datadog::Contrib::Rails::Utils.adapter_port
         end
 
         def self.tracer
-          return Datadog.tracer unless datadog_trace
-          @tracer ||= datadog_trace.fetch(:tracer)
+          @tracer ||= Datadog.configuration[:sinatra][:tracer]
         end
 
         def self.database_service
@@ -82,6 +85,9 @@ module Datadog
           # obfuscated version
           span.span_type = Datadog::Ext::SQL::TYPE
           span.set_tag('active_record.db.vendor', adapter_name)
+          span.set_tag('active_record.db.name', database_name)
+          span.set_tag('out.host', adapter_host)
+          span.set_tag('out.port', adapter_port)
           span.start_time = start
           span.finish(finish)
         rescue StandardError => e

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

@@ -23,6 +23,7 @@ module Datadog
 
             add_pin
             add_plugin(Seahorse::Client::Base, *loaded_constants)
+            Datadog.tracer.set_service_info(get_option(:service_name), 'aws', Ext::AppTypes::WEB)
 
             @patched = true
           rescue => e

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

@@ -22,6 +22,7 @@ module Datadog
 
             add_pin!
             Instrumentation.patch!
+            Datadog.tracer.set_service_info(get_option(:service_name), 'dalli', Ext::AppTypes::CACHE)
 
             @patched = true
           rescue => e
@@ -42,7 +43,7 @@ module Datadog
           end
 
           def add_pin!
-            Pin.new(get_option(:service_name), app_type: Ext::AppTypes::DB).tap do |pin|
+            Pin.new(get_option(:service_name), app_type: Ext::AppTypes::CACHE).tap do |pin|
               pin.onto(::Dalli)
             end
           end

data/lib/ddtrace/contrib/dalli/quantize.rb

@@ -10,6 +10,8 @@ module Datadog
         def format_command(operation, args)
           command = [operation, *args].join(' ').strip
           Utils.truncate(command, MAX_CMD_LENGTH)
+        rescue ::Encoding::CompatibilityError
+          "#{operation} BLOB (OMITTED)"
         end
       end
     end

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

@@ -9,7 +9,6 @@ module Datadog
       BODY = 'elasticsearch.body'.freeze
 
       SERVICE = 'elasticsearch'.freeze
-      SPAN_TYPE = 'elasticsearch'.freeze
 
       # Patcher enables patching of 'elasticsearch/transport' module.
       # This is used in monkey.rb to automatically apply patches
@@ -35,6 +34,7 @@ module Datadog
               require 'ddtrace/contrib/elasticsearch/quantize'
 
               patch_elasticsearch_transport_client()
+              Datadog.tracer.set_service_info(get_option(:service_name), 'elasticsearch', Ext::AppTypes::DB)
 
               @patched = true
             rescue StandardError => e
@@ -45,6 +45,7 @@ module Datadog
         end
 
         # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
         def patch_elasticsearch_transport_client
           # rubocop:disable Metrics/BlockLength
           ::Elasticsearch::Transport::Client.class_eval do
@@ -77,8 +78,12 @@ module Datadog
               response = nil
               pin.tracer.trace('elasticsearch.query') do |span|
                 begin
+                  connection = transport.connections.first
+                  host = connection.host[:host] if connection
+                  port = connection.host[:port] if connection
+
                   span.service = pin.service
-                  span.span_type = SPAN_TYPE
+                  span.span_type = Ext::AppTypes::DB
 
                   # load JSON for the following fields unless they're already strings
                   params = JSON.generate(params) if params && !params.is_a?(String)
@@ -88,6 +93,8 @@ module Datadog
                   span.set_tag(URL, url)
                   span.set_tag(PARAMS, params) if params
                   span.set_tag(BODY, body) if body
+                  span.set_tag('out.host', host) if host
+                  span.set_tag('out.port', port) if port
 
                   quantized_url = Datadog::Contrib::Elasticsearch::Quantize.format_url(url)
                   span.resource = "#{method} #{quantized_url}"

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -10,32 +10,24 @@ module Datadog
       class Middleware < ::Faraday::Middleware
         include Ext::DistributedTracing
 
-        DEFAULT_ERROR_HANDLER = lambda do |env|
-          Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-        end
-
-        DEFAULT_OPTIONS = {
-          distributed_tracing: false,
-          split_by_domain: false,
-          error_handler: DEFAULT_ERROR_HANDLER
-        }.freeze
-
         def initialize(app, options = {})
           super(app)
-          @options = DEFAULT_OPTIONS.merge(options)
+          @options = Datadog.configuration[:faraday].merge(options)
+          @tracer = Pin.get_from(::Faraday).tracer
+          setup_service!
         end
 
         def call(env)
-          dd_pin.tracer.trace(SERVICE) do |span|
+          tracer.trace(NAME) do |span|
             annotate!(span, env)
-            propagate!(span, env) if options[:distributed_tracing] && dd_pin.tracer.enabled
+            propagate!(span, env) if options[:distributed_tracing] && tracer.enabled
             app.call(env).on_complete { |resp| handle_response(span, resp) }
           end
         end
 
         private
 
-        attr_reader :app, :options
+        attr_reader :app, :options, :tracer
 
         def annotate!(span, env)
           span.resource = env[:method].to_s.upcase
@@ -59,14 +51,16 @@ module Datadog
           Datadog::HTTPPropagator.inject!(span.context, env[:request_headers])
         end
 
-        def dd_pin
-          Pin.get_from(::Faraday)
-        end
-
         def service_name(env)
           return env[:url].host if options[:split_by_domain]
 
-          dd_pin.service
+          options[:service_name]
+        end
+
+        def setup_service!
+          return if options[:service_name] == Datadog.configuration[:faraday][:service_name]
+
+          Patcher.register_service(options[:service_name])
         end
       end
     end

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

@@ -2,13 +2,23 @@ module Datadog
   module Contrib
     module Faraday
       COMPATIBLE_UNTIL = Gem::Version.new('1.0.0')
-      SERVICE = 'faraday-request'.freeze
+      SERVICE = 'faraday'.freeze
+      NAME = 'faraday.request'.freeze
 
       # Responsible for hooking the instrumentation into faraday
       module Patcher
         include Base
+
         register_as :faraday, auto_patch: true
+
+        DEFAULT_ERROR_HANDLER = lambda do |env|
+          Ext::HTTP::ERROR_RANGE.cover?(env[:status])
+        end
+
         option :service_name, default: SERVICE
+        option :distributed_tracing, default: false
+        option :error_handler, default: DEFAULT_ERROR_HANDLER
+        option :tracer, default: Datadog.tracer
 
         @patched = false
 
@@ -21,6 +31,7 @@ module Datadog
 
             add_pin
             add_middleware
+            register_service(get_option(:service_name))
 
             @patched = true
           rescue => e
@@ -32,6 +43,10 @@ module Datadog
             @patched
           end
 
+          def register_service(name)
+            get_option(:tracer).set_service_info(name, 'faraday', Ext::AppTypes::WEB)
+          end
+
           private
 
           def compatible?
@@ -41,9 +56,9 @@ module Datadog
           end
 
           def add_pin
-            Pin.new(SERVICE, app_type: Ext::AppTypes::WEB).tap do |pin|
+            Pin.new(get_option(:service_name), app_type: Ext::AppTypes::WEB).tap do |pin|
               pin.onto(::Faraday)
-              pin.service = Datadog.configuration[:faraday][:service_name]
+              pin.tracer = get_option(:tracer)
             end
           end
 

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

@@ -14,16 +14,6 @@ module Datadog
 
       module_function
 
-      # TODO: Remove this once we drop support for legacy configuration
-      def distributed_tracing_enabled
-        Datadog.configuration[:http][:distributed_tracing_enabled]
-      end
-
-      # TODO: Remove this once we drop support for legacy configuration
-      def distributed_tracing_enabled=(value)
-        Datadog.configuration[:http][:distributed_tracing_enabled] = value
-      end
-
       def should_skip_tracing?(req, address, port, transport, pin)
         # we don't want to trace our own call to the API (they use net/http)
         # when we know the host & port (from the URI) we use it, else (most-likely
@@ -46,11 +36,11 @@ module Datadog
       end
 
       def should_skip_distributed_tracing?(pin)
-        global_value = Datadog.configuration[:http][:distributed_tracing_enabled]
-        unless pin.config.nil?
-          return !pin.config.fetch(:distributed_tracing_enabled, global_value)
+        if pin.config && pin.config.key?(:distributed_tracing)
+          return !pin.config[:distributed_tracing]
         end
-        !global_value
+
+        !Datadog.configuration[:http][:distributed_tracing]
       end
 
       # Patcher enables patching of 'net/http' module.
@@ -58,7 +48,7 @@ module Datadog
       module Patcher
         include Base
         register_as :http, auto_patch: true
-        option :distributed_tracing_enabled, default: false
+        option :distributed_tracing, default: false
 
         @patched = false
 

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

@@ -0,0 +1,81 @@
+require 'ddtrace/ext/app_types'
+
+module Datadog
+  module Contrib
+    module Racecar
+      # Provides instrumentation for `racecar` through ActiveSupport instrumentation signals
+      module Patcher
+        include Base
+        NAME_MESSAGE = 'racecar.message'.freeze
+        NAME_BATCH = 'racecar.batch'.freeze
+        register_as :racecar
+        option :tracer, default: Datadog.tracer
+        option :service_name, default: 'racecar'
+
+        class << self
+          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))
+
+            configuration[:tracer].set_service_info(
+              configuration[:service_name],
+              'racecar',
+              Ext::AppTypes::WORKER
+            )
+
+            @patched = true
+          end
+
+          def patched?
+            return @patched if defined?(@patched)
+            @patched = false
+          end
+
+          private
+
+          def configuration
+            Datadog.configuration[:racecar]
+          end
+
+          def compatible?
+            defined?(::Racecar) && defined?(::ActiveSupport::Notifications)
+          end
+
+          def start(event, *_, payload)
+            ensure_clean_context!
+
+            name = event[/message/] ? NAME_MESSAGE : NAME_BATCH
+            span = configuration[:tracer].trace(name)
+            span.service = configuration[:service_name]
+            span.resource = payload[:consumer_class]
+            span.set_tag('kafka.topic', payload[:topic])
+            span.set_tag('kafka.consumer', payload[:consumer_class])
+            span.set_tag('kafka.partition', payload[:partition])
+            span.set_tag('kafka.offset', payload[:offset]) if payload.key?(:offset)
+            span.set_tag('kafka.first_offset', payload[:first_offset]) if payload.key?(:first_offset)
+            span.set_tag('kafka.message_count', payload[:message_count]) if payload.key?(:message_count)
+          end
+
+          def finish(*_, payload)
+            current_span = configuration[:tracer].call_context.current_span
+
+            return unless current_span
+
+            current_span.set_error(payload[:exception_object]) if payload[:exception_object]
+            current_span.finish
+          end
+
+          def ensure_clean_context!
+            return unless configuration[:tracer].call_context.current_span
+
+            configuration[:tracer].provider.context = Context.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,64 +13,35 @@ module Datadog
       # application. If request tags are not set by the app, they will be set using
       # information available at the Rack level.
       class TraceMiddleware
-        include Base
-        register_as :rack
-
-        option :tracer, default: Datadog.tracer
-        option :service_name, default: 'rack', depends_on: [:tracer] do |value|
-          get_option(:tracer).set_service_info(value, 'rack', Ext::AppTypes::WEB)
-          value
-        end
-        option :distributed_tracing_enabled, default: false
-
-        def initialize(app, options = {})
-          # update options with our configuration, unless it's already available
-          [:tracer, :service_name, :distributed_tracing_enabled].each do |k|
-            Datadog.configuration[:rack][k] = options[k] unless options[k].nil?
-          end
-
+        def initialize(app)
           @app = app
         end
 
-        def configure
-          # ensure that the configuration is executed only once
-          return clean_context if @tracer && @service
-
-          # retrieve the current tracer and service
-          @tracer = Datadog.configuration[:rack][:tracer]
-          @service = Datadog.configuration[:rack][:service_name]
-          @distributed_tracing_enabled = Datadog.configuration[:rack][:distributed_tracing_enabled]
-
-          # configure the Rack service
-        end
-
-        # rubocop:disable Metrics/MethodLength
         def call(env)
-          # configure the Rack middleware once
-          configure()
+          # 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: service,
             resource: nil,
             span_type: Datadog::Ext::HTTP::TYPE
           }
 
-          request_span = nil
-          begin
-            if @distributed_tracing_enabled
-              context = HTTPPropagator.extract(env)
-              @tracer.provider.context = context if context.trace_id
-            end
-          ensure
-            # start a new request span and attach it to the current Rack environment;
-            # we must ensure that the span `resource` is set later
-            request_span = @tracer.trace('rack.request', trace_options)
+          if distributed_tracing
+            context = HTTPPropagator.extract(env)
+            tracer.provider.context = context if context.trace_id
           end
 
+          # start a new request span and attach it to the current Rack environment;
+          # we must ensure that the span `resource` is set later
+          request_span = tracer.trace('rack.request', trace_options)
           env[:datadog_rack_request_span] = request_span
 
           # call the rest of the stack
           status, headers, response = @app.call(env)
+          [status, headers, response]
 
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
@@ -82,7 +53,7 @@ module Datadog
           # catch exceptions that may be raised in the middleware chain
           # Note: if a middleware catches an Exception without re raising,
           # the Exception cannot be recorded here.
-          request_span.set_error(e)
+          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
@@ -98,7 +69,7 @@ module Datadog
           # 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 = "#{env['REQUEST_METHOD']} #{status}".strip unless request_span.resource
+          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
@@ -115,18 +86,22 @@ module Datadog
             request_span.status = 1
           end
 
-          request_span.finish()
+          # ensure the request_span is finished and the context reset;
+          # this assumes that the Rack middleware creates a root span
+          request_span.finish
 
-          [status, headers, response]
+          # TODO: Remove this once we change how context propagation works. This
+          # ensures we clean thread-local variables on each HTTP request avoiding
+          # memory leaks.
+          tracer.provider.context = Datadog::Context.new
         end
 
-        private
-
-        # TODO: Remove this once we change how context propagation works. This
-        # ensures we clean thread-local variables on each HTTP request avoiding
-        # memory leaks.
-        def clean_context
-          @tracer.provider.context = Datadog::Context.new
+        def resource_name_for(env, status)
+          if Datadog.configuration[:rack][:middleware_names]
+            "#{env['RESPONSE_MIDDLEWARE']}##{env['REQUEST_METHOD']}"
+          else
+            "#{env['REQUEST_METHOD']} #{status}".strip
+          end
         end
       end
     end

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

@@ -0,0 +1,58 @@
+module Datadog
+  module Contrib
+    module Rack
+      # Provides instrumentation for `rack`
+      module Patcher
+        include Base
+        register_as :rack
+        option :tracer, default: Datadog.tracer
+        option :distributed_tracing, default: false
+        option :middleware_names, default: false
+        option :application
+        option :service_name, default: 'rack', depends_on: [:tracer] do |value|
+          get_option(:tracer).set_service_info(value, 'rack', Ext::AppTypes::WEB)
+          value
+        end
+
+        module_function
+
+        def patch
+          return true if patched?
+
+          require_relative 'middlewares'
+          @patched = true
+
+          return unless get_option(:middleware_names)
+
+          top = get_option(:application) || rails_app
+          retain_middleware_name(top)
+        end
+
+        def patched?
+          @patched ||= false
+        end
+
+        def rails_app
+          return unless Datadog.registry[:rails].compatible?
+          ::Rails.application.app
+        end
+
+        def retain_middleware_name(middleware)
+          return unless middleware && middleware.respond_to?(:call)
+
+          middleware.singleton_class.class_eval do
+            alias_method :__call, :call
+
+            def call(env)
+              env['RESPONSE_MIDDLEWARE'] = self.class.to_s
+              __call(env)
+            end
+          end
+
+          following = middleware.instance_variable_get('@app')
+          retain_middleware_name(following)
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,10 @@ module Datadog
         def self.sql(_name, start, finish, _id, payload)
           tracer = Datadog.configuration[:rails][:tracer]
           database_service = Datadog.configuration[:rails][:database_service]
-          adapter_name = ::ActiveRecord::Base.connection_config[:adapter]
-          adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(adapter_name)
+          adapter_name = Datadog::Contrib::Rails::Utils.adapter_name
+          database_name = Datadog::Contrib::Rails::Utils.database_name
+          adapter_host = Datadog::Contrib::Rails::Utils.adapter_host
+          adapter_port = Datadog::Contrib::Rails::Utils.adapter_port
           span_type = Datadog::Ext::SQL::TYPE
 
           span = tracer.trace(
@@ -44,7 +46,10 @@ module Datadog
           # obfuscated version
           span.span_type = Datadog::Ext::SQL::TYPE
           span.set_tag('rails.db.vendor', adapter_name)
+          span.set_tag('rails.db.name', database_name)
           span.set_tag('rails.db.cached', cached) if cached
+          span.set_tag('out.host', adapter_host)
+          span.set_tag('out.port', adapter_port)
           span.start_time = start
           span.finish(finish)
         rescue StandardError => e

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

@@ -11,17 +11,6 @@ require 'ddtrace/contrib/rails/active_record'
 require 'ddtrace/contrib/rails/active_support'
 require 'ddtrace/contrib/rails/utils'
 
-# Rails < 3.1
-if defined?(::ActiveRecord) && !defined?(::ActiveRecord::Base.connection_config)
-  ActiveRecord::Base.class_eval do
-    class << self
-      def connection_config
-        connection_pool.spec.config
-      end
-    end
-  end
-end
-
 module Datadog
   module Contrib
     # Instrument Rails.
@@ -31,18 +20,16 @@ module Datadog
       # - instrument parts of the framework when needed
       module Framework
         # configure Datadog settings
-        def self.configure(rails_config)
-          user_config = rails_config[:config].datadog_trace rescue {}
-          Datadog.configuration.use(:rails, user_config)
+        def self.setup
           config = Datadog.configuration[:rails]
-          tracer = config[:tracer]
           config[:service_name] ||= Utils.app_name
+          tracer = config[:tracer]
 
           Datadog.configuration.use(
             :rack,
             tracer: tracer,
             service_name: config[:service_name],
-            distributed_tracing_enabled: config[:distributed_tracing_enabled]
+            distributed_tracing: config[:distributed_tracing]
           )
 
           config[:controller_service] ||= config[:service_name]
@@ -50,25 +37,22 @@ module Datadog
 
           tracer.set_service_info(config[:controller_service], 'rails', Ext::AppTypes::WEB)
           tracer.set_service_info(config[:cache_service], 'rails', Ext::AppTypes::CACHE)
+          set_database_service
 
           # By default, default service would be guessed from the script
           # being executed, but here we know better, get it from Rails config.
           tracer.default_service = config[:service_name]
+        end
 
-          if defined?(::ActiveRecord)
-            begin
-              # set default database service details and store it in the configuration
-              conn_cfg = ::ActiveRecord::Base.connection_config()
-              adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(conn_cfg[:adapter])
-              config[:database_service] ||= "#{config[:service_name]}-#{adapter_name}"
-              tracer.set_service_info(config[:database_service], adapter_name, Ext::AppTypes::DB)
-            rescue StandardError => e
-              Datadog::Tracer.log.warn("Unable to get database config (#{e}), skipping ActiveRecord instrumentation")
-            end
-          end
+        def self.set_database_service
+          return unless defined?(::ActiveRecord)
 
-          # update global configurations
-          ::Rails.configuration.datadog_trace = Datadog.registry[:rails].to_h
+          config = Datadog.configuration[:rails]
+          adapter_name = Utils.adapter_name
+          config[:database_service] ||= "#{config[:service_name]}-#{adapter_name}"
+          config[:tracer].set_service_info(config[:database_service], adapter_name, Ext::AppTypes::DB)
+        rescue => e
+          Tracer.log.warn("Unable to get database config (#{e}), skipping ActiveRecord instrumentation")
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Datadog
         option :controller_service
         option :cache_service
         option :database_service
-        option :distributed_tracing_enabled, default: false
+        option :distributed_tracing, default: false
         option :template_base_path, default: 'views/'
         option :tracer, default: Datadog.tracer
 

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

@@ -8,8 +8,8 @@ module Datadog
     config.app_middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
     config.app_middleware.use(Datadog::Contrib::Rails::ExceptionMiddleware)
 
-    config.after_initialize do |app|
-      Datadog::Contrib::Rails::Framework.configure(config: app.config)
+    config.after_initialize do
+      Datadog::Contrib::Rails::Framework.setup
       Datadog::Contrib::Rails::ActionController.instrument
       Datadog::Contrib::Rails::ActionView.instrument
       Datadog::Contrib::Rails::ActiveRecord.instrument

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

@@ -45,6 +45,32 @@ module Datadog
             ::Rails.application.class.to_s.underscore
           end
         end
+
+        def self.adapter_name
+          normalize_vendor(connection_config[:adapter])
+        end
+
+        def self.database_name
+          connection_config[:database]
+        end
+
+        def self.adapter_host
+          connection_config[:host]
+        end
+
+        def self.adapter_port
+          connection_config[:port]
+        end
+
+        def self.connection_config
+          if defined?(::ActiveRecord::Base.connection_config)
+            ::ActiveRecord::Base.connection_config
+          else
+            ::ActiveRecord::Base.connection_pool.spec.config
+          end
+        end
+
+        private_class_method :connection_config
       end
     end
   end

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

@@ -12,6 +12,7 @@ module Datadog
 
         def format_arg(arg)
           str = arg.is_a?(Symbol) ? arg.to_s.upcase : arg.to_s
+          str = str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
           Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue StandardError => e
           Datadog::Tracer.log.debug("non formattable Redis arg #{str}: #{e}")

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

@@ -16,14 +16,17 @@ module Datadog
         option :service_name, default: SERVICE
 
         @patched = false
+        option :workers, default: []
 
         class << self
           def patch
             return @patched if patched? || !defined?(::Resque)
 
             require 'ddtrace/ext/app_types'
+            require_relative 'resque_job'
 
             add_pin
+            get_option(:workers).each { |worker| worker.extend(ResqueJob) }
             @patched = true
           rescue => e
             Tracer.log.error("Unable to apply Resque integration: #{e}")

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

@@ -40,7 +40,7 @@ module Datadog
           service = sidekiq_service(resource_worker(resource))
           set_service_info(service)
 
-          @tracer.trace('sidekiq.job', service: service, span_type: 'job') do |span|
+          @tracer.trace('sidekiq.job', service: service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
             span.resource = resource
             span.set_tag('sidekiq.job.id', job['jid'])
             span.set_tag('sidekiq.job.retry', job['retry'])

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

@@ -30,11 +30,19 @@ module Datadog
 
         option :tracer, default: Datadog.tracer
 
+        option :resource_script_names, default: false
+
         def route(verb, action, *)
           # Keep track of the route name when the app is instantiated for an
           # incoming request.
           condition do
-            @datadog_route = action
+            # If the option to prepend script names is enabled, then
+            # prepend the script name from the request onto the action.
+            @datadog_route = if Datadog.configuration[:sinatra][:resource_script_names]
+                               "#{request.script_name}#{action}"
+                             else
+                               action
+                             end
           end
 
           super
@@ -48,7 +56,7 @@ module Datadog
               output = ''
               tracer = Datadog.configuration[:sinatra][:tracer]
               if tracer.enabled
-                tracer.trace('sinatra.render_template') do |span|
+                tracer.trace('sinatra.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
                   # If data is a string, it is a literal template and we don't
                   # want to record it.
                   span.set_tag('sinatra.template_name', data) if data.is_a? Symbol

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

@@ -24,6 +24,7 @@ module Datadog
           add_pin!
           ExceptionHandler.patch!
           Instrumentation.patch!
+          Datadog.tracer.set_service_info(get_option(:service_name), 'sucker_punch', Ext::AppTypes::WORKER)
 
           @patched = true
         rescue => e

data/lib/ddtrace/ext/app_types.rb

@@ -5,6 +5,7 @@ module Datadog
       DB = 'db'.freeze
       CACHE = 'cache'.freeze
       WORKER = 'worker'.freeze
+      CUSTOM = 'custom'.freeze
     end
   end
 end

data/lib/ddtrace/monkey.rb

@@ -4,6 +4,7 @@ require 'thread'
 # 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'
@@ -16,6 +17,7 @@ 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'
 
 module Datadog
   # Monkey is used for monkey-patching 3rd party libs.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.11.0.beta1
+  version: 0.11.0.beta2
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-04 00:00:00.000000000 Z
+date: 2017-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.9.2
 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
@@ -201,7 +243,9 @@ files:
 - lib/ddtrace/contrib/mongodb/parsers.rb
 - lib/ddtrace/contrib/mongodb/patcher.rb
 - lib/ddtrace/contrib/mongodb/subscribers.rb
+- lib/ddtrace/contrib/racecar/patcher.rb
 - lib/ddtrace/contrib/rack/middlewares.rb
+- lib/ddtrace/contrib/rack/patcher.rb
 - lib/ddtrace/contrib/rails/action_controller.rb
 - lib/ddtrace/contrib/rails/action_view.rb
 - lib/ddtrace/contrib/rails/active_record.rb
@@ -274,7 +318,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.9
+rubygems_version: 2.4.5.2
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications