ddtrace 0.54.2 → 1.10.1

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

@@ -0,0 +1,305 @@
+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.class.name} #{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

data/lib/datadog/tracing/contrib/active_support/cache/instrumentation.rb

@@ -0,0 +1,278 @@
+require_relative '../../../../core/utils'
+require_relative '../../../metadata/ext'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Defines instrumentation for ActiveSupport caching
+          # rubocop:disable Lint/RescueException
+          module Instrumentation
+            module_function
+
+            def start_trace_cache(payload)
+              return unless enabled?
+
+              # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
+              # This check ensures that two reads are not nested since they don't provide
+              # interesting details.
+              # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
+              # to avoid any kind of issue.
+              current_span = Tracing.active_span
+              return if current_span.try(:name) == Ext::SPAN_CACHE &&
+                (
+                  payload[:action] == Ext::RESOURCE_CACHE_GET &&
+                  current_span.try(:resource) == Ext::RESOURCE_CACHE_GET ||
+                  payload[:action] == Ext::RESOURCE_CACHE_MGET &&
+                  current_span.try(:resource) == Ext::RESOURCE_CACHE_MGET
+                )
+
+              tracing_context = payload.fetch(:tracing_context)
+
+              # create a new ``Span`` and add it to the tracing context
+              service = Datadog.configuration.tracing[:active_support][:cache_service]
+              type = Ext::SPAN_TYPE_CACHE
+              span = Tracing.trace(Ext::SPAN_CACHE, service: service, span_type: type)
+              span.resource = payload.fetch(:action)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, service)
+
+              tracing_context[:dd_cache_span] = span
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            def finish_trace_cache(payload)
+              return unless enabled?
+
+              # retrieve the tracing context and continue the trace
+              tracing_context = payload.fetch(:tracing_context)
+              span = tracing_context[:dd_cache_span]
+              return unless span && !span.finished?
+
+              begin
+                # discard parameters from the cache_store configuration
+                if defined?(::Rails)
+                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+                end
+
+                normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
+                cache_key = Core::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+
+                span.set_error(payload[:exception]) if payload[:exception]
+              ensure
+                span.finish
+              end
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            def finish_trace_cache_multi(payload)
+              return unless enabled?
+
+              # retrieve the tracing context and continue the trace
+              tracing_context = payload.fetch(:tracing_context)
+              span = tracing_context[:dd_cache_span]
+              return unless span && !span.finished?
+
+              begin
+                # discard parameters from the cache_store configuration
+                if defined?(::Rails)
+                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+                end
+                normalized_keys = payload.fetch(:keys, []).map do |key|
+                  ::ActiveSupport::Cache.expand_cache_key(key)
+                end
+                cache_keys = Core::Utils.truncate(normalized_keys, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_keys)
+
+                span.set_error(payload[:exception]) if payload[:exception]
+              ensure
+                span.finish
+              end
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            def enabled?
+              Tracing.enabled? && Datadog.configuration.tracing[:active_support][:enabled]
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading
+            module Read
+              def read(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_GET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading of multiple keys
+            module ReadMulti
+              def read_multi(*keys, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MGET,
+                  keys: keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching
+            module Fetch
+              def fetch(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_GET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching of multiple keys
+            module FetchMulti
+              def fetch_multi(*args, &block)
+                # extract options hash
+                keys = args[-1].instance_of?(Hash) ? args[0..-2] : args
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MGET,
+                  keys: keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing
+            module Write
+              def write(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_SET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing of multiple keys
+            module WriteMulti
+              def write_multi(hash, options = nil)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MSET,
+                  keys: hash.keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache deleting
+            module Delete
+              def delete(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_DELETE,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+          end
+          # rubocop:enable Lint/RescueException
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/cache/patcher.rb

@@ -0,0 +1,71 @@
+require_relative '../../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Patcher enables patching of 'active_support' module.
+          module Patcher
+            include Contrib::Patcher
+
+            module_function
+
+            def target_version
+              Integration.version
+            end
+
+            def patch
+              patch_cache_store_read
+              patch_cache_store_read_multi
+              patch_cache_store_fetch
+              patch_cache_store_fetch_multi
+              patch_cache_store_write
+              patch_cache_store_write_multi
+              patch_cache_store_delete
+            end
+
+            def cache_store_class(meth)
+              ::ActiveSupport::Cache::Store
+            end
+
+            def patch_cache_store_read
+              cache_store_class(:read).prepend(Cache::Instrumentation::Read)
+            end
+
+            def patch_cache_store_read_multi
+              cache_store_class(:read_multi).prepend(Cache::Instrumentation::ReadMulti)
+            end
+
+            def patch_cache_store_fetch
+              cache_store_class(:fetch).prepend(Cache::Instrumentation::Fetch)
+            end
+
+            def patch_cache_store_fetch_multi
+              klass = cache_store_class(:fetch_multi)
+              return unless klass.public_method_defined?(:fetch_multi)
+
+              klass.prepend(Cache::Instrumentation::FetchMulti)
+            end
+
+            def patch_cache_store_write
+              cache_store_class(:write).prepend(Cache::Instrumentation::Write)
+            end
+
+            def patch_cache_store_write_multi
+              klass = cache_store_class(:write_multi)
+              return unless klass.public_method_defined?(:write_multi)
+
+              klass.prepend(Cache::Instrumentation::WriteMulti)
+            end
+
+            def patch_cache_store_delete
+              cache_store_class(:delete).prepend(Cache::Instrumentation::Delete)
+            end
+          end
+        end
+      end
+    end
+  end
+end