ddtrace 0.13.0 → 0.14.0

data/benchmarks/sidekiq_test.rb

@@ -0,0 +1,154 @@
+ENV['RAILS_ENV'] = 'production'
+require 'English'
+
+# Benchmark Configuration container
+module TestConfiguration
+  module_function
+
+  def sidekiq
+    Sidekiq.options.tap do |options|
+      options[:tag] = 'test'
+      options[:queues] << 'default'
+      options[:concurrency] = 20
+      options[:timeout] = 2
+    end
+  end
+
+  def redis
+    { pool_size: 30, timeout: 3 }
+  end
+
+  def iteration_count
+    1000
+  end
+end
+
+require 'bundler/setup'
+require 'rails/all'
+Bundler.require(*Rails.groups)
+
+# Example Rails App
+module SampleApp
+  class Application < Rails::Application; end
+end
+
+# Overrides rails configueration locations
+module OverrideConfiguration
+  def paths
+    super.tap { |path| path.add 'config/database', with: 'benchmarks/postgres_database.yml' }
+  end
+end
+
+Rails::Application::Configuration.prepend(OverrideConfiguration)
+
+Rails.application.configure do
+  config.cache_classes = true
+  config.eager_load = true
+  config.active_job.queue_adapter = :sidekiq
+end
+
+ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+Rails.application.initialize!
+
+ActiveRecord::Schema.define do
+  drop_table(:samples) if connection.table_exists?(:samples)
+
+  create_table :samples do |t|
+    t.string :name
+    t.timestamps
+  end
+end
+
+class Sample < ActiveRecord::Base; end
+
+require 'sidekiq/launcher'
+require 'sidekiq/cli'
+require 'concurrent/atomic/atomic_fixnum'
+
+Sidekiq.configure_server do |config|
+  redis_conn = proc do
+    Redis.new(
+      host: ENV.fetch('TEST_REDIS_HOST', '127.0.0.1'),
+      port: ENV.fetch('TEST_REDIS_PORT', 6379)
+    )
+  end
+  config.redis = ConnectionPool.new(size: TestConfiguration.redis[:pool_size],
+                                    timeout: TestConfiguration.redis[:timeout],
+                                    &redis_conn)
+end
+
+# Simple Sidekiq worker performing the real benchmark
+class Worker
+  class << self
+    attr_reader :iterations, :conditional_variable
+  end
+
+  @iterations = Concurrent::AtomicFixnum.new(0)
+  @conditional_variable = ConditionVariable.new
+
+  include Sidekiq::Worker
+  def perform(iter, max_iterations)
+    self.class.iterations.increment
+    self.class.conditional_variable.broadcast if self.class.iterations.value > max_iterations
+
+    Sample.create!(name: iter.to_s).save
+
+    100.times do
+      Sample.last.name
+    end
+
+    Sample.last(100).to_a
+  end
+end
+
+if Datadog.respond_to?(:configure)
+  Datadog.configure do |d|
+    d.use :rails, enabled: true, tags: { 'tag' => 'value' }
+    d.use :http
+    d.use :sidekiq, service_name: 'service'
+    d.use :redis
+    d.use :dalli
+    d.use :resque, workers: [Worker]
+
+    processor = Datadog::Pipeline::SpanProcessor.new do |span|
+      true if span.service == 'B'
+    end
+
+    Datadog::Pipeline.before_flush(processor)
+  end
+end
+
+def current_memory
+  `ps -o rss #{$PROCESS_ID}`.split("\n")[1].to_f / 1024
+end
+
+def time
+  Process.clock_gettime(Process::CLOCK_MONOTONIC)
+end
+
+def launch(iterations, options)
+  iterations.times do |i|
+    Worker.perform_async(i, iterations)
+  end
+
+  launcher = Sidekiq::Launcher.new(options)
+  launcher.run
+end
+
+def wait_and_measure(iterations)
+  start = time
+
+  STDERR.puts "#{time - start}, #{current_memory}"
+
+  mutex = Mutex.new
+
+  while Worker.iterations.value < iterations
+    mutex.synchronize do
+      Worker.conditional_variable.wait(mutex, 1)
+      STDERR.puts "#{time - start}, #{current_memory}"
+    end
+  end
+end
+
+launch(TestConfiguration.iteration_count, TestConfiguration.sidekiq)
+wait_and_measure(TestConfiguration.iteration_count)

data/ddtrace.gemspec

@@ -43,6 +43,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.add_development_dependency 'webmock', '~> 2.0'
   spec.add_development_dependency 'builder'
+  spec.add_development_dependency 'ruby-prof'
+  spec.add_development_dependency 'sqlite3'
+
   # locking transitive dependency of webmock
   spec.add_development_dependency 'addressable', '~> 2.4.0'
   spec.add_development_dependency 'redcarpet', '~> 3.4' if RUBY_PLATFORM != 'java'

data/docs/GettingStarted.md

@@ -26,6 +26,7 @@ For descriptions of terminology used in APM, take a look at the [official docume
      - [Active Record](#active-record)
      - [AWS](#aws)
      - [Dalli](#dalli)
+     - [DelayedJob](#delayedjob)
      - [Elastic Search](#elastic-search)
      - [Excon](#excon)
      - [Faraday](#faraday)
@@ -33,12 +34,14 @@ For descriptions of terminology used in APM, take a look at the [official docume
      - [Grape](#grape)
      - [GraphQL](#graphql)
      - [MongoDB](#mongodb)
+     - [MySQL2](#mysql2)
      - [Net/HTTP](#nethttp)
      - [Racecar](#racecar)
      - [Rack](#rack)
      - [Rails](#rails)
      - [Rake](#rake)
      - [Redis](#redis)
+     - [Rest Client](#restclient)
      - [Resque](#resque)
      - [Sequel](#sequel)
      - [Sidekiq](#sidekiq)
@@ -96,7 +99,7 @@ The Ruby APM tracer sends trace data through the Datadog Agent.
 ### Quickstart for Rails applications
 
 1. Add the `ddtrace` gem to your Gemfile:
-    
+
     ```ruby
     source 'https://rubygems.org'
     gem 'ddtrace'
@@ -162,6 +165,7 @@ And `options` is an optional `Hash` that accepts the following parameters:
 | ``child_of``    | `Datadog::Span` / `Datadog::Context` | Parent for this span. If not provided, will automatically become current active span. | `nil` |
 | ``start_time``  | `Integer` | When the span actually starts. Useful when tracing events that have already happened. | `Time.now.utc` |
 | ``tags``        | `Hash` | Extra tags which should be added to the span. | `{}` |
+| ``on_error``    | `Proc` | Handler invoked when a block is provided to trace, and it raises an error. Provided `span` and `error` as arguments. Sets error on the span by default. | `proc { |span, error| span.set_error(error) unless span.nil? }` |
 
 It's highly recommended you set both `service` and `resource` at a minimum. Spans without a `service` or `resource` as `nil` will be discarded by the Datadog agent.
 
@@ -226,17 +230,26 @@ def finish(name, id, payload)
   end
 end
 ```
-#####Enriching traces from nested methods
+##### Enriching traces from nested methods
 
-You can tag additional information to current active span from any method. Note however that if the method is called and there is no span currently active `active_span` will be nil. 
+You can tag additional information to current active span from any method. Note however that if the method is called and there is no span currently active `active_span` will be nil.
 
 ```ruby
 # e.g. adding tag to active span
-    
+
 current_span = Datadog.tracer.active_span
 current_span.set_tag('my_tag', 'my_value') unless current_span.nil?
 ```
 
+You can also get the root span of the current active trace using the `active_root_span` method. This method will return `nil` if there is no active trace.
+
+```ruby
+# e.g. adding tag to active root span
+
+current_root_span = Datadog.tracer.active_root_span
+current_root_span.set_tag('my_tag', 'my_value') unless current_root_span.nil?
+```
+
 ## Integration instrumentation
 
 Many popular libraries and frameworks are supported out-of-the-box, which can be auto-instrumented. Although they are not activated automatically, they can be easily activated and configured by using the `Datadog.configure` API:
@@ -257,6 +270,7 @@ For a list of available integrations, and their configuration options, please re
 | Active Record  | `active_record` | `>= 3.2, < 5.2`        | *[Link](#active-record)*  | *[Link](https://github.com/rails/rails/tree/master/activerecord)*              |
 | AWS            | `aws`           | `>= 2.0`               | *[Link](#aws)*            | *[Link](https://github.com/aws/aws-sdk-ruby)*                                  |
 | Dalli          | `dalli`         | `>= 2.7`               | *[Link](#dalli)*          | *[Link](https://github.com/petergoldstein/dalli)*                              |
+| DelayedJob     | `delayed_job`   | `>= 4.1`               | *[Link](#delayedjob)*     | *[Link](https://github.com/collectiveidea/delayed_job)*                        |
 | Elastic Search | `elasticsearch` | `>= 6.0`               | *[Link](#elastic-search)* | *[Link](https://github.com/elastic/elasticsearch-ruby)*                        |
 | Excon          | `excon`         | `>= 0.62`              | *[Link](#excon)*          | *[Link](https://github.com/excon/excon)*                                       |
 | Faraday        | `faraday`       | `>= 0.14`              | *[Link](#faraday)*        | *[Link](https://github.com/lostisland/faraday)*                                |
@@ -264,12 +278,14 @@ For a list of available integrations, and their configuration options, please re
 | Grape          | `grape`         | `>= 1.0`               | *[Link](#grape)*          | *[Link](https://github.com/ruby-grape/grape)*                                  |
 | GraphQL        | `graphql`       | `>= 1.7.9`             | *[Link](#graphql)*        | *[Link](https://github.com/rmosolgo/graphql-ruby)*                             |
 | MongoDB        | `mongo`         | `>= 2.0, < 2.5`        | *[Link](#mongodb)*        | *[Link](https://github.com/mongodb/mongo-ruby-driver)*                         |
+| MySQL2         | `mysql2`        | `>= 0.5`               | *[Link](#mysql2)*         | *[Link](https://github.com/brianmario/mysql2)*                                 |
 | Net/HTTP       | `http`          | *(Any supported Ruby)* | *[Link](#nethttp)*        | *[Link](https://ruby-doc.org/stdlib-2.4.0/libdoc/net/http/rdoc/Net/HTTP.html)* |
 | Racecar        | `racecar`       | `>= 0.3.5`             | *[Link](#racecar)*        | *[Link](https://github.com/zendesk/racecar)*                                   |
 | Rack           | `rack`          | `>= 1.4.7`             | *[Link](#rack)*           | *[Link](https://github.com/rack/rack)*                                         |
 | Rails          | `rails`         | `>= 3.2, < 5.2`        | *[Link](#rails)*          | *[Link](https://github.com/rails/rails)*                                       |
 | Rake           | `rake`          | `>= 12.0`              | *[Link](#rake)*           | *[Link](https://github.com/ruby/rake)*                                         |
 | Redis          | `redis`         | `>= 3.2, < 4.0`        | *[Link](#redis)*          | *[Link](https://github.com/redis/redis-rb)*                                    |
+| Rest Client    | `rest-client`   | `>= 1.8`               | *[Link](#restclient)*     | *[Link](https://github.com/rest-client/rest-client)*                           |
 | Resque         | `resque`        | `>= 1.0, < 2.0`        | *[Link](#resque)*         | *[Link](https://github.com/resque/resque)*                                     |
 | Sequel         | `sequel`        | `>= 3.41`              | *[Link](#sequel)*         | *[Link](https://github.com/jeremyevans/sequel)*                                |
 | Sidekiq        | `sidekiq`       | `>= 4.0`               | *[Link](#sidekiq)*        | *[Link](https://github.com/mperham/sidekiq)*                                   |
@@ -304,6 +320,44 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | ``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`` |
 
+**Configuring trace settings per database**
+
+You can provide the `databases` option to configure trace settings by database connection:
+
+```ruby
+# Provide a `:describes` option with a connection key.
+# Any of the following keys are acceptable, and equivalent to one another.
+# If a block is provided, it yields a Settings object that
+# accepts any of the configuration options listed above.
+
+Datadog.configure do |c|
+  # Symbol matching your database connection in config/database.yml
+  # Only available if you are using Rails with ActiveRecord.
+  c.use :active_record, describes: :secondary_database, service_name: 'secondary-db'
+
+  c.use :active_record, describes: :secondary_database do |second_db|
+    second_db.service_name = 'secondary-db'
+  end
+
+  # Connection string with the following connection settings:
+  # Adapter, user, host, port, database
+  c.use :active_record, describes: 'mysql2://root@127.0.0.1:3306/mysql', service_name: 'secondary-db'
+
+  # Hash with following connection settings
+  # Adapter, user, host, port, database
+  c.use :active_record, describes: {
+      adapter:  'mysql2',
+      host:     '127.0.0.1',
+      port:     '3306',
+      database: 'mysql',
+      username: 'root'
+    },
+    service_name: 'secondary-db'
+end
+```
+
+If ActiveRecord traces an event that uses a connection described within `databases`, it will use the trace settings assigned to that connection. If the connection does not match any in the `databases` option, it will use settings defined by `c.use :active_record` instead.
+
 ### AWS
 
 The AWS integration will trace every interaction (e.g. API calls) with AWS services (S3, ElastiCache etc.).
@@ -455,7 +509,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 ### gRPC
 
-The `grpc` integration adds both client and server interceptors, which run as middleware prior to executing the service's remote procedure call. As gRPC applications are often distributed, the integration shares trace information between client and server. 
+The `grpc` integration adds both client and server interceptors, which run as middleware prior to executing the service's remote procedure call. As gRPC applications are often distributed, the integration shares trace information between client and server.
 
 To setup your integration, use the ``Datadog.configure`` method like so:
 
@@ -613,6 +667,29 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | ``service_name`` | Service name used for `mongo` instrumentation | mongodb |
 | ``quantize`` | Hash containing options for quantization. May include `:show` with an Array of keys to not quantize (or `:all` to skip quantization), or `:exclude` with Array of keys to exclude entirely. | ```{ show: [:collection, :database, :operation]  }``` |
 
+### MySQL2
+
+The MySQL2 integration traces any SQL command sent through `mysql2` gem.
+
+```ruby
+require 'mysql2'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :mysql2, options
+end
+
+client = Mysql2::Client.new(:host => "localhost", :username => "root")
+client.query("SELECT * FROM users WHERE group='x'")
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| --- | --- | --- |
+| ``service_name`` | Service name used for MySQL2 instrumentation | `mysql2` |
+| ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
+
 ### Net/HTTP
 
 The Net/HTTP integration will trace any HTTP call using the standard lib Net::HTTP module.
@@ -759,7 +836,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | Key | Description | Default |
 | --- | --- | --- |
 | ``service_name`` | Service name used when tracing application requests (on the `rack` level) | ``<app_name>`` (inferred from your Rails application namespace) |
-| ``controller_service`` | Service name used when tracing a Rails action controller | ``<app_name>-controller`` |
+| ``controller_service`` | Service name used when tracing a Rails action controller | ``<app_name>`` |
 | ``cache_service`` | Cache service name used when tracing cache activity | ``<app_name>-cache`` |
 | ``database_service`` | Database service name used when tracing database activity | ``<app_name>-<adapter_name>`` |
 | ``exception_controller`` | Class or Module which identifies a custom exception controller class. Tracer provides improved error behavior when it can identify custom exception controllers. By default, without this option, it 'guesses' what a custom exception controller looks like. Providing this option aids this identification. | ``nil`` |
@@ -767,6 +844,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | ``middleware_names`` | Enables any short-circuited middleware requests to display the middleware name as resource for the trace. | `false` |
 | ``template_base_path`` | Used when the template name is parsed. If you don't store your templates in the ``views/`` folder, you may need to change this value | ``views/`` |
 | ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
+| ``databases`` | Hash of tracer settings to use for each database connection. See [ActiveRecord](#activerecord) for more details. | ``{}`` |
 
 ### Rake
 
@@ -869,6 +947,27 @@ customer_cache.get(...) # traced call will belong to `customer-cache` service
 invoice_cache.get(...) # traced call will belong to `invoice-cache` service
 ```
 
+### Rest Client
+
+The `rest-client` integration is available through the `ddtrace` middleware:
+
+```ruby
+require 'rest_client'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :rest_client, service_name: 'rest_client' # global service name
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| --- | --- | --- |
+| `service_name` | Service name for Rest Client instrumentation. | `'rest_client'` |
+| `distributed_tracing` | Enables [distributed tracing](#distributed-tracing) | `false` |
+| `tracer` | A `Datadog::Tracer` instance used to instrument the application. Usually you don't need to set that. | `Datadog.tracer` |
+
 ### Resque
 
 The Resque integration uses Resque hooks that wraps the ``perform`` method.
@@ -963,6 +1062,27 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | --- | --- | --- |
 | ``service_name`` | Service name used for `sidekiq` instrumentation | sidekiq |
 
+### DelayedJob
+
+The DelayedJob integration uses lifecycle hooks to trace the job executions.
+
+You can enable it through `Datadog.configure`:
+
+```ruby
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :delayed_job, options
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| --- | --- | --- |
+| ``service_name`` | Service name used for `DelayedJob` instrumentation | delayed_job |
+| ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
+
 ### Sinatra
 
 The Sinatra integration traces requests and template rendering.
@@ -1238,6 +1358,7 @@ For more details on how to activate distributed tracing for integrations, see th
 
 - [Excon](#excon)
 - [Faraday](#faraday)
+- [Rest Client](#restclient)
 - [Net/HTTP](#nethttp)
 - [Rack](#rack)
 - [Rails](#rails)

data/lib/ddtrace/configuration.rb

@@ -8,20 +8,32 @@ module Datadog
     InvalidIntegrationError = Class.new(StandardError)
 
     def initialize(options = {})
-      @registry = options.fetch(:registry, Datadog.registry)
+      @registry = options.fetch(:registry) { Datadog.registry }
       @wrapped_registry = {}
     end
 
-    def [](integration_name)
-      @wrapped_registry[integration_name] ||= Proxy.new(fetch_integration(integration_name))
+    def [](integration_name, configuration_name = :default)
+      integration = fetch_integration(integration_name)
+
+      if integration.class <= Datadog::Contrib::Integration
+        integration.configuration(configuration_name)
+      else
+        @wrapped_registry[integration_name] ||= Proxy.new(integration)
+      end
     end
 
-    def use(integration_name, options = {})
+    def use(integration_name, options = {}, &block)
       integration = fetch_integration(integration_name)
-      settings = Proxy.new(integration)
 
-      integration.sorted_options.each do |name|
-        settings[name] = options.fetch(name, settings[name])
+      if integration.class <= Datadog::Contrib::Integration
+        configuration_name = options[:describes] || :default
+        filtered_options = options.reject { |k, _v| k == :describes }
+        integration.configure(configuration_name, filtered_options, &block)
+      else
+        settings = Proxy.new(integration)
+        integration.sorted_options.each do |name|
+          settings[name] = options.fetch(name, settings[name])
+        end
       end
 
       integration.patch if integration.respond_to?(:patch)

data/lib/ddtrace/context.rb

@@ -63,6 +63,12 @@ module Datadog
       end
     end
 
+    def current_root_span
+      @mutex.synchronize do
+        return @current_root_span
+      end
+    end
+
     # Add a span to the context trace list, keeping it as the last active span.
     def add_span(span)
       @mutex.synchronize do
@@ -77,6 +83,7 @@ module Datadog
           return
         end
         set_current_span(span)
+        @current_root_span = span if @trace.empty?
         @trace << span
         span.context = self
       end
@@ -158,6 +165,7 @@ module Datadog
       @sampling_priority = options.fetch(:sampling_priority, nil)
       @finished_spans = 0
       @current_span = nil
+      @current_root_span = nil
     end
 
     def set_current_span(span)

data/lib/ddtrace/contrib/active_record/configuration/resolver.rb

@@ -0,0 +1,46 @@
+require 'ddtrace/contrib/configuration/resolver'
+require 'ddtrace/vendor/active_record/connection_specification'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      module Configuration
+        # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
+        class Resolver < Contrib::Configuration::Resolver
+          def initialize(configurations = nil)
+            @configurations = configurations
+          end
+
+          def configurations
+            @configurations || ::ActiveRecord::Base.configurations
+          end
+
+          def connection_resolver
+            @resolver ||= begin
+              if defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
+                ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
+              else
+                ::Datadog::Vendor::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
+              end
+            end
+          end
+
+          def resolve(spec)
+            return :default if spec == :default
+            normalize(connection_resolver.resolve(spec).symbolize_keys)
+          end
+
+          def normalize(hash)
+            {
+              adapter:  hash[:adapter],
+              host:     hash[:host],
+              port:     hash[:port],
+              database: hash[:database],
+              username: hash[:username]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_record/configuration/settings.rb

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/active_record/utils'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      module Configuration
+        # Unique settings for ActiveRecord
+        class Settings < Contrib::Configuration::Settings
+          option :orm_service_name
+          option :service_name, depends_on: [:tracer] do |value|
+            (value || Utils.adapter_name).tap do |service_name|
+              tracer.set_service_info(service_name, 'active_record', Ext::AppTypes::DB)
+            end
+          end
+
+          option :tracer, default: Datadog.tracer do |value|
+            value.tap do
+              Events.subscriptions.each do |subscription|
+                subscription.tracer = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_record/events/sql.rb

@@ -22,9 +22,13 @@ module Datadog
           end
 
           def process(span, event, _id, payload)
-            connection_config = Utils.connection_config(payload[:connection_id])
-            span.name = "#{connection_config[:adapter_name]}.query"
-            span.service = configuration[:service_name]
+            config = Utils.connection_config(payload[:connection_id])
+            settings = Datadog.configuration[:active_record, config]
+            adapter_name = Datadog::Utils::Database.normalize_vendor(config[:adapter])
+            service_name = !settings.nil? ? settings.service_name : configuration[:service_name]
+
+            span.name = "#{adapter_name}.query"
+            span.service = service_name
             span.resource = payload.fetch(:sql)
             span.span_type = Datadog::Ext::SQL::TYPE
 
@@ -33,11 +37,11 @@ module Datadog
             # is simply cached from memory, so the notification is fired with start == finish.
             cached = payload[:cached] || (payload[:name] == 'CACHE')
 
-            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', config[:database])
             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', config[:host]) if config[:host]
+            span.set_tag('out.port', config[:port]) if config[:port]
           rescue StandardError => e
             Datadog::Tracer.log.debug(e.message)
           end

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

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/active_record/events'
+require 'ddtrace/contrib/active_record/configuration/resolver'
+require 'ddtrace/contrib/active_record/configuration/settings'
+require 'ddtrace/contrib/active_record/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # Describes the ActiveRecord integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :active_record, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['activerecord'] && Gem.loaded_specs['activerecord'].version
+        end
+
+        def self.present?
+          super && defined?(::ActiveRecord)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('3.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActiveRecord::Patcher
+        end
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+      end
+    end
+  end
+end