ddtrace 0.6.2 → 0.7.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MmJhODJmN2VmNjMxNzY5OTg5NGE1NjEwOTgwZTE0MGU5ZTE1ZjJlYQ==
-  data.tar.gz: !binary |-
-    ZTg5OWNhMjdjMDlhNDVlNDMwN2MzODYzNDgyMGM5MTc1MmMwNzFhZg==
+SHA1:
+  metadata.gz: 36285521893bb7e1b8ceaa8f28d5d0b2b5103239
+  data.tar.gz: 0108b54ce0043a1ac7acd4412ea8cae915e5fdd2
 SHA512:
-  metadata.gz: !binary |-
-    ZThkYmY4ZDQ2MjJiNGJkNTg5YTFjYTJhNmRmMWM1NTFiZGFjZGYzOGJhOTM1
-    ZWU3ODc1MDExNDliNTgzMGM3YzZiOTE4ZTE0YTlkNWJmNjkzMzJlOGRhNzQz
-    MzE2MTRhMDNkNzA3NmNmMmJmZWIzYmEwN2U3NzU1NmVhNjMzYWQ=
-  data.tar.gz: !binary |-
-    MWM3N2I4N2IxNDU5NDZhZTU2YWZmNGU2YmMyYjU2ZmZkNTk4YzgxMGVmZGIz
-    YzM0ZDczYWVhZGMyMjhlNzQ1ZTJjMTBiNjRiNjc4YmIwMTE4ODgyYzE1MDEy
-    NTFhYzFhZGFlNzdmN2M5Y2VhNWQ1ZmJjZDRiNDFjM2QxOWM2YWE=
+  metadata.gz: 1e41922419e9d96624ced8d265301dd1bf4aa2bb487b083a768ffb3282280e5c2f5a8551179016e87b53bd681bd26af9be69bb22e710db1b3bc0d77c3a53ef5d
+  data.tar.gz: c02b8907da2873100ba44f4abeee8ff9c2034869adea96406b69a8ff79357339bfdfc5da8c1d172d92b976f8232de0436d7d14104019405573e8ef7aaa6150fd

data/Appraisals

@@ -92,9 +92,11 @@ end
 if RUBY_VERSION >= '2.2.2'
   appraise 'contrib' do
     gem 'elasticsearch-transport'
+    gem 'grape'
+    gem 'rack'
+    gem 'rack-test'
     gem 'redis'
     gem 'hiredis'
-    gem 'rack-test'
     gem 'sinatra'
     gem 'sqlite3'
     gem 'activerecord'
@@ -105,8 +107,8 @@ else
     gem 'elasticsearch-transport'
     gem 'redis'
     gem 'hiredis'
-    gem 'rack-test', '0.6.2'
     gem 'rack', '1.4.7'
+    gem 'rack-test'
     gem 'sinatra', '1.4.5'
     gem 'sqlite3'
     gem 'activerecord', '3.2.22.5'

data/README.md

@@ -4,9 +4,9 @@
 
 ## Documentation
 
-You can find the latest documentation in the Datadog's [private repository][docs]
+You can find the latest documentation on [rubydoc.info][docs]
 
-[docs]: http://gems.datadoghq.com/trace/docs/
+[docs]: http://www.rubydoc.info/github/DataDog/dd-trace-rb/
 
 ## Getting started
 
@@ -25,6 +25,12 @@ If you're using ``Bundler``, just update your ``Gemfile`` as follows:
     gem 'ddtrace'
 ```
 
+To use a development/preview version, use:
+
+```ruby
+    gem 'ddtrace', :github => 'DataDog/dd-trace-rb', :branch => 'me/my-feature-branch'
+```
+
 ### Quickstart (manual instrumentation)
 
 If you aren't using a supported framework instrumentation, you may want to to manually instrument your code.
@@ -34,7 +40,7 @@ to trace requests to the home page:
 ```ruby
     require 'ddtrace'
     require 'sinatra'
-    require 'activerecord'
+    require 'active_record'
 
     # a generic tracer that you can use across your application
     tracer = Datadog.tracer
@@ -59,29 +65,30 @@ to trace requests to the home page:
     end
 ```
 
-### Monkey patching
+### Quickstart (integration)
 
-By default, our monkey-patching is not active, you need to
-explicitly activate it by calling `Datadog::Monkey.patch_all`
-or `Datadog::Monkey.patch_module`
-
-This ultimately allows you to enable or disable tracing on a per-library basis.
-
-The example below shows the Redis case, but any other non-rails library
-should work the same way:
+Instead of doing the above manually, whenever an integration is available,
+you can activate it. The example above would become:
 
 ```ruby
-
-    require 'redis'
     require 'ddtrace'
+    require 'sinatra'
+    require 'active_record'
 
-    Datadog::Monkey.patch_all # you need to explicitly patch it
+    Datadog::Monkey.patch_all # monkey patch all available integrations
 
-    # now do your Redis stuff, eg:
-    redis = Redis.new
-    redis.set 'foo', 'bar' # traced!
+    # now write your code naturally, it's traced automatically
+    get '/' do
+      @posts = Posts.order(created_at: :desc).limit(10)
+      erb :index
+    end
 ```
 
+To know if a given framework or lib is supported by our client,
+please consult our [integrations][contrib] list.
+
+[contrib]: http://www.rubydoc.info/github/DataDog/dd-trace-rb/Datadog/Contrib
+
 ## Development
 
 ### Testing
@@ -91,21 +98,31 @@ Configure your environment through:
     $ bundle install
     $ appraisal install
 
-You can launch tests using the following rake command:
+You can launch tests using the following Rake commands:
 
-    $ rake test:main                                     # tracer tests
-    $ appraisal rails<version>-<database>rake test:rails # tests Rails matrix
-    $ appraisal contrib rake test:redis                  # tests Redis integration
-    $ appraisal contrib rake test:monkey                 # tests monkey patching
+    $ rake test:main                                      # tracer tests
+    $ appraisal rails<version>-<database> rake test:rails # tests Rails matrix
+    $ appraisal contrib rake test:redis                   # tests Redis integration
+    ...
 
-Available appraisals are:
+Run ``rake --tasks`` for the list of available Rake tasks.
 
-* ``rails{3,4,5}-postgres``: Rails with PostgreSQL
-* ``rails{3,4,5}-mysql2``: Rails with MySQL
-* ``contrib``: Other contrib libraries (Redis, ...)
+Available appraisals are:
 
-jRuby includes only Rails 3.x and 4.x because the current implementation of jdbc drivers, don't support
-ActiveRecord 5.x.
+* ``contrib``: default for integrations
+* ``contrib-old``: default for integrations, with version suited for old Ruby (possibly unmaintained) versions
+* ``rails3-mysql2``: Rails3 with Mysql
+* ``rails3-postgres``: Rails 3 with Postgres
+* ``rails3-postgres-redis``: Rails 3 with Postgres and Redis
+* ``rails3-postgres-sidekiq``: Rails 3 with Postgres and Sidekiq
+* ``rails4-mysql2``: Rails4 with Mysql
+* ``rails4-postgres``: Rails 4 with Postgres
+* ``rails4-postgres-redis``: Rails 4 with Postgres and Redis
+* ``rails4-postgres-sidekiq``: Rails 4 with Postgres and Sidekiq
+* ``rails5-mysql2``: Rails5 with Mysql
+* ``rails5-postgres``: Rails 5 with Postgres
+* ``rails5-postgres-redis``: Rails 5 with Postgres and Redis
+* ``rails5-postgres-sidekiq``: Rails 5 with Postgres and Sidekiq
 
 The test suite requires many backing services (PostgreSQL, MySQL, Redis, ...) and we're using
 ``docker`` and ``docker-compose`` to start these services in the CI.

data/Rakefile

@@ -44,7 +44,7 @@ namespace :test do
     t.test_files = FileList['test/contrib/rails/**/*active_job*_test.rb']
   end
 
-  [:elasticsearch, :http, :redis, :sinatra, :sidekiq].each do |contrib|
+  [:elasticsearch, :http, :redis, :sinatra, :sidekiq, :rack, :grape].each do |contrib|
     Rake::TestTask.new(contrib) do |t|
       t.libs << %w[test lib]
       t.test_files = FileList["test/contrib/#{contrib}/*_test.rb"]
@@ -132,11 +132,14 @@ task :ci do
     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_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 $SIDEKIQ_OLD_VERSIONS --verbose do appraisal contrib-old rake test:sidekiq'
   when 2
     sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails3-mysql2 rake test:rails'

data/docs/GettingStarted.md

@@ -21,10 +21,17 @@ We strongly suggest pinning the version of the library you deploy.
 ## Quickstart
 
 The easiest way to get started with the tracing client is to instrument your web application. ``ddtrace`` gem
-provides auto instrumentation for the following web frameworks:
+provides auto instrumentation for the following web frameworks and libraries:
 
 * [Ruby on Rails](#label-Ruby+on+Rails)
+* [Sidekiq](#label-Sidekiq)
 * [Sinatra](#label-Sinatra)
+* [Rack](#label-Rack)
+* [Grape](#label-Grape)
+* [Active Record](#label-Active+Record)
+* [Elastic Search](#label-Elastic+Search)
+* [Net/HTTP](#label-Net/HTTP)
+* [Redis](#label-Redis)
 
 ## Web Frameworks
 
@@ -45,6 +52,7 @@ To enable the Rails auto instrumentation, create an initializer file in your ``c
     }
 
 If you're using Rails 3 or higher, your application will be listed as ``my-rails-app`` in your service list.
+To integrate Rails instrumentation with third-party libraries such as Grape, please check the available settings below.
 
 #### Configure the tracer with initializers
 
@@ -57,9 +65,11 @@ of the Datadog tracer, you can override the following defaults:
       enabled: true,
       auto_instrument: false,
       auto_instrument_redis: false,
+      auto_instrument_grape: false,
       default_service: 'rails-app',
-      default_database_service: 'postgresql',
+      default_controller_service: 'rails-controller',
       default_cache_service: 'rails-cache',
+      default_database_service: 'postgresql',
       template_base_path: 'views/',
       tracer: Datadog.tracer,
       debug: false,
@@ -77,10 +87,15 @@ Available settings are:
   with a condition, to enable the auto-instrumentation only for particular environments (production, staging, etc...).
 * ``auto_instrument_redis``: if set to ``true`` Redis calls will be traced as such. Calls to Redis cache may be
   still instrumented but you will not have the detail of low-level Redis calls.
+* ``auto_instrument_grape``: if set to ``true`` and you're using a Grape application, all calls to your endpoints are
+  traced, including filters execution.
 * ``default_service``: set the service name used when tracing application requests. Defaults to ``rails-app``
+* ``default_controller_service``: set the service name used when tracing a Rails action controller. Defaults to ``rails-controller``
+* ``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``.
-* ``default_cache_service``: set the cache service name used when tracing cache activity. Defaults to ``rails-cache``
+* ``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
   your templates in the ``views/`` folder, you may need to change this value
 * ``tracer``: is the global tracer used by the tracing application. Usually you don't need to change that value
@@ -129,20 +144,82 @@ Available settings are:
 * ``trace_agent_hostname``: set the hostname of the trace agent.
 * ``trace_agent_port``: set the port the trace agent is listening on.
 
+### Rack
+
+The Rack integration provides a middleware that traces all requests before they reach the underlying framework
+or application. It responds to the Rack minimal interface, providing reasonable values that can be
+retrieved at the Rack level.
+To start using the middleware in your generic Rack application, add it to your ``config.ru``:
+
+    # config.ru example
+    use Datadog::Contrib::Rack::TraceMiddleware
+
+    app = proc do |env|
+      [ 200, {'Content-Type' => 'text/plain'}, "OK" ]
+    end
+
+    run app
+
+#### Configure the tracer
+
+To modify the default middleware configuration, you can use middleware options as follows:
+
+    # config.ru example
+    use Datadog::Contrib::Rack::TraceMiddleware default_service: 'rack-stack'
+
+    app = proc do |env|
+      [ 200, {'Content-Type' => 'text/plain'}, "OK" ]
+    end
+
+    run app
+
+Available settings are:
+
+* ``tracer`` (default: ``Datadog.tracer``): set the tracer to use. Usually you don't need to change that value
+  unless you're already using a different initialized tracer somewhere else. If you need to change some
+  configurations such as the ``hostname``, use the [Tracer#configure](Datadog/Tracer.html#configure-instance_method)
+  method before adding the middleware
+* ``default_service`` (default: ``rack``): set the service name used when the Rack request is traced
+
 ## Other libraries
 
-### Redis
+### Grape
 
-The Redis integration will trace simple calls as well as pipelines.
+The Grape integration adds the instrumentation to Grape endpoints and filters. This integration can work side by side
+with other integrations like Rack and Rails. To activate your integration, use the ``patch_module`` function before
+defining your Grape application:
 
-    require 'redis'
+    # api.rb
+    require 'grape'
     require 'ddtrace'
 
-    Datadog::Monkey.patch_module(:redis) # you need to explicitly patch it
+    Datadog::Monkey.patch_module(:grape)
 
-    # now do your Redis stuff, eg:
-    redis = Redis.new
-    redis.set 'foo', 'bar' # traced!
+    # then define your application
+    class RackTestingAPI < Grape::API
+      desc 'main endpoint'
+      get :success do
+        'Hello world!'
+      end
+    end
+
+### Active Record
+
+Most of the time, Active Record is set up as part of a web framework (Rails, Sinatra...)
+however it can be set up alone:
+
+    require 'tmpdir'
+    require 'sqlite3'
+    require 'active_record'
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:active_record) # explicitly patch it
+
+    Dir::Tmpname.create(['test', '.sqlite']) do |db|
+      conn = ActiveRecord::Base.establish_connection(adapter: 'sqlite3',
+                                                     database: db)
+      conn.connection.execute('SELECT 42') # traced!
+    end
 
 ### Elastic Search
 
@@ -152,7 +229,7 @@ in the ``Client`` object:
     require 'elasticsearch/transport'
     require 'ddtrace'
 
-    Datadog::Monkey.patch_module(:elasticsearch) # you need to explicitly patch it
+    Datadog::Monkey.patch_module(:elasticsearch) # explicitly patch it
 
     # now do your Elastic Search stuff, eg:
     client = Elasticsearch::Client.new url: 'http://127.0.0.1:9200'
@@ -170,7 +247,7 @@ Net::HTTP module.
     require 'net/http'
     require 'ddtrace'
 
-    Datadog::Monkey.patch_module(:http) # you need to explicitly patch it
+    Datadog::Monkey.patch_module(:http) # explicitly patch it
 
     Net::HTTP.start('127.0.0.1', 8080) do |http|
       request = Net::HTTP::Get.new '/index'
@@ -179,6 +256,19 @@ Net::HTTP module.
 
     content = Net::HTTP.get(URI('http://127.0.0.1/index.html'))
 
+### Redis
+
+The Redis integration will trace simple calls as well as pipelines.
+
+    require 'redis'
+    require 'ddtrace'
+
+    Datadog::Monkey.patch_module(:redis) # explicitly patch it
+
+    # now do your Redis stuff, eg:
+    redis = Redis.new
+    redis.set 'foo', 'bar' # traced!
+
 ### Sidekiq
 
 The Sidekiq integration is a server-side middleware which will trace job
@@ -242,7 +332,7 @@ to trace requests to the home page:
 
     require 'ddtrace'
     require 'sinatra'
-    require 'activerecord'
+    require 'active_record'
 
     # a generic tracer that you can use across your application
     tracer = Datadog.tracer
@@ -372,7 +462,7 @@ for the first time:
 
     require 'ddtrace'
     require 'sinatra'
-    require 'activerecord'
+    require 'active_record'
 
     # enable debug mode
     Datadog::Tracer.debug_logging = true
@@ -389,6 +479,23 @@ for the first time:
 Remember that the debug mode may affect your application performance and so it must not be used
 in a production environment.
 
+### Environment and tags
+
+By default, the trace agent (not this library, but the program running in
+the background collecting data from various clients) uses the tags
+set in the agent config file, see our
+[environments tutorial](https://app.datadoghq.com/apm/docs/tutorials/environments) for details.
+
+These values can be overridden at the tracer level:
+
+    Datadog.tracer.set_tags('env' => 'prod')
+
+This enables you to set this value on a per tracer basis, so you can have
+for example several applications reporting for different environments on the same host.
+
+Ultimately, tags can be set per span, but `env` should typically be the same
+for all spans belonging to a given trace.
+
 ### Sampling
 
 `ddtrace` can perform trace sampling. While the trace agent already samples
@@ -401,6 +508,67 @@ overhead.
     sampler = Datadog::RateSampler.new(0.5) # sample 50% of the traces
     Datadog.tracer.configure(sampler: sampler)
 
+### Distributed Tracing
+
+To trace requests across hosts, the spans on the secondary hosts must be linked together by setting ``trace_id`` and ``parent_id``:
+
+    def request_on_secondary_host(parent_trace_id, parent_span_id)
+        tracer.trace('web.request') do |span|
+           span.parent_id = parent_span_id
+           span.trace_id = parent_trace_id
+
+           # perform user code
+        end
+    end
+
+Users can pass along the ``parent_trace_id`` and ``parent_span_id`` via whatever method best matches the RPC framework.
+
+Below is an example using Net/HTTP and Sinatra, where we bypass the integrations to demo how distributed tracing works.
+
+On the client:
+
+    require 'net/http'
+    require 'ddtrace'
+
+    # Do *not* monkey patch here, we do it "manually", to demo the feature
+    # Datadog::Monkey.patch_module(:http)
+
+    uri = URI('http://localhost:4567/')
+
+    Datadog.tracer.trace('web.call') do |span|
+      req = Net::HTTP::Get.new(uri)
+      req['x-ddtrace-parent_trace_id'] = span.trace_id.to_s
+      req['x-ddtrace-parent_span_id'] = span.span_id.to_s
+
+      response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+        http.request(req)
+      end
+
+      puts response.body
+    end
+
+On the server:
+
+    require 'sinatra'
+    require 'ddtrace'
+
+    # Do *not* use Sinatra integration, we do it "manually", to demo the feature
+    # require 'ddtrace/contrib/sinatra/tracer'
+
+    get '/' do
+      parent_trace_id = request.env['HTTP_X_DDTRACE_PARENT_TRACE_ID']
+      parent_span_id = request.env['HTTP_X_DDTRACE_PARENT_SPAN_ID']
+
+      Datadog.tracer.trace('web.work') do |span|
+         if parent_trace_id && parent_span_id
+           span.trace_id = parent_trace_id.to_i
+           span.parent_id = parent_span_id.to_i
+         end
+
+        'Hello world!'
+      end
+    end
+
 ### Supported Versions
 
 #### Ruby interpreters

data/gemfiles/contrib.gemfile

@@ -3,13 +3,14 @@
 source "https://rubygems.org"
 
 gem "elasticsearch-transport"
+gem "grape"
+gem "rack"
+gem "rack-test"
 gem "redis"
 gem "hiredis"
-gem "rack-test"
 gem "sinatra"
-gem 'sqlite3'
+gem "sqlite3"
 gem "activerecord"
 gem "sidekiq"
-gem "activerecord"
 
 gemspec :path => "../"

data/gemfiles/contrib_old.gemfile

@@ -5,9 +5,10 @@ source "https://rubygems.org"
 gem "elasticsearch-transport"
 gem "redis"
 gem "hiredis"
-gem "rack-test", "0.6.2"
 gem "rack", "1.4.7"
+gem "rack-test"
 gem "sinatra", "1.4.5"
+gem "sqlite3"
 gem "activerecord", "3.2.22.5"
 gem "sidekiq", "4.0.0"
 

data/lib/ddtrace.rb

@@ -31,13 +31,29 @@ if defined?(Rails::VERSION)
     require 'ddtrace/contrib/rails/framework'
 
     module Datadog
-      # Run the auto instrumentation directly after initializers in
-      # `config/initializers` are executed
+      # Railtie class initializes
       class Railtie < Rails::Railtie
+        # 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()
           Datadog::Contrib::Rails::Framework.auto_instrument_redis()
+          Datadog::Contrib::Rails::Framework.auto_instrument_grape()
+
+          # 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

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

@@ -18,6 +18,7 @@ module Datadog
             begin
               require 'ddtrace/contrib/rails/utils'
               require 'ddtrace/ext/sql'
+              require 'ddtrace/ext/app_types'
 
               patch_active_record()
 
@@ -50,11 +51,16 @@ module Datadog
         end
 
         def self.tracer
+          return Datadog.tracer unless datadog_trace
           @tracer ||= datadog_trace.fetch(:tracer)
         end
 
         def self.database_service
-          @database_service ||= datadog_trace.fetch(:default_database_service, adapter_name())
+          @database_service ||= if defined?(::Sinatra)
+                                  datadog_trace.fetch(:default_database_service, adapter_name())
+                                else
+                                  adapter_name()
+                                end
           if @database_service
             tracer().set_service_info(@database_service, 'sinatra',
                                       Datadog::Ext::AppTypes::DB)

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -0,0 +1,164 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/errors'
+
+module Datadog
+  module Contrib
+    module Grape
+      # rubocop:disable Metrics/ModuleLength
+      # Endpoint module includes a list of subscribers to create
+      # traces when a Grape endpoint is hit
+      module Endpoint
+        KEY_RUN = 'datadog_grape_endpoint_run'.freeze
+        KEY_RENDER = 'datadog_grape_endpoint_render'.freeze
+
+        def self.subscribe
+          # Grape is instrumented only if it's available
+          return unless defined?(::Grape) && defined?(::ActiveSupport::Notifications)
+
+          # subscribe when a Grape endpoint is hit
+          ::ActiveSupport::Notifications.subscribe('endpoint_run.grape.start_process') do |*args|
+            endpoint_start_process(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
+            endpoint_run(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_render.grape.start_render') do |*args|
+            endpoint_start_render(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
+            endpoint_render(*args)
+          end
+          ::ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
+            endpoint_run_filters(*args)
+          end
+        end
+
+        def self.endpoint_start_process(*)
+          return if Thread.current[KEY_RUN]
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # store the beginning of a trace
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('grape.endpoint_run', service: service, span_type: type)
+
+          Thread.current[KEY_RUN] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_run(name, start, finish, id, payload)
+          return unless Thread.current[KEY_RUN]
+          Thread.current[KEY_RUN] = false
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          tracer = pin.tracer
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            # collect endpoint details
+            api_view = payload[:endpoint].options[:for].to_s
+            path = payload[:endpoint].options[:path].join('/')
+            resource = "#{api_view}##{path}"
+            span.resource = resource
+
+            # set the request span resource if it's a `rack.request` span
+            request_span = payload[:env][:datadog_rack_request_span]
+            if !request_span.nil? && request_span.name == 'rack.request'
+              request_span.resource = resource
+            end
+
+            # catch thrown exceptions
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+
+            # ovverride the current span with this notification values
+            span.set_tag('grape.route.endpoint', api_view)
+            span.set_tag('grape.route.path', path)
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_start_render(*)
+          return if Thread.current[KEY_RENDER]
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # store the beginning of a trace
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('grape.endpoint_render', service: service, span_type: type)
+
+          Thread.current[KEY_RENDER] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_render(name, start, finish, id, payload)
+          return unless Thread.current[KEY_RENDER]
+          Thread.current[KEY_RENDER] = false
+
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          tracer = pin.tracer
+          span = tracer.active_span()
+          return unless span
+
+          # catch thrown exceptions
+          begin
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.endpoint_run_filters(name, start, finish, id, payload)
+          # retrieve the tracer from the PIN object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+
+          # safe-guard to prevent submitting empty filters
+          zero_length = (finish - start).zero?
+          filters = payload[:filters]
+          type = payload[:type]
+          return if (!filters || filters.empty?) || !type || zero_length
+
+          tracer = pin.tracer
+          service = pin.service
+          type = Datadog::Ext::HTTP::TYPE
+          span = tracer.trace('grape.endpoint_run_filters', service: service, span_type: type)
+
+          begin
+            # catch thrown exceptions
+            span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+            span.set_tag('grape.filter.type', type.to_s)
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Datadog
+  module Contrib
+    module Grape
+      SERVICE = 'grape'.freeze
+
+      # Patcher that introduces more instrumentation for Grape endpoints, so that
+      # new signals are executed at the beginning of each step (filters, render and run)
+      module Patcher
+        @patched = false
+
+        module_function
+
+        def patched?
+          @patched
+        end
+
+        def patch
+          if !@patched && defined?(::Grape)
+            begin
+              # do not require these by default, but only when actually patching
+              require 'ddtrace'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/grape/endpoint'
+
+              @patched = true
+              # patch all endpoints
+              patch_endpoint_run()
+              patch_endpoint_render()
+
+              # attach a PIN object globally and set the service once
+              pin = Datadog::Pin.new(SERVICE, app: 'grape', app_type: Datadog::Ext::AppTypes::WEB)
+              pin.onto(::Grape)
+              if pin.tracer && pin.service
+                pin.tracer.set_service_info(pin.service, 'grape', pin.app_type)
+              end
+
+              # subscribe to ActiveSupport events
+              Datadog::Contrib::Grape::Endpoint.subscribe()
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Grape integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        def patch_endpoint_run
+          ::Grape::Endpoint.class_eval do
+            alias_method :run_without_datadog, :run
+            def run(*args)
+              ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process')
+              run_without_datadog(*args)
+            end
+          end
+        end
+
+        def patch_endpoint_render
+          ::Grape::Endpoint.class_eval do
+            class << self
+              alias_method :generate_api_method_without_datadog, :generate_api_method
+              def generate_api_method(*params, &block)
+                method_api = generate_api_method_without_datadog(*params, &block)
+                proc do |*args|
+                  ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
+                  method_api.call(*args)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Contrib
+    # Rack module includes middlewares that are required to trace any framework
+    # and application built on top of Rack.
+    module Rack
+      # TraceMiddleware ensures that the Rack Request is properly traced
+      # from the beginning to the end. The middleware adds the request span
+      # in the Rack environment so that it can be retrieved by the underlying
+      # application. If request tags are not set by the app, they will be set using
+      # information available at the Rack level.
+      class TraceMiddleware
+        DEFAULT_CONFIG = {
+          tracer: Datadog.tracer,
+          default_service: 'rack'
+        }.freeze
+
+        def initialize(app, options = {})
+          # update options with our configuration, unless it's already available
+          options[:tracer] ||= DEFAULT_CONFIG[:tracer]
+          options[:default_service] ||= DEFAULT_CONFIG[:default_service]
+
+          @app = app
+          @options = options
+        end
+
+        def configure
+          # ensure that the configuration is executed only once
+          return if @tracer && @service
+
+          # retrieve the current tracer and service
+          @tracer = @options.fetch(:tracer)
+          @service = @options.fetch(:default_service)
+
+          # configure the Rack service
+          @tracer.set_service_info(
+            @service,
+            'rack',
+            Datadog::Ext::AppTypes::WEB
+          )
+        end
+
+        def call(env)
+          # configure the Rack middleware once
+          configure()
+
+          # 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',
+            service: @service,
+            resource: nil,
+            span_type: Datadog::Ext::HTTP::TYPE
+          )
+          env[:datadog_rack_request_span] = request_span
+
+          # call the rest of the stack
+          status, headers, response = @app.call(env)
+        rescue StandardError => e
+          # 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)
+          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 = "#{env['REQUEST_METHOD']} #{status}".strip unless request_span.resource
+          request_span.set_tag('http.method', env['REQUEST_METHOD']) if request_span.get_tag('http.method').nil?
+          request_span.set_tag('http.url', url) if request_span.get_tag('http.url').nil?
+          request_span.set_tag('http.status_code', status) if request_span.get_tag('http.status_code').nil? && status
+
+          # 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
+            # in any case we don't touch the stacktrace if it has been set
+            if request_span.get_tag(Datadog::Ext::Errors::STACK).nil?
+              request_span.set_tag(Datadog::Ext::Errors::STACK, caller().join("\n"))
+            end
+          end
+
+          request_span.finish()
+
+          [status, headers, response]
+        end
+      end
+    end
+  end
+end

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

@@ -24,9 +24,9 @@ module Datadog
           return if Thread.current[KEY]
 
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          service = ::Rails.configuration.datadog_trace.fetch(:default_service)
+          service = ::Rails.configuration.datadog_trace.fetch(:default_controller_service)
           type = Datadog::Ext::HTTP::TYPE
-          tracer.trace('rails.request', service: service, span_type: type)
+          tracer.trace('rails.action_controller', service: service, span_type: type)
 
           Thread.current[KEY] = true
         rescue StandardError => e
@@ -42,9 +42,14 @@ module Datadog
           return unless span
 
           begin
-            span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
-            span.set_tag(Datadog::Ext::HTTP::URL, payload.fetch(:path))
-            span.set_tag(Datadog::Ext::HTTP::METHOD, payload.fetch(:method))
+            resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+            span.resource = resource
+
+            # set the parent resource if it's a `rack.request` span
+            if !span.parent.nil? && span.parent.name == 'rack.request'
+              span.parent.resource = resource
+            end
+
             span.set_tag('rails.route.action', payload.fetch(:action))
             span.set_tag('rails.route.controller', payload.fetch(:controller))
 
@@ -54,18 +59,14 @@ module Datadog
               status = payload.fetch(:status, '?').to_s
               if status.starts_with?('5')
                 span.status = 1
-                span.set_tag(Datadog::Ext::Errors::STACK, caller().join('\n'))
+                span.set_tag(Datadog::Ext::Errors::STACK, caller().join("\n"))
               end
-              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
             else
               error = payload[:exception]
               span.status = 1
               span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
               span.set_tag(Datadog::Ext::Errors::MSG, error[1])
-              span.set_tag(Datadog::Ext::Errors::STACK, caller().join('\n'))
-              # [manu,christian]: it's right to have a 500? there are cases in Rails that let
-              # user to recover the error after this point?
-              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, payload.fetch(:status, '500').to_s)
+              span.set_tag(Datadog::Ext::Errors::STACK, caller().join("\n"))
             end
           ensure
             span.start_time = start

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

@@ -1,5 +1,9 @@
+require 'ddtrace/pin'
 require 'ddtrace/ext/app_types'
 
+require 'ddtrace/contrib/grape/endpoint'
+require 'ddtrace/contrib/rack/middlewares'
+
 require 'ddtrace/contrib/rails/core_extensions'
 require 'ddtrace/contrib/rails/action_controller'
 require 'ddtrace/contrib/rails/action_view'
@@ -20,8 +24,11 @@ module Datadog
           enabled: true,
           auto_instrument: false,
           auto_instrument_redis: false,
+          auto_instrument_grape: false,
           default_service: 'rails-app',
+          default_controller_service: 'rails-controller',
           default_cache_service: 'rails-cache',
+          default_grape_service: 'grape',
           template_base_path: 'views/',
           tracer: Datadog.tracer,
           debug: false,
@@ -57,6 +64,12 @@ module Datadog
           # set default service details
           datadog_config[:tracer].set_service_info(
             datadog_config[:default_service],
+            'rack',
+            Datadog::Ext::AppTypes::WEB
+          )
+
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_controller_service],
             'rails',
             Datadog::Ext::AppTypes::WEB
           )
@@ -115,6 +128,19 @@ module Datadog
           end
         end
 
+        def self.auto_instrument_grape
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument_grape]
+
+          # patch the Grape library so that endpoints are traced
+          Datadog::Monkey.patch_module(:grape)
+
+          # update the Grape pin object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+          pin.tracer = ::Rails.configuration.datadog_trace[:tracer]
+          pin.service = ::Rails.configuration.datadog_trace[:default_grape_service]
+        end
+
         # automatically instrument all Rails component
         def self.auto_instrument
           return unless ::Rails.configuration.datadog_trace[:auto_instrument]

data/lib/ddtrace/logger.rb

@@ -13,19 +13,24 @@ module Datadog
     end
 
     def add(severity, message = nil, progname = nil, &block)
-      return super unless debug?
-
-      # We are in debug mode, add stack trace to help debugging
       where = ''
-      c = caller
-      where = "(#{c[1]}) " if c.length > 1
 
-      if block_given?
-        super(severity, message, progname) do
-          "#{where}#{yield}"
+      # We are in debug mode, or this is an error, add stack trace to help debugging
+      if debug? || severity >= ::Logger::ERROR
+        c = caller
+        where = "(#{c[1]}) " if c.length > 1
+      end
+
+      if message.nil?
+        if block_given?
+          super(severity, message, progname) do
+            "[#{self.progname}] #{where}#{yield}"
+          end
+        else
+          super(severity, message, "[#{self.progname}] #{where}#{progname}")
         end
       else
-        super(severity, message, "#{where}#{progname}")
+        super(severity, "[#{self.progname}] #{where}#{message}")
       end
     end
 

data/lib/ddtrace/monkey.rb

@@ -5,14 +5,21 @@ require 'thread'
 # patching code, which is required on demand, when patching.
 require 'ddtrace/contrib/active_record/patcher'
 require 'ddtrace/contrib/elasticsearch/patcher'
-require 'ddtrace/contrib/http/patcher'
+require 'ddtrace/contrib/grape/patcher'
 require 'ddtrace/contrib/redis/patcher'
+require 'ddtrace/contrib/http/patcher'
 
 module Datadog
   # Monkey is used for monkey-patching 3rd party libs.
   module Monkey
     @patched = []
-    @autopatch_modules = { elasticsearch: true, http: true, redis: true, active_record: false }
+    @autopatch_modules = {
+      elasticsearch: true,
+      http: true,
+      redis: true,
+      grape: true,
+      active_record: false
+    }
     # 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.
@@ -21,6 +28,7 @@ module Datadog
     @patchers = { elasticsearch: Datadog::Contrib::Elasticsearch::Patcher,
                   http: Datadog::Contrib::HTTP::Patcher,
                   redis: Datadog::Contrib::Redis::Patcher,
+                  grape: Datadog::Contrib::Grape::Patcher,
                   active_record: Datadog::Contrib::ActiveRecord::Patcher }
     @mutex = Mutex.new
 
@@ -37,7 +45,7 @@ module Datadog
     def patch_module(m)
       @mutex.synchronize do
         patcher = @patchers[m]
-        raise 'Unsupported module #{m}' unless patcher
+        raise "Unsupported module #{m}" unless patcher
         patcher.patch
       end
     end

data/lib/ddtrace/span.rb

@@ -86,23 +86,25 @@ module Datadog
       @status = 1
       @meta[Datadog::Ext::Errors::MSG] = e.message if e.respond_to?(:message) && e.message
       @meta[Datadog::Ext::Errors::TYPE] = e.class.to_s
-      @meta[Datadog::Ext::Errors::STACK] = e.backtrace.join('\n') if e.respond_to?(:backtrace) && e.backtrace
+      @meta[Datadog::Ext::Errors::STACK] = e.backtrace.join("\n") if e.respond_to?(:backtrace) && e.backtrace
     end
 
     # Mark the span finished at the current time and submit it.
-    def finish
-      finish_at(Time.now.utc)
-    end
-
-    # Mark the span finished at the given time and submit it.
-    def finish_at(end_time)
-      @end_time = end_time
+    def finish(finish_time = nil)
+      return if finished?
 
+      @end_time = finish_time.nil? ? Time.now.utc : finish_time
       @tracer.record(self) unless @tracer.nil?
-
       self
     end
 
+    # Proxy function that flag a span as finished with the given
+    # timestamp. This function is used for retro-compatibility.
+    # DEPRECATED: remove this function in the next release
+    def finish_at(finish_time)
+      finish(finish_time)
+    end
+
     # Return whether the span is finished or not.
     def finished?
       !@end_time.nil?

data/lib/ddtrace/version.rb

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

metadata

@@ -1,103 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-07 00:00:00.000000000 Z
+date: 2017-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.10'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: ! 'ddtrace is Datadog’s tracing client for Ruby. It is used to trace
-  requests
-
+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
-
   have great visiblity into bottlenecks and troublesome requests.
-
-'
 email:
 - dev@datadoghq.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .env
-- .gitignore
-- .rubocop.yml
-- .yardopts
+- ".env"
+- ".gitignore"
+- ".rubocop.yml"
+- ".yardopts"
 - Appraisals
 - Gemfile
 - LICENSE
@@ -126,7 +136,10 @@ files:
 - lib/ddtrace/contrib/active_record/patcher.rb
 - lib/ddtrace/contrib/elasticsearch/patcher.rb
 - lib/ddtrace/contrib/elasticsearch/quantize.rb
+- lib/ddtrace/contrib/grape/endpoint.rb
+- lib/ddtrace/contrib/grape/patcher.rb
 - lib/ddtrace/contrib/http/patcher.rb
+- lib/ddtrace/contrib/rack/middlewares.rb
 - lib/ddtrace/contrib/rails/action_controller.rb
 - lib/ddtrace/contrib/rails/action_view.rb
 - lib/ddtrace/contrib/rails/active_record.rb
@@ -169,17 +182,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications