newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/distributed_trace_payload.rb

@@ -1,246 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'json'
-require 'base64'
-require 'set'
-
-module NewRelic
-  module Agent
-    #
-    # This class contains properties related to distributed traces.
-    # To obtain an instance, call
-    # {DistributedTracing#create_distributed_trace_payload}
-    #
-    # @api public
-    class DistributedTracePayload
-      VERSION =[0, 1].freeze
-      PARENT_TYPE = "App".freeze
-      POUND = '#'.freeze
-
-      # Key names for serialization
-      VERSION_KEY                = 'v'.freeze
-      DATA_KEY                   = 'd'.freeze
-      PARENT_TYPE_KEY            = 'ty'.freeze
-      PARENT_ACCOUNT_ID_KEY      = 'ac'.freeze
-      PARENT_APP_KEY             = 'ap'.freeze
-      TRUSTED_ACCOUNT_KEY        = 'tk'.freeze
-      ID_KEY                     = 'id'.freeze
-      TX_KEY                     = 'tx'.freeze
-      TRACE_ID_KEY               = 'tr'.freeze
-      SAMPLED_KEY                = 'sa'.freeze
-      TIMESTAMP_KEY              = 'ti'.freeze
-      PRIORITY_KEY               = 'pr'.freeze
-
-      # Intrinsic Keys
-      PARENT_TYPE_INTRINSIC_KEY                = "parent.type".freeze
-      PARENT_APP_INTRINSIC_KEY                 = "parent.app".freeze
-      PARENT_ACCOUNT_ID_INTRINSIC_KEY          = "parent.account".freeze
-      PARENT_TRANSPORT_TYPE_INTRINSIC_KEY      = "parent.transportType".freeze
-      PARENT_TRANSPORT_DURATION_INTRINSIC_KEY  = "parent.transportDuration".freeze
-      GUID_INTRINSIC_KEY                       = "guid".freeze
-      TRACE_ID_INTRINSIC_KEY                   = "traceId".freeze
-      PARENT_ID_INTRINSIC_KEY                  = "parentId".freeze
-      PARENT_SPAN_ID_INTRINSIC_KEY             = "parentSpanId".freeze
-      SAMPLED_INTRINSIC_KEY                    = "sampled".freeze
-      COMMA                                    = ",".freeze
-
-      INTRINSIC_KEYS = [
-        PARENT_TYPE_INTRINSIC_KEY,
-        PARENT_APP_INTRINSIC_KEY,
-        PARENT_ACCOUNT_ID_INTRINSIC_KEY,
-        PARENT_TRANSPORT_TYPE_INTRINSIC_KEY,
-        PARENT_TRANSPORT_DURATION_INTRINSIC_KEY,
-        GUID_INTRINSIC_KEY,
-        TRACE_ID_INTRINSIC_KEY,
-        PARENT_ID_INTRINSIC_KEY,
-        PARENT_SPAN_ID_INTRINSIC_KEY,
-        SAMPLED_INTRINSIC_KEY
-      ].freeze
-
-      # Intrinsic Values
-      PARENT_TRANSPORT_TYPE_UNKNOWN = 'Unknown'.freeze
-
-      class << self
-
-        def for_transaction transaction
-          return nil unless connected?
-
-          payload = new
-          payload.version = VERSION
-          payload.parent_type = PARENT_TYPE
-          payload.parent_account_id = Agent.config[:account_id]
-          payload.parent_app_id = Agent.config[:primary_application_id]
-
-          assign_trusted_account_key(payload, payload.parent_account_id)
-
-          payload.id = current_segment_id(transaction)
-          payload.transaction_id = transaction.guid
-          payload.timestamp = (Time.now.to_f * 1000).round
-          payload.trace_id = transaction.trace_id
-          payload.sampled = transaction.sampled?
-          payload.priority = transaction.priority
-
-          payload
-        end
-
-        def from_json serialized_payload
-          raw_payload = JSON.parse serialized_payload
-          return raw_payload if raw_payload.nil?
-          payload_data = raw_payload[DATA_KEY]
-
-          payload = new
-          payload.version             = raw_payload[VERSION_KEY]
-          payload.parent_type         = payload_data[PARENT_TYPE_KEY]
-          payload.parent_account_id   = payload_data[PARENT_ACCOUNT_ID_KEY]
-          payload.parent_app_id       = payload_data[PARENT_APP_KEY]
-          payload.trusted_account_key = payload_data[TRUSTED_ACCOUNT_KEY]
-          payload.timestamp           = payload_data[TIMESTAMP_KEY]
-          payload.id                  = payload_data[ID_KEY]
-          payload.transaction_id      = payload_data[TX_KEY]
-          payload.trace_id            = payload_data[TRACE_ID_KEY]
-          payload.sampled             = payload_data[SAMPLED_KEY]
-          payload.priority            = payload_data[PRIORITY_KEY]
-
-          payload
-        end
-
-        def from_http_safe http_safe_payload
-          decoded_payload = Base64.strict_decode64 http_safe_payload
-          from_json decoded_payload
-        end
-
-        def assign_initial_intrinsics transaction, transaction_payload
-          transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
-          transaction_payload[TRACE_ID_INTRINSIC_KEY] = transaction.trace_id
-          transaction_payload[SAMPLED_INTRINSIC_KEY] = transaction.sampled?
-        end
-
-        def major_version_matches?(payload)
-          payload.version[0] == VERSION[0]
-        end
-
-        private
-
-        # We use the presence of the account_id and primary_application in the
-        # config to tell if we have connected yet.
-        def connected?
-          Agent.config[:account_id] && Agent.config[:primary_application_id]
-        end
-
-        def assign_trusted_account_key payload, account_id
-          trusted_account_key = Agent.config[:trusted_account_key]
-
-          if account_id != trusted_account_key
-            payload.trusted_account_key = trusted_account_key
-          end
-        end
-
-        def current_segment_id(transaction)
-          if Agent.config[:'span_events.enabled'] && transaction.sampled? &&
-              transaction.current_segment
-            transaction.current_segment.guid
-          end
-        end
-      end
-
-      attr_accessor :version,
-                    :parent_type,
-                    :parent_account_id,
-                    :parent_app_id,
-                    :trusted_account_key,
-                    :id,
-                    :transaction_id,
-                    :trace_id,
-                    :sampled,
-                    :priority,
-                    :timestamp
-
-      alias_method :sampled?, :sampled
-
-      attr_reader :caller_transport_type
-
-      def caller_transport_type=(type)
-        @caller_transport_type = valid_transport_type_for(type)
-      end
-
-      def initialize
-        @caller_transport_type = PARENT_TRANSPORT_TYPE_UNKNOWN
-      end
-
-      def to_json
-        result = {
-          VERSION_KEY => version
-        }
-
-        result[DATA_KEY] = {
-          PARENT_TYPE_KEY       => parent_type,
-          PARENT_ACCOUNT_ID_KEY => parent_account_id,
-          PARENT_APP_KEY        => parent_app_id,
-          TX_KEY                => transaction_id,
-          TRACE_ID_KEY          => trace_id,
-          SAMPLED_KEY           => sampled,
-          PRIORITY_KEY          => priority,
-          TIMESTAMP_KEY         => timestamp,
-        }
-
-        result[DATA_KEY][ID_KEY]              = id if id
-        result[DATA_KEY][TRUSTED_ACCOUNT_KEY] = trusted_account_key if trusted_account_key
-
-        JSON.dump(result)
-      end
-
-      # Encode this payload as a string suitable for passing via an
-      # HTTP header.
-      #
-      # @return [String] Payload translated to JSON and encoded for
-      #                  inclusion in headers
-      #
-      # @api public
-      def http_safe
-        Base64.strict_encode64 to_json
-      end
-
-      # Represent this payload as a raw JSON string.
-      #
-      # @return [String] Payload translated to JSON
-      #
-      # @api public
-      def text
-        to_json
-      end
-
-      def assign_intrinsics transaction, transaction_payload
-        transaction_payload[PARENT_TYPE_INTRINSIC_KEY] = parent_type
-        transaction_payload[PARENT_APP_INTRINSIC_KEY] = parent_app_id
-        transaction_payload[PARENT_ACCOUNT_ID_INTRINSIC_KEY] = parent_account_id
-        transaction_payload[PARENT_TRANSPORT_TYPE_INTRINSIC_KEY] = caller_transport_type
-        transaction_payload[PARENT_TRANSPORT_DURATION_INTRINSIC_KEY] = transaction.transport_duration
-        transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
-        transaction_payload[TRACE_ID_INTRINSIC_KEY] = trace_id
-        transaction_payload[PARENT_ID_INTRINSIC_KEY] = transaction.parent_id if transaction.parent_id
-        transaction_payload[PARENT_SPAN_ID_INTRINSIC_KEY] = id if id
-        transaction_payload[SAMPLED_INTRINSIC_KEY] = transaction.sampled?
-      end
-
-      private
-
-      ALLOWABLE_TRANSPORT_TYPES = Set.new(%w[
-        Unknown
-        HTTP
-        HTTPS
-        Kafka
-        JMS
-        IronMQ
-        AMQP
-        Queue
-        Other
-      ]).freeze
-
-      def valid_transport_type_for(value)
-        return value if ALLOWABLE_TRANSPORT_TYPES.include?(value)
-        PARENT_TRANSPORT_TYPE_UNKNOWN
-      end
-    end
-  end
-end

data/lib/new_relic/agent/http_clients/abstract_request.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module Agent
-    module HTTPClients
-
-      # This class provides a public interface for wrapping HTTP requests. This
-      # may be used to create wrappers that are compatible with New Relic's
-      # external request API.
-      #
-      # @api public
-      class AbstractRequest
-        ERROR_MESSAGE = 'Subclasses of NewRelic::Agent::HTTPClients::AbstractRequest must implement a '.freeze
-
-        def []
-          raise NotImplementedError, ERROR_MESSAGE + ':[] method'
-        end
-
-        def []=
-          raise NotImplementedError, ERROR_MESSAGE + ':[]= method'
-        end
-
-        def host_from_header
-          raise NotImplementedError, ERROR_MESSAGE + ':host_from_header method'
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/active_record_4.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/instrumentation/active_record_prepend'
-require 'new_relic/agent/instrumentation/active_record_subscriber'
-require 'new_relic/agent/prepend_supportability'
-
-DependencyDetection.defer do
-  named :active_record_4
-
-  depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i == 4
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
-      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
-  end
-
-  executes do
-    ActiveSupport::Notifications.subscribe('sql.active_record',
-      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
-
-    ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveRecord::Base, ::ActiveRecord::Relation)
-
-      if NewRelic::Agent.config[:prepend_active_record_instrumentation]
-        ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions
-        ::ActiveRecord::Relation.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions
-      else
-        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/active_record_5.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/instrumentation/active_record_subscriber'
-require 'new_relic/agent/instrumentation/active_record_prepend'
-
-DependencyDetection.defer do
-  named :active_record_5
-
-  depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i == 5
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
-      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord 5 instrumentation'
-  end
-
-  executes do
-    ActiveSupport::Notifications.subscribe('sql.active_record',
-      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
-
-    ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveRecord::Base, ::ActiveRecord::Relation)
-      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions
-      ::ActiveRecord::Relation.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions
-
-      if ::ActiveRecord::VERSION::MINOR.to_i == 1 &&
-         ::ActiveRecord::VERSION::TINY.to_i >= 6
-        ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/acts_as_solr.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/database'
-
-module NewRelic
-  module Instrumentation
-    module ActsAsSolrInstrumentation
-      module ParserMethodsInstrumentation
-        def parse_query_with_newrelic(*args)
-          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
-            begin
-              parse_query_without_newrelic(*args)
-            ensure
-              return unless txn = ::NewRelic::Agent::TransactionState.tl_get.current_transaction
-              txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-DependencyDetection.defer do
-  @name = :acts_as_solr
-
-  depends_on do
-    defined?(ActsAsSolr)
-  end
-
-  depends_on do
-    defined?(ActsAsSolr::ParserMethods)
-  end
-
-  depends_on do
-    defined?(ActsAsSolr::ClassMethods)
-  end
-
-  depends_on do
-    defined?(ActsAsSolr::CommonMethods)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing ActsAsSolr instrumentation'
-  end
-
-  executes do
-    ActsAsSolr::ParserMethods.module_eval do
-      include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
-      alias :parse_query_without_newrelic :parse_query
-      alias :parse_query :parse_query_with_newrelic
-    end
-  end
-
-  executes do
-    ActsAsSolr::ClassMethods.module_eval do
-      %w[find_by_solr find_id_by_solr multi_solr_search count_by_solr].each do |method|
-        add_method_tracer method, 'SolrClient/ActsAsSolr/query'
-      end
-      add_method_tracer :rebuild_solr_index, 'SolrClient/ActsAsSolr/index'
-    end
-  end
-
-  executes do
-    ActsAsSolr::CommonMethods.module_eval do
-      add_method_tracer :solr_add, 'SolrClient/ActsAsSolr/add'
-      add_method_tracer :solr_delete, 'SolrClient/ActsAsSolr/delete'
-      add_method_tracer :solr_commit, 'SolrClient/ActsAsSolr/commit'
-      add_method_tracer :solr_optimize, 'SolrClient/ActsAsSolr/optimize'
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/authlogic.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-DependencyDetection.defer do
-  @name = :authlogic
-
-  depends_on do
-    defined?(Authlogic) &&
-      defined?(Authlogic::Session) &&
-      defined?(Authlogic::Session::Base)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Authlogic instrumentation'
-  end
-
-  executes do
-    Authlogic::Session::Base.class_eval do
-      class << self
-        add_method_tracer :find, 'Custom/Authlogic/find'
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/data_mapper.rb

@@ -1,202 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-DependencyDetection.defer do
-  named :data_mapper
-
-  depends_on do
-    defined?(::DataMapper) &&
-      defined?(::DataMapper::Model) &&
-      defined?(::DataMapper::Resource) &&
-      defined?(::DataMapper::Collection)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing DataMapper instrumentation'
-    require 'new_relic/agent/datastores/metric_helper'
-  end
-
-  executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :get
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :first
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :last
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :all
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy!
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :aggregate
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find_by_sql
-  end
-
-  executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy!
-  end
-
-  executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :get
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :first
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :last
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :all
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :lazy_load
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy!
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :aggregate
-  end
-
-  executes do
-    # Catch direct SQL calls that bypass CRUD
-    if defined?(::DataMapper::Adapters::DataObjectsAdapter)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :select, true
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :execute, true
-    end
-  end
-
-  executes do
-    # DM::Validations overrides Model#create, so we patch it here as well
-    if defined?(::DataMapper::Validations::ClassMethods)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Validations::ClassMethods, :create
-    end
-  end
-
-  executes do
-    # DM::Transaction calls commit() twice, so potentially shows up twice.
-    if defined?(::DataMapper::Transaction)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Transaction, :commit, true
-    end
-  end
-
-  executes do
-    if defined?(::DataObjects::Connection)
-      ::DataObjects::Connection.class_eval do
-        include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module DataMapperTracing
-      def self.add_tracer(clazz, method_name, operation_only = false)
-        clazz.class_eval do
-          if method_defined?(method_name) || private_method_defined?(method_name)
-            define_method("#{method_name}_with_newrelic",
-                          NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
-
-            alias_method "#{method_name}_without_newrelic", method_name
-            alias_method method_name, "#{method_name}_with_newrelic"
-          end
-        end
-      end
-
-      DATA_MAPPER = "DataMapper".freeze
-      PASSWORD_REGEX = /&password=.*?(&|$)/
-      AMPERSAND = '&'.freeze
-      PASSWORD_PARAM = '&password='.freeze
-
-      def self.method_body(clazz, method_name, operation_only)
-        use_model_name   = NewRelic::Helper.instance_methods_include?(clazz, :model)
-        metric_operation = method_name.to_s.gsub(/[!?]/, "")
-
-        Proc.new do |*args, &blk|
-          begin
-            if operation_only
-              # Used by direct SQL, like ::DataMapper::Adapters::DataObjectsAdapter#select
-              name = nil
-            elsif use_model_name
-              # Used by ::DataMapper::Collection to get contained model name
-              name = self.model.name
-            elsif self.is_a?(Class)
-              # Used by class-style access, like Model.first()
-              name = self.name
-            else
-              # Used by instance-style access, like model.update(attr: "new")
-              name = self.class.name
-            end
-
-            segment = NewRelic::Agent::Tracer.start_datastore_segment(
-              product: DATA_MAPPER,
-              operation: metric_operation,
-              collection: name
-            )
-
-            begin
-              self.send("#{method_name}_without_newrelic", *args, &blk)
-            rescue ::DataObjects::ConnectionError => e
-              raise
-            rescue ::DataObjects::SQLError => e
-              e.uri.gsub!(PASSWORD_REGEX, AMPERSAND) if e.uri.include?(PASSWORD_PARAM)
-
-              strategy = NewRelic::Agent::Database.record_sql_method(:slow_sql)
-              case strategy
-              when :obfuscated
-                adapter_name = if self.respond_to?(:options)
-                    self.options[:adapter]
-                  else
-                    if self.repository.adapter.respond_to?(:options)
-                      self.repository.adapter.options[:adapter]
-                    else
-                      # DataMapper < 0.10.0
-                      self.repository.adapter.uri.scheme
-                    end
-                  end
-                statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
-                obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
-                e.instance_variable_set(:@query, obfuscated_sql)
-              when :off
-                e.instance_variable_set(:@query, nil)
-              end
-
-              raise
-            ensure
-              segment.finish if segment
-            end
-          end
-        end
-      end
-    end
-
-    module Instrumentation
-      module DataMapperInstrumentation
-        # Unlike in AR, log is called in DM after the query actually ran,
-        # complete with metrics.  Since DO has already calculated the
-        # duration, there's nothing more to measure, so just record and log.
-        #
-        # We rely on the assumption that all possible entry points have been
-        # hooked with tracers, ensuring that notice_sql attaches this SQL to
-        # the proper call scope.
-        def log(msg) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-          return unless state.is_execution_traced?
-
-          txn = state.current_transaction
-
-          if txn && txn.current_segment.respond_to?(:notice_sql)
-            txn.current_segment.notice_sql msg.query
-          end
-        ensure
-          super
-        end
-      end
-    end
-  end
-end