appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/inst/moped.rb

@@ -0,0 +1,466 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'json'
+
+module AppOpticsAPM
+  module Inst
+    ##
+    # Moped
+    #
+    module Moped
+      FLAVOR = :mongodb
+
+      # Moped::Database
+      DB_OPS         = [:command, :drop].freeze
+
+      # Moped::Indexes
+      INDEX_OPS      = [:create, :drop].freeze
+
+      # Moped::Query
+      QUERY_OPS      = [:count, :sort, :limit, :distinct, :update, :update_all, :upsert,
+                        :explain, :modify, :remove, :remove_all].freeze
+
+      # Moped::Collection
+      COLLECTION_OPS = [:drop, :find, :indexes, :insert, :aggregate].freeze
+
+      ##
+      # remote_host
+      #
+      # This utility method converts the server into a host:port
+      # pair for reporting
+      #
+      def remote_host(server)
+        if ::Moped::VERSION < '2.0.0'
+          server
+        else
+          "#{server.address.host}:#{server.address.port}"
+        end
+      end
+    end
+
+    ##
+    # MopedDatabase
+    #
+    module MopedDatabase
+      include AppOpticsAPM::Inst::Moped
+
+      def self.included(klass)
+        AppOpticsAPM::Inst::Moped::DB_OPS.each do |m|
+          AppOpticsAPM::Util.method_alias(klass, m)
+        end
+      end
+
+      def extract_trace_details(op)
+        report_kvs = {}
+        report_kvs[:Flavor] = AppOpticsAPM::Inst::Moped::FLAVOR
+        # FIXME: We're only grabbing the first of potentially multiple servers here
+        report_kvs[:RemoteHost] = remote_host(session.cluster.seeds.first)
+        report_kvs[:Database] = name
+        report_kvs[:QueryOp] = op.to_s
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:moped][:collect_backtraces]
+      rescue StandardError => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+      ensure
+        return report_kvs
+      end
+
+      def command_with_appoptics(command)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.layer_op && command.key?(:mapreduce)
+          begin
+            report_kvs = extract_trace_details(:map_reduce)
+            report_kvs[:Map_Function] = command[:map]
+            report_kvs[:Reduce_Function] = command[:reduce]
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          end
+
+          AppOpticsAPM::API.trace(:mongo, report_kvs) do
+            command_without_appoptics(command)
+          end
+        else
+          command_without_appoptics(command)
+        end
+      end
+
+      def drop_with_appoptics
+        return drop_without_appoptics unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:drop_database)
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          drop_without_appoptics
+        end
+      end
+    end
+
+    ##
+    # MopedIndexes
+    #
+    module MopedIndexes
+      include AppOpticsAPM::Inst::Moped
+
+      def self.included(klass)
+        AppOpticsAPM::Inst::Moped::INDEX_OPS.each do |m|
+          AppOpticsAPM::Util.method_alias(klass, m)
+        end
+      end
+
+      def extract_trace_details(op)
+        report_kvs = {}
+        report_kvs[:Flavor] = AppOpticsAPM::Inst::Moped::FLAVOR
+
+        # FIXME: We're only grabbing the first of potentially multiple servers here
+        first = database.session.cluster.seeds.first
+        if ::Moped::VERSION < '2.0.0'
+          report_kvs[:RemoteHost] = first
+        else
+          report_kvs[:RemoteHost] = "#{first.address.host}:#{first.address.port}"
+        end
+        report_kvs[:Database] = database.name
+        report_kvs[:QueryOp] = op.to_s
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:moped][:collect_backtraces]
+      rescue StandardError => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+      ensure
+        return report_kvs
+      end
+
+      def create_with_appoptics(key, options = {})
+        return create_without_appoptics(key, options) unless AppOpticsAPM.tracing?
+
+        begin
+          # We report :create_index here to be consistent
+          # with other mongo implementations
+          report_kvs = extract_trace_details(:create_index)
+          report_kvs[:Key] = key.to_json
+          report_kvs[:Options] = options.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs, :create_index) do
+          create_without_appoptics(key, options = {})
+        end
+      end
+
+      def drop_with_appoptics(key = nil)
+        return drop_without_appoptics(key) unless AppOpticsAPM.tracing?
+
+        begin
+          # We report :drop_indexes here to be consistent
+          # with other mongo implementations
+          report_kvs = extract_trace_details(:drop_indexes)
+          report_kvs[:Key] = key.nil? ? :all : key.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          drop_without_appoptics(key = nil)
+        end
+      end
+    end
+
+    ##
+    # MopedQuery
+    #
+    module MopedQuery
+      include AppOpticsAPM::Inst::Moped
+
+      def self.included(klass)
+        AppOpticsAPM::Inst::Moped::QUERY_OPS.each do |m|
+          AppOpticsAPM::Util.method_alias(klass, m)
+        end
+      end
+
+      def extract_trace_details(op)
+        report_kvs = {}
+        report_kvs[:Flavor] = AppOpticsAPM::Inst::Moped::FLAVOR
+        # FIXME: We're only grabbing the first of potentially multiple servers here
+        first = collection.database.session.cluster.seeds.first
+        report_kvs[:RemoteHost] = remote_host(first)
+        report_kvs[:Database] = collection.database.name
+        report_kvs[:Collection] = collection.name
+        report_kvs[:QueryOp] = op.to_s
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:moped][:collect_backtraces]
+      rescue StandardError => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+      ensure
+        return report_kvs
+      end
+
+      def count_with_appoptics
+        return count_without_appoptics unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:count)
+          report_kvs[:Query] = selector.empty? ? :all : selector.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          count_without_appoptics
+        end
+      end
+
+      def sort_with_appoptics(sort)
+        return sort_without_appoptics(sort) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:sort)
+          report_kvs[:Query] = selector.empty? ? :all : selector.to_json
+          report_kvs[:Order] = sort.to_s
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          sort_without_appoptics(sort)
+        end
+      end
+
+      def limit_with_appoptics(limit)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:explain)
+          begin
+            report_kvs = extract_trace_details(:limit)
+            report_kvs[:Query] = selector.empty? ? :all : selector.to_json
+            report_kvs[:Limit] = limit.to_s
+          rescue StandardError => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          end
+
+          AppOpticsAPM::API.trace(:mongo, report_kvs) do
+            limit_without_appoptics(limit)
+          end
+        else
+          limit_without_appoptics(limit)
+        end
+      end
+
+      def distinct_with_appoptics(key)
+        return distinct_without_appoptics(key) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:distinct)
+          report_kvs[:Query] = selector.empty? ? :all : selector.to_json
+          report_kvs[:Key] = key.to_s
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          distinct_without_appoptics(key)
+        end
+      end
+
+      def update_with_appoptics(change, flags = nil)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:update_all) && !AppOpticsAPM.tracing_layer_op?(:upsert)
+          begin
+            report_kvs = extract_trace_details(:update)
+            report_kvs[:Flags] = flags.to_s if flags
+            report_kvs[:Update_Document] = change.to_json
+          rescue StandardError => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          end
+
+          AppOpticsAPM::API.trace(:mongo, report_kvs) do
+            update_without_appoptics(change, flags)
+          end
+        else
+          update_without_appoptics(change, flags)
+        end
+      end
+
+      def update_all_with_appoptics(change)
+        return update_all_without_appoptics(change) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:update_all)
+          report_kvs[:Update_Document] = change.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs, :update_all) do
+          update_all_without_appoptics(change)
+        end
+      end
+
+      def upsert_with_appoptics(change)
+        return upsert_without_appoptics(change) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:upsert)
+          report_kvs[:Query] = selector.to_json
+          report_kvs[:Update_Document] = change.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs, :upsert) do
+          upsert_without_appoptics(change)
+        end
+      end
+
+      def explain_with_appoptics
+        return explain_without_appoptics unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:explain)
+          report_kvs[:Query] = selector.empty? ? :all : selector.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs, :explain) do
+          explain_without_appoptics
+        end
+      end
+
+      def modify_with_appoptics(change, options = {})
+        return modify_without_appoptics(change, options) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:modify)
+          report_kvs[:Update_Document] = selector.empty? ? :all : selector.to_json
+          report_kvs[:Change] = change.to_json
+          report_kvs[:Options] = options.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          modify_without_appoptics(change, options)
+        end
+      end
+
+      def remove_with_appoptics
+        return remove_without_appoptics unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:remove)
+          report_kvs[:Query] = selector.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          remove_without_appoptics
+        end
+      end
+
+      def remove_all_with_appoptics
+        return remove_all_without_appoptics unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:remove_all)
+          report_kvs[:Query] = selector.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          remove_all_without_appoptics
+        end
+      end
+    end
+
+    ##
+    # MopedCollection
+    #
+    module MopedCollection
+      include AppOpticsAPM::Inst::Moped
+
+      def self.included(klass)
+        AppOpticsAPM::Inst::Moped::COLLECTION_OPS.each do |m|
+          AppOpticsAPM::Util.method_alias(klass, m)
+        end
+      end
+
+      def extract_trace_details(op)
+        report_kvs = {}
+        report_kvs[:Flavor] = AppOpticsAPM::Inst::Moped::FLAVOR
+        # FIXME: We're only grabbing the first of potentially multiple servers here
+        report_kvs[:RemoteHost] = remote_host(database.session.cluster.seeds.first)
+        report_kvs[:Database] = database.name
+        report_kvs[:Collection] = name
+        report_kvs[:QueryOp] = op.to_s
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:moped][:collect_backtraces]
+      rescue StandardError => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+      ensure
+        return report_kvs
+      end
+
+      def drop_with_appoptics
+        return drop_without_appoptics unless AppOpticsAPM.tracing?
+
+        # We report :drop_collection here to be consistent
+        # with other mongo implementations
+        report_kvs = extract_trace_details(:drop_collection)
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          drop_without_appoptics
+        end
+      end
+
+      def find_with_appoptics(selector = {})
+        return find_without_appoptics(selector) unless AppOpticsAPM.tracing?
+
+        begin
+          report_kvs = extract_trace_details(:find)
+          report_kvs[:Query] = selector.empty? ? 'all' : selector.to_json
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          find_without_appoptics(selector)
+        end
+      end
+
+      def indexes_with_appoptics
+        return indexes_without_appoptics unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:indexes)
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          indexes_without_appoptics
+        end
+      end
+
+      def insert_with_appoptics(documents, flags = nil)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:create_index)
+          report_kvs = extract_trace_details(:insert)
+
+          AppOpticsAPM::API.trace(:mongo, report_kvs) do
+            insert_without_appoptics(documents, flags)
+          end
+        else
+          insert_without_appoptics(documents, flags)
+        end
+      end
+
+      def aggregate_with_appoptics(*pipeline)
+        return aggregate_without_appoptics(*pipeline) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:aggregate)
+        report_kvs[:Query] = pipeline
+
+        AppOpticsAPM::API.trace(:mongo, report_kvs) do
+          aggregate_without_appoptics(pipeline)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Moped) && AppOpticsAPM::Config[:moped][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting moped' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Moped::Database,   AppOpticsAPM::Inst::MopedDatabase)
+  AppOpticsAPM::Util.send_include(Moped::Collection, AppOpticsAPM::Inst::MopedCollection)
+  AppOpticsAPM::Util.send_include(Moped::Query,      AppOpticsAPM::Inst::MopedQuery)
+  AppOpticsAPM::Util.send_include(Moped::Indexes,    AppOpticsAPM::Inst::MopedIndexes)
+end

data/lib/appoptics_apm/inst/rack.rb

@@ -0,0 +1,182 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'uri'
+require 'cgi'
+
+if AppOpticsAPM.loaded
+  module AppOpticsAPM
+    ##
+    # AppOpticsAPM::Rack
+    #
+    # The AppOpticsAPM::Rack middleware used to sample a subset of incoming
+    # requests for instrumentation and reporting.  Tracing context can
+    # be received here (via the X-Trace HTTP header) or initiated here
+    # based on configured tracing mode.
+    #
+    # After the rack layer passes on to the following layers (Rails, Sinatra,
+    # Padrino, Grape), then the instrumentation downstream will
+    # automatically detect whether this is a sampled request or not
+    # and act accordingly.
+    #
+    class Rack
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+
+        # In the case of nested Ruby apps such as Grape inside of Rails
+        # or Grape inside of Grape, each app has it's own instance
+        # of rack middleware. We want to avoid tracing rack more than once
+        return @app.call(env) if AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
+
+        incoming = AppOpticsAPM::Context.isValid
+        AppOpticsAPM.transaction_name = nil
+
+        url = env['PATH_INFO']
+        options = AppOpticsAPM::XTraceOptions.new(env['HTTP_X_TRACE_OPTIONS'], env['HTTP_X_TRACE_OPTIONS_SIGNATURE'])
+        xtrace = AppOpticsAPM::XTrace.valid?(env['HTTP_X_TRACE']) ? (env['HTTP_X_TRACE']) : nil
+        settings = AppOpticsAPM::TransactionSettings.new(url, xtrace, options)
+        profile_spans = AppOpticsAPM::Config['profiling'] == :enabled ? 1 : -1
+
+        response =
+          propagate_xtrace(env, settings, xtrace) do
+            sample(env, settings, options, profile_spans) do
+              AppOpticsAPM::Profiling.run do
+                AppOpticsAPM::TransactionMetrics.metrics(env, settings) do
+                  @app.call(env)
+                end
+              end
+            end
+          end || [500, {}, nil]
+        options.add_response_header(response[1], settings)
+
+        AppOpticsAPM::Context.clear unless incoming
+        response
+      rescue
+        AppOpticsAPM::Context.clear unless incoming
+        raise
+        # can't use ensure for Context.clearing, because the Grape middleware
+        # needs the context in case of an error, it is somewhat convoluted ...
+      end
+
+      def self.noop?
+        false
+      end
+
+      private
+
+      def collect(env)
+        req = ::Rack::Request.new(env)
+        report_kvs = {}
+
+        begin
+          report_kvs[:'HTTP-Host']      = req.host
+          report_kvs[:Port]             = req.port
+          report_kvs[:Proto]            = req.scheme
+          report_kvs[:Method]           = req.request_method
+          report_kvs[:AJAX]             = true if req.xhr?
+          report_kvs[:ClientIP]         = req.ip
+
+          if AppOpticsAPM::Config[:rack][:log_args]
+            report_kvs[:'Query-String'] = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+          end
+
+          report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
+          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rack][:collect_backtraces]
+
+          # Report any request queue'ing headers.  Report as 'Request-Start' or the summed Queue-Time
+          report_kvs[:'Request-Start']     = env['HTTP_X_REQUEST_START']    if env.key?('HTTP_X_REQUEST_START')
+          report_kvs[:'Request-Start']     = env['HTTP_X_QUEUE_START']      if env.key?('HTTP_X_QUEUE_START')
+          report_kvs[:'Queue-Time']        = env['HTTP_X_QUEUE_TIME']       if env.key?('HTTP_X_QUEUE_TIME')
+
+          report_kvs[:'Forwarded-For']     = env['HTTP_X_FORWARDED_FOR']    if env.key?('HTTP_X_FORWARDED_FOR')
+          report_kvs[:'Forwarded-Host']    = env['HTTP_X_FORWARDED_HOST']   if env.key?('HTTP_X_FORWARDED_HOST')
+          report_kvs[:'Forwarded-Proto']   = env['HTTP_X_FORWARDED_PROTO']  if env.key?('HTTP_X_FORWARDED_PROTO')
+          report_kvs[:'Forwarded-Port']    = env['HTTP_X_FORWARDED_PORT']   if env.key?('HTTP_X_FORWARDED_PORT')
+
+          report_kvs[:'Ruby.AppOptics.Version'] = AppOpticsAPM::Version::STRING
+          report_kvs[:ProcessID]         = Process.pid
+          report_kvs[:ThreadID]          = Thread.current.to_s[/0x\w*/]
+        rescue StandardError => e
+          # Discard any potential exceptions. Debug log and report whatever we can.
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] Rack KV collection error: #{e.inspect}"
+        end
+        report_kvs
+      end
+
+      def propagate_xtrace(env, settings, xtrace)
+        return yield unless settings.do_propagate
+
+        if xtrace
+          xtrace_local = xtrace.dup
+          AppOpticsAPM::XTrace.unset_sampled(xtrace_local) unless settings.do_sample
+          env['HTTP_X_TRACE'] = xtrace_local
+        end
+
+        status, headers, response = yield
+
+        headers ||= {}
+        headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+        headers['X-Trace'] ||= xtrace if xtrace
+        headers['X-Trace'] && AppOpticsAPM::XTrace.unset_sampled(headers['X-Trace']) unless settings.do_sample
+
+        [status, headers, response]
+      end
+
+      def sample(env, settings, options, profile_spans)
+        xtrace = env['HTTP_X_TRACE']
+        if settings.do_sample
+          begin
+            report_kvs = collect(env)
+            settings.add_kvs(report_kvs)
+            options&.add_kvs(report_kvs, settings)
+
+            AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs, settings)
+
+            status, headers, response = yield
+
+            AppOpticsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: AppOpticsAPM.transaction_name,
+                                                ProfileSpans: profile_spans})
+
+            [status, headers, response]
+          rescue Exception => e
+            # it is ok to rescue Exception here because we are reraising it (we just need a chance to log_end)
+            AppOpticsAPM::API.log_exception(:rack, e)
+            AppOpticsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: AppOpticsAPM.transaction_name,
+                                                ProfileSpans: profile_spans
+                                              })
+            raise
+          end
+        else
+          AppOpticsAPM::API.create_nontracing_context(xtrace)
+          yield
+        end
+      end
+
+    end
+  end
+else
+  module AppOpticsAPM
+    class Rack
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def self.noop?
+        true
+      end
+    end
+  end
+end

data/lib/appoptics_apm/inst/rack_cache.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2020 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module RackCacheContext
+
+    ###
+    # This adds a controller.action like transaction name for
+    # requests directly served from the cache without involving a controller.
+    # The resulting transaction name is `rack-cache.<cache-store>`,
+    # e.g. `rack-cache.memcached`
+    #
+    # It is not a full instrumentation, no span is added.
+    #
+    def call!(env)
+      metastore_type = begin
+        if options['rack-cache.metastore']
+          options['rack-cache.metastore'].match(/^([^\:]*)\:/)[1]
+        end || 'unknown_store'
+      rescue
+        'unknown_store'
+      end
+
+      env['appoptics_apm.action'] = metastore_type
+      env['appoptics_apm.controller'] = 'rack-cache'
+
+      super
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:rack_cache][:transaction_name] && defined?(Rack::Cache::Context)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack_cache' if AppOpticsAPM::Config[:verbose]
+  Rack::Cache::Context.send(:prepend, ::AppOpticsAPM::RackCacheContext)
+end