solarwinds_apm 5.0.0

data/lib/solarwinds_apm/inst/rack.rb

@@ -0,0 +1,217 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'uri'
+require 'cgi'
+
+if SolarWindsAPM.loaded
+  module SolarWindsAPM
+    ##
+    # SolarWindsAPM::Rack
+    #
+    # The SolarWindsAPM::Rack middleware used to sample a subset of incoming
+    # requests for instrumentation and reporting.  Tracing context can
+    # be received here (via the X-Trace HTTP header) or initiated here
+    # based on configured tracing mode.
+    #
+    # After the rack layer passes on to the following layers (Rails, Sinatra,
+    # Padrino, Grape), then the instrumentation downstream will
+    # automatically detect whether this is a sampled request or not
+    # and act accordingly.
+    #
+    class Rack
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+
+        # In the case of nested Ruby apps such as Grape inside of Rails
+        # or Grape inside of Grape, each app has it's own instance
+        # of rack middleware. We want to avoid tracing rack more than once
+        return @app.call(env) if SolarWindsAPM.tracing? && SolarWindsAPM.layer == :rack
+
+        # there may be a legit existing context that we need to continue
+        # we need to check if we marked a start in env
+        # env is specific per request
+        existing_context = false
+        if SolarWindsAPM::Context.isValid
+          existing_context = env['SW_APM_TRACE_STARTED'] == 'true'
+
+          if existing_context
+            # include or override tracecontext in env, so that the current context gets continued
+            add_tracecontext_headers(env)
+          else
+            SolarWindsAPM::Context.clear
+          end
+        end
+
+        SolarWindsAPM.transaction_name = nil
+
+        url = env['PATH_INFO']
+        options = SolarWindsAPM::XTraceOptions.new(env['HTTP_X_TRACE_OPTIONS'], env['HTTP_X_TRACE_OPTIONS_SIGNATURE'])
+
+        # store incoming information in a thread local variable
+        settings = SolarWindsAPM::TransactionSettings.new(url, env, options)
+
+        profile_spans = SolarWindsAPM::Config['profiling'] == :enabled ? 1 : -1
+
+        response =
+          propagate_tracecontext(env, settings) do
+            sample(env, settings, options, profile_spans) do
+              SolarWindsAPM::Profiling.run do
+                SolarWindsAPM::TransactionMetrics.metrics(env, settings) do
+                  @app.call(env)
+                end
+              end
+            end
+          end || [500, {}, nil]
+        options.add_response_header(response[1], settings)
+
+        unless existing_context
+          SolarWindsAPM::Context.clear
+          SolarWindsAPM.trace_context = nil
+        end
+        response
+      rescue
+        unless existing_context
+          SolarWindsAPM::Context.clear
+          SolarWindsAPM.trace_context = nil
+        end
+        raise
+        # can't use ensure for Context.clearing, because the Grape middleware
+        # needs the context in case of an error, it is somewhat convoluted ...
+      end
+
+      def self.noop?
+        false
+      end
+
+      private
+
+      def collect(env)
+        req = ::Rack::Request.new(env)
+        report_kvs = {}
+
+        begin
+          report_kvs[:'HTTP-Host']      = req.host
+          report_kvs[:Port]             = req.port
+          report_kvs[:Proto]            = req.scheme
+          report_kvs[:Method]           = req.request_method
+          report_kvs[:AJAX]             = true if req.xhr?
+          report_kvs[:ClientIP]         = req.ip
+
+          if SolarWindsAPM::Config[:rack][:log_args]
+            report_kvs[:'Query-String'] = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+          end
+
+          report_kvs[:URL] = SolarWindsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
+          report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::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')
+          report_kvs[:'Queue-Time']        = env['HTTP_X_QUEUE_TIME']       if env.key?('HTTP_X_QUEUE_TIME')
+
+          report_kvs[:'Forwarded-For']     = env['HTTP_X_FORWARDED_FOR']    if env.key?('HTTP_X_FORWARDED_FOR')
+          report_kvs[:'Forwarded-Host']    = env['HTTP_X_FORWARDED_HOST']   if env.key?('HTTP_X_FORWARDED_HOST')
+          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.SolarWindsAPM.Version'] = SolarWindsAPM::Version::STRING
+          report_kvs[:ProcessID]         = Process.pid
+          report_kvs[:ThreadID]          = Thread.current.to_s[/0x\w*/]
+        rescue StandardError => e
+          # Discard any potential exceptions. Debug log and report whatever we can.
+          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Rack KV collection error: #{e.inspect}"
+        end
+        report_kvs
+      end
+
+      # this adds x-trace info to the request and return header
+      # if it is not a request for an asset (defined in config file as 'dnt')
+      def propagate_tracecontext(env, settings)
+        return yield unless settings.do_propagate
+
+        if SolarWindsAPM.trace_context&.tracestring
+          # creating a dup because we are modifying it when setting/unsetting the sampling bit
+          tracestring_dup = SolarWindsAPM.trace_context.tracestring.dup
+          if settings.do_sample
+            SolarWindsAPM::TraceString.set_sampled(tracestring_dup)
+          else
+            SolarWindsAPM::TraceString.unset_sampled(tracestring_dup)
+          end
+          env['HTTP_TRACEPARENT'] = tracestring_dup
+          env['HTTP_TRACESTATE'] = SolarWindsAPM::TraceState.add_sw_member(
+            SolarWindsAPM.trace_context&.tracestate,
+            SolarWindsAPM::TraceString.span_id_flags(tracestring_dup)
+          )
+        end
+
+        status, headers, response = yield
+
+        # TODO this will be finalized when we have a spec for w3c response headers
+        headers ||= {}
+        headers['X-Trace'] = SolarWindsAPM::Context.toString if SolarWindsAPM::Context.isValid
+
+        [status, headers, response]
+      end
+
+      def sample(env, settings, options, profile_spans)
+        if settings.do_sample
+          begin
+            report_kvs = collect(env)
+            settings.add_kvs(report_kvs)
+            options&.add_kvs(report_kvs, settings)
+
+            SolarWindsAPM::API.log_start(:rack, report_kvs, env, settings)
+            # mark the trace as started for this request
+            env['SW_APM_TRACE_STARTED'] = 'true'
+
+            status, headers, response = yield
+
+            SolarWindsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: SolarWindsAPM.transaction_name,
+                                                ProfileSpans: profile_spans })
+
+            [status, headers, response]
+          rescue Exception => e
+            # it is ok to rescue Exception here because we are reraising it (we just need a chance to log_end)
+            SolarWindsAPM::API.log_exception(:rack, e)
+            SolarWindsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: SolarWindsAPM.transaction_name,
+                                                ProfileSpans: profile_spans
+                                              })
+            raise
+          end
+        else
+          SolarWindsAPM::API.create_nontracing_context(SolarWindsAPM.trace_context.tracestring)
+          yield
+        end
+      end
+
+    end
+  end
+else
+  module SolarWindsAPM
+    class Rack
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def self.noop?
+        true
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/inst/rack_cache.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2020 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module RackCacheContext
+
+    ###
+    # This adds a controller.action like transaction name for
+    # requests directly served from the cache without involving a controller.
+    # The resulting transaction name is `rack-cache.<cache-store>`,
+    # e.g. `rack-cache.memcached`
+    #
+    # It is not a full instrumentation, no span is added.
+    #
+    def call!(env)
+      metastore_type = begin
+        if options['rack-cache.metastore']
+          options['rack-cache.metastore'].match(/^([^\:]*)\:/)[1]
+        end || 'unknown_store'
+      rescue
+        'unknown_store'
+      end
+
+      env['solarwinds_apm.action'] = metastore_type
+      env['solarwinds_apm.controller'] = 'rack-cache'
+
+      super
+    end
+  end
+end
+
+if SolarWindsAPM::Config[:rack_cache][:transaction_name] && defined?(Rack::Cache::Context)
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting rack_cache' if SolarWindsAPM::Config[:verbose]
+  Rack::Cache::Context.send(:prepend, ::SolarWindsAPM::RackCacheContext)
+end

data/lib/solarwinds_apm/inst/redis.rb

@@ -0,0 +1,273 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    module Redis
+      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) && Gem::Version.new(Redis::VERSION) >= Gem::Version.new('3.0.0')
+    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting redis' if SolarWindsAPM::Config[:verbose]
+    SolarWindsAPM::Util.send_include(Redis::Client, SolarWindsAPM::Inst::Redis::Client)
+  end
+end

data/lib/solarwinds_apm/inst/resque.rb

@@ -0,0 +1,129 @@
+# 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

@@ -0,0 +1,43 @@
+# 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