mmtrix_rpm 1.0.0.1

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

@@ -0,0 +1,167 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/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
+    ::Mmtrix::Agent.logger.info 'Installing DataMapper instrumentation'
+    require 'mmtrix/agent/datastores/metric_helper'
+  end
+
+  executes do
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :get
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :first
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :last
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :all
+
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy!
+
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :aggregate
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find_by_sql
+  end
+
+  executes do
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy!
+  end
+
+  executes do
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :get
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :first
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :last
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :all
+
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :lazy_load
+
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update!
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy!
+
+    Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :aggregate
+  end
+
+  executes do
+    # Catch direct SQL calls that bypass CRUD
+    if defined?(::DataMapper::Adapters::DataObjectsAdapter)
+      Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :select, true
+      Mmtrix::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)
+      Mmtrix::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)
+      Mmtrix::Agent::DataMapperTracing.add_tracer ::DataMapper::Transaction, :commit, true
+    end
+  end
+
+  executes do
+    if defined?(::DataObjects::Connection)
+      ::DataObjects::Connection.class_eval do
+        include ::Mmtrix::Agent::Instrumentation::DataMapperInstrumentation
+      end
+    end
+  end
+end
+
+module Mmtrix
+  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_mmtrix",
+                          Mmtrix::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
+
+            alias_method "#{method_name}_without_mmtrix", method_name
+            alias_method method_name, "#{method_name}_with_mmtrix"
+          end
+        end
+      end
+
+      DATA_MAPPER = "DataMapper".freeze
+
+      def self.method_body(clazz, method_name, operation_only)
+        use_model_name   = Mmtrix::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
+
+            metrics = Mmtrix::Agent::Datastores::MetricHelper.metrics_for(
+              DATA_MAPPER,
+              metric_operation,
+              name)
+
+            Mmtrix::Agent::MethodTracer.trace_execution_scoped(metrics) do
+              self.send("#{method_name}_without_mmtrix", *args, &blk)
+            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 = Mmtrix::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
+
+          duration = msg.duration / 1000000.0
+          Mmtrix::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration, state)
+        ensure
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/delayed_job_instrumentation.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/agent/instrumentation/controller_instrumentation'
+
+DependencyDetection.defer do
+  @name = :delayed_job
+
+  depends_on do
+    !Mmtrix::Agent.config[:disable_dj]
+  end
+
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !Mmtrix::Agent.config[:disable_dj]
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing DelayedJob instrumentation [part 1/2]'
+  end
+
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_mmtrix(*args)
+        initialize_without_mmtrix(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        Mmtrix::DelayedJobInjection.worker_name = worker_name
+
+        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job)
+          ::Mmtrix::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+          install_mmtrix_job_tracer
+          Mmtrix::Control.instance.init_plugin :dispatcher => :delayed_job
+        else
+          Mmtrix::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+        end
+      end
+
+      alias initialize_without_mmtrix initialize
+      alias initialize initialize_with_mmtrix
+
+      def install_mmtrix_job_tracer
+        Delayed::Job.class_eval do
+          include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+          if self.instance_methods.include?('name') || self.instance_methods.include?(:name)
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
+          else
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/evented_subscriber.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      class EventedSubscriber
+        def initialize
+          @queue_key = ['Mmtrix', self.class.name, object_id].join('-')
+        end
+
+        def self.subscribed?
+          # TODO: need to talk to Rails core about an API for this,
+          # rather than digging through Listener ivars
+          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
+            .find{|s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def self.subscribe(pattern)
+          if !subscribed?
+            ActiveSupport::Notifications.subscribe(pattern, new)
+          end
+        end
+
+        def start(name, id, payload)
+          event = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+          push_event(event)
+          return event
+        end
+
+        def finish(name, id, payload)
+          pop_event(id)
+        end
+
+        def log_notification_error(error, name, event_type)
+          # These are important enough failures that we want the backtraces
+          # logged at error level, hence the explicit log_exception call.
+          Mmtrix::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
+          Mmtrix::Agent.logger.log_exception(:error, error)
+        end
+
+        def push_event(event)
+          parent = event_stack[event.transaction_id].last
+          if parent && event.respond_to?(:parent=)
+            event.parent = parent
+            parent << event
+          end
+          event_stack[event.transaction_id].push event
+        end
+
+        def pop_event(transaction_id)
+          event = event_stack[transaction_id].pop
+          event.end = Time.now
+          return event
+        end
+
+        def event_stack
+          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+        end
+      end
+
+      # Taken from ActiveSupport::Notifications::Event, pasted here
+      # with a couple minor additions so we don't have a hard
+      # dependency on ActiveSupport::Notifications.
+      #
+      # Represents an intrumentation event, provides timing and metric
+      # name information useful when recording metrics.
+      class Event
+        attr_reader :name, :time, :transaction_id, :payload, :children
+        attr_accessor :end, :parent, :frame
+
+        def initialize(name, start, ending, transaction_id, payload)
+          @name           = name
+          @payload        = payload.dup
+          @time           = start
+          @transaction_id = transaction_id
+          @end            = ending
+          @children       = []
+        end
+
+        def metric_name
+          raise NotImplementedError
+        end
+
+        def duration
+          self.end - time
+        end
+
+        def <<(event)
+          @children << event
+        end
+
+        def parent_of?(event)
+          @children.include? event
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/excon/connection.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module ::Excon
+  class Connection
+    def mmtrix_connection_params
+      (@connection || @data)
+    end
+
+    def mmtrix_resolved_request_params(request_params)
+      resolved = mmtrix_connection_params.merge(request_params)
+      resolved[:headers] = resolved[:headers].merge(request_params[:headers] || {})
+      resolved
+    end
+
+    def request_with_mmtrix_trace(params, &block)
+      orig_response = nil
+      resolved_params = mmtrix_resolved_request_params(params)
+      wrapped_request = ::Mmtrix::Agent::HTTPClients::ExconHTTPRequest.new(resolved_params)
+      ::Mmtrix::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
+        orig_response = request_without_mmtrix_trace(resolved_params, &block)
+        ::Mmtrix::Agent::HTTPClients::ExconHTTPResponse.new(orig_response)
+      end
+      orig_response
+    end
+
+    def self.install_mmtrix_instrumentation
+      alias request_without_mmtrix_trace request
+      alias request request_with_mmtrix_trace
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/excon/middleware.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module ::Excon
+  module Middleware
+    class MmtrixCrossAppTracing
+      TRACE_DATA_IVAR = :@mmtrix_trace_data
+
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def request_call(datum) #THREAD_LOCAL_ACCESS
+        begin
+          # Only instrument this request if we haven't already done so, because
+          # we can get request_call multiple times for requests marked as
+          # :idempotent in the options, but there will be only a single
+          # accompanying response_call/error_call.
+          if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            wrapped_request = ::Mmtrix::Agent::HTTPClients::ExconHTTPRequest.new(datum)
+            state   = ::Mmtrix::Agent::TransactionState.tl_get
+            t0      = Time.now
+            node = ::Mmtrix::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, node, wrapped_request])
+          end
+        rescue => e
+          Mmtrix::Agent.logger.debug(e)
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        finish_trace(datum)
+        @stack.response_call(datum)
+      end
+
+      def error_call(datum)
+        finish_trace(datum)
+        @stack.error_call(datum)
+      end
+
+      def finish_trace(datum) #THREAD_LOCAL_ACCESS
+        trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+        if trace_data
+          datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
+          t0, node, wrapped_request = trace_data
+          if datum[:response]
+            wrapped_response = ::Mmtrix::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
+          end
+          state = ::Mmtrix::Agent::TransactionState.tl_get
+          ::Mmtrix::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/excon.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  named :excon
+
+  # We have two ways of instrumenting Excon:
+  # - For newer versions, use the middleware mechanism Excon exposes
+  # - For older versions, monkey-patch Excon::Connection#request
+  #
+  # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
+  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
+  #   instrumentation for.
+  #
+  # Note that middlewares were added to Excon prior to 0.19, but we don't
+  # use middleware-based instrumentation prior to that version because it didn't
+  # expose a way for middlewares to know about request failures.
+  #
+  # Why don't we use Excon.defaults[:instrumentor]?
+  # While this might seem a perfect fit, it unfortunately isn't suitable in
+  # current form. Someone might reasonably set the default instrumentor to
+  # something else after we install our instrumentation. Ideally, excon would
+  # itself conform to the #subscribe interface of ActiveSupport::Notifications,
+  # so we could safely subscribe and not be clobbered by future subscribers,
+  # but alas, it does not yet.
+
+  EXCON_MIN_VERSION = ::Mmtrix::VersionNumber.new("0.10.1")
+  EXCON_MIDDLEWARE_MIN_VERSION = ::Mmtrix::VersionNumber.new("0.19.0")
+
+  depends_on do
+    defined?(::Excon) && defined?(::Excon::VERSION)
+  end
+
+  executes do
+    excon_version = Mmtrix::VersionNumber.new(::Excon::VERSION)
+    if excon_version >= EXCON_MIN_VERSION
+      install_excon_instrumentation(excon_version)
+    else
+      ::Mmtrix::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
+    end
+  end
+
+  def install_excon_instrumentation(excon_version)
+    require 'mmtrix/agent/cross_app_tracing'
+    require 'mmtrix/agent/http_clients/excon_wrappers'
+
+    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
+      install_middleware_excon_instrumentation
+    else
+      install_legacy_excon_instrumentation
+    end
+  end
+
+  def install_middleware_excon_instrumentation
+    ::Mmtrix::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    require 'mmtrix/agent/instrumentation/excon/middleware'
+    defaults = Excon.defaults
+
+    if defaults[:middlewares]
+      defaults[:middlewares] << ::Excon::Middleware::MmtrixCrossAppTracing
+    else
+      ::Mmtrix::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+    end
+  end
+
+  def install_legacy_excon_instrumentation
+    ::Mmtrix::Agent.logger.info 'Installing legacy Excon instrumentation'
+    require 'mmtrix/agent/instrumentation/excon/connection'
+    ::Excon::Connection.install_mmtrix_instrumentation
+  end
+end

data/lib/mmtrix/agent/instrumentation/grape.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/agent/parameter_filtering'
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      module GrapeInstrumentation
+        extend self
+
+        API_ENDPOINT   = 'api.endpoint'.freeze
+        FORMAT_REGEX   = /\(\/?\.:format\)/.freeze
+        VERSION_REGEX  = /:version(\/|$)/.freeze
+        EMPTY_STRING   = ''.freeze
+        MIN_VERSION    = VersionNumber.new("0.2.0")
+
+        def handle_transaction(endpoint, class_name)
+          return unless endpoint && route = endpoint.route
+          name_transaction(route, class_name)
+          capture_params(endpoint)
+        end
+
+        def name_transaction(route, class_name)
+          txn_name = name_for_transaction(route, class_name)
+          node_name = "Middleware/Grape/#{class_name}/call"
+          Transaction.set_default_transaction_name(txn_name, :grape, node_name)
+        end
+
+        def name_for_transaction(route, class_name)
+          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+          method_name = route.route_method
+
+          if route.route_version
+            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
+          else
+            "#{class_name}#{action_name} (#{method_name})"
+          end
+        end
+
+        def capture_params(endpoint)
+          txn = Transaction.tl_current
+          env = endpoint.request.env
+          params = ParameterFiltering::apply_filters(env, endpoint.params)
+          params.delete("route_info")
+          txn.filtered_params = params
+          txn.merge_request_parameters(params)
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  # Why not just :grape? mmtrix-grape used that name already, and while we're
+  # not shipping yet, overloading the name interferes with the plugin.
+  named :grape_instrumentation
+
+  depends_on do
+    ::Mmtrix::Agent.config[:disable_grape] == false
+  end
+
+  depends_on do
+    defined?(::Grape::VERSION) &&
+      ::Mmtrix::VersionNumber.new(::Grape::VERSION) >= ::Mmtrix::Agent::Instrumentation::GrapeInstrumentation::MIN_VERSION
+  end
+
+  depends_on do
+    begin
+      if defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?("mmtrix-grape")
+        ::Mmtrix::Agent.logger.info("Not installing Mmtrix supported Grape instrumentation because the third party mmtrix-grape gem is present")
+        false
+      else
+        true
+      end
+    rescue => e
+      ::Mmtrix::Agent.logger.info("Could not determine if third party mmtrix-grape gem is installed", e)
+      true
+    end
+  end
+
+  executes do
+    Mmtrix::Agent.logger.info 'Installing Mmtrix supported Grape instrumentation'
+    instrument_call
+  end
+
+  def instrument_call
+    ::Grape::API.class_eval do
+      def call_with_mmtrix(env)
+        begin
+          response = call_without_mmtrix(env)
+        ensure
+          begin
+            endpoint = env[::Mmtrix::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
+            ::Mmtrix::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, self.class.name)
+          rescue => e
+            ::Mmtrix::Agent.logger.warn("Error in Grape instrumentation", e)
+          end
+        end
+
+        response
+      end
+
+      alias_method :call_without_mmtrix, :call
+      alias_method :call, :call_with_mmtrix
+    end
+  end
+
+end

data/lib/mmtrix/agent/instrumentation/httpclient.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  named :httpclient
+
+  HTTPCLIENT_MIN_VERSION = '2.2.0'
+
+  depends_on do
+    defined?(HTTPClient) && defined?(HTTPClient::VERSION)
+  end
+
+  depends_on do
+    minimum_supported_version = Mmtrix::VersionNumber.new(HTTPCLIENT_MIN_VERSION)
+    current_version = Mmtrix::VersionNumber.new(HTTPClient::VERSION)
+
+    current_version >= minimum_supported_version
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing HTTPClient instrumentation'
+    require 'mmtrix/agent/cross_app_tracing'
+    require 'mmtrix/agent/http_clients/httpclient_wrappers'
+  end
+
+  executes do
+    class HTTPClient
+      def do_get_block_with_mmtrix(req, proxy, conn, &block)
+        wrapped_request = Mmtrix::Agent::HTTPClients::HTTPClientRequest.new(req)
+
+        response = nil
+        ::Mmtrix::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
+          do_get_block_without_mmtrix(req, proxy, conn, &block)
+          response = conn.pop
+          conn.push response
+          ::Mmtrix::Agent::HTTPClients::HTTPClientResponse.new(response)
+        end
+        response
+      end
+
+      alias do_get_block_without_mmtrix do_get_block
+      alias do_get_block do_get_block_with_mmtrix
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/ignore_actions.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      module IgnoreActions
+        def self.is_filtered?(key, klass, action_name)
+          # We'll walk the superclass chain and see if
+          # any class says 'yes, filter this one'.
+
+          while klass.respond_to? :mmtrix_read_attr
+            ignore_actions = klass.mmtrix_read_attr(key)
+
+            should_filter = case ignore_actions
+            when Hash
+              only_actions   = Array(ignore_actions[:only])
+              except_actions = Array(ignore_actions[:except])
+              action_name    = action_name.to_sym
+
+              only_actions.include?(action_name) || (!except_actions.empty? && !except_actions.include?(action_name))
+            else
+              !!ignore_actions
+            end
+
+            return true if should_filter
+
+            # Nothing so far says we should filter,
+            # so keep checking up the superclass chain.
+            klass = klass.superclass
+          end
+
+          # Getting here means that no class filtered this.
+          false
+        end
+      end
+    end
+  end
+end
+