appoptics_apm 4.0.2

data/lib/appoptics_apm/inst/excon.rb

@@ -0,0 +1,130 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ExconConnection
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :request, ::Excon::Connection)
+        ::AppOpticsAPM::Util.method_alias(klass, :requests, ::Excon::Connection)
+      end
+
+      private
+
+      def appoptics_collect(params)
+        kvs = {}
+        kvs[:IsService] = 1
+        kvs[:RemoteProtocol] = ::AppOpticsAPM::Util.upcase(@data[:scheme])
+        kvs[:RemoteHost] = @data[:host]
+
+        # Conditionally log query args
+        if AppOpticsAPM::Config[:excon][:log_args] && @data[:query]
+          if @data[:query].is_a?(Hash)
+            if RUBY_VERSION >= '1.9.2'
+              kvs[:ServiceArg] = "#{@data[:path]}?#{URI.encode_www_form(@data[:query])}"
+            else
+              # An imperfect solution for the lack of URI.encode_www_form for Ruby versions before
+              # 1.9.2.  We manually create a query string for reporting purposes only.
+              query_arg = ""
+              @data[:query].each_pair { |k,v| query_arg += "#{k}=#{v}?"; }
+              kvs[:ServiceArg] = "#{@data[:path]}?#{query_arg.chop}"
+            end
+          else
+            kvs[:ServiceArg] = "#{@data[:path]}?#{@data[:query]}"
+          end
+        else
+          kvs[:ServiceArg] = @data[:path]
+        end
+
+        # In the case of HTTP pipelining, params could be an array of
+        # request hashes.
+        if params.is_a?(Array)
+          methods = []
+          params.each do |p|
+            methods << ::AppOpticsAPM::Util.upcase(p[:method])
+          end
+          kvs[:HTTPMethods] = methods.join(', ')[0..1024]
+          kvs[:Pipeline] = true
+        else
+          kvs[:HTTPMethod] = ::AppOpticsAPM::Util.upcase(params[:method])
+        end
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:excon][:collect_backtraces]
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing excon KVs: #{e.message}"
+        AppOpticsAPM.logger.debug e.backtrace.join('\n') if ::AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      public
+
+      def requests_with_appoptics(pipeline_params)
+        responses = nil
+        AppOpticsAPM::API.trace(:excon, appoptics_collect(pipeline_params)) do
+          responses = requests_without_appoptics(pipeline_params)
+        end
+        responses
+      end
+
+      def request_with_appoptics(params={}, &block)
+        # Avoid cross host tracing for blacklisted domains
+        blacklisted = AppOpticsAPM::API.blacklisted?(@data[:hostname])
+
+        # If we're not tracing, just do a fast return.
+        # If making HTTP pipeline requests (ordered batched)
+        # then just return as we're tracing from parent
+        # <tt>requests</tt>
+        if !AppOpticsAPM.tracing? || params[:pipeline]
+          @data[:headers]['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid && !blacklisted
+          return request_without_appoptics(params, &block)
+        end
+
+        begin
+          response_context = nil
+
+          kvs = appoptics_collect(params)
+          kvs[:Blacklisted] = true if blacklisted
+
+          AppOpticsAPM::API.log_entry(:excon, kvs)
+          kvs.clear
+
+          req_context = AppOpticsAPM::Context.toString
+          @data[:headers]['X-Trace'] = req_context unless blacklisted
+
+          # The core excon call
+          response = request_without_appoptics(params, &block)
+
+          # excon only passes back a hash (datum) for HTTP pipelining...
+          # In that case, we should never arrive here but for the OCD, double check
+          # the datatype before trying to extract pertinent info
+          if response.is_a?(Excon::Response)
+            response_context = response.headers['X-Trace']
+            kvs[:HTTPStatus] = response.status
+
+            # If we get a redirect, report the location header
+            if ((300..308).to_a.include? response.status.to_i) && response.headers.key?('Location')
+              kvs[:Location] = response.headers['Location']
+            end
+
+            if response_context && !blacklisted
+              AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+            end
+          end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:excon, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:excon, kvs) unless params[:pipeline]
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:excon][:enabled] && defined?(::Excon)
+  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting excon' if AppOpticsAPM::Config[:verbose]
+  ::AppOpticsAPM::Util.send_include(::Excon::Connection, ::AppOpticsAPM::Inst::ExconConnection)
+end

data/lib/appoptics_apm/inst/faraday.rb

@@ -0,0 +1,77 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module FaradayConnection
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :run_request, ::Faraday::Connection)
+      end
+
+      def run_request_with_appoptics(method, url, body, headers, &block)
+        unless AppOpticsAPM.tracing?
+          xtrace = AppOpticsAPM::Context.toString
+          @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace) && !AppOpticsAPM::API.blacklisted?(@url_prefix.to_s)
+          return run_request_without_appoptics(method, url, body, headers, &block)
+        end
+
+        begin
+          AppOpticsAPM::API.log_entry(:faraday)
+
+          xtrace = AppOpticsAPM::Context.toString
+          @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace) && !AppOpticsAPM::API.blacklisted?(@url_prefix.to_s)
+          result = run_request_without_appoptics(method, url, body, headers, &block)
+
+          kvs = {}
+          kvs[:Middleware] = @builder.handlers
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:faraday][:collect_backtraces]
+
+          # Only send service KVs if we're not using the Net::HTTP adapter
+          # Otherwise, the Net::HTTP instrumentation will send the service KVs
+          handle_service = !@builder.handlers.include?(Faraday::Adapter::NetHttp) &&
+              !@builder.handlers.include?(Faraday::Adapter::Excon)
+          if handle_service
+            blacklisted = AppOpticsAPM::API.blacklisted?(@url_prefix.to_s)
+            context = AppOpticsAPM::Context.toString
+            task_id = AppOpticsAPM::XTrace.task_id(context)
+
+            # Avoid cross host tracing for blacklisted domains
+            # Conditionally add the X-Trace header to the outgoing request
+            @headers['X-Trace'] = context unless blacklisted
+
+            kvs[:IsService] = 1
+            kvs[:RemoteProtocol] = (@url_prefix.scheme == 'https') ? 'HTTPS' : 'HTTP'
+            kvs[:RemoteHost] = @url_prefix.host
+            kvs[:RemotePort] = @url_prefix.port
+            kvs[:ServiceArg] = url
+            kvs[:HTTPMethod] = method
+            kvs[:HTTPStatus] = result.status
+            kvs[:Blacklisted] = true if blacklisted
+
+            # Re-attach net::http edge unless it's blacklisted or if we don't have a
+            # valid X-Trace header
+            unless blacklisted
+              xtrace = result.headers['X-Trace']
+              AppOpticsAPM::XTrace.continue_service_context(context, xtrace)
+            end
+          end
+
+          AppOpticsAPM::API.log(:faraday, :info, kvs)
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(:faraday, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:faraday)
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:faraday][:enabled]
+  if defined?(::Faraday)
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting faraday' if AppOpticsAPM::Config[:verbose]
+    ::AppOpticsAPM::Util.send_include(::Faraday::Connection, ::AppOpticsAPM::Inst::FaradayConnection)
+  end
+end

data/lib/appoptics_apm/inst/http.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'net/http'
+
+if AppOpticsAPM::Config[:nethttp][:enabled]
+
+  Net::HTTP.class_eval do
+    def request_with_appoptics(*args, &block)
+      # Avoid cross host tracing for blacklisted domains
+      blacklisted = AppOpticsAPM::API.blacklisted?(addr_port)
+
+      # If we're not tracing, just do a fast return. Since
+      # net/http.request calls itself, only trace
+      # once the http session has been started.
+      if !AppOpticsAPM.tracing? || !started?
+        unless blacklisted
+          xtrace = AppOpticsAPM::Context.toString
+          args[0]['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+        end
+        return request_without_appoptics(*args, &block)
+      end
+
+      AppOpticsAPM::API.trace(:'net-http') do
+        opts = {}
+        context = AppOpticsAPM::Context.toString
+        task_id = AppOpticsAPM::XTrace.task_id(context)
+
+        # Collect KVs to report in the info event
+        if args.length && args[0]
+          req = args[0]
+
+          opts[:IsService] = 1
+          opts[:RemoteProtocol] = use_ssl? ? :HTTPS : :HTTP
+          opts[:RemoteHost] = addr_port
+
+          # Conditionally log query params
+          if AppOpticsAPM::Config[:nethttp][:log_args]
+            opts[:ServiceArg] = req.path
+          else
+            opts[:ServiceArg] = req.path.split('?').first
+          end
+
+          opts[:HTTPMethod] = req.method
+          opts[:Blacklisted] = true if blacklisted
+          opts[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:nethttp][:collect_backtraces]
+
+          req['X-Trace'] = context unless blacklisted
+        end
+
+        begin
+          # The actual net::http call
+          resp = request_without_appoptics(*args, &block)
+
+          # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+          unless blacklisted
+            xtrace = resp.get_fields('X-Trace')
+            xtrace = xtrace[0] if xtrace && xtrace.is_a?(Array)
+
+            AppOpticsAPM::XTrace.continue_service_context(context, xtrace)
+          end
+
+          opts[:HTTPStatus] = resp.code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? resp.code.to_i) && resp.header["Location"]
+            opts[:Location] = resp.header["Location"]
+          end
+
+          next resp
+        ensure
+          # Log the info event with the KVs in opts
+          AppOpticsAPM::API.log(:'net-http', :info, opts)
+        end
+      end
+    end
+
+    alias request_without_appoptics request
+    alias request request_with_appoptics
+
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting net/http' if AppOpticsAPM::Config[:verbose]
+  end
+end

data/lib/appoptics_apm/inst/httpclient.rb

@@ -0,0 +1,176 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module HTTPClient
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :do_request, ::HTTPClient)
+        ::AppOpticsAPM::Util.method_alias(klass, :do_request_async, ::HTTPClient)
+        ::AppOpticsAPM::Util.method_alias(klass, :do_get_stream, ::HTTPClient)
+      end
+
+      def appoptics_collect(method, uri, query = nil)
+        kvs = {}
+        kvs[:IsService] = 1
+
+        # Conditionally log URL query params
+        # Because of the hook points, the query arg can come in under <tt>query</tt>
+        # or as a part of <tt>uri</tt> (not both).  Here we handle both cases.
+        if AppOpticsAPM::Config[:httpclient][:log_args]
+          if query
+            kvs[:RemoteURL] = uri.to_s + '?' + AppOpticsAPM::Util.to_query(query)
+          else
+            kvs[:RemoteURL] = uri.to_s
+          end
+        else
+          kvs[:RemoteURL] = uri.to_s.split('?').first
+        end
+
+        kvs[:RemoteProtocol] = uri.scheme.upcase
+        kvs[:RemoteHost] = "#{uri.host}:#{uri.port}"
+        kvs[:ServiceArg] = "/?#{uri.query}"
+        kvs[:HTTPMethod] = ::AppOpticsAPM::Util.upcase(method)
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:httpclient][:collect_backtraces]
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing httpclient KVs: #{e.message}"
+        AppOpticsAPM.logger.debug e.backtrace.join('\n') if ::AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      def do_request_with_appoptics(method, uri, query, body, header, &block)
+        # Avoid cross host tracing for blacklisted domains
+        blacklisted = AppOpticsAPM::API.blacklisted?(uri.hostname)
+
+        # If we're not tracing, just do a fast return.
+        unless AppOpticsAPM.tracing?
+          add_xtrace_header(header) unless blacklisted
+          return do_request_without_appoptics(method, uri, query, body, header, &block)
+        end
+
+        begin
+          req_context = nil
+          response_context = nil
+
+          kvs = appoptics_collect(method, uri, query)
+          kvs[:Blacklisted] = true if blacklisted
+
+          AppOpticsAPM::API.log_entry(:httpclient, kvs)
+          kvs.clear
+
+          req_context = add_xtrace_header(header) unless blacklisted
+
+          # The core httpclient call
+          response = do_request_without_appoptics(method, uri, query, body, header, &block)
+
+          response_context = response.headers['X-Trace']
+          kvs[:HTTPStatus] = response.status_code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? response.status.to_i) && response.headers.key?('Location')
+            kvs[:Location] = response.headers['Location']
+          end
+
+          if response_context && !blacklisted
+            AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:httpclient, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:httpclient, kvs)
+        end
+      end
+
+      def do_request_async_with_appoptics(method, uri, query, body, header)
+        add_xtrace_header(header)
+        do_request_async_without_appoptics(method, uri, query, body, header)
+      end
+
+      def do_get_stream_with_appoptics(req, proxy, conn)
+        AppOpticsAPM::Context.fromString(req.header['X-Trace'].first) unless req.header['X-Trace'].empty?
+        # Avoid cross host tracing for blacklisted domains
+        uri = req.http_header.request_uri
+        blacklisted = AppOpticsAPM::API.blacklisted?(uri.hostname)
+
+        unless AppOpticsAPM.tracing?
+          req.header.delete('X-Trace') if blacklisted
+          return do_get_stream_without_appoptics(req, proxy, conn)
+        end
+
+        begin
+          response = nil
+          req_context = nil
+          method = req.http_header.request_method
+
+          kvs = appoptics_collect(method, uri)
+          kvs[:Blacklisted] = true if blacklisted
+          kvs[:Async] = 1
+
+          AppOpticsAPM::API.log_entry(:httpclient, kvs)
+          kvs.clear
+
+          blacklisted ? req.header.delete('X-Trace') : req_context = add_xtrace_header(req.header)
+
+          # The core httpclient call
+          result = do_get_stream_without_appoptics(req, proxy, conn)
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          if result.is_a?(::HTTP::Message)
+            response = result
+          else
+            response = conn.pop
+          end
+
+          response_context = response.headers['X-Trace']
+          kvs[:HTTPStatus] = response.status_code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? response.status.to_i) && response.headers.key?('Location')
+            kvs[:Location] = response.headers['Location']
+          end
+
+          if response_context && !blacklisted
+            AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          conn.push response if result.is_a?(::HTTPClient::Connection)
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(:httpclient, e)
+          raise e
+        ensure
+          # AppOpticsAPM::API.log_exit('httpclient', kvs.merge('Async' => 1))
+          AppOpticsAPM::API.log_exit(:httpclient, kvs)
+        end
+      end
+
+      private
+
+      def add_xtrace_header(headers)
+        req_context = AppOpticsAPM::Context.toString
+        return nil unless AppOpticsAPM::XTrace.valid?(req_context)
+        # Be aware of various ways to call/use httpclient
+        if headers.is_a?(Array)
+          headers.delete_if { |kv| kv[0] == 'X-Trace' }
+          headers.push ['X-Trace', req_context]
+        elsif headers.is_a?(Hash)
+          headers['X-Trace'] = req_context
+        elsif headers.is_a? HTTP::Message::Headers
+          headers.set('X-Trace', req_context)
+        end
+        req_context
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:httpclient][:enabled] && defined?(::HTTPClient)
+  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting httpclient' if AppOpticsAPM::Config[:verbose]
+  ::AppOpticsAPM::Util.send_include(::HTTPClient, ::AppOpticsAPM::Inst::HTTPClient)
+end

data/lib/appoptics_apm/inst/memcache.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module MemCache
+      include AppOpticsAPM::API::Memcache
+
+      def self.included(cls)
+        AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting memcache' if AppOpticsAPM::Config[:verbose]
+
+        cls.class_eval do
+          MEMCACHE_OPS.reject { |m| !method_defined?(m) }.each do |m|
+
+            define_method("#{m}_with_appoptics") do |*args|
+              report_kvs = { :KVOp => m }
+              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcache][:collect_backtraces]
+
+              if AppOpticsAPM.tracing?
+                AppOpticsAPM::API.trace(:memcache, report_kvs) do
+                  send("#{m}_without_appoptics", *args)
+                end
+              else
+                send("#{m}_without_appoptics", *args)
+              end
+            end
+
+            class_eval "alias #{m}_without_appoptics #{m}"
+            class_eval "alias #{m} #{m}_with_appoptics"
+          end
+        end
+
+        [:request_setup, :cache_get, :get_multi].each do |m|
+          if ::MemCache.method_defined? :request_setup
+            cls.class_eval "alias #{m}_without_appoptics #{m}"
+            cls.class_eval "alias #{m} #{m}_with_appoptics"
+          elsif AppOpticsAPM::Config[:verbose]
+            AppOpticsAPM.logger.warn "[appoptics_apm/loading] Couldn't properly instrument Memcache: #{m}"
+          end
+        end
+      end
+
+      def get_multi_with_appoptics(*args)
+        return get_multi_without_appoptics(args) unless AppOpticsAPM.tracing?
+
+        info_kvs = {}
+
+        begin
+          info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcache][:collect_backtraces]
+
+          if args.last.is_a?(Hash) || args.last.nil?
+            info_kvs[:KVKeyCount] = args.flatten.length - 1
+          else
+            info_kvs[:KVKeyCount] = args.flatten.length
+          end
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error collecting info keys: #{e.message}"
+          AppOpticsAPM.logger.debug e.backtrace
+        end
+
+        AppOpticsAPM::API.trace(:memcache, { :KVOp => :get_multi }, :get_multi) do
+          values = get_multi_without_appoptics(args)
+
+          info_kvs[:KVHitCount] = values.length
+          AppOpticsAPM::API.log(:memcache, :info, info_kvs)
+
+          values
+        end
+      end
+
+      def request_setup_with_appoptics(*args)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:get_multi)
+          server, cache_key = request_setup_without_appoptics(*args)
+
+          info_kvs = { :KVKey => cache_key, :RemoteHost => server.host }
+          info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcache][:collect_backtraces]
+          AppOpticsAPM::API.log(:memcache, :info, info_kvs)
+
+          [server, cache_key]
+        else
+          request_setup_without_appoptics(*args)
+        end
+      end
+
+      def cache_get_with_appoptics(server, cache_key)
+        result = cache_get_without_appoptics(server, cache_key)
+
+        info_kvs = { :KVHit => memcache_hit?(result) }
+        info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcache][:collect_backtraces]
+        AppOpticsAPM::API.log(:memcache, :info, info_kvs)
+
+        result
+      end
+    end # module MemCache
+  end # module Inst
+end # module AppOpticsAPM
+
+if defined?(::MemCache) && AppOpticsAPM::Config[:memcache][:enabled]
+  ::MemCache.class_eval do
+    include AppOpticsAPM::Inst::MemCache
+  end
+end

data/lib/appoptics_apm/inst/memcached.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module Memcached
+      include AppOpticsAPM::API::Memcache
+
+      def self.included(cls)
+        AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting memcached' if AppOpticsAPM::Config[:verbose]
+
+        cls.class_eval do
+          MEMCACHE_OPS.reject { |m| !method_defined?(m) }.each do |m|
+            define_method("#{m}_with_appoptics") do |*args|
+              opts = { :KVOp => m }
+
+              if args.length && !args[0].is_a?(Array)
+                opts[:KVKey] = args[0].to_s
+                rhost = remote_host(args[0].to_s)
+                opts[:RemoteHost] = rhost if rhost
+              end
+
+              AppOpticsAPM::API.trace(:memcache, opts) do
+                result = send("#{m}_without_appoptics", *args)
+
+                info_kvs = {}
+                info_kvs[:KVHit] = memcache_hit?(result) if m == :get && args.length && args[0].class == String
+                info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcached][:collect_backtraces]
+
+                AppOpticsAPM::API.log(:memcache, :info, info_kvs) unless info_kvs.empty?
+                result
+              end
+            end
+
+            class_eval "alias #{m}_without_appoptics #{m}"
+            class_eval "alias #{m} #{m}_with_appoptics"
+          end
+        end
+      end
+
+    end # module Memcached
+
+    module MemcachedRails
+      def self.included(cls)
+        cls.class_eval do
+          if ::Memcached::Rails.method_defined? :get_multi
+            alias get_multi_without_appoptics get_multi
+            alias get_multi get_multi_with_appoptics
+          elsif AppOpticsAPM::Config[:verbose]
+            AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument Memcached.  Partial traces may occur.'
+          end
+        end
+      end
+
+      def get_multi_with_appoptics(keys, raw = false)
+        if AppOpticsAPM.tracing?
+          layer_kvs = {}
+          layer_kvs[:KVOp] = :get_multi
+
+          AppOpticsAPM::API.trace(:memcache, layer_kvs || {}, :get_multi) do
+            begin
+              info_kvs = {}
+              info_kvs[:KVKeyCount] = keys.flatten.length
+
+              values = get_multi_without_appoptics(keys, raw)
+
+              info_kvs[:KVHitCount] = values.length
+              info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:memcached][:collect_backtraces]
+
+              AppOpticsAPM::API.log(:memcache, :info, info_kvs)
+            rescue
+              values = get_multi_without_appoptics(keys, raw)
+            end
+            values
+          end
+        else
+          get_multi_without_appoptics(keys, raw)
+        end
+      end
+    end # module MemcachedRails
+  end # module Inst
+end # module AppOpticsAPM
+
+if defined?(::Memcached) && AppOpticsAPM::Config[:memcached][:enabled]
+  ::Memcached.class_eval do
+    include AppOpticsAPM::Inst::Memcached
+  end
+
+  if defined?(::Memcached::Rails)
+    ::Memcached::Rails.class_eval do
+      include AppOpticsAPM::Inst::MemcachedRails
+    end
+  end
+end