ddtrace 0.53.0 → 1.0.0.beta1

data/lib/datadog/tracing/contrib/active_record/integration.rb

@@ -0,0 +1,55 @@
+# typed: false
+require 'datadog/tracing/contrib/active_record/configuration/resolver'
+require 'datadog/tracing/contrib/active_record/configuration/settings'
+require 'datadog/tracing/contrib/active_record/events'
+require 'datadog/tracing/contrib/active_record/patcher'
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Describes the ActiveRecord integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :active_record, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['activerecord'] && Gem.loaded_specs['activerecord'].version
+          end
+
+          def self.loaded?
+            !defined?(::ActiveRecord).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          # enabled by rails integration so should only auto instrument
+          # if detected that it is being used without rails
+          def auto_instrument?
+            !Contrib::Rails::Utils.railtie_supported?
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            ActiveRecord::Patcher
+          end
+
+          def resolver
+            @resolver ||= Configuration::Resolver.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/patcher.rb

@@ -0,0 +1,26 @@
+# typed: true
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/active_record/events'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Patcher enables patching of 'active_record' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            Events.subscribe!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/utils.rb

@@ -0,0 +1,127 @@
+# typed: false
+require 'datadog/core/environment/ext'
+require 'datadog/tracing/contrib/utils/database'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Common utilities for Rails
+        module Utils
+          EMPTY_CONFIG = {}.freeze
+
+          def self.adapter_name
+            Contrib::Utils::Database.normalize_vendor(connection_config[:adapter])
+          end
+
+          def self.database_name
+            connection_config[:database]
+          end
+
+          def self.adapter_host
+            connection_config[:host]
+          end
+
+          def self.adapter_port
+            connection_config[:port]
+          end
+
+          # Returns the connection configuration hash from the
+          # current connection
+          #
+          # Since Rails 6.0, we have direct access to the object,
+          # while older versions of Rails only provide us the
+          # connection id.
+          #
+          # @see https://github.com/rails/rails/pull/34602
+          def self.connection_config(connection = nil, connection_id = nil)
+            return default_connection_config if connection.nil? && connection_id.nil?
+
+            conn = if !connection.nil?
+                     # Since Rails 6.0, the connection object
+                     # is directly available.
+                     connection
+                   else
+                     # For Rails < 6.0, only the `connection_id`
+                     # is available. We have to find the connection
+                     # object from it.
+                     connection_from_id(connection_id)
+                   end
+
+            if conn && conn.instance_variable_defined?(:@config)
+              conn.instance_variable_get(:@config)
+            else
+              EMPTY_CONFIG
+            end
+          end
+
+          # DEV: JRuby responds to {ObjectSpace._id2ref}, despite raising an error
+          # DEV: when invoked. Thus, we have to explicitly check for Ruby runtime.
+          if Core::Environment::Ext::RUBY_ENGINE != 'jruby'
+            # CRuby has access to {ObjectSpace._id2ref}, which allows for
+            # direct look up of the connection object.
+            def self.connection_from_id(connection_id)
+              # `connection_id` is the `#object_id` of the
+              # connection. We can perform an ObjectSpace
+              # lookup to find it.
+              #
+              # This works not only for ActiveRecord, but for
+              # extensions that might have their own connection
+              # pool (e.g. https://rubygems.org/gems/makara).
+              ObjectSpace._id2ref(connection_id)
+            rescue => e
+              # Because `connection_id` references a live connection
+              # present in the current stack, it is very unlikely that
+              # `_id2ref` will fail, but we add this safeguard just
+              # in case.
+              Datadog.logger.debug(
+                "connection_id #{connection_id} does not represent a valid object. " \
+                        "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
+              )
+            end
+          else
+            # JRuby does not enable {ObjectSpace._id2ref} by default,
+            # as it has large performance impact:
+            # https://github.com/jruby/jruby/wiki/PerformanceTuning/cf155dd9#dont-enable-objectspace
+            #
+            # This fallback code does not support the makara gem,
+            # as its connections don't live in the ActiveRecord
+            # connection pool.
+            def self.connection_from_id(connection_id)
+              ::ActiveRecord::Base
+                .connection_handler
+                .connection_pool_list
+                .flat_map(&:connections)
+                .find { |c| c.object_id == connection_id }
+            end
+          end
+
+          # @return [Hash]
+          def self.default_connection_config
+            return @default_connection_config if instance_variable_defined?(:@default_connection_config)
+
+            current_connection_name = if ::ActiveRecord::Base.respond_to?(:connection_specification_name)
+                                        ::ActiveRecord::Base.connection_specification_name
+                                      else
+                                        ::ActiveRecord::Base
+                                      end
+
+            connection_pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(current_connection_name)
+            connection_pool.nil? ? EMPTY_CONFIG : (@default_connection_config = db_config(connection_pool))
+          rescue StandardError
+            EMPTY_CONFIG
+          end
+
+          # @return [Hash]
+          def self.db_config(connection_pool)
+            if ::Rails::VERSION::MAJOR >= 6 && ::Rails::VERSION::MINOR >= 1
+              connection_pool.db_config.configuration_hash
+            else
+              connection_pool.spec.config
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/vendor/connection_specification.rb

@@ -0,0 +1,306 @@
+# typed: false
+require 'uri'
+
+# NOTE: This code is copied directly from ActiveRecord.
+#       Its purpose is to resolve connection information.
+#       It exists here only because it doesn't exist in Rails 3.2.
+#       When support for Rails 3.2 is dropped, this can be removed.
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        module Vendor
+          # Copy/paste from:
+          # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_handling.rb
+          module ConnectionHandling
+            RAILS_ENV = -> { (Rails.env if defined?(Rails) && defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
+          end
+
+          # Copy/paste from:
+          # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+          module ConnectionAdapters
+            class ConnectionSpecification
+              attr_reader :name, :config, :adapter_method
+
+              def initialize(name, config, adapter_method)
+                @name, @config, @adapter_method = name, config, adapter_method
+              end
+
+              def initialize_dup(original)
+                @config = original.config.dup
+              end
+
+              def to_hash
+                @config.merge(name: @name)
+              end
+
+              # Expands a connection string into a hash.
+              class ConnectionUrlResolver # :nodoc:
+                # == Example
+                #
+                #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+                #   ConnectionUrlResolver.new(url).to_hash
+                #   # => {
+                #     "adapter"  => "postgresql",
+                #     "host"     => "localhost",
+                #     "port"     => 9000,
+                #     "database" => "foo_test",
+                #     "username" => "foo",
+                #     "password" => "bar",
+                #     "pool"     => "5",
+                #     "timeout"  => "3000"
+                #   }
+                def initialize(url)
+                  raise "Database URL cannot be empty" if url.blank?
+                  @uri     = uri_parser.parse(url)
+                  @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
+                  @adapter = "postgresql" if @adapter == "postgres"
+
+                  if @uri.opaque
+                    @uri.opaque, @query = @uri.opaque.split("?", 2)
+                  else
+                    @query = @uri.query
+                  end
+                end
+
+                # Converts the given URL to a full connection hash.
+                def to_hash
+                  config = raw_config.reject { |_, value| value.blank? }
+                  config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+                  config
+                end
+
+                private
+
+                  def uri
+                    @uri
+                  end
+
+                  def uri_parser
+                    @uri_parser ||= URI::Parser.new
+                  end
+
+                  # Converts the query parameters of the URI into a hash.
+                  #
+                  #   "localhost?pool=5&reaping_frequency=2"
+                  #   # => { "pool" => "5", "reaping_frequency" => "2" }
+                  #
+                  # returns empty hash if no query present.
+                  #
+                  #   "localhost"
+                  #   # => {}
+                  def query_hash
+                    Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
+                  end
+
+                  def raw_config
+                    if uri.opaque
+                      query_hash.merge(
+                        "adapter"  => @adapter,
+                        "database" => uri.opaque)
+                    else
+                      query_hash.merge(
+                        "adapter"  => @adapter,
+                        "username" => uri.user,
+                        "password" => uri.password,
+                        "port"     => uri.port,
+                        "database" => database_from_path,
+                        "host"     => uri.hostname)
+                    end
+                  end
+
+                  # Returns name of the database.
+                  def database_from_path
+                    if @adapter == "sqlite3"
+                      # 'sqlite3:/foo' is absolute, because that makes sense. The
+                      # corresponding relative version, 'sqlite3:foo', is handled
+                      # elsewhere, as an "opaque".
+
+                      uri.path
+                    else
+                      # Only SQLite uses a filename as the "database" name; for
+                      # anything else, a leading slash would be silly.
+
+                      uri.path.sub(%r{^/}, "")
+                    end
+                  end
+              end
+
+              ##
+              # Builds a ConnectionSpecification from user input.
+              class Resolver # :nodoc:
+                attr_reader :configurations
+
+                # Accepts a hash two layers deep, keys on the first layer represent
+                # environments such as "production". Keys must be strings.
+                def initialize(configurations)
+                  @configurations = configurations
+                end
+
+                # Returns a hash with database connection information.
+                #
+                # == Examples
+                #
+                # Full hash Configuration.
+                #
+                #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+                #   Resolver.new(configurations).resolve(:production)
+                #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
+                #
+                # Initialized with URL configuration strings.
+                #
+                #   configurations = { "production" => "postgresql://localhost/foo" }
+                #   Resolver.new(configurations).resolve(:production)
+                #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+                #
+                def resolve(config)
+                  if config
+                    resolve_connection config
+                  elsif env = ConnectionHandling::RAILS_ENV.call
+                    resolve_symbol_connection env.to_sym
+                  else
+                    raise AdapterNotSpecified
+                  end
+                end
+
+                # Expands each key in @configurations hash into fully resolved hash
+                def resolve_all
+                  config = configurations.dup
+
+                  if env = ConnectionHandling::DEFAULT_ENV.call
+                    env_config = config[env] if config[env].is_a?(Hash) && !(config[env].key?("adapter") || config[env].key?("url"))
+                  end
+
+                  config.reject! { |k, v| v.is_a?(Hash) && !(v.key?("adapter") || v.key?("url")) }
+                  config.merge! env_config if env_config
+
+                  config.each do |key, value|
+                    config[key] = resolve(value) if value
+                  end
+
+                  config
+                end
+
+                # Returns an instance of ConnectionSpecification for a given adapter.
+                # Accepts a hash one layer deep that contains all connection information.
+                #
+                # == Example
+                #
+                #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+                #   spec = Resolver.new(config).spec(:production)
+                #   spec.adapter_method
+                #   # => "sqlite3_connection"
+                #   spec.config
+                #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
+                #
+                def spec(config)
+                  spec = resolve(config).symbolize_keys
+
+                  raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+                  # Require the adapter itself and give useful feedback about
+                  #   1. Missing adapter gems and
+                  #   2. Adapter gems' missing dependencies.
+                  path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
+                  begin
+                    require path_to_adapter
+                  rescue LoadError => e
+                    # We couldn't require the adapter itself. Raise an exception that
+                    # points out config typos and missing gems.
+                    if e.path == path_to_adapter
+                      # We can assume that a non-builtin adapter was specified, so it's
+                      # either misspelled or missing from Gemfile.
+                      raise e.class, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+                    # Bubbled up from the adapter require. Prefix the exception message
+                    # with some guidance about how to address it and reraise.
+                    else
+                      raise e.class, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+                    end
+                  end
+
+                  adapter_method = "#{spec[:adapter]}_connection"
+
+                  unless ::ActiveRecord::Base.respond_to?(adapter_method)
+                    raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+                  end
+
+                  ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
+                end
+
+                private
+
+                  # Returns fully resolved connection, accepts hash, string or symbol.
+                  # Always returns a hash.
+                  #
+                  # == Examples
+                  #
+                  # Symbol representing current environment.
+                  #
+                  #   Resolver.new("production" => {}).resolve_connection(:production)
+                  #   # => {}
+                  #
+                  # One layer deep hash of connection values.
+                  #
+                  #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
+                  #   # => { "adapter" => "sqlite3" }
+                  #
+                  # Connection URL.
+                  #
+                  #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
+                  #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+                  #
+                  def resolve_connection(spec)
+                    case spec
+                    when Symbol
+                      resolve_symbol_connection spec
+                    when String
+                      resolve_url_connection spec
+                    when Hash
+                      resolve_hash_connection spec
+                    end
+                  end
+
+                  # Takes the environment such as +:production+ or +:development+.
+                  # This requires that the @configurations was initialized with a key that
+                  # matches.
+                  #
+                  #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
+                  #   # => {}
+                  #
+                  def resolve_symbol_connection(spec)
+                    if config = configurations[spec.to_s]
+                      resolve_connection(config).merge("name" => spec.to_s)
+                    else
+                      raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+                    end
+                  end
+
+                  # Accepts a hash. Expands the "url" key that contains a
+                  # URL database connection to a full connection
+                  # hash and merges with the rest of the hash.
+                  # Connection details inside of the "url" key win any merge conflicts
+                  def resolve_hash_connection(spec)
+                    if spec["url"] && spec["url"] !~ /^jdbc:/
+                      connection_hash = resolve_url_connection(spec.delete("url"))
+                      spec.merge!(connection_hash)
+                    end
+                    spec
+                  end
+
+                  # Takes a connection URL.
+                  #
+                  #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
+                  #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+                  #
+                  def resolve_url_connection(url)
+                    ConnectionUrlResolver.new(url).to_hash
+                  end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end