solarwinds_apm 5.1.8 → 6.0.0.preV1

data/lib/solarwinds_apm/inst/rack.rb

@@ -1,223 +0,0 @@
-# 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
-              if defined?(SolarWindsAPM::Profiling)
-                SolarWindsAPM::Profiling.run do
-                  SolarWindsAPM::TransactionMetrics.metrics(env, settings) do
-                    @app.call(env)
-                  end
-                end
-              else
-                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

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

@@ -1,280 +0,0 @@
-# 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)
-          # call_pipelined is alias of call in redisclient middlewares
-          SolarWindsAPM::Util.method_alias(klass, :call, ::RedisClient)
-          SolarWindsAPM::Util.method_alias(klass, :call_pipelined, ::RedisClient)
-        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, config)
-          SolarWindsAPM.logger.debug "extract_trace_details command => #{command.inspect}"
-          kvs = {}
-          op = command.first
-          op = op.to_sym
-
-          kvs[:KVOp] = command[0]
-          kvs[:RemoteHost] = config.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] && command[3]) # replace the idiom of 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]
-          # turn every string into number
-          # kvs.each do |k,v|
-          #   kvs[k] = v.to_i if v.is_a(String)
-          # end
-        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(commands, config)
-          SolarWindsAPM.logger.debug "extract_pipeline_details command => #{commands.inspect}"
-          kvs = {}
-
-          kvs[:RemoteHost] = config.host
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:redis][:collect_backtraces]
-
-          command_count = commands.count
-          kvs[:KVOpCount] = command_count
-
-          kvs[:KVOp] = if commands.first == :multi
-            :multi
-          else
-            :pipeline
-          end
-
-          # Report pipelined operations  if the number
-          # of ops is reasonable
-          if command_count < 12
-            ops = []
-            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 RedisClient.call.  Here
-        # (when tracing) we capture KVs to report and pass
-        # the call along
-        #
-        def call_with_sw_apm(command, config, &block)
-          SolarWindsAPM.logger.debug "call_with_sw_apm command => #{command.inspect}"
-          if SolarWindsAPM.tracing?
-            SolarWindsAPM::API.log_entry(:redis, {})
-
-            begin
-              r = call_without_sw_apm(command, config, &block)
-              report_kvs = extract_trace_details(command, r, config)
-              SolarWindsAPM.logger.debug "call_with_sw_apm command => #{report_kvs.inspect}"
-              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, config, &block)
-          end
-        end
-
-        #
-        # The wrapper method for RedisClient.call_pipeline.  Here
-        # (when tracing) we capture KVs to report and pass the call along
-        # 5.0.0 + removed the deprecated pipelined and multi signature. Commands now MUST be called on the block argument, not the original redis instance
-        def call_pipelined_with_sw_apm(commands, config, &block)
-          SolarWindsAPM.logger.debug "call_pipelined_with_sw_apm command => #{commands.inspect}"
-          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(commands, config)
-            begin
-              call_pipelined_without_sw_apm(commands, config, &block)
-            rescue StandardError => e
-              SolarWindsAPM::API.log_exception(:redis, e)
-              raise
-            ensure
-              SolarWindsAPM::API.log_exit(:redis, report_kvs)
-            end
-          else
-            call_pipelined_without_sw_apm(commands, config, &block)
-          end
-        end
-      end
-    end
-  end
-end
-
-if SolarWindsAPM::Config[:redis][:enabled]
-  if defined?(::RedisClient)
-    SolarWindsAPM.logger.info "[solarwinds_apm/loading] Instrumenting redis through RedisClient #{RedisClient::VERSION}" if SolarWindsAPM::Config[:verbose]
-    ::RedisClient.register(SolarWindsAPM::Inst::Redis::Client)
-  end
-end