appoptics_apm 4.0.2

data/lib/appoptics_apm/config.rb

@@ -0,0 +1,281 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  ##
+  # This module exposes a nested configuration hash that can be used to
+  # configure and/or modify the functionality of the appoptics_apm gem.
+  #
+  # Use AppOpticsAPM::Config.show to view the entire nested hash.
+  #
+  module Config
+    @@config = {}
+
+    @@instrumentation = [:action_controller, :action_controller_api, :action_view,
+                         :active_record, :bunnyclient, :bunnyconsumer, :cassandra, :curb,
+                         :dalli, :delayed_jobclient, :delayed_jobworker,
+                         :em_http_request, :excon, :faraday, :grape,
+                         :httpclient, :nethttp, :memcached,
+                         :memcache, :mongo, :moped, :rack, :redis,
+                         :resqueclient, :resqueworker, :rest_client,
+                         :sequel, :sidekiqclient, :sidekiqworker, :typhoeus]
+
+    # Subgrouping of instrumentation
+    @@http_clients = [:curb, :excon, :em_http_request, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+
+    ##
+    # Return the raw nested hash.
+    #
+    def self.show
+      @@config
+    end
+
+    ##
+    # initialize
+    #
+    # Initializer method to set everything up with a
+    # default configuration.
+    #
+    # rubocop:disable Metrics/AbcSize
+    def self.initialize(_data = {})
+      # Setup default instrumentation values
+      @@instrumentation.each do |k|
+        @@config[k] = {}
+        @@config[k][:enabled] = true
+        @@config[k][:collect_backtraces] = false
+        @@config[k][:log_args] = true
+      end
+
+      # Beta instrumentation disabled by default
+      AppOpticsAPM::Config[:em_http_request][:enabled] = false
+
+      # Set collect_backtraces defaults
+      AppOpticsAPM::Config[:action_controller][:collect_backtraces] = false
+      AppOpticsAPM::Config[:action_controller_api][:collect_backtraces] = false
+      AppOpticsAPM::Config[:active_record][:collect_backtraces] = true
+      AppOpticsAPM::Config[:bunnyclient][:collect_backtraces] = false
+      AppOpticsAPM::Config[:bunnyconsumer][:collect_backtraces] = false
+      AppOpticsAPM::Config[:action_view][:collect_backtraces] = true
+      AppOpticsAPM::Config[:cassandra][:collect_backtraces] = true
+      AppOpticsAPM::Config[:curb][:collect_backtraces] = true
+      AppOpticsAPM::Config[:dalli][:collect_backtraces] = false
+      AppOpticsAPM::Config[:delayed_jobclient][:collect_backtraces] = false
+      AppOpticsAPM::Config[:delayed_jobworker][:collect_backtraces] = false
+      AppOpticsAPM::Config[:em_http_request][:collect_backtraces] = false
+      AppOpticsAPM::Config[:excon][:collect_backtraces] = true
+      AppOpticsAPM::Config[:faraday][:collect_backtraces] = false
+      AppOpticsAPM::Config[:grape][:collect_backtraces] = true
+      AppOpticsAPM::Config[:httpclient][:collect_backtraces] = true
+      AppOpticsAPM::Config[:memcache][:collect_backtraces] = false
+      AppOpticsAPM::Config[:memcached][:collect_backtraces] = false
+      AppOpticsAPM::Config[:mongo][:collect_backtraces] = true
+      AppOpticsAPM::Config[:moped][:collect_backtraces] = true
+      AppOpticsAPM::Config[:nethttp][:collect_backtraces] = true
+      AppOpticsAPM::Config[:rack][:collect_backtraces] = false
+      AppOpticsAPM::Config[:redis][:collect_backtraces] = false
+      AppOpticsAPM::Config[:resqueclient][:collect_backtraces] = true
+      AppOpticsAPM::Config[:resqueworker][:collect_backtraces] = false
+      AppOpticsAPM::Config[:rest_client][:collect_backtraces] = false
+      AppOpticsAPM::Config[:sequel][:collect_backtraces] = true
+      AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces] = false
+      AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces] = false
+      AppOpticsAPM::Config[:typhoeus][:collect_backtraces] = false
+
+      # Legacy Resque config support.  To be removed in a future version
+      @@config[:resque] = {}
+
+      # Setup an empty host blacklist (see: AppOpticsAPM::API::Util.blacklisted?)
+      @@config[:blacklist] = []
+
+      # Logging of outgoing HTTP query args
+      #
+      # This optionally disables the logging of query args of outgoing
+      # HTTP clients such as Net::HTTP, excon, typhoeus and others.
+      #
+      # This flag is global to all HTTP client instrumentation.
+      #
+      # To configure this on a per instrumentation basis, set this
+      # option to true and instead disable the instrumenstation specific
+      # option <tt>log_args</tt>:
+      #
+      #   AppOpticsAPM::Config[:nethttp][:log_args] = false
+      #   AppOpticsAPM::Config[:excon][:log_args] = false
+      #   AppOpticsAPM::Config[:typhoeus][:log_args] = true
+      #
+      @@config[:include_url_query_params] = true
+
+      # Logging of incoming HTTP query args
+      #
+      # This optionally disables the logging of incoming URL request
+      # query args.
+      #
+      # This flag is global and currently only affects the Rack
+      # instrumentation which reports incoming request URLs and
+      # query args by default.
+      @@config[:include_remote_url_params] = true
+
+      # The AppOpticsAPM Ruby gem has the ability to sanitize query literals
+      # from SQL statements.  By default this is enabled to
+      # avoid collecting and reporting query literals to AppOpticsAPM.
+      @@config[:sanitize_sql] = true
+
+      # The regular expression used to sanitize SQL.
+      @@config[:sanitize_sql_regexp] = '(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)'
+      @@config[:sanitize_sql_opts]   = Regexp::IGNORECASE
+
+      # Do Not Trace
+      # These two values allow you to configure specific URL patterns to
+      # never be traced.  By default, this is set to common static file
+      # extensions but you may want to customize this list for your needs.
+      #
+      # dnt_regexp and dnt_opts is passed to Regexp.new to create
+      # a regular expression object.  That is then used to match against
+      # the incoming request path.
+      #
+      # The path string originates from the rack layer and is retrieved
+      # as follows:
+      #
+      #   req = ::Rack::Request.new(env)
+      #   path = URI.unescape(req.path)
+      #
+      # Usage:
+      #   AppOpticsAPM::Config[:dnt_regexp] = "lobster$"
+      #   AppOpticsAPM::Config[:dnt_opts]   = Regexp::IGNORECASE
+      #
+      # This will ignore all requests that end with the string lobster
+      # regardless of case
+      #
+      # Requests with positive matches (non nil) will not be traced.
+      # See lib/appoptics_apm/util.rb: AppOpticsAPM::Util.static_asset?
+      #
+      @@config[:dnt_regexp] = '\.(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|otf|eot|ttf|woff|woff2|svg|less)(\?.+){0,1}$'
+      @@config[:dnt_opts]   = Regexp::IGNORECASE
+
+      # In Rails, raised exceptions with rescue handlers via
+      # <tt>rescue_from</tt> are not reported to the AppOptics
+      # dashboard by default.  Setting this value to true will
+      # report all raised exception regardless.
+      #
+      @@config[:report_rescued_errors] = false
+
+      # The bunny (Rabbitmq) instrumentation can optionally report
+      # Controller and Action values to allow filtering of bunny
+      # message handling in # the UI.  Use of Controller and Action
+      # for filters is temporary until the UI is updated with
+      # additional filters.
+      #
+      # These values identify which properties of
+      # Bunny::MessageProperties to report as Controller
+      # and Action.  The defaults are to report :app_id (as
+      # Controller) and :type (as Action).  If these values
+      # are not specified in the publish, then nothing
+      # will be reported here.
+      #
+      @@config[:bunnyconsumer][:controller] = :app_id
+      @@config[:bunnyconsumer][:action] = :type
+
+      @@config[:verbose] = ENV.key?('APPOPTICS_GEM_VERBOSE') && ENV['APPOPTICS_GEM_VERBOSE'] == 'true' ? true : false
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def self.update!(data)
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def self.merge!(data)
+      update!(data)
+    end
+
+    def self.[](key)
+      if key == :resque
+        AppOpticsAPM.logger.warn '[appoptics_apm/warn] :resque config is deprecated.  It is now split into :resqueclient and :resqueworker.'
+        AppOpticsAPM.logger.warn "[appoptics_apm/warn] Called from #{Kernel.caller[0]}"
+      end
+
+      @@config[key.to_sym]
+    end
+
+    ##
+    # []=
+    #
+    # Config variable assignment method.  Here we validate and store the
+    # assigned value(s) and trigger any secondary action needed.
+    #
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def self.[]=(key, value)
+      @@config[key.to_sym] = value
+
+      if key == :sampling_rate
+        AppOpticsAPM.logger.warn 'sampling_rate is not a supported setting for AppOpticsAPM::Config.  ' \
+                         'Please use :sample_rate.'
+
+      elsif key == :sample_rate
+        unless value.is_a?(Integer) || value.is_a?(Float)
+          fail 'appoptics_apm :sample_rate must be a number between 0 and 1000000 (1m)'
+        end
+
+        # Validate :sample_rate value
+        unless value.between?(0, 1e6)
+          fail 'appoptics_apm :sample_rate must be between 0 and 1000000 (1m)'
+        end
+
+        # Assure value is an integer
+        @@config[key.to_sym] = value.to_i
+        AppOpticsAPM.set_sample_rate(value) if AppOpticsAPM.loaded
+
+      elsif key == :action_blacklist
+        AppOpticsAPM.logger.warn "[appoptics_apm/unsupported] :action_blacklist has been deprecated and no longer functions."
+
+      elsif key == :resque
+        AppOpticsAPM.logger.warn "[appoptics_apm/warn] :resque config is deprecated.  It is now split into :resqueclient and :resqueworker."
+        AppOpticsAPM.logger.warn "[appoptics_apm/warn] Called from #{Kernel.caller[0]}"
+
+      elsif key == :include_url_query_params
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@config[:rack][:log_args] = value
+
+      elsif key == :include_remote_url_params
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@http_clients.each do |i|
+          @@config[i][:log_args] = value
+        end
+      end
+
+      # Update liboboe if updating :tracing_mode
+      if key == :tracing_mode
+        AppOpticsAPM.set_tracing_mode(value.to_sym) if AppOpticsAPM.loaded
+
+        # Make sure that the mode is stored as a symbol
+        @@config[key.to_sym] = value.to_sym
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+    def self.method_missing(sym, *args)
+      class_var_name = "@@#{sym}"
+
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        # Try part of the @@config hash first
+        if @@config.key?(sym)
+          self[sym]
+
+        # Then try as a class variable
+        elsif self.class_variable_defined?(class_var_name.to_sym)
+          self.class_eval(class_var_name)
+
+        # Congrats - You've won a brand new nil...
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+AppOpticsAPM::Config.initialize

data/lib/appoptics_apm/frameworks/grape.rb

@@ -0,0 +1,93 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Grape
+    module API
+      def self.extended(klass)
+        ::AppOpticsAPM::Util.class_method_alias(klass, :inherited, ::Grape::API)
+      end
+
+      def inherited_with_appoptics(subclass)
+        inherited_without_appoptics(subclass)
+
+        subclass.use ::AppOpticsAPM::Rack
+      end
+    end
+
+    module Endpoint
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :run, ::Grape::Endpoint)
+      end
+
+      def run_with_appoptics(*args)
+        # Report Controller/Action and Transaction as best possible
+        report_kvs = {}
+
+        report_kvs[:Controller] = options[:for].name
+        if route && route.pattern
+          report_kvs[:Action] = route.pattern.origin
+        else
+          report_kvs[:Action] = args.empty? ? env['PATH_INFO'] : args[0]['PATH_INFO']
+        end
+
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        ::AppOpticsAPM::API.log_entry('grape', report_kvs)
+
+        run_without_appoptics(*args)
+      ensure
+        ::AppOpticsAPM::API.log_exit('grape')
+      end
+    end
+
+    module Middleware
+      module Error
+        def self.included(klass)
+          ::AppOpticsAPM::Util.method_alias(klass, :error_response, ::Grape::Middleware::Error)
+        end
+
+        def error_response_with_appoptics(error = {})
+          status, headers, body = error_response_without_appoptics(error)
+
+          if AppOpticsAPM.tracing?
+            # Since Grape uses throw/catch and not Exceptions, we manually log
+            # the error here.
+            kvs = {}
+            kvs[:ErrorClass] = 'GrapeError'
+            kvs[:ErrorMsg] = error[:message] ? error[:message] : "No message given."
+            kvs[:Backtrace] = ::AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
+
+            ::AppOpticsAPM::API.log(nil, 'error', kvs)
+
+            # Since calls to error() are handled similar to abort in Grape.  We
+            # manually log the rack exit here since the original code won't
+            # be returned to
+            xtrace = AppOpticsAPM::API.log_end('rack', :Status => status)
+
+            if headers && AppOpticsAPM::XTrace.valid?(xtrace)
+              unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
+                headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+              end
+            end
+          end
+
+          [status, headers, body]
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:grape][:enabled] && defined?(::Grape)
+  require 'appoptics_apm/inst/rack'
+
+  AppOpticsAPM.logger.info "[appoptics_apm/loading] Instrumenting Grape" if AppOpticsAPM::Config[:verbose]
+
+  AppOpticsAPM::Inst.load_instrumentation
+
+  ::AppOpticsAPM::Util.send_extend(::Grape::API,               ::AppOpticsAPM::Grape::API)
+  ::AppOpticsAPM::Util.send_include(::Grape::Endpoint,          ::AppOpticsAPM::Grape::Endpoint)
+  ::AppOpticsAPM::Util.send_include(::Grape::Middleware::Error, ::AppOpticsAPM::Grape::Middleware::Error)
+end

data/lib/appoptics_apm/frameworks/padrino/templates.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module PadrinoInst
+    module Rendering
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      def render_with_appoptics(engine, data = nil, options = {}, locals = {}, &block)
+        if AppOpticsAPM.tracing?
+          report_kvs = {}
+
+          if data
+            report_kvs[:engine] = engine
+            report_kvs[:template] = data
+          else
+            report_kvs[:template] = engine
+          end
+
+          if AppOpticsAPM.tracing_layer_op?(:render)
+            # For recursive calls to :render (for sub-partials and layouts),
+            # use method profiling.
+            begin
+              report_kvs[:FunctionName] = :render
+              report_kvs[:Class]        = :Rendering
+              report_kvs[:Module]       = :Padrino
+              report_kvs[:File]         = __FILE__
+              report_kvs[:LineNumber]   = __LINE__
+            rescue StandardError => e
+              ::AppOpticsAPM.logger.debug e.message
+              ::AppOpticsAPM.logger.debug e.backtrace.join(', ')
+            end
+
+            AppOpticsAPM::API.profile(report_kvs[:template], report_kvs, false) do
+              render_without_appoptics(engine, data, options, locals, &block)
+            end
+          else
+            # Fall back to the raw tracing API so we can pass KVs
+            # back on exit (a limitation of the AppOpticsAPM::API.trace
+            # block method) This removes the need for an info
+            # event to send additonal KVs
+            ::AppOpticsAPM::API.log_entry(:render, {}, :render)
+
+            begin
+              render_without_appoptics(engine, data, options, locals, &block)
+            ensure
+              ::AppOpticsAPM::API.log_exit(:render, report_kvs)
+            end
+          end
+        else
+          render_without_appoptics(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module PadrinoInst
+    module Routing
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+      end
+
+      def dispatch_with_appoptics
+
+        ::AppOpticsAPM::API.log_entry('padrino', {})
+
+        result = dispatch_without_appoptics
+
+        # Report Controller/Action and Transaction as best possible
+        report_kvs = {}
+        controller = (request.controller && !request.controller.empty?) ? request.controller : nil
+        report_kvs[:Controller] = controller || self.class
+        report_kvs[:Action] = request.route_obj ? request.route_obj.path : request.action
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        result
+      ensure
+        ::AppOpticsAPM::API.log_exit('padrino', report_kvs)
+      end
+    end
+  end
+end
+
+if defined?(::Padrino)
+  # This instrumentation is a superset of the Sinatra instrumentation similar
+  # to how Padrino is a superset of Sinatra itself.
+  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Padrino' if AppOpticsAPM::Config[:verbose]
+
+  require 'appoptics_apm/frameworks/padrino/templates'
+
+  Padrino.after_load do
+    ::AppOpticsAPM.logger = ::Padrino.logger if ::Padrino.respond_to?(:logger)
+    ::AppOpticsAPM::Inst.load_instrumentation
+
+    ::AppOpticsAPM::Util.send_include(::Padrino::Routing::InstanceMethods, ::AppOpticsAPM::PadrinoInst::Routing)
+    if defined?(::Padrino::Rendering)
+      ::AppOpticsAPM::Util.send_include(::Padrino::Rendering::InstanceMethods, ::AppOpticsAPM::PadrinoInst::Rendering)
+    end
+
+    # Report __Init after fork when in Heroku
+    AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+  end
+end

data/lib/appoptics_apm/frameworks/rails/inst/action_controller.rb

@@ -0,0 +1,106 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # RailsBase
+    #
+    # This module contains the instrumentation code common to
+    # many Rails versions.
+    #
+    module RailsBase
+
+      #
+      # has_handler?
+      #
+      # Determins if <tt>exception</tt> has a registered
+      # handler via <tt>rescue_from</tt>
+      #
+      def has_handler?(exception)
+        # Don't log exceptions if they have a rescue handler set
+        has_handler = false
+        rescue_handlers.detect do |klass_name, _handler|
+          # Rescue handlers can be specified as strings or constant names
+          klass = self.class.const_get(klass_name) rescue nil
+          klass ||= klass_name.constantize rescue nil
+          has_handler = exception.is_a?(klass) if klass
+        end
+        has_handler
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error searching Rails handlers: #{e.message}"
+        return false
+      end
+
+      #
+      # log_rails_error?
+      #
+      # Determins whether we should log a raised exception to the
+      # AppOptics dashboard.  This is determined by whether the exception
+      # has a rescue handler setup and the value of
+      # AppOpticsAPM::Config[:report_rescued_errors]
+      #
+      def log_rails_error?(exception)
+        # As it's perculating up through the layers...  make sure that
+        # we only report it once.
+        return false if exception.instance_variable_get(:@appoptics_logged)
+
+        has_handler = has_handler?(exception)
+
+        if !has_handler || (has_handler && AppOpticsAPM::Config[:report_rescued_errors])
+          return true
+        end
+        false
+      end
+
+      ##
+      # This method does the logging if we are tracing
+      # it `wraps` around the call to the original method
+      #
+      def trace(layer)
+        return yield unless AppOpticsAPM.tracing?
+        begin
+          AppOpticsAPM::API.log_entry(layer)
+          yield
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception(layer, e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit(layer)
+        end
+      end
+
+
+      #
+      # render_with_appoptics
+      #
+      # Our render wrapper that calls 'add_logging', which will log if we are tracing
+      #
+      def render_with_appoptics(*args, &blk)
+        trace('actionview') do
+          render_without_appoptics(*args, &blk)
+        end
+      end
+    end
+  end
+end
+
+# ActionController::Base
+if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actioncontroller' if AppOpticsAPM::Config[:verbose]
+  require "appoptics_apm/frameworks/rails/inst/action_controller#{Rails::VERSION::MAJOR}"
+  if Rails::VERSION::MAJOR >= 5
+    ::ActionController::Base.send(:prepend, ::AppOpticsAPM::Inst::ActionController)
+  else
+    ::AppOpticsAPM::Util.send_include(::ActionController::Base, AppOpticsAPM::Inst::ActionController)
+  end
+end
+
+# ActionController::API - Rails 5+ or via the rails-api gem
+if defined?(ActionController::API) && AppOpticsAPM::Config[:action_controller_api][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actioncontroller api' if AppOpticsAPM::Config[:verbose]
+  require "appoptics_apm/frameworks/rails/inst/action_controller_api"
+  ::ActionController::API.send(:prepend, ::AppOpticsAPM::Inst::ActionControllerAPI)
+end
+
+# vim:set expandtab:tabstop=2

data/lib/appoptics_apm/frameworks/rails/inst/action_controller2.rb

@@ -0,0 +1,61 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v2
+    #
+    module ActionController
+      include ::AppOpticsAPM::Inst::RailsBase
+
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :perform_action)
+        ::AppOpticsAPM::Util.method_alias(klass, :rescue_action)
+        ::AppOpticsAPM::Util.method_alias(klass, :process)
+        ::AppOpticsAPM::Util.method_alias(klass, :render)
+      end
+
+      def process_with_appoptics(*args)
+        AppOpticsAPM::API.log_entry('rails')
+        process_without_appoptics(*args)
+
+      rescue Exception => e
+        AppOpticsAPM::API.log_exception(nil, e) if log_rails_error?(e)
+        raise
+      ensure
+        AppOpticsAPM::API.log_exit('rails')
+      end
+
+      def perform_action_with_appoptics(*arguments)
+        kvs = {
+          :Controller  => @_request.path_parameters['controller'],
+          :Action      => @_request.path_parameters['action']
+        }
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+
+        AppOpticsAPM::API.log(nil, 'info', kvs)
+        perform_action_without_appoptics(*arguments)
+      end
+
+      def rescue_action_with_appoptics(exn)
+        AppOpticsAPM::API.log_exception(nil, exn) if log_rails_error?(exn)
+        rescue_action_without_appoptics(exn)
+      end
+
+      def render_with_appoptics(options = nil, extra_options = {}, &block)
+        AppOpticsAPM::API.log_entry('actionview')
+        render_without_appoptics(options, extra_options, &block)
+
+      rescue Exception => e
+        AppOpticsAPM::API.log_exception(nil, e) if log_rails_error?(e)
+        raise
+      ensure
+        AppOpticsAPM::API.log_exit('actionview')
+      end
+    end
+  end
+end