appoptics_apm 4.4.0 → 4.4.1

data/lib/appoptics_apm/inst/rack.rb

@@ -50,17 +50,19 @@ if AppOpticsAPM.loaded
         report_kvs = {}
 
         begin
-          report_kvs[:'HTTP-Host']        = req.host
+          report_kvs[:'HTTP-Host']      = req.host
           report_kvs[:Port]             = req.port
           report_kvs[:Proto]            = req.scheme
-          report_kvs[:Method]            = req.request_method
+          report_kvs[:Method]           = req.request_method
           report_kvs[:AJAX]             = true if req.xhr?
           report_kvs[:ClientIP]         = req.ip
 
           if AppOpticsAPM::Config[:rack][:log_args]
-            report_kvs[:'Query-String']     = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+            report_kvs[:'Query-String'] = ::CGI.unescape(req.query_string) unless req.query_string.empty?
           end
 
+          report_kvs[:Backtrace]        = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rack][:collect_backtraces]
+
           # Report any request queue'ing headers.  Report as 'Request-Start' or the summed Queue-Time
           report_kvs[:'Request-Start']     = env['HTTP_X_REQUEST_START']    if env.key?('HTTP_X_REQUEST_START')
           report_kvs[:'Request-Start']     = env['HTTP_X_QUEUE_START']      if env.key?('HTTP_X_QUEUE_START')
@@ -71,7 +73,7 @@ if AppOpticsAPM.loaded
           report_kvs[:'Forwarded-Proto']   = env['HTTP_X_FORWARDED_PROTO']  if env.key?('HTTP_X_FORWARDED_PROTO')
           report_kvs[:'Forwarded-Port']    = env['HTTP_X_FORWARDED_PORT']   if env.key?('HTTP_X_FORWARDED_PORT')
 
-          report_kvs[:'Ruby.AppOptics.Version'] = ::AppOpticsAPM::Version::STRING
+          report_kvs[:'Ruby.AppOptics.Version'] = AppOpticsAPM::Version::STRING
           report_kvs[:ProcessID]         = Process.pid
           report_kvs[:ThreadID]          = Thread.current.to_s[/0x\w*/]
         rescue StandardError => e
@@ -111,7 +113,7 @@ if AppOpticsAPM.loaded
         req_url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
         status = 500        # initialize with 500
 
-        report_kvs = {}
+        report_kvs = collect(req, env)
         report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
 
         # Check for and validate X-Trace request header to pick up tracing context
@@ -125,13 +127,7 @@ if AppOpticsAPM.loaded
         # AppOpticsAPM.has_xtrace_header = xtrace
         # AppOpticsAPM.is_continued_trace = AppOpticsAPM.has_incoming_context || AppOpticsAPM.has_xtrace_header
 
-        AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs) unless ::AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
-
-        # We log an info event with the HTTP KVs found in AppOpticsAPM::Rack.collect
-        # This is done here so in the case of stacks that try/catch/abort
-        # (looking at you Grape) we're sure the KVs get reported now as
-        # this code may not be returned to later.
-        AppOpticsAPM::API.log_info(:rack, collect(req, env))
+        AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs) unless AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
 
         status, headers, response = @app.call(env)
         confirmed_transaction_name = send_metrics(env, req, req_url, start, status)
@@ -157,12 +153,13 @@ if AppOpticsAPM.loaded
 
 
       def send_metrics(env, req, req_url, start, status)
-        return if ::AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
+        return if AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
 
         status = status.to_i
         error = status.between?(500,599) ? 1 : 0
         duration =(1000 * 1000 * (Time.now - start)).round(0)
-        AppOpticsAPM::Span.createHttpSpan(transaction_name(env), req_url, domain(req), duration, status, req.request_method, error) || ''
+        method = req.request_method
+        AppOpticsAPM::Span.createHttpSpan(transaction_name(env), req_url, domain(req), duration, status, method, error) || ''
       end
 
       def domain(req)

data/lib/appoptics_apm/inst/redis.rb

@@ -59,8 +59,8 @@ module AppOpticsAPM
         def self.included(klass)
           # We wrap two of the Redis methods to instrument
           # operations
-          ::AppOpticsAPM::Util.method_alias(klass, :call, ::Redis::Client)
-          ::AppOpticsAPM::Util.method_alias(klass, :call_pipeline, ::Redis::Client)
+          AppOpticsAPM::Util.method_alias(klass, :call, ::Redis::Client)
+          AppOpticsAPM::Util.method_alias(klass, :call_pipeline, ::Redis::Client)
         end
 
         # Given any Redis operation command array, this method
@@ -218,17 +218,17 @@ module AppOpticsAPM
         #
         def call_with_appoptics(command, &block)
           if AppOpticsAPM.tracing?
-            ::AppOpticsAPM::API.log_entry(:redis, {})
+            AppOpticsAPM::API.log_entry(:redis, {})
 
             begin
               r = call_without_appoptics(command, &block)
               report_kvs = extract_trace_details(command, r)
               r
             rescue StandardError => e
-              ::AppOpticsAPM::API.log_exception(:redis, e)
+              AppOpticsAPM::API.log_exception(:redis, e)
               raise
             ensure
-              ::AppOpticsAPM::API.log_exit(:redis, report_kvs)
+              AppOpticsAPM::API.log_exit(:redis, report_kvs)
             end
 
           else
@@ -246,17 +246,17 @@ module AppOpticsAPM
             # 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(:redis, {})
+            AppOpticsAPM::API.log_entry(:redis, {})
 
             report_kvs = extract_pipeline_details(pipeline)
 
             begin
               call_pipeline_without_appoptics(pipeline)
             rescue StandardError => e
-              ::AppOpticsAPM::API.log_exception(:redis, e)
+              AppOpticsAPM::API.log_exception(:redis, e)
               raise
             ensure
-              ::AppOpticsAPM::API.log_exit(:redis, report_kvs)
+              AppOpticsAPM::API.log_exit(:redis, report_kvs)
             end
           else
             call_pipeline_without_appoptics(pipeline)
@@ -268,8 +268,8 @@ module AppOpticsAPM
 end
 
 if AppOpticsAPM::Config[:redis][:enabled]
-  if defined?(::Redis) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0')
+  if defined?(Redis) && Gem::Version.new(Redis::VERSION) >= Gem::Version.new('3.0.0')
     AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting redis' if AppOpticsAPM::Config[:verbose]
-    ::AppOpticsAPM::Util.send_include(::Redis::Client, ::AppOpticsAPM::Inst::Redis::Client)
+    AppOpticsAPM::Util.send_include(Redis::Client, AppOpticsAPM::Inst::Redis::Client)
   end
 end

data/lib/appoptics_apm/inst/resque.rb

@@ -9,9 +9,9 @@ module AppOpticsAPM
     module ResqueClient
       def self.included(klass)
         klass.send :extend, ::Resque
-        ::AppOpticsAPM::Util.method_alias(klass, :enqueue, ::Resque)
-        ::AppOpticsAPM::Util.method_alias(klass, :enqueue_to, ::Resque)
-        ::AppOpticsAPM::Util.method_alias(klass, :dequeue, ::Resque)
+        AppOpticsAPM::Util.method_alias(klass, :enqueue, ::Resque)
+        AppOpticsAPM::Util.method_alias(klass, :enqueue_to, ::Resque)
+        AppOpticsAPM::Util.method_alias(klass, :dequeue, ::Resque)
       end
 
       def extract_trace_details(op, klass, args)
@@ -81,7 +81,7 @@ module AppOpticsAPM
 
     module ResqueWorker
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :perform, ::Resque::Worker)
+        AppOpticsAPM::Util.method_alias(klass, :perform, ::Resque::Worker)
       end
 
       def perform_with_appoptics(job)
@@ -125,7 +125,7 @@ module AppOpticsAPM
 
     module ResqueJob
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :fail, ::Resque::Job)
+        AppOpticsAPM::Util.method_alias(klass, :fail, ::Resque::Job)
       end
 
       def fail_with_appoptics(exception)
@@ -138,13 +138,13 @@ module AppOpticsAPM
   end
 end
 
-if defined?(::Resque)
+if defined?(Resque)
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting resque' if AppOpticsAPM::Config[:verbose]
 
-  ::AppOpticsAPM::Util.send_include(::Resque,         ::AppOpticsAPM::Inst::ResqueClient) if AppOpticsAPM::Config[:resqueclient][:enabled]
-  ::AppOpticsAPM::Util.send_include(::Resque::Worker, ::AppOpticsAPM::Inst::ResqueWorker) if AppOpticsAPM::Config[:resqueworker][:enabled]
+  AppOpticsAPM::Util.send_include(Resque,         AppOpticsAPM::Inst::ResqueClient) if AppOpticsAPM::Config[:resqueclient][:enabled]
+  AppOpticsAPM::Util.send_include(Resque::Worker, AppOpticsAPM::Inst::ResqueWorker) if AppOpticsAPM::Config[:resqueworker][:enabled]
   if AppOpticsAPM::Config[:resqueclient][:enabled] || AppOpticsAPM::Config[:resqueworker][:enabled]
-    ::AppOpticsAPM::Util.send_include(::Resque::Job,    ::AppOpticsAPM::Inst::ResqueJob)
+    AppOpticsAPM::Util.send_include(Resque::Job,    AppOpticsAPM::Inst::ResqueJob)
   end
 end
 

data/lib/appoptics_apm/inst/rest-client.rb

@@ -5,7 +5,7 @@ module AppOpticsAPM
   module Inst
     module RestClientRequest
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute, ::RestClient::Request)
+        AppOpticsAPM::Util.method_alias(klass, :execute, ::RestClient::Request)
       end
 
       ##
@@ -42,9 +42,7 @@ module AppOpticsAPM
   end
 end
 
-if AppOpticsAPM::Config[:rest_client][:enabled]
-  if defined?(::RestClient)
-    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rest-client' if AppOpticsAPM::Config[:verbose]
-    ::AppOpticsAPM::Util.send_include(::RestClient::Request, ::AppOpticsAPM::Inst::RestClientRequest)
-  end
+if defined?(RestClient) && AppOpticsAPM::Config[:rest_client][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rest-client' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(RestClient::Request, AppOpticsAPM::Inst::RestClientRequest)
 end

data/lib/appoptics_apm/inst/sequel.rb

@@ -86,10 +86,10 @@ module AppOpticsAPM
       include AppOpticsAPM::Inst::Sequel
 
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :run, ::Sequel::Database)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
       end
 
       def run_with_appoptics(sql, opts = ::Sequel::OPTS)
@@ -135,10 +135,10 @@ module AppOpticsAPM
       include AppOpticsAPM::Inst::Sequel
 
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute, ::Sequel::Dataset)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
-        ::AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
       end
 
       def execute_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
@@ -172,7 +172,7 @@ if AppOpticsAPM::Config[:sequel][:enabled]
 
   if defined?(::Sequel)
     AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sequel' if AppOpticsAPM::Config[:verbose]
-    ::AppOpticsAPM::Util.send_include(::Sequel::Database, ::AppOpticsAPM::Inst::SequelDatabase)
-    ::AppOpticsAPM::Util.send_include(::Sequel::Dataset, ::AppOpticsAPM::Inst::SequelDataset)
+    AppOpticsAPM::Util.send_include(::Sequel::Database, AppOpticsAPM::Inst::SequelDatabase)
+    AppOpticsAPM::Util.send_include(::Sequel::Dataset, AppOpticsAPM::Inst::SequelDataset)
   end
 end

data/lib/appoptics_apm/inst/sidekiq-client.rb

@@ -43,13 +43,13 @@ module AppOpticsAPM
   end
 end
 
-if defined?(::Sidekiq) && AppOpticsAPM::Config[:sidekiqclient][:enabled]
-  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq client' if AppOpticsAPM::Config[:verbose]
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqclient][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq client' if AppOpticsAPM::Config[:verbose]
 
-  ::Sidekiq.configure_client do |config|
+  Sidekiq.configure_client do |config|
     config.client_middleware do |chain|
-      ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq client middleware' if AppOpticsAPM::Config[:verbose]
-      chain.add ::AppOpticsAPM::SidekiqClient
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq client middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqClient
     end
   end
 end

data/lib/appoptics_apm/inst/sidekiq-worker.rb

@@ -53,13 +53,13 @@ module AppOpticsAPM
   end
 end
 
-if defined?(::Sidekiq) && AppOpticsAPM::Config[:sidekiqworker][:enabled]
-  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq worker' if AppOpticsAPM::Config[:verbose]
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqworker][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq worker' if AppOpticsAPM::Config[:verbose]
 
-  ::Sidekiq.configure_server do |config|
+  Sidekiq.configure_server do |config|
     config.server_middleware do |chain|
-      ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq worker middleware' if AppOpticsAPM::Config[:verbose]
-      chain.add ::AppOpticsAPM::SidekiqWorker
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq worker middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqWorker
     end
   end
 end

data/lib/appoptics_apm/inst/twitter-cassandra.rb

@@ -261,14 +261,14 @@ module AppOpticsAPM
 end
 
 # There are two main Cassandra clients for Ruby.  This one from Twitter
-# and the other from datastax.  This one defined ::Cassandra as a class
+# and the other from datastax.  This one defined Cassandra as a class
 # and datastax defines it as a module.  We use this to detect
 # and differentiate between the client in use.
 
-if defined?(::Cassandra) && ::Cassandra.is_a?(Class) && AppOpticsAPM::Config[:cassandra][:enabled]
+if defined?(Cassandra) && Cassandra.is_a?(Class) && AppOpticsAPM::Config[:cassandra][:enabled]
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting cassandra' if AppOpticsAPM::Config[:verbose]
 
-  class ::Cassandra
+  class Cassandra
     include AppOpticsAPM::Inst::Cassandra
 
     [:insert, :remove, :count_columns, :get_columns, :multi_get_columns, :get,

data/lib/appoptics_apm/inst/typhoeus.rb

@@ -7,7 +7,7 @@ module AppOpticsAPM
     module TyphoeusRequestOps
 
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Request::Operations)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Request::Operations)
       end
 
       def run_with_appoptics
@@ -28,7 +28,7 @@ module AppOpticsAPM
           kvs = {}
           kvs[:Spec] = 'rsc'
           kvs[:IsService] = 1
-          kvs[:HTTPMethod] = ::AppOpticsAPM::Util.upcase(options[:method])
+          kvs[:HTTPMethod] = AppOpticsAPM::Util.upcase(options[:method])
 
           response = run_without_appoptics
 
@@ -64,7 +64,7 @@ module AppOpticsAPM
 
     module TyphoeusHydraRunnable
       def self.included(klass)
-        ::AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Hydra)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Hydra)
       end
 
       def run_with_appoptics
@@ -82,6 +82,7 @@ module AppOpticsAPM
         kvs[:queued_requests] = queued_requests.count
         kvs[:max_concurrency] = max_concurrency
         kvs[:Async] = 1
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:typhoeus][:collect_backtraces]
 
         # FIXME: Until we figure out a strategy to deal with libcurl internal
         # threading and Ethon's use of easy handles, here we just do a simple
@@ -100,10 +101,8 @@ module AppOpticsAPM
   end
 end
 
-if AppOpticsAPM::Config[:typhoeus][:enabled]
-  if defined?(::Typhoeus)
-    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting typhoeus' if AppOpticsAPM::Config[:verbose]
-    ::AppOpticsAPM::Util.send_include(::Typhoeus::Request::Operations, ::AppOpticsAPM::Inst::TyphoeusRequestOps)
-    ::AppOpticsAPM::Util.send_include(::Typhoeus::Hydra, ::AppOpticsAPM::Inst::TyphoeusHydraRunnable)
-  end
+if defined?(Typhoeus) && AppOpticsAPM::Config[:typhoeus][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting typhoeus' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Typhoeus::Request::Operations, AppOpticsAPM::Inst::TyphoeusRequestOps)
+  AppOpticsAPM::Util.send_include(Typhoeus::Hydra, AppOpticsAPM::Inst::TyphoeusHydraRunnable)
 end

data/lib/appoptics_apm/legacy_method_profiling.rb

@@ -51,7 +51,7 @@ module AppOpticsAPMMethodProfiling
                   entry_kvs['File']          = '#{file}'
                   entry_kvs['LineNumber']    = '#{line}'
                   entry_kvs['Args']          = AppOpticsAPM::API.pps(*args) if #{store_args}
-                  entry_kvs.merge!(::AppOpticsAPM::API.get_class_name(self))
+                  entry_kvs.merge!(AppOpticsAPM::API.get_class_name(self))
 
                   AppOpticsAPM::API.log(nil, 'profile_entry', entry_kvs)
 

data/lib/appoptics_apm/ruby.rb

@@ -31,5 +31,5 @@ module AppOpticsAPM
 end
 
 if AppOpticsAPM.loaded && !AppOpticsAPM.framework?
-  ::AppOpticsAPM::Ruby.load
+  AppOpticsAPM::Ruby.load
 end

data/lib/appoptics_apm/sdk/custom_metrics.rb

@@ -56,7 +56,7 @@ module AppOpticsAPM
       #       start = Time.now
       #       yield # yield to where work is done
       #       duration = Time.now - start
-      #       AppOpticsAPM::SDK.increment_metric(name, duration, 1, false, tags)
+      #       AppOpticsAPM::SDK.summary_metric(name, duration, 1, false, tags)
       #     end
       #   end
       #

data/lib/appoptics_apm/sdk/tracing.rb

@@ -94,6 +94,7 @@ module AppOpticsAPM
         opts.delete('TransactionName')
 
         AppOpticsAPM::API.log_entry(span, opts, protect_op)
+        opts[:Backtrace] && opts.delete(:Backtrace) # to avoid sending backtrace twice (faster to check presence here)
         begin
           yield
         rescue Exception => e
@@ -182,6 +183,8 @@ module AppOpticsAPM
         AppOpticsAPM.transaction_name = opts.delete('TransactionName') || opts.delete(:TransactionName)
 
         AppOpticsAPM::API.log_start(span, xtrace, opts)
+        opts[:Backtrace] && opts.delete(:Backtrace) # to avoid sending backtrace twice (faster to check presence here)
+
         # AppOpticsAPM::Event.startTrace creates an Event without an Edge
         exit_evt = AppOpticsAPM::Event.startTrace(AppOpticsAPM::Context.get)
         result = begin

data/lib/appoptics_apm/support.rb

@@ -57,8 +57,8 @@ module AppOpticsAPM
     using_rails = defined?(::Rails)
     AppOpticsAPM.logger.warn "Using Rails?: #{yesno(using_rails)}"
     if using_rails
-      AppOpticsAPM.logger.warn "AppOpticsAPM::Rails loaded?: #{yesno(defined?(::AppOpticsAPM::Rails))}"
-      if defined?(::AppOpticsAPM::Rack)
+      AppOpticsAPM.logger.warn "AppOpticsAPM::Rails loaded?: #{yesno(defined?(AppOpticsAPM::Rails))}"
+      if defined?(AppOpticsAPM::Rack)
         AppOpticsAPM.logger.warn "AppOpticsAPM::Rack middleware loaded?: #{yesno(::Rails.configuration.middleware.include? AppOpticsAPM::Rack)}"
       end
     end

data/lib/appoptics_apm/thread_local.rb

@@ -7,7 +7,7 @@ module AppOpticsAPM
   #
   # Example usage:
   # module AppOpticsAPMBase
-  #   extend ::AppOpticsAPM::ThreadLocal
+  #   extend AppOpticsAPM::ThreadLocal
   #   thread_local :layer_op
   # end
   module ThreadLocal

data/lib/appoptics_apm/util.rb

@@ -170,7 +170,7 @@ module AppOpticsAPM
         return sql unless AppOpticsAPM::Config[:sanitize_sql]
 
         regexp = Regexp.new(AppOpticsAPM::Config[:sanitize_sql_regexp], AppOpticsAPM::Config[:sanitize_sql_opts])
-        sql.gsub(regexp, '?')
+        sql.gsub(/\\\'/,'').gsub(regexp, '?')
       end
 
       ##
@@ -265,12 +265,12 @@ module AppOpticsAPM
           platform_info['Force']                        = true
           platform_info['Ruby.Platform.Version']        = RUBY_PLATFORM
           platform_info['Ruby.Version']                 = RUBY_VERSION
-          platform_info['Ruby.AppOptics.Version']    = ::AppOpticsAPM::Version::STRING
+          platform_info['Ruby.AppOptics.Version']    = AppOpticsAPM::Version::STRING
 
           clib_version_file = File.join(Gem::Specification.find_by_name('appoptics_apm').gem_dir, 'ext', 'oboe_metal', 'src', 'VERSION')
           platform_info['Ruby.clib.Version']            = File.read(clib_version_file).chomp
-          platform_info['RubyHeroku.AppOpticsAPM.Version'] = ::AppOpticsAPMHeroku::Version::STRING if defined?(::AppOpticsAPMHeroku)
-          platform_info['Ruby.TraceMode.Version']       = ::AppOpticsAPM::Config[:tracing_mode]
+          platform_info['RubyHeroku.AppOpticsAPM.Version'] = AppOpticsAPMHeroku::Version::STRING if defined?(AppOpticsAPMHeroku)
+          platform_info['Ruby.TraceMode.Version']       = AppOpticsAPM::Config[:tracing_mode]
 
           # Collect up the loaded gems
           if defined?(Gem) && Gem.respond_to?(:loaded_specs)

data/lib/appoptics_apm/version.rb

@@ -8,7 +8,7 @@ module AppOpticsAPM
   module Version
     MAJOR = 4
     MINOR = 4
-    PATCH = 0
+    PATCH = 1
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end