appoptics_apm-zearn 4.13.1

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

@@ -0,0 +1,104 @@
+# 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?
+      #
+      # Determines 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(:@exn_logged)
+
+        return false if has_handler?(exception) && !AppOpticsAPM::Config[:report_rescued_errors]
+
+        true
+      end
+
+      ##
+      # This method does the logging if we are tracing
+      # it `wraps` around the call to the original method
+      #
+      # This can't use the SDK trace() method because of the log_rails_error?(e) condition
+      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] && Rails::VERSION::MAJOR <= 6
+  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)
+  elsif Rails::VERSION::MAJOR < 5
+    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]  && Rails::VERSION::MAJOR <= 6
+  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_controller4.rb

@@ -0,0 +1,48 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v4
+    #
+    module ActionController
+      include AppOpticsAPM::Inst::RailsBase
+
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :process_action, :appoptics
+          alias_method_chain :render, :appoptics
+        end
+      end
+
+      def process_action_with_appoptics(method_name, *args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => self.action_name,
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return process_action_without_appoptics(method_name, *args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry('rails', kvs)
+
+          process_action_without_appoptics(method_name, *args)
+
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit('rails')
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,50 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v5
+    #
+    module ActionController
+      include AppOpticsAPM::Inst::RailsBase
+
+      def process_action(method_name, *args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => self.action_name,
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return super(method_name, *args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry('rails', kvs)
+          super(method_name, *args)
+
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit('rails')
+        end
+      end
+
+      #
+      # render
+      #
+      # Our render wrapper that calls 'trace', which will log if we are tracing
+      #
+      def render(*args, &blk)
+        trace('actionview') do
+          super(*args, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v6
+    #
+    module ActionController
+      include AppOpticsAPM::Inst::RailsBase
+
+      def process_action(method_name, *args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => self.action_name,
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return super(method_name, *args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry('rails', kvs)
+          super(method_name, *args)
+
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit('rails')
+        end
+      end
+
+      #
+      # render
+      #
+      # Our render wrapper that calls 'trace', which will log if we are tracing
+      #
+      def render(*args, &blk)
+        trace('actionview') do
+          super(*args, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v5.
+    #
+    module ActionControllerAPI
+      include AppOpticsAPM::Inst::RailsBase
+
+      def process_action(method_name, *args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => self.action_name
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return super(method_name, *args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller_api][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry('rails-api', kvs)
+          super(method_name, *args)
+
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit('rails-api')
+        end
+      end
+
+      #
+      # render
+      #
+      # Our render wrapper that calls 'trace', which will log if we are tracing
+      #
+      def render(*args, &blk)
+        trace('actionview') do
+          super(*args, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+if defined?(ActionView::Base) && AppOpticsAPM::Config[:action_view][:enabled]
+
+  if Rails::VERSION::MAJOR >= 4
+
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actionview' if AppOpticsAPM::Config[:verbose]
+    if ActionView.version >= Gem::Version.new('6.1.0') # the methods changed in this version
+
+      ActionView::PartialRenderer.class_eval do
+        alias :render_partial_template_without_appoptics :render_partial_template
+
+        def render_partial_template(*args)
+          _, _, template, _, _ = args
+          entry_kvs = {}
+          begin
+            entry_kvs[:Partial] = template.virtual_path
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+          end
+          AppOpticsAPM::SDK.trace(:partial, entry_kvs) do
+            entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+            render_partial_template_without_appoptics(*args)
+          end
+        end
+      end
+
+      ActionView::CollectionRenderer.class_eval do
+        alias :render_collection_without_appoptics :render_collection
+
+        def render_collection(*args)
+          _, _, _, template, _, _ = args
+          entry_kvs = {}
+          begin
+            entry_kvs[:Partial] = template.virtual_path
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+          end
+          AppOpticsAPM::SDK.trace(:collection, entry_kvs) do
+            entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+            render_collection_without_appoptics(*args)
+          end
+        end
+      end
+
+    else # Rails < 6.1.0
+
+      ActionView::PartialRenderer.class_eval do
+        alias :render_partial_without_appoptics :render_partial
+        def render_partial(*args)
+          template = @template || args[1]
+          entry_kvs = {}
+          begin
+            entry_kvs[:Partial] = template.virtual_path
+            # entry_kvs[:Partial] = AppOpticsAPM::Util.prettify(@options[:partial]) if @options.is_a?(Hash)
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+          end
+
+          AppOpticsAPM::SDK.trace('partial', entry_kvs) do
+            entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+            render_partial_without_appoptics(*args)
+          end
+        end
+
+        alias :render_collection_without_appoptics :render_collection
+        def render_collection(*args)
+          template = @template || args[1]
+          entry_kvs = {}
+          begin
+            entry_kvs[:Partial] = template.virtual_path
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+          end
+
+          AppOpticsAPM::SDK.trace('collection', entry_kvs) do
+            entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+            render_collection_without_appoptics(*args)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# vim:set expandtab:tabstop=2

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

@@ -0,0 +1,27 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'appoptics_apm/frameworks/rails/inst/connection_adapters/mysql'
+require 'appoptics_apm/frameworks/rails/inst/connection_adapters/mysql2'
+require 'appoptics_apm/frameworks/rails/inst/connection_adapters/postgresql'
+
+if AppOpticsAPM::Config[:active_record][:enabled] && !defined?(JRUBY_VERSION) && Rails::VERSION::MAJOR <= 6
+  begin
+    adapter = ActiveRecord::Base.connection_config[:adapter]
+
+    if Rails::VERSION::MAJOR < 5
+      require 'appoptics_apm/frameworks/rails/inst/connection_adapters/utils'
+    elsif Rails::VERSION::MAJOR >= 5
+      require 'appoptics_apm/frameworks/rails/inst/connection_adapters/utils5x'
+    end
+
+    AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.mysql      if adapter == 'mysql'
+    AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.mysql2     if adapter == 'mysql2'
+    AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.postgresql if adapter =~ /postgresql|postgis/i
+
+  rescue StandardError => e
+    AppOpticsAPM.logger.error "[appoptics_apm/error] AppOpticsAPM/ActiveRecord error: #{e.inspect}"
+    AppOpticsAPM.logger.debug e.backtrace.join("\n")
+  end
+end
+# vim:set expandtab:tabstop=2

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/mysql.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ConnectionAdapters
+      module FlavorInitializers
+        def self.mysql
+          AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting activerecord mysqladapter' if AppOpticsAPM::Config[:verbose]
+
+          # ActiveRecord 3.2 and higher
+          if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 2) ||
+              ActiveRecord::VERSION::MAJOR == 4
+
+            # AbstractMysqlAdapter
+            AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter,
+                                    AppOpticsAPM::Inst::ConnectionAdapters::Utils)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, :execute)
+
+            # MysqlAdapter
+            AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::MysqlAdapter,
+                                    AppOpticsAPM::Inst::ConnectionAdapters::Utils)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::MysqlAdapter, :exec_query)
+
+          else
+            # ActiveRecord 3.1 and below
+
+            # MysqlAdapter
+            AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::MysqlAdapter,
+                                    AppOpticsAPM::Inst::ConnectionAdapters::Utils)
+
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::MysqlAdapter, :execute)
+
+            if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
+              AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::MysqlAdapter, :begin_db_transaction)
+              AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::MysqlAdapter, :exec_delete)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/mysql2.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ConnectionAdapters
+      module FlavorInitializers
+        def self.mysql2
+          AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting activerecord mysql2adapter' if AppOpticsAPM::Config[:verbose]
+
+          AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::Mysql2Adapter,
+                                  AppOpticsAPM::Inst::ConnectionAdapters::Utils)
+
+          if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0) ||
+              ActiveRecord::VERSION::MAJOR == 2
+            # ActiveRecord 3.0 and prior
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::Mysql2Adapter, :execute)
+          else
+            # ActiveRecord 3.1 and above
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::Mysql2Adapter, :exec_insert)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::Mysql2Adapter, :exec_query)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::Mysql2Adapter, :exec_update)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::Mysql2Adapter, :exec_delete)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/postgresql.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ConnectionAdapters
+      module FlavorInitializers
+        def self.postgresql
+
+          AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting activerecord postgresqladapter' if AppOpticsAPM::Config[:verbose]
+
+          AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter,
+                                  AppOpticsAPM::Inst::ConnectionAdapters::Utils)
+
+          if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR > 0) ||
+                ActiveRecord::VERSION::MAJOR >= 4
+
+            # ActiveRecord 3.1 and up
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_query)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_update)
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_delete)
+
+          else
+            # ActiveRecord 3.0 and prior
+            AppOpticsAPM::Util.method_alias(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :execute)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/utils.rb

@@ -0,0 +1,119 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ConnectionAdapters
+      module Utils
+
+        def extract_trace_details(sql, name = nil, binds = [])
+          opts = {}
+          if AppOpticsAPM::Config[:sanitize_sql]
+            # Sanitize SQL and don't report binds
+            opts[:Query] = AppOpticsAPM::Util.sanitize_sql(sql)
+          else
+            # Report raw SQL and any binds if they exist
+            opts[:Query] = sql.to_s
+            opts[:QueryArgs] = binds.map { |col, val| [col.name, val.to_s] } unless binds.empty?
+          end
+
+          opts[:Name] = name.to_s if name
+          opts[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:active_record][:collect_backtraces]
+
+          config = ActiveRecord::Base.connection_config
+          if config
+            opts[:Database]   = config[:database] if config.key?(:database)
+            opts[:RemoteHost] = config[:host]     if config.key?(:host)
+            adapter_name = config[:adapter]
+
+            case adapter_name
+            when /mysql/i
+              opts[:Flavor] = 'mysql'
+            when /^postgres|^postgis/i
+              opts[:Flavor] = 'postgresql'
+            end
+          end
+        rescue StandardError => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/rails] Exception raised capturing ActiveRecord KVs: #{e.inspect}"
+          AppOpticsAPM.logger.debug e.backtrace.join('\n')
+        ensure
+          return opts
+        end
+
+        # We don't want to trace framework caches.  Only instrument SQL that
+        # directly hits the database.
+        def ignore_payload?(name)
+          %w(SCHEMA EXPLAIN CACHE).include?(name.to_s) ||
+            (name && name.to_sym == :skip_logging) ||
+            name == 'ActiveRecord::SchemaMigration Load'
+        end
+
+        def execute_with_appoptics(sql, name = nil)
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              execute_without_appoptics(sql, name)
+            end
+          else
+            execute_without_appoptics(sql, name)
+          end
+        end
+
+        def exec_query_with_appoptics(sql, name = nil, binds = [])
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              exec_query_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_query_without_appoptics(sql, name, binds)
+          end
+        end
+
+        def exec_delete_with_appoptics(sql, name = nil, binds = [])
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              exec_delete_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_delete_without_appoptics(sql, name, binds)
+          end
+        end
+
+        def exec_update_with_appoptics(sql, name = nil, binds = [])
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              exec_update_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_update_without_appoptics(sql, name, binds)
+          end
+        end
+
+        def exec_insert_with_appoptics(sql, name = nil, binds = [], *args)
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              exec_insert_without_appoptics(sql, name, binds, *args)
+            end
+          else
+            exec_insert_without_appoptics(sql, name, binds, *args)
+          end
+        end
+
+        def begin_db_transaction_with_appoptics
+          AppOpticsAPM::API.trace('activerecord', { :Query => 'BEGIN', :Flavor => :mysql }, :ar_started) do
+            begin_db_transaction_without_appoptics
+          end
+        end
+      end # Utils
+    end
+  end
+end