appoptics_apm 4.4.0 → 4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f55957c02fb447084c8430a6dff438ce8ff3725f1eaf755e1c0f9092f94360b0
-  data.tar.gz: 02a24b754db042ec253cefb0160217bb9d136a2ad360916630bc4413007b3786
+  metadata.gz: 2c47f21237c21b5074eae5806315b7abc78380b75a964385c611157d561ef9e9
+  data.tar.gz: cca745771a727e6e85fb2e5accfa380f20bd2932f2ecf0bf23fdf84d8fdbd923
 SHA512:
-  metadata.gz: ed5020f576a5ebc447bdfad639140373670cdc30ff50e5c8b379bdd3c1fab74b764eea21ef3f0e3a5670152f64daa07db6b08bf291bb0468ece448fc4f7f1399
-  data.tar.gz: f0d5f73b872b8d869b3308aff1180447f2a46f48039afa84f0ce8a43a2e06bdcaeb13fbca95453c9cc80988f93a85c1c534882b963e528ed0904195b6d75edb0
+  metadata.gz: 97639be2a19811b48f8de96867b86d912727834108d3770ab10bb447e8be07de02a8e4b9db985a1227735980fb3831dd4338ccaa253c069feb3e250600c8a7ec
+  data.tar.gz: 6d7c6a513f80161d3848c9a857de69504d42deffe64d125390d8b98ffdbf017f8101e9afa326ee78fbbd04b6b1a1b713b52aded8cbd7c1b9331d57ca6ce80d96

data/.travis.yml

@@ -30,6 +30,9 @@ gemfile:
 
 matrix:
   exclude:
+    - rvm: ruby-head
+      gemfile: gemfiles/rails42.gemfile
+
     - rvm: 2.5.3
       env: DBTYPE=mysql
     - rvm: 2.4.5

data/examples/carrying_context.rb

@@ -19,7 +19,7 @@
 #
 # For example, when a web request comes into a stack, a tracing
 # context is established using `AppOpticsAPM::API.log_start` as the request
-# enters through the rack middleware via `::AppOpticsAPM::Rack`.
+# enters through the rack middleware via `AppOpticsAPM::Rack`.
 #
 # That tracing context is then continued using `AppOpticsAPM::API.trace` or
 # `AppOpticsAPM::API.log_entry` for each subsequent layer such as Rails,

data/lib/appoptics_apm/api/logging.rb

@@ -102,7 +102,7 @@ module AppOpticsAPM
       #
       # Returns an xtrace metadata string if we are tracing
       def log_start(layer, xtrace = nil, opts = {})
-        return if !AppOpticsAPM.loaded || (opts.key?(:URL) && ::AppOpticsAPM::Util.static_asset?(opts[:URL]))
+        return if !AppOpticsAPM.loaded || (opts.key?(:URL) && AppOpticsAPM::Util.static_asset?(opts[:URL]))
 
         #--
         # Is the below necessary? Only on JRuby? Could there be an existing context but not x-trace header?

data/lib/appoptics_apm/api/profiling.rb

@@ -124,10 +124,10 @@ module AppOpticsAPM
 
         source_location = []
         if instance_method
-          ::AppOpticsAPM::Util.send_include(klass, ::AppOpticsAPM::MethodProfiling)
+          AppOpticsAPM::Util.send_include(klass, AppOpticsAPM::MethodProfiling)
           source_location = klass.instance_method(method).source_location
         elsif class_method
-          ::AppOpticsAPM::Util.send_extend(klass, ::AppOpticsAPM::MethodProfiling)
+          AppOpticsAPM::Util.send_extend(klass, AppOpticsAPM::MethodProfiling)
           source_location = klass.method(method).source_location
         end
 

data/lib/appoptics_apm/api/tracing.rb

@@ -48,7 +48,6 @@ module AppOpticsAPM
         [start_trace_with_target(span, xtrace, target, opts) { yield }, target['X-Trace']]
       end
 
-
     end
   end
 end

data/lib/appoptics_apm/base.rb

@@ -33,7 +33,7 @@ TRACE_FILE = '/tmp/appoptics_traces.bson'.freeze
 # Current variations as of 2014-09-10 are a c-extension, JRuby (using AppOpticsAPM Java
 # instrumentation) and a Heroku c-extension (with embedded tracelyzer)
 module AppOpticsAPMBase
-  extend ::AppOpticsAPM::ThreadLocal
+  extend AppOpticsAPM::ThreadLocal
 
   attr_accessor :reporter
   attr_accessor :loaded

data/lib/appoptics_apm/config.rb

@@ -15,9 +15,9 @@ module AppOpticsAPM
                          :active_record, :bunnyclient, :bunnyconsumer, :cassandra, :curb,
                          :dalli, :delayed_jobclient, :delayed_jobworker,
                          :em_http_request, :excon, :faraday, :grpc_client, :grape,
-                         :httpclient, :nethttp, :memcached, :mongo, :moped, :rack, :redis,
+                         :httpclient, :memcached, :mongo, :moped, :nethttp, :padrino, :rack, :redis,
                          :resqueclient, :resqueworker, :rest_client,
-                         :sequel, :sidekiqclient, :sidekiqworker, :typhoeus]
+                         :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus]
 
     # Subgrouping of instrumentation
     @@http_clients = [:curb, :excon, :em_http_request, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]

data/lib/appoptics_apm/frameworks/grape.rb

@@ -7,19 +7,19 @@ module AppOpticsAPM
   module Grape
     module API
       def self.extended(klass)
-        ::AppOpticsAPM::Util.class_method_alias(klass, :inherited, ::Grape::API)
+        AppOpticsAPM::Util.class_method_alias(klass, :inherited, ::Grape::API)
       end
 
       def inherited_with_appoptics(subclass)
         inherited_without_appoptics(subclass)
 
-        subclass.use ::AppOpticsAPM::Rack
+        subclass.use AppOpticsAPM::Rack
       end
     end
 
     module Endpoint
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :run, ::Grape::Endpoint)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Grape::Endpoint)
       end
 
       def run_with_appoptics(*args)
@@ -33,22 +33,23 @@ module AppOpticsAPM
         else
           report_kvs[:Action] = args.empty? ? env['PATH_INFO'] : args[0]['PATH_INFO']
         end
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
 
         env['appoptics_apm.controller'] = report_kvs[:Controller]
         env['appoptics_apm.action']     = report_kvs[:Action]
 
-        ::AppOpticsAPM::API.log_entry('grape', report_kvs)
+        AppOpticsAPM::API.log_entry('grape', report_kvs)
 
         run_without_appoptics(*args)
       ensure
-        ::AppOpticsAPM::API.log_exit('grape')
+        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)
+          AppOpticsAPM::Util.method_alias(klass, :error_response, ::Grape::Middleware::Error)
         end
 
         def error_response_with_appoptics(error = {})
@@ -60,9 +61,9 @@ module AppOpticsAPM
 
             # Since Grape uses throw/catch and not Exceptions, we have to create an exception here
             exception = GrapeError.new(error[:message] ? error[:message] : "No message given.")
-            exception.set_backtrace(::AppOpticsAPM::API.backtrace)
+            exception.set_backtrace(AppOpticsAPM::API.backtrace)
 
-            ::AppOpticsAPM::API.log_exception('rack', exception )
+            AppOpticsAPM::API.log_exception('rack', exception)
 
             # Since calls to error() are handled similar to abort in Grape.  We
             # manually log the rack exit here since the original code won't
@@ -83,14 +84,14 @@ module AppOpticsAPM
   end
 end
 
-if AppOpticsAPM::Config[:grape][:enabled] && defined?(::Grape)
+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)
+  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.rb

@@ -5,17 +5,17 @@ module AppOpticsAPM
   module PadrinoInst
     module Routing
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+        AppOpticsAPM::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
       end
 
       def dispatch_with_appoptics
 
-        ::AppOpticsAPM::API.log_entry('padrino', {})
+        AppOpticsAPM::API.log_entry('padrino', {})
+        report_kvs = {}
 
         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
@@ -24,29 +24,82 @@ module AppOpticsAPM
 
         result
       rescue => e
-        ::AppOpticsAPM::API.log_exception('padrino', e)
+        AppOpticsAPM::API.log_exception('padrino', e)
         raise e
       ensure
-        ::AppOpticsAPM::API.log_exit('padrino', report_kvs)
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+        AppOpticsAPM::API.log_exit('padrino', report_kvs)
+      end
+    end
+
+    module Rendering
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      # TODO add test coverage, currently there are no tests for this
+      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 "[appoptics_apm/padrino] #{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
+              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+              AppOpticsAPM::API.log_exit(:render, report_kvs)
+            end
+          end
+        else
+          render_without_appoptics(engine, data, options, locals, &block)
+        end
       end
     end
   end
 end
 
-if defined?(::Padrino)
+if defined?(Padrino) && AppopticsAPM::Config[:padrino][:enabled]
   # 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'
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Padrino' if AppOpticsAPM::Config[:verbose]
 
   Padrino.after_load do
-    ::AppOpticsAPM.logger = ::Padrino.logger if ::Padrino.respond_to?(:logger)
-    ::AppOpticsAPM::Inst.load_instrumentation
+    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)
+    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

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

@@ -88,9 +88,9 @@ if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][
   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)
+    ActionController::Base.send(:prepend, ::AppOpticsAPM::Inst::ActionController)
   else
-    ::AppOpticsAPM::Util.send_include(::ActionController::Base, AppOpticsAPM::Inst::ActionController)
+    AppOpticsAPM::Util.send_include(::ActionController::Base, AppOpticsAPM::Inst::ActionController)
   end
 end
 
@@ -98,7 +98,7 @@ end
 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)
+  ActionController::API.send(:prepend, ::AppOpticsAPM::Inst::ActionControllerAPI)
 end
 
 # vim:set expandtab:tabstop=2

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

@@ -10,7 +10,7 @@ module AppOpticsAPM
     # to Rails v3
     #
     module ActionController
-      include ::AppOpticsAPM::Inst::RailsBase
+      include AppOpticsAPM::Inst::RailsBase
 
       def self.included(base)
         base.class_eval do
@@ -21,12 +21,8 @@ module AppOpticsAPM
       end
 
       def process_with_appoptics(*args)
-        kvs = {
-            :Controller   => self.class.name,
-            :Action       => self.action_name,
-        }
-        request.env['appoptics_apm.controller'] = kvs[:Controller]
-        request.env['appoptics_apm.action'] = kvs[:Action]
+        request.env['appoptics_apm.controller'] = self.class.name
+        request.env['appoptics_apm.action'] = self.action_name
 
         trace('rails') do
           process_without_appoptics(*args)
@@ -49,6 +45,7 @@ module AppOpticsAPM
           process_action_without_appoptics(*args)
         rescue Exception
           kvs[:Status] = 500
+          kvs.delete(:Backtrace)
           AppOpticsAPM::API.log(nil, 'info', kvs)
           raise
         end

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

@@ -10,7 +10,7 @@ module AppOpticsAPM
     # to Rails v4
     #
     module ActionController
-      include ::AppOpticsAPM::Inst::RailsBase
+      include AppOpticsAPM::Inst::RailsBase
 
       def self.included(base)
         base.class_eval do

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

@@ -10,7 +10,7 @@ module AppOpticsAPM
     # to Rails v5
     #
     module ActionController
-      include ::AppOpticsAPM::Inst::RailsBase
+      include AppOpticsAPM::Inst::RailsBase
 
       def process_action(method_name, *args)
         kvs = {

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

@@ -10,7 +10,7 @@ module AppOpticsAPM
     # to Rails v5.
     #
     module ActionControllerAPI
-      include ::AppOpticsAPM::Inst::RailsBase
+      include AppOpticsAPM::Inst::RailsBase
 
       def process_action(method_name, *args)
         kvs = {
@@ -38,7 +38,7 @@ module AppOpticsAPM
       #
       # render
       #
-      # Our render wrapper that calls 'add_logging', which will log if we are tracing
+      # Our render wrapper that calls 'trace', which will log if we are tracing
       #
       def render(*args, &blk)
         trace('actionview') do

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

@@ -9,31 +9,31 @@ module AppOpticsAPM
           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
+          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)
+            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)
+            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.send_include(ActiveRecord::ConnectionAdapters::MysqlAdapter,
+                                    AppOpticsAPM::Inst::ConnectionAdapters::Utils)
 
-            AppOpticsAPM::Util.method_alias(::ActiveRecord::ConnectionAdapters::MysqlAdapter, :execute)
+            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)
+            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

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

@@ -8,19 +8,19 @@ module AppOpticsAPM
         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)
+          AppOpticsAPM::Util.send_include(ActiveRecord::ConnectionAdapters::Mysql2Adapter,
+                                  AppOpticsAPM::Inst::ConnectionAdapters::Utils)
 
-          if (::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR == 0) ||
-              ::ActiveRecord::VERSION::MAJOR == 2
+          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)
+            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)
+            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