ddtrace 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fc0133019cee5e3bf12a664792a40ae95f320f7
-  data.tar.gz: 43f7412b5613d8fffc74ddd204bec29c81ac5118
+  metadata.gz: 3896d5d634a6a65d95f815955b5e62108562a55c
+  data.tar.gz: a4d606173f9f92749e757bccc17a8524a91a916e
 SHA512:
-  metadata.gz: 9739cdc4f56336a81e6366b30658fa0f6670c403e7d5d2dd6014a3545f69fb4b3188acd0fb8b499a3a15e211f97ac3d50a81e5f3cc76cb9b8f612eb2778b18ac
-  data.tar.gz: 7b8c1ea6173c53e988548aca2a487357bf0022f23279e94c84097880c9a22866c3d0b9ef83ef34e18abfe85bdc12aa9760e55031b5ccd01020594ec78a2aa1a6
+  metadata.gz: 9ef525976240577dd0d39692749416765ace3b5542202d6b9db4674c8467c2d76c3bcfa8a4755e62b79fc31d4478c49960b10aba4607d3963d71754518fac240
+  data.tar.gz: 9eaf559a0c2d59798e8441c45342f3d3084358955e318677e42c506a95f548ad5b688eee4b0edf649e7f638befa6ee621337e6dd591fc9d12ebe011de30d8283

data/.env

@@ -8,4 +8,6 @@ TEST_MYSQL_PASSWORD=mysql
 TEST_MYSQL_USER=mysql
 TEST_ELASTICSEARCH_REST_PORT=49200
 TEST_ELASTICSEARCH_NATIVE_PORT=49300
-TEST_REDIS_PORT=46379
+TEST_REDIS_PORT=46379
+TEST_MONGODB_PORT=57017
+TEST_MEMCACHED_PORT=41121

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 /.config
 /coverage/
 /InstalledFiles

data/Appraisals

@@ -111,6 +111,7 @@ end
 if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
   appraise 'contrib' do
     gem 'elasticsearch-transport'
+    gem 'mongo'
     gem 'grape'
     gem 'rack'
     gem 'rack-test'
@@ -120,10 +121,15 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
     gem 'sqlite3'
     gem 'activerecord'
     gem 'sidekiq'
+    gem 'aws-sdk'
+    gem 'sucker_punch'
+    gem 'dalli'
+    gem 'resque'
   end
 else
   appraise 'contrib-old' do
     gem 'elasticsearch-transport'
+    gem 'mongo'
     gem 'redis', '< 4.0.0'
     gem 'hiredis'
     gem 'rack', '1.4.7'
@@ -132,5 +138,9 @@ else
     gem 'sqlite3'
     gem 'activerecord', '3.2.22.5'
     gem 'sidekiq', '4.0.0'
+    gem 'aws-sdk', '~> 2.0'
+    gem 'sucker_punch'
+    gem 'dalli'
+    gem 'resque'
   end
 end

data/Rakefile

@@ -51,7 +51,21 @@ namespace :test do
     t.test_files = FileList['test/contrib/rails/**/*disable_env*_test.rb']
   end
 
-  [:elasticsearch, :http, :redis, :sinatra, :sidekiq, :rack, :grape].each do |contrib|
+  [
+    :elasticsearch,
+    :http,
+    :redis,
+    :sinatra,
+    :sidekiq,
+    :rack,
+    :faraday,
+    :grape,
+    :aws,
+    :sucker_punch,
+    :mongodb,
+    :resque,
+    :dalli
+  ].each do |contrib|
     Rake::TestTask.new(contrib) do |t|
       t.libs << %w[test lib]
       t.test_files = FileList["test/contrib/#{contrib}/*_test.rb"]
@@ -140,12 +154,24 @@ task :ci do
     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'
+    sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake test:aws'
+    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:dalli'
+    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'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:sinatra'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:rack'
+    sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:faraday'
+    sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:aws'
+    sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake test:mongodb'
+    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 $RAILS3_VERSIONS --verbose do appraisal rails30-postgres rake test:rails'

data/ddtrace.gemspec

@@ -35,8 +35,8 @@ EOS
   spec.add_dependency 'msgpack'
 
   spec.add_development_dependency 'rake', '~> 10.5'
-  spec.add_development_dependency('rubocop', '~> 0.47') if RUBY_VERSION >= '2.1.0'
+  spec.add_development_dependency('rubocop', '= 0.49.1') if RUBY_VERSION >= '2.1.0'
   spec.add_development_dependency 'minitest', '= 5.10.1'
-  spec.add_development_dependency 'appraisal', '~> 2.1'
+  spec.add_development_dependency 'appraisal', '~> 2.2'
   spec.add_development_dependency 'yard', '~> 0.9'
 end

data/docker-compose.yml

@@ -32,6 +32,16 @@ redis:
     ports:
         - "127.0.0.1:${TEST_REDIS_PORT}:6379"
 
+mongodb:
+    image: mongo:3.5
+    ports:
+        - "127.0.0.1:${TEST_MONGODB_PORT}:27017"
+
+memcached:
+    image: memcached:1.5-alpine
+    ports:
+        - "127.0.0.1:${TEST_MEMCACHED_PORT}:11211"
+
 ddagent:
     image: datadog/docker-dd-agent
     environment:

data/docs/GettingStarted.md

@@ -30,6 +30,10 @@ provides auto instrumentation for the following web frameworks and libraries:
 * [Grape](#Grape)
 * [Active Record](#Active_Record)
 * [Elastic Search](#Elastic_Search)
+* [MongoDB](#MongoDB)
+* [Dalli](#Dalli)
+* [Faraday](#Faraday)
+* [SuckerPunch](#SuckerPunch)
 * [Net/HTTP](#Net_HTTP)
 * [Redis](#Redis)
 
@@ -70,6 +74,7 @@ of the Datadog tracer, you can override the following defaults:
       default_controller_service: 'rails-controller',
       default_cache_service: 'rails-cache',
       default_database_service: 'postgresql',
+      distributed_tracing_enabled: false,
       template_base_path: 'views/',
       tracer: Datadog.tracer,
       debug: false,
@@ -94,6 +99,8 @@ Available settings are:
 * ``default_cache_service``: set the cache service name used when tracing cache activity. Defaults to ``rails-cache``
 * ``default_database_service``: set the database service name used when tracing database activity. Defaults to the
   current adapter name, so if you're using PostgreSQL it will be ``postgres``.
+* ``distributed_tracing_enabled``: enable [distributed tracing](#Distributed_Tracing) so that this service trace is
+  connected with a trace of another service if tracing headers are sent
 * ``default_grape_service``: set the service name used when tracing a Grape application mounted in your Rails router.
   Defaults to ``grape``
 * ``template_base_path``: used when the template name is parsed in the auto instrumented code. If you don't store
@@ -279,6 +286,27 @@ Note that if you enable both Elasticsearch and Net/HTTP integrations then
 for each call, two spans are created, one for Elasctisearch and one for Net/HTTP.
 This typically happens if you call ``patch_all`` to enable all integrations by default.
 
+### MongoDB
+
+The integration traces any `Command` that is sent from the
+[MongoDB Ruby Driver](https://github.com/mongodb/mongo-ruby-driver) to a MongoDB cluster.
+By extension, Object Document Mappers (ODM) such as Mongoid are automatically instrumented
+if they use the official Ruby driver. To activate the integration, simply:
+
+    require 'mongo'
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:mongo)
+
+    # now create a MongoDB client and use it as usual:
+    client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'artists')
+    collection = client[:people]
+    collection.insert_one({ name: 'Steve' })
+
+    # to change the MongoDB service, use the Pin object
+    pin = Datadog::Pin.get_from(client)
+    pin.service = 'mongodb-primary'
+
 ### Net/HTTP
 
 The Net/HTTP integration will trace any HTTP call using the standard lib
@@ -321,6 +349,51 @@ Or, by enabling distributed tracing for all HTTP calls:
 
 See [distributed tracing](#Distributed_Tracing) for details.
 
+### Faraday
+
+The `faraday` integration is available through the `ddtrace` middleware:
+
+    require 'faraday'
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:faraday) # registers the tracing middleware
+
+    connection = Faraday.new('https://example.com') do |builder|
+      builder.use(:ddtrace, options)
+      builder.adapter Faraday.default_adapter
+    end
+
+    connection.get('/foo')
+
+### AWS
+
+The AWS integration will trace every interaction (e.g. API calls) with AWS
+services (S3, ElastiCache etc.).
+
+    require 'aws-sdk'
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:aws) # explicitly patch it
+
+    Aws::S3::Client.new.list_buckets # traced call
+
+### Dalli
+
+Dalli integration will trace all calls to your ``memcached`` server:
+
+    require 'dalli'
+    require 'ddtrace'
+
+    # patch Dalli so all clients are traced
+    Datadog::Monkey.patch_module(:dalli)
+
+    client = Dalli::Client.new('localhost:11211', options)
+    client.set('abc', 123)
+
+    # to change Dalli service name, use the Pin class
+    pin = Datadog::Pin.get_from(client)
+    pin.service = 'primary-cache'
+
 ### Redis
 
 The Redis integration will trace simple calls as well as pipelines.
@@ -349,6 +422,21 @@ executions. It can be added as any other Sidekiq middleware:
       end
     end
 
+### SuckerPunch
+
+The `sucker_punch` integration traces all scheduled jobs:
+
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:sucker_punch)
+
+    # the execution of this job is traced
+    LogJob.perform_async('login')
+
+    # to change SuckerPunch service name, use the Pin class
+    pin = Datadog::Pin.get_from(::SuckerPunch)
+    pin.service = 'deploy-queues'
+
 #### Configure the tracer middleware
 
 To modify the default configuration, simply pass arguments to the middleware.
@@ -387,6 +475,23 @@ giving precedence to the middleware settings. Inherited configurations are:
 * ``trace_agent_hostname``
 * ``trace_agent_port``
 
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Type | Default | Description |
+| --- | --- | --- | --- |
+| `split_by_domain` | Boolean | `false` | Uses the request domain as the service name when set to `true`. |
+| `distributed_tracing` | Boolean | `false` | Propagates tracing context along the HTTP request when set to `true`. |
+| `error_handler` | Callable | [Click Here](https://github.com/DataDog/dd-trace-rb/blob/4fe3bc9df032eac3cd294b0bebcc866080dbe04f/lib/ddtrace/contrib/faraday/middleware.rb#L11-L13) | A callable object that receives a single argument – the request environment. If it evaluates to a *truthy* value, the trace span is marked as an error. By default, only server-side errors (e.g. `5xx`) are flagged as errors. |
+
+It's worth mentioning that `ddtrace` also supports instrumentation for the
+`net/http` library, so if you're using it as farady's backend you might see
+instrumentation both on `faraday` and `net/http` levels. If you want to avoid
+multiple levels of instrumentation for your HTTP requests, remember that you can
+always fine tune witch libraries are patched by calling:
+
+    Datadog::Monkey.patch([:foo, :bar])
+    # instead of Datadog::Monkey.patch_all
+
 ## Advanced usage
 
 ### Manual Instrumentation
@@ -659,6 +764,20 @@ provided you pass a ``:distributed_tracing_enabled`` option set to ``true``.
 
 This is disabled by default.
 
+### Processing Pipeline
+
+Sometimes it might be interesting to intercept `Span` objects before they get
+sent upstream.  To achieve that, you can hook custom *processors* into the
+pipeline using the method `Datadog::Pipeline.before_flush`:
+
+    Datadog::Pipeline.before_flush(
+      Datadog::Pipeline::SpanFilter.new { |span| span.resource =~ /PingController/ },
+      Datadog::Pipeline::SpanFilter.new { |span| span.get_tag('host') == 'localhost' }
+      Datadog::Pipeline::SpanProcessor.new { |span| span.resource.gsub!(/password=.*/, '') }
+    )
+
+For more information, please refer to this [link](https://github.com/DataDog/dd-trace-rb/pull/214).
+
 ### Troubleshooting
 
 #### Logs

data/gemfiles/contrib.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "elasticsearch-transport"
+gem "mongo"
 gem "grape"
 gem "rack"
 gem "rack-test"
@@ -12,5 +13,9 @@ gem "sinatra"
 gem "sqlite3"
 gem "activerecord"
 gem "sidekiq"
+gem "aws-sdk"
+gem "sucker_punch"
+gem "dalli"
+gem "resque"
 
 gemspec path: "../"

data/gemfiles/contrib_old.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "elasticsearch-transport"
+gem "mongo"
 gem "redis", "< 4.0.0"
 gem "hiredis"
 gem "rack", "1.4.7"
@@ -11,5 +12,8 @@ gem "sinatra", "1.4.5"
 gem "sqlite3"
 gem "activerecord", "3.2.22.5"
 gem "sidekiq", "4.0.0"
+gem "aws-sdk", "~> 2.0"
+gem "sucker_punch"
+gem "resque"
 
 gemspec path: "../"

data/lib/ddtrace.rb

@@ -2,6 +2,7 @@ require 'ddtrace/monkey'
 require 'ddtrace/pin'
 require 'ddtrace/tracer'
 require 'ddtrace/error'
+require 'ddtrace/pipeline'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -36,11 +37,13 @@ if defined?(Rails::VERSION)
       module Datadog
         # Railtie class initializes
         class Railtie < Rails::Railtie
+          # add instrumentation middlewares
+          options = {}
+          config.app_middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware, options)
           config.app_middleware.use(Datadog::Contrib::Rails::ExceptionMiddleware)
 
           # auto instrument Rails and third party components after
           # the framework initialization
-          options = {}
           config.after_initialize do |app|
             Datadog::Contrib::Rails::Framework.configure(config: app.config)
             Datadog::Contrib::Rails::Framework.auto_instrument()
@@ -50,16 +53,6 @@ if defined?(Rails::VERSION)
             # override Rack Middleware configurations with Rails
             options.update(::Rails.configuration.datadog_trace)
           end
-
-          # Configure datadog settings before building the middleware stack.
-          # This is required because the middleware stack is frozen after
-          # the initialization and so it's too late to add our tracing
-          # functionalities.
-          initializer :datadog_config, before: :build_middleware_stack do |app|
-            app.config.middleware.insert_before(
-              0, Datadog::Contrib::Rack::TraceMiddleware, options
-            )
-          end
         end
       end
     else

data/lib/ddtrace/buffer.rb

@@ -10,11 +10,13 @@ module Datadog
 
       @mutex = Mutex.new()
       @traces = []
+      @closed = false
     end
 
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
     # even if the buffer is full. In that case, a random trace is discarded.
     def push(trace)
+      return if @closed
       @mutex.synchronize do
         len = @traces.length
         if len < @max_size || @max_size <= 0
@@ -48,5 +50,17 @@ module Datadog
         return traces
       end
     end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+      end
+    end
+
+    def closed?
+      @mutex.synchronise do
+        return @closed
+      end
+    end
   end
 end

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

@@ -0,0 +1,43 @@
+module Datadog
+  module Contrib
+    module Aws
+      # A Seahorse::Client::Plugin that enables instrumentation for all AWS services
+      class Instrumentation < Seahorse::Client::Plugin
+        def add_handlers(handlers, _)
+          handlers.add(Handler, step: :validate)
+        end
+      end
+
+      # Generates Spans for all interactions with AWS
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          pin = Datadog::Pin.get_from(::Aws)
+
+          return @handler.call(context) unless pin && pin.enabled?
+
+          pin.tracer.trace(RESOURCE) do |span|
+            result = @handler.call(context)
+            annotate!(span, pin, ParsedContext.new(context))
+            result
+          end
+        end
+
+        private
+
+        def annotate!(span, pin, context)
+          span.service = pin.service
+          span.span_type = pin.app_type
+          span.name = context.safely(:resource)
+          span.resource = RESOURCE
+          span.set_tag('aws.agent', AGENT)
+          span.set_tag('aws.operation', context.safely(:operation))
+          span.set_tag('aws.region', context.safely(:region))
+          span.set_tag('path', context.safely(:path))
+          span.set_tag('host', context.safely(:host))
+          span.set_tag(Ext::HTTP::METHOD, context.safely(:http_method))
+          span.set_tag(Ext::HTTP::STATUS_CODE, context.safely(:status_code))
+        end
+      end
+    end
+  end
+end