ddtrace 0.11.4 → 0.12.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31d6da2597a1d5479adcaf45268088c482e72d30
-  data.tar.gz: e36b2dcb51d0f780ab15f365c9e5ad3989509e81
+  metadata.gz: c35c1da69a010fb6a52f5caf2fe6e4491a9692ed
+  data.tar.gz: 863ec1e1fef7a32862e4ed480ec4e2e8cb987ab2
 SHA512:
-  metadata.gz: 91cae89a7b193e57861cbb78bc456bae57c1edfe5d3e65869245be105e826fabe604477c34f21c95846f1173b3df80de4889da780b91854c9dd69589766eb1a7
-  data.tar.gz: 2323a8f95dd92228c607f92550dccf30268369444f2595dcb52673da74cb4a548c363ab46b631a81ddd3d812f2ed0e8f4abafe91d63fb90caca64ea91cde55ef
+  metadata.gz: 5bd026479bc9e2e741bc57766a9cccf19d3139ab54fa1a771f31db70dd43f971a57352c25d894f23f1f86a2a32225b37655b5092eb72c2972b812b4388eedd82
+  data.tar.gz: 443279a5c424456e89b085d6b7271caa99fb0ba22ffb5d333306d9d3bbeb35d1aea183f6bc3fb26bf4820d2df50965f97d877bbbab1ad28aa0510a0e54ed95f4

data/Appraisals

@@ -57,7 +57,7 @@ if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
   if RUBY_VERSION >= '2.1.10'
     appraise 'rails4-mysql2' do
       gem 'rails', '4.2.7.1'
-      gem 'mysql2', '< 0.5', platform: :ruby
+      gem 'mysql2', platform: :ruby
       gem 'activerecord-jdbcmysql-adapter', platform: :jruby
     end
 
@@ -79,7 +79,7 @@ if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
   if RUBY_VERSION >= '2.2.2'
     appraise 'rails5-mysql2' do
       gem 'rails', '5.0.1'
-      gem 'mysql2', '< 0.5', platform: :ruby
+      gem 'mysql2', platform: :ruby
     end
 
     appraise 'rails5-postgres' do
@@ -115,6 +115,7 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
   appraise 'contrib' do
     gem 'elasticsearch-transport'
     gem 'mongo', '< 2.5'
+    gem 'graphql'
     gem 'grape'
     gem 'rack'
     gem 'rack-test'
@@ -122,14 +123,14 @@ if RUBY_VERSION >= '2.2.2' && RUBY_PLATFORM != 'java'
     gem 'hiredis'
     gem 'sinatra'
     gem 'sqlite3'
-    gem 'activerecord', '< 5.1.5'
+    gem 'activerecord'
     gem 'sidekiq'
     gem 'aws-sdk'
     gem 'sucker_punch'
     gem 'dalli'
     gem 'resque', '< 2.0'
     gem 'racecar', '>= 0.3.5'
-    gem 'mysql2', '< 0.5', platform: :ruby
+    gem 'mysql2', platform: :ruby
   end
 else
   appraise 'contrib-old' do

data/README.md

@@ -14,23 +14,21 @@ You can find the latest documentation on [rubydoc.info][docs]
 
 Install the Ruby client with the ``gem`` command:
 
-```
-gem install ddtrace
-```
+    gem install ddtrace
 
 If you're using ``Bundler``, just update your ``Gemfile`` as follows:
 
 ```ruby
-source 'https://rubygems.org'
+    source 'https://rubygems.org'
 
-# tracing gem
-gem 'ddtrace'
+    # tracing gem
+    gem 'ddtrace'
 ```
 
 To use a development/preview version, use:
 
 ```ruby
-gem 'ddtrace', :github => 'DataDog/dd-trace-rb', :branch => 'me/my-feature-branch'
+    gem 'ddtrace', :github => 'DataDog/dd-trace-rb', :branch => 'me/my-feature-branch'
 ```
 
 ### Quickstart (manual instrumentation)
@@ -40,31 +38,31 @@ Adding tracing to your code is very simple. As an example, let’s imagine we ha
 to trace requests to the home page:
 
 ```ruby
-require 'ddtrace'
-require 'sinatra'
-require 'active_record'
-
-# a generic tracer that you can use across your application
-tracer = Datadog.tracer
-
-get '/' do
-  tracer.trace('web.request') do |span|
-    # set some span metadata
-    span.service = 'my-web-site'
-    span.resource = '/'
-    span.set_tag('http.method', request.request_method)
-
-    # trace the activerecord call
-    tracer.trace('posts.fetch') do
-      @posts = Posts.order(created_at: :desc).limit(10)
-    end
-
-    # trace the template rendering
-    tracer.trace('template.render') do
-      erb :index
+    require 'ddtrace'
+    require 'sinatra'
+    require 'active_record'
+
+    # a generic tracer that you can use across your application
+    tracer = Datadog.tracer
+
+    get '/' do
+      tracer.trace('web.request') do |span|
+        # set some span metadata
+        span.service = 'my-web-site'
+        span.resource = '/'
+        span.set_tag('http.method', request.request_method)
+
+        # trace the activerecord call
+        tracer.trace('posts.fetch') do
+          @posts = Posts.order(created_at: :desc).limit(10)
+        end
+
+        # trace the template rendering
+        tracer.trace('template.render') do
+          erb :index
+        end
+      end
     end
-  end
-end
 ```
 
 ### Quickstart (integration)
@@ -73,20 +71,20 @@ Instead of doing the above manually, whenever an integration is available,
 you can activate it. The example above would become:
 
 ```ruby
-require 'ddtrace'
-require 'sinatra'
-require 'active_record'
-
-Datadog.configure do |c|
-  c.use :sinatra
-  c.use :active_record
-end
-
-# now write your code naturally, it's traced automatically
-get '/' do
-  @posts = Posts.order(created_at: :desc).limit(10)
-  erb :index
-end
+    require 'ddtrace'
+    require 'sinatra'
+    require 'active_record'
+
+    Datadog.configure do |c|
+      c.use :sinatra
+      c.use :active_record
+    end
+
+    # now write your code naturally, it's traced automatically
+    get '/' do
+      @posts = Posts.order(created_at: :desc).limit(10)
+      erb :index
+    end
 ```
 
 This will automatically trace any app inherited from `Sinatra::Application`.
@@ -94,26 +92,14 @@ To trace apps inherited from `Sinatra::Base`, you should manually register
 the tracer inside your class.
 
 ```ruby
-require "ddtrace"
-require "ddtrace/contrib/sinatra/tracer"
-
-class App < Sinatra::Base
-  register Datadog::Contrib::Sinatra::Tracer
-end
-```
-
-To configure the Datadog Tracer, you can define the `configure` block as follows:
+    require "ddtrace"
+    require "ddtrace/contrib/sinatra/tracer"
 
-```ruby
-Datadog.configure do |c|
-  c.tracer enabled: false, hostname: 'trace-agent.local'
-  # [...]
-end
+    class App < Sinatra::Base
+      register Datadog::Contrib::Sinatra::Tracer
+    end
 ```
 
-For a list of available options, check the [Tracer documentation](http://gems.datadoghq.com/trace/docs/#Configure_the_tracer).
-
-
 To know if a given framework or lib is supported by our client,
 please consult our [integrations][contrib] list.
 

data/Rakefile

@@ -48,6 +48,7 @@ namespace :spec do
     :rack,
     :faraday,
     :grape,
+    :graphql,
     :aws,
     :sucker_punch,
     :mongodb,
@@ -108,18 +109,19 @@ namespace :test do
   end
 
   [
+    :aws,
     :elasticsearch,
-    :http,
-    :redis,
-    :sinatra,
-    :sidekiq,
-    :rack,
     :faraday,
     :grape,
-    :aws,
-    :sucker_punch,
+    :http,
     :mongodb,
-    :resque
+    :resque,
+    :rack,
+    :redis,
+    :resque,
+    :sidekiq,
+    :sinatra,
+    :sucker_punch
   ].each do |contrib|
     Rake::TestTask.new(contrib) do |t|
       t.libs << %w[test lib]
@@ -230,6 +232,7 @@ task :ci do
     # RSpec
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:active_record'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:dalli'
+    sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:graphql'
     sh 'rvm $MRI_VERSIONS --verbose do appraisal contrib rake spec:racecar'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake spec:dalli'
     sh 'rvm $MRI_OLD_VERSIONS --verbose do appraisal contrib-old rake spec:active_record'
@@ -258,13 +261,6 @@ task :ci do
     sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres rake test:railsdisableenv'
     # RSpec
     sh 'rvm $LAST_STABLE --verbose do rake benchmark'
-    sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails30-postgres rake spec:rails'
-    sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails32-mysql2 rake spec:rails'
-    sh 'rvm $RAILS3_VERSIONS --verbose do appraisal rails32-postgres rake spec:rails'
-    sh 'rvm $RAILS4_VERSIONS --verbose do appraisal rails4-mysql2 rake spec:rails'
-    sh 'rvm $RAILS4_VERSIONS --verbose do appraisal rails4-postgres rake spec:rails'
-    sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-mysql2 rake spec:rails'
-    sh 'rvm $RAILS5_VERSIONS --verbose do appraisal rails5-postgres rake spec:rails'
   else
     puts 'Too many workers than parallel tasks'
   end

data/docs/GettingStarted.md

@@ -41,6 +41,7 @@ For further details and options, check our integrations list.
 * [Ruby on Rails](#Ruby_on_Rails)
 * [Sinatra](#Sinatra)
 * [Rack](#Rack)
+* [GraphQL](#GraphQL)
 * [Grape](#Grape)
 * [Active Record](#Active_Record)
 * [Elastic Search](#Elastic_Search)
@@ -144,6 +145,57 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 ## Other libraries
 
+### GraphQL
+
+*Version 1.7.9+ supported*
+
+The GraphQL integration activates instrumentation for GraphQL queries. To activate your integration, use the ``Datadog.configure`` method:
+
+    # Inside Rails initializer or equivalent
+    Datadog.configure do |c|
+      c.use :graphql,
+            service_name: 'graphql',
+            schemas: [YourSchema]
+    end
+
+    # Then run a GraphQL query
+    YourSchema.execute(query, variables: {}, context: {}, operation_name: nil)
+
+The `use :graphql` method accepts the following parameters:
+
+| Key | Description | Default |
+| --- | --- | --- |
+| ``service_name`` | Service name used for `graphql` instrumentation | ``ruby-graphql`` |
+| ``schemas`` | Required. Array of `GraphQL::Schema` objects which to trace. Tracing will be added to all the schemas listed, using the options provided to this configuration. If you do not provide any, then tracing will not be activated. | ``[]`` |
+| ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
+
+##### Manually configuring GraphQL schemas
+
+If you prefer to individually configure the tracer settings for a schema (e.g. you have multiple schemas with different service names),
+in the schema definition, you can add the following [using the GraphQL API](http://graphql-ruby.org/queries/tracing.html):
+
+```
+YourSchema = GraphQL::Schema.define do
+  use(
+    GraphQL::Tracing::DataDogTracing,
+    service: 'graphql'
+  )
+end
+```
+
+Or you can modify an already defined schema:
+
+```
+YourSchema.define do
+  use(
+    GraphQL::Tracing::DataDogTracing,
+    service: 'graphql'
+  )
+end
+```
+
+Do *not* `use :graphql` in `Datadog.configure` if you choose to configure manually, as to avoid double tracing. These two means of configuring GraphQL tracing are considered mutually exclusive.
+
 ### Grape
 
 The Grape integration adds the instrumentation to Grape endpoints and filters. This integration can work side by side
@@ -196,7 +248,8 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | --- | --- |
-| ``service_name`` | Service name used for `active_record` instrumentation | active_record |
+| ``service_name`` | Service name used for database portion of `active_record` instrumentation. | Name of database adapter (e.g. `mysql2`) |
+| ``orm_service_name`` | Service name used for the Ruby ORM portion of `active_record` instrumentation. Overrides service name for ORM spans if explicitly set, which otherwise inherit their service from their parent.  | ``active_record`` |
 
 ### Elastic Search
 
@@ -657,7 +710,7 @@ pipeline using the method `Datadog::Pipeline.before_flush`:
     Datadog::Pipeline.before_flush(
       # filter the Span if the given block evaluates true
       Datadog::Pipeline::SpanFilter.new { |span| span.resource =~ /PingController/ },
-      Datadog::Pipeline::SpanFilter.new { |span| span.get_tag('host') == 'localhost' },
+      Datadog::Pipeline::SpanFilter.new { |span| span.get_tag('host') == 'localhost' }
 
       # alter the Span updating fields or tags
       Datadog::Pipeline::SpanProcessor.new { |span| span.resource.gsub!(/password=.*/, '') }

data/gemfiles/contrib.gemfile

@@ -5,6 +5,7 @@ source "https://rubygems.org"
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
 gem "elasticsearch-transport"
 gem "mongo", "< 2.5"
+gem "graphql"
 gem "grape"
 gem "rack"
 gem "rack-test"
@@ -12,13 +13,13 @@ gem "redis", "< 4.0"
 gem "hiredis"
 gem "sinatra"
 gem "sqlite3"
-gem "activerecord", "< 5.1.5"
+gem "activerecord"
 gem "sidekiq"
 gem "aws-sdk"
 gem "sucker_punch"
 gem "dalli"
 gem "resque", "< 2.0"
 gem "racecar", ">= 0.3.5"
-gem "mysql2", "< 0.5", platform: :ruby
+gem "mysql2", platform: :ruby
 
 gemspec path: "../"

data/gemfiles/rails4_mysql2.gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
 gem "rails", "4.2.7.1"
-gem "mysql2", "< 0.5", platform: :ruby
+gem "mysql2", platform: :ruby
 gem "activerecord-jdbcmysql-adapter", platform: :jruby
 
 gemspec path: "../"

data/gemfiles/rails5_mysql2.gemfile

@@ -4,6 +4,6 @@ source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
 gem "rails", "5.0.1"
-gem "mysql2", "< 0.5", platform: :ruby
+gem "mysql2", platform: :ruby
 
 gemspec path: "../"

data/lib/ddtrace.rb

@@ -59,6 +59,7 @@ require 'ddtrace/contrib/active_record/patcher'
 require 'ddtrace/contrib/elasticsearch/patcher'
 require 'ddtrace/contrib/faraday/patcher'
 require 'ddtrace/contrib/grape/patcher'
+require 'ddtrace/contrib/graphql/patcher'
 require 'ddtrace/contrib/redis/patcher'
 require 'ddtrace/contrib/http/patcher'
 require 'ddtrace/contrib/aws/patcher'

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

@@ -1,3 +1,6 @@
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+
 module Datadog
   module Contrib
     module ActiveRecord
@@ -5,7 +8,10 @@ module Datadog
       module Patcher
         include Base
         register_as :active_record, auto_patch: false
-        option :service_name
+        option :service_name do |value|
+          value.tap { @database_service_name = nil }
+        end
+        option :orm_service_name
         option :tracer, default: Datadog.tracer
 
         @patched = false
@@ -21,11 +27,8 @@ module Datadog
           if !@patched && defined?(::ActiveRecord)
             begin
               require 'ddtrace/contrib/rails/utils'
-              require 'ddtrace/ext/sql'
-              require 'ddtrace/ext/app_types'
-
-              patch_active_record()
 
+              patch_active_record
               @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
@@ -40,25 +43,51 @@ module Datadog
           ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
             sql(*args)
           end
+
+          if instantiation_tracing_supported?
+            # subscribe when the active record instantiates objects
+            ::ActiveSupport::Notifications.subscribe('instantiation.active_record') do |*args|
+              instantiation(*args)
+            end
+          end
         end
 
-        def self.database_service
-          return @database_service if defined?(@database_service)
+        def instantiation_tracing_supported?
+          Gem.loaded_specs['activerecord'] \
+            && Gem.loaded_specs['activerecord'].version >= Gem::Version.new('4.2')
+        end
 
-          @database_service = get_option(:service_name) || Datadog::Contrib::Rails::Utils.adapter_name
-          get_option(:tracer).set_service_info(@database_service, 'active_record', Ext::AppTypes::DB)
-          @database_service
+        # NOTE: Resolve this here instead of in the option defaults,
+        #       because resolving adapter name as a default causes ActiveRecord to connect,
+        #       which isn't a good idea at initialization time.
+        def self.database_service_name
+          @database_service_name ||= (get_option(:service_name) || adapter_name).tap do |name|
+            get_option(:tracer).set_service_info(name, 'active_record', Ext::AppTypes::DB)
+          end
         end
 
-        def self.sql(_name, start, finish, _id, payload)
-          span_type = Datadog::Ext::SQL::TYPE
-          connection_config = Datadog::Contrib::Rails::Utils.connection_config(payload[:connection_id])
+        def self.adapter_name
+          @adapter_name ||= Datadog::Contrib::Rails::Utils.adapter_name
+        end
+
+        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.sql(_name, start, finish, _id, payload)
           span = get_option(:tracer).trace(
-            "#{connection_config[:adapter_name]}.query",
+            "#{adapter_name}.query",
             resource: payload.fetch(:sql),
-            service: database_service,
-            span_type: span_type
+            service: database_service_name,
+            span_type: Datadog::Ext::SQL::TYPE
           )
 
           # Find out if the SQL query has been cached in this request. This meta is really
@@ -69,16 +98,39 @@ module Datadog
           # the span should have the query ONLY in the Resource attribute,
           # so that the ``sql.query`` tag will be set in the agent with an
           # obfuscated version
-          span.span_type = Datadog::Ext::SQL::TYPE
-          span.set_tag('active_record.db.vendor', connection_config[:adapter_name])
-          span.set_tag('active_record.db.name', connection_config[:database_name])
+          span.set_tag('active_record.db.vendor', adapter_name)
+          span.set_tag('active_record.db.name', database_name)
           span.set_tag('active_record.db.cached', cached) if cached
-          span.set_tag('out.host', connection_config[:adapter_host])
-          span.set_tag('out.port', connection_config[:adapter_port])
+          span.set_tag('out.host', adapter_host)
+          span.set_tag('out.port', adapter_port)
+          span.start_time = start
+          span.finish(finish)
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def self.instantiation(_name, start, finish, _id, payload)
+          span = get_option(:tracer).trace(
+            'active_record.instantiation',
+            resource: payload.fetch(:class_name),
+            span_type: 'custom'
+          )
+
+          # Inherit service name from parent, if available.
+          span.service = if get_option(:orm_service_name)
+                           get_option(:orm_service_name)
+                         elsif span.parent
+                           span.parent.service
+                         else
+                           'active_record'
+                         end
+
+          span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
+          span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
           span.start_time = start
           span.finish(finish)
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
       end
     end