solarwinds_apm 5.1.9 → 6.0.0.preV2

data/lib/solarwinds_apm/inst/redis_v4.rb

@@ -1,273 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module RedisV4
-      module Client
-        # The operations listed in this constant skip collecting KVKey
-        NO_KEY_OPS = [:auth, :keys, :randomkey, :scan, :sdiff, :sdiffstore, :sinter,
-                      :sinterstore, :smove, :sunion, :sunionstore, :zinterstore,
-                      :zunionstore, :publish, :select, :eval, :evalsha, :script].freeze
-
-        # Instead of a giant switch statement, we use a hash constant to map out what
-        # KVs need to be collected for each of the many many Redis operations
-        # Hash formatting by undiagnosed OCD
-        KV_COLLECT_MAP = {
-          :brpoplpush  => { :destination  => 2 }, :rpoplpush   => { :destination  => 2 },
-          :sdiffstore  => { :destination  => 1 }, :sinterstore => { :destination  => 1 },
-          :sunionstore => { :destination  => 1 }, :zinterstore => { :destination  => 1 },
-          :zunionstore => { :destination  => 1 }, :publish     => { :channel      => 1 },
-          :incrby      => { :increment    => 2 }, :incrbyfloat => { :increment    => 2 },
-          :pexpire     => { :milliseconds => 2 }, :pexpireat   => { :milliseconds => 2 },
-          :expireat    => { :timestamp    => 2 }, :decrby      => { :decrement    => 2 },
-          :psetex      => { :ttl     => 2 },      :restore  => { :ttl     => 2 },
-          :setex       => { :ttl     => 2 },      :setnx    => { :ttl     => 2 },
-          :move        => { :db      => 2 },      :select   => { :db      => 1 },
-          :lindex      => { :index   => 2 },      :getset   => { :value   => 2 },
-          :keys        => { :pattern => 1 },      :expire   => { :seconds => 2 },
-          :rename      => { :newkey  => 2 },      :renamenx => { :newkey  => 2 },
-          :getbit      => { :offset  => 2 },      :setbit   => { :offset  => 2 },
-          :setrange    => { :offset  => 2 },      :evalsha  => { :sha     => 1 },
-          :getrange    => { :start => 2, :end       => 3 },
-          :zrange      => { :start => 2, :end       => 3 },
-          :bitcount    => { :start => 2, :stop      => 3 },
-          :lrange      => { :start => 2, :stop      => 3 },
-          :zrevrange   => { :start => 2, :stop      => 3 },
-          :hincrby     => { :field => 2, :increment => 3 },
-          :smove           => { :source    => 1, :destination => 2 },
-          :bitop           => { :operation => 1, :destkey     => 2 },
-          :hincrbyfloat    => { :field     => 2, :increment   => 3 },
-          :zremrangebyrank => { :start     => 2, :stop        => 3 }
-        }.freeze
-
-        # The following operations don't require any special handling. For these,
-        # we only collect KVKey and KVOp
-        #
-        # :append, :blpop, :brpop, :decr, :del, :dump, :exists,
-        # :hgetall, :hkeys, :hlen, :hvals, :hmset, :incr, :linsert,
-        # :llen, :lpop, :lpush, :lpushx, :lrem, :lset, :ltrim,
-        # :persist, :pttl, :hscan, :rpop, :rpush, :rpushx, :sadd,
-        # :scard, :sismember, :smembers, :strlen, :sort, :spop,
-        # :srandmember, :srem, :sscan, :ttl, :type, :zadd, :zcard,
-        # :zcount, :zincrby, :zrangebyscore, :zrank, :zrem,
-        # :zremrangebyscore, :zrevrank, :zrevrangebyscore, :zscore
-        #
-        # For the operations in NO_KEY_OPS (above) we only collect
-        # KVOp (no KVKey)
-
-        def self.included(klass)
-          # We wrap two of the Redis methods to instrument
-          # operations
-          SolarWindsAPM::Util.method_alias(klass, :call, ::Redis::Client)
-          SolarWindsAPM::Util.method_alias(klass, :call_pipeline, ::Redis::Client)
-        end
-
-        # Given any Redis operation command array, this method
-        # extracts the Key/Values to report to the SolarWinds         # dashboard.
-        #
-        # @param command [Array] the Redis operation array
-        # @param r [Return] the return value from the operation
-        # @return [Hash] the Key/Values to report
-        def extract_trace_details(command, r)
-          kvs = {}
-          op = command.first
-
-          kvs[:KVOp] = command[0]
-          kvs[:RemoteHost] = @options[:host]
-          unless NO_KEY_OPS.include?(op) || op == :del && command[1..-1].flatten.count > 1
-            if command[1].is_a?(Array)
-              kvs[:KVKey] = command[1].first
-            else
-              kvs[:KVKey] = command[1]
-            end
-          end
-
-          if KV_COLLECT_MAP[op]
-            # Extract KVs from command for this op
-            KV_COLLECT_MAP[op].each { |k, v| kvs[k] = command[v] }
-          else
-            # This case statement handle special cases not handled
-            # by KV_COLLECT_MAP
-            case op
-            when :set
-              if command.count > 3
-                if command[3].is_a?(Hash)
-                  options = command[3]
-                  kvs[:ex] = options[:ex] if options.key?(:ex)
-                  kvs[:px] = options[:px] if options.key?(:px)
-                  kvs[:nx] = options[:nx] if options.key?(:nx)
-                  kvs[:xx] = options[:xx] if options.key?(:xx)
-                else
-                  options = command[3..-1]
-                  until (opts = options.shift(2)).empty?
-                    case opts[0]
-                    when 'EX' then; kvs[:ex] = opts[1]
-                    when 'PX' then; kvs[:px] = opts[1]
-                    when 'NX' then; kvs[:nx] = opts[1]
-                    when 'XX' then; kvs[:xx] = opts[1]
-                    end
-                  end
-                end
-              end
-
-            when :get
-              kvs[:KVHit] = r.nil? ? 0 : 1
-
-            when :hdel, :hexists, :hget, :hset, :hsetnx
-              kvs[:field] = command[2] unless command[2].is_a?(Array)
-              if op == :hget
-                kvs[:KVHit] = r.nil? ? 0 : 1
-              end
-
-            when :eval
-              if command[1].length > 1024
-                kvs[:Script] = command[1][0..1023] + '(...snip...)'
-              else
-                kvs[:Script] = command[1]
-              end
-
-            when :script
-              kvs[:subcommand] = command[1]
-              kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:redis][:collect_backtraces]
-              if command[1] == 'load'
-                if command[1].length > 1024
-                  kvs[:Script] = command[2][0..1023] + '(...snip...)'
-                else
-                  kvs[:Script] = command[2]
-                end
-              elsif command[1] == :exists
-                if command[2].is_a?(Array)
-                  kvs[:KVKey] = command[2].inspect
-                else
-                  kvs[:KVKey] = command[2]
-                end
-              end
-
-            when :mget
-              if command[1].is_a?(Array)
-                kvs[:KVKeyCount] = command[1].count
-              else
-                kvs[:KVKeyCount] = command.count - 1
-              end
-              values = r.select { |i| i }
-              kvs[:KVHitCount] = values.count
-
-            when :hmget
-              kvs[:KVKeyCount] = command.count - 2
-              values = r.select { |i| i }
-              kvs[:KVHitCount] = values.count
-
-            when :mset, :msetnx
-              if command[1].is_a?(Array)
-                kvs[:KVKeyCount] = command[1].count / 2
-              else
-                kvs[:KVKeyCount] = (command.count - 1) / 2
-              end
-            end # case op
-          end # if KV_COLLECT_MAP[op]
-        rescue StandardError => e
-          SolarWindsAPM.logger.debug "[solarwinds_apm/redis] Error collecting redis KVs: #{e.message}"
-          SolarWindsAPM.logger.debug e.backtrace.join('\n')
-        ensure
-          return kvs
-        end
-
-        # Extracts the Key/Values to report from a pipelined
-        # call to the SolarWinds dashboard.
-        #
-        # @param pipeline [Redis::Pipeline] the Redis pipeline instance
-        # @return [Hash] the Key/Values to report
-        def extract_pipeline_details(pipeline)
-          kvs = {}
-
-          kvs[:RemoteHost] = @options[:host]
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:redis][:collect_backtraces]
-
-          command_count = pipeline.commands.count
-          kvs[:KVOpCount] = command_count
-
-          kvs[:KVOp] = if pipeline.commands.first == :multi
-            :multi
-          else
-            :pipeline
-          end
-
-          # Report pipelined operations  if the number
-          # of ops is reasonable
-          if command_count < 12
-            ops = []
-            pipeline.commands.each do |c|
-              ops << c.first
-            end
-            kvs[:KVOps] = ops.join(', ')
-          end
-        rescue StandardError => e
-          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Error extracting pipelined commands: #{e.message}"
-          SolarWindsAPM.logger.debug e.backtrace
-        ensure
-          return kvs
-        end
-
-        #
-        # The wrapper method for Redis::Client.call.  Here
-        # (when tracing) we capture KVs to report and pass
-        # the call along
-        #
-        def call_with_sw_apm(command, &block)
-          if SolarWindsAPM.tracing?
-            SolarWindsAPM::API.log_entry(:redis, {})
-
-            begin
-              r = call_without_sw_apm(command, &block)
-              report_kvs = extract_trace_details(command, r)
-              r
-            rescue StandardError => e
-              SolarWindsAPM::API.log_exception(:redis, e)
-              raise
-            ensure
-              SolarWindsAPM::API.log_exit(:redis, report_kvs)
-            end
-
-          else
-            call_without_sw_apm(command, &block)
-          end
-        end
-
-        #
-        # The wrapper method for Redis::Client.call_pipeline.  Here
-        # (when tracing) we capture KVs to report and pass the call along
-        #
-        def call_pipeline_with_sw_apm(pipeline)
-          if SolarWindsAPM.tracing?
-            # Fall back to the raw tracing API so we can pass KVs
-            # back on exit (a limitation of the SolarWindsAPM::API.trace
-            # block method)  This removes the need for an info
-            # event to send additonal KVs
-            SolarWindsAPM::API.log_entry(:redis, {})
-
-            report_kvs = extract_pipeline_details(pipeline)
-
-            begin
-              call_pipeline_without_sw_apm(pipeline)
-            rescue StandardError => e
-              SolarWindsAPM::API.log_exception(:redis, e)
-              raise
-            ensure
-              SolarWindsAPM::API.log_exit(:redis, report_kvs)
-            end
-          else
-            call_pipeline_without_sw_apm(pipeline)
-          end
-        end
-      end
-    end
-  end
-end
-
-if SolarWindsAPM::Config[:redis][:enabled]
-  if defined?(::Redis) && ::Redis::VERSION < '5' && ::Redis::VERSION > '3'
-    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting redis' if SolarWindsAPM::Config[:verbose]
-    SolarWindsAPM::Util.send_include(::Redis::Client, SolarWindsAPM::Inst::RedisV4::Client)
-  end
-end

data/lib/solarwinds_apm/inst/resque.rb

@@ -1,129 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-require 'socket'
-require 'json'
-
-module SolarWindsAPM
-  module Inst
-    module ResqueClient
-
-      self.include SolarWindsAPM::SDK::TraceContextHeaders
-
-      def extract_trace_details(klass, args)
-        report_kvs = {}
-
-        begin
-          report_kvs[:Spec] = :pushq
-          report_kvs[:Flavor] = :resque
-          report_kvs[:JobName] = klass.to_s
-
-          if SolarWindsAPM::Config[:resqueclient][:log_args]
-            kv_args = args.to_json
-
-            # Limit the argument json string to 1024 bytes
-            if kv_args.length > 1024
-              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
-            else
-              report_kvs[:Args] = kv_args
-            end
-          end
-          report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:resqueclient][:collect_backtraces]
-          report_kvs[:Queue] = klass.instance_variable_get(:@queue)
-        rescue => e
-          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
-        end
-
-        report_kvs
-      end
-
-      def push(queue, item)
-        if SolarWindsAPM.tracing?
-          report_kvs = extract_trace_details(item[:class], item[:args])
-          report_kvs[:Queue] = queue.to_s if queue
-
-          SolarWindsAPM::SDK.trace(:'resque-client', kvs: report_kvs) do
-            add_tracecontext_headers(item)
-            super
-          end
-        else
-          super
-        end
-      end
-
-      def dequeue(klass, *args)
-        if SolarWindsAPM.tracing?
-          report_kvs = extract_trace_details(klass, args)
-          SolarWindsAPM::SDK.trace(:'resque-client', kvs: report_kvs) do
-            super(klass, *args)
-          end
-        else
-          super(klass, *args)
-        end
-      end
-    end
-
-    module ResqueJob
-
-      def perform
-        report_kvs = {}
-
-        begin
-          report_kvs[:Spec] = :job
-          report_kvs[:Flavor] = :resque
-          report_kvs[:JobName] = payload['class'].to_s
-          report_kvs[:Queue] = queue.to_s
-
-          # Set these keys for the ability to separate out
-          # background tasks into a separate app on the server-side UI
-
-          report_kvs[:'HTTP-Host'] = Socket.gethostname
-          report_kvs[:Controller] = "Resque_#{queue}"
-          report_kvs[:Action] = payload['class'].to_s
-          report_kvs[:URL] = "/resque/#{queue}/#{payload['class']}"
-
-          if SolarWindsAPM::Config[:resqueworker][:log_args]
-            kv_args = payload['args'].to_json
-
-            # Limit the argument json string to 1024 bytes
-            if kv_args.length > 1024
-              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
-            else
-              report_kvs[:Args] = kv_args
-            end
-          end
-
-          report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:resqueworker][:collect_backtraces]
-        rescue => e
-          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
-        end
-
-        SolarWindsAPM::SDK.start_trace('resque-worker', kvs: report_kvs, headers: payload) do
-          super
-        end
-
-        def fail(exception)
-          if SolarWindsAPM.tracing?
-            SolarWindsAPM::API.log_exception(:resque, exception)
-          end
-          super(exception)
-        end
-      end
-    end
-  end
-end
-
-if defined?(::Resque)
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting resque' if SolarWindsAPM::Config[:verbose]
-
-  if SolarWindsAPM::Config[:resqueclient][:enabled]
-    ::Resque.singleton_class.prepend(SolarWindsAPM::Inst::ResqueClient)
-    ::Resque.singleton_class.prepend(SolarWindsAPM::Inst::ResqueClient)
-  end
-
-  if SolarWindsAPM::Config[:resqueclient][:enabled] || SolarWindsAPM::Config[:resqueworker][:enabled]
-    Resque::Job.prepend(SolarWindsAPM::Inst::ResqueJob)
-  end
-end
-
-

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

@@ -1,43 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module RestClientRequest
-      include SolarWindsAPM::SDK::TraceContextHeaders
-
-      ##
-      # execute
-      #
-      # The wrapper method for RestClient::Request.execute
-      #
-      def execute(&block)
-        unless SolarWindsAPM.tracing?
-          add_tracecontext_headers(@processed_headers)
-          return super(&block)
-        end
-
-        begin
-          kvs = {}
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:rest_client][:collect_backtraces]
-          SolarWindsAPM::API.log_entry('rest-client', kvs)
-
-          add_tracecontext_headers(@processed_headers)
-
-          # The core rest-client call
-          super(&block)
-        rescue => e
-          SolarWindsAPM::API.log_exception('rest-client', e)
-          raise e
-        ensure
-          SolarWindsAPM::API.log_exit('rest-client')
-        end
-      end
-    end
-  end
-end
-
-if defined?(RestClient) && SolarWindsAPM::Config[:rest_client][:enabled]
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting rest-client' if SolarWindsAPM::Config[:verbose]
-  RestClient::Request.prepend(SolarWindsAPM::Inst::RestClientRequest)
-end

data/lib/solarwinds_apm/inst/sequel.rb

@@ -1,241 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    ##
-    # SolarWindsAPM::Inst::Sequel
-    #
-    # The common (shared) methods used by the SolarWindsAPM Sequel instrumentation
-    # across multiple modules/classes.
-    #
-    module Sequel
-      ##
-      # assign_kvs
-      #
-      # Given SQL and the options hash, this method extracts the interesting
-      # bits for reporting to the SolarWinds dashboard.
-      #
-      # kvs is a hash and we are taking advantage of using it by reference to
-      # assign kvs to the exit event (important for trace injection)
-      #
-      def assign_kvs(sql, opts, kvs)
-        unless sql.is_a?(String)
-          kvs[:IsPreparedStatement] = true
-        end
-
-        if ::Sequel::VERSION > '4.36.0' && !sql.is_a?(String)
-          # TODO check if this is true for all sql
-          # In 4.37.0, sql was converted to a prepared statement object
-          sql = sql.prepared_sql unless sql.is_a?(Symbol)
-        end
-
-        if SolarWindsAPM::Config[:sanitize_sql]
-          # Sanitize SQL and don't report binds
-          if sql.is_a?(Symbol)
-            kvs[:Query] = sql
-          else
-            sql = SolarWindsAPM::Util.remove_traceparent(sql)
-            kvs[:Query] = SolarWindsAPM::Util.sanitize_sql(sql)
-          end
-        else
-          # Report raw SQL and any binds if they exist
-          kvs[:Query] = SolarWindsAPM::Util.remove_traceparent(sql.to_s)
-          kvs[:QueryArgs] = opts[:arguments] if opts.is_a?(Hash) && opts.key?(:arguments)
-        end
-
-        kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:sequel][:collect_backtraces]
-
-        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
-          db_opts = @opts
-        elsif @pool
-          db_opts = @pool.db.opts
-        else
-          db_opts = @db.opts
-        end
-
-        kvs[:Database]   = db_opts[:database]
-        kvs[:RemoteHost] = db_opts[:host]
-        kvs[:RemotePort] = db_opts[:port] if db_opts.key?(:port)
-        kvs[:Flavor]     = db_opts[:adapter]
-      rescue => e
-        SolarWindsAPM.logger.debug "[solarwinds_apm/debug Error capturing Sequel KVs: #{e.message}" if SolarWindsAPM::Config[:verbose]
-      end
-
-      ##
-      # exec_with_sw_apm
-      #
-      # This method wraps and routes the call to the specified
-      # original method call
-      #
-      def exec_with_sw_apm(method, sql, opts = ::Sequel::OPTS, &block)
-        kvs = {}
-        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
-          new_sql = add_traceparent(sql, kvs)
-          assign_kvs(new_sql, opts, kvs) if SolarWindsAPM.tracing?
-          send(method, new_sql, opts, &block)
-        end
-      end
-
-      def add_traceparent(sql, kvs)
-        return sql unless SolarWindsAPM.tracing? && SolarWindsAPM::Config[:tag_sql]
-
-        case sql
-        when String
-          return SolarWindsAPM::SDK.current_trace_info.add_traceparent_to_sql(sql, kvs)
-        when Symbol
-          if defined?(prepared_statement) # for mysql2
-            ps = prepared_statement(sql)
-            new_ps = add_traceparent_to_ps(ps, kvs)
-            set_prepared_statement(sql, new_ps)
-            return sql # related query may have been modified
-          elsif self.is_a?(::Sequel::Dataset) # for postgresql
-            ps = self
-            new_ps = add_traceparent_to_ps(ps, kvs)
-            self.db.set_prepared_statement(sql, new_ps)
-            return sql
-          end
-        when ::Sequel::Dataset::ArgumentMapper # for mysql2
-          new_sql = add_traceparent_to_ps(sql, kvs)
-          return new_sql # related query may have been modified
-        end
-        sql # return original when none of the cases match
-      end
-
-      # this method uses some non-api methods partially copied from
-      # `execute_prepared_statement` in `mysql2.rb`
-      # and `prepare` in `prepared_statements.rb` in the sequel gem
-      def add_traceparent_to_ps(ps, kvs)
-        sql = ps.prepared_sql
-        new_sql = SolarWindsAPM::SDK.current_trace_info.add_traceparent_to_sql(sql, kvs)
-
-        unless new_sql == sql
-          new_ps = ps.clone(:prepared_sql=>new_sql, :sql=>new_sql)
-          return new_ps
-        end
-
-        ps # no change, no trace context added
-      end
-    end
-
-    module SequelDatabase
-      include SolarWindsAPM::Inst::Sequel
-
-      def self.included(klass)
-        SolarWindsAPM::Util.method_alias(klass, :run, ::Sequel::Database)
-        SolarWindsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
-        SolarWindsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
-        SolarWindsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
-      end
-
-      def run_with_sw_apm(sql, opts = ::Sequel::OPTS)
-        kvs = {}
-        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
-          new_sql = add_traceparent(sql, kvs)
-          assign_kvs(new_sql, opts, kvs) if SolarWindsAPM.tracing?
-          run_without_sw_apm(new_sql, opts)
-        end
-      end
-
-      def execute_ddl_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        # If we're already tracing a sequel operation, then this call likely came
-        # from Sequel::Dataset.  In this case, just pass it on.
-        return execute_ddl_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
-
-        exec_with_sw_apm(:execute_ddl_without_sw_apm, sql, opts, &block)
-      end
-
-      def execute_dui_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        # If we're already tracing a sequel operation, then this call likely came
-        # from Sequel::Dataset.  In this case, just pass it on.
-        return execute_dui_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
-
-        exec_with_sw_apm(:execute_dui_without_sw_apm, sql, opts, &block)
-      end
-
-      def execute_insert_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        # If we're already tracing a sequel operation, then this call likely came
-        # from Sequel::Dataset.  In this case, just pass it on.
-        return execute_insert_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
-
-        exec_with_sw_apm(:execute_insert_without_sw_apm, sql, opts, &block)
-      end
-    end # module SequelDatabase
-
-    module AdapterDatabase
-      include SolarWindsAPM::Inst::Sequel
-
-      def self.included(klass)
-        if defined?(::Sequel::MySQL::MysqlMysql2::DatabaseMethods)
-          SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::MySQL::MysqlMysql2::DatabaseMethods)
-        end
-        if defined?(::Sequel::Postgres::Database)
-          SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::Postgres::Database)
-        end
-      end
-
-      def execute_with_sw_apm(*args, &block)
-        # if this is called via a dataset it is already being traced
-        return execute_without_sw_apm(*args, &block) if SolarWindsAPM.tracing_layer?(:sequel)
-
-        kvs = {}
-        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
-          new_sql = add_traceparent(args[0], kvs)
-          args[0] = new_sql
-          assign_kvs(args[0], args[1], kvs) if SolarWindsAPM.tracing?
-          execute_without_sw_apm(*args, &block)
-        end
-      end
-    end
-
-    module SequelDataset
-      include SolarWindsAPM::Inst::Sequel
-
-      def self.included(klass)
-        SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::Dataset)
-        SolarWindsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
-        SolarWindsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
-        SolarWindsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
-      end
-
-      def execute_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        exec_with_sw_apm(:execute_without_sw_apm, sql, opts, &block)
-      end
-
-      def execute_ddl_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        exec_with_sw_apm(:execute_ddl_without_sw_apm, sql, opts, &block)
-      end
-
-      def execute_dui_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        exec_with_sw_apm(:execute_dui_without_sw_apm, sql, opts, &block)
-      end
-
-      def execute_insert_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
-        exec_with_sw_apm(:execute_insert_without_sw_apm, sql, opts, &block)
-      end
-
-    end # module SequelDataset
-  end # module Inst
-end # module SolarWindsAPM
-
-if SolarWindsAPM::Config[:sequel][:enabled]
-  if defined?(::Sequel) && ::Sequel::VERSION < '4.0.0'
-    # For versions before 4.0.0, Sequel::OPTS wasn't defined.
-    # Define it as an empty hash for backwards compatibility.
-    module ::Sequel
-      OPTS = {}
-    end
-  end
-
-  if defined?(::Sequel)
-    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting sequel' if SolarWindsAPM::Config[:verbose]
-    SolarWindsAPM::Util.send_include(::Sequel::Database, SolarWindsAPM::Inst::SequelDatabase)
-    SolarWindsAPM::Util.send_include(::Sequel::Dataset, SolarWindsAPM::Inst::SequelDataset)
-
-    # TODO this is temporary, we need to instrument `require`, see NH-9711
-    require 'sequel/adapters/mysql2'
-    SolarWindsAPM::Util.send_include(::Sequel::MySQL::MysqlMysql2::DatabaseMethods, SolarWindsAPM::Inst::AdapterDatabase)
-    require 'sequel/adapters/postgres'
-    SolarWindsAPM::Util.send_include(::Sequel::Postgres::Database, SolarWindsAPM::Inst::AdapterDatabase)
-  end
-end