solarwinds_apm 5.1.9 → 6.0.0.preV2

data/lib/solarwinds_apm/inst/dalli.rb

@@ -1,89 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module Dalli
-      include SolarWindsAPM::API::Memcache
-
-      def self.included(cls)
-        cls.class_eval do
-          SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting memcache (dalli)' if SolarWindsAPM::Config[:verbose]
-          if ::Dalli::Client.private_method_defined? :perform
-            alias perform_without_sw_apm perform
-            alias perform perform_with_sw_apm
-          else
-            SolarWindsAPM.logger.warn '[solarwinds_apm/loading] Couldn\'t properly instrument Memcache (Dalli).  Partial traces may occur.'
-          end
-
-          if ::Dalli::Client.method_defined? :get_multi
-            alias get_multi_without_sw_apm get_multi
-            alias get_multi get_multi_with_sw_apm
-          end
-        end
-      end
-
-      def perform_with_sw_apm(*all_args, &blk)
-        op, key, *args = *all_args
-
-        report_kvs = {}
-        report_kvs[:KVOp] = op
-        report_kvs[:KVKey] = key
-
-        servers = @servers || @normalized_servers # name change since Dall 3.2.0
-        if servers.is_a?(Array) && !servers.empty?
-          report_kvs[:RemoteHost] = servers.join(", ")
-        end
-
-        if SolarWindsAPM.tracing? && !SolarWindsAPM.tracing_layer_op?(:get_multi)
-          SolarWindsAPM::SDK.trace(:memcache, kvs: report_kvs) do
-            result = perform_without_sw_apm(*all_args, &blk)
-
-            # Clear the hash for a potential info event
-            report_kvs.clear
-            report_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
-            report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:dalli][:collect_backtraces]
-
-            result
-          end
-        else
-          perform_without_sw_apm(*all_args, &blk)
-        end
-      end
-
-      def get_multi_with_sw_apm(*keys)
-        return get_multi_without_sw_apm(*keys) unless SolarWindsAPM.tracing?
-
-        info_kvs = {}
-
-        begin
-          info_kvs[:KVKeyCount] = keys.flatten.length
-          info_kvs[:KVKeyCount] = (info_kvs[:KVKeyCount] - 1) if keys.last.is_a?(Hash) || keys.last.nil?
-
-          servers = @servers || @normalized_servers # name change since Dalli 3.2.1
-          if servers.is_a?(Array) && !servers.empty?
-            info_kvs[:RemoteHost] = servers.join(", ")
-          end
-        rescue => e
-          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
-        end
-
-        info_kvs[:KVOp] = :get_multi
-        info_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:dalli][:collect_backtraces]
-        SolarWindsAPM::SDK.trace(:memcache, kvs: info_kvs, protect_op: :get_multi) do
-          values = get_multi_without_sw_apm(*keys)
-
-          info_kvs[:KVHitCount] = values.length
-
-          values
-        end
-      end
-    end
-  end
-end
-
-if defined?(Dalli) && SolarWindsAPM::Config[:dalli][:enabled]
-  ::Dalli::Client.module_eval do
-    include SolarWindsAPM::Inst::Dalli
-  end
-end

data/lib/solarwinds_apm/inst/delayed_job.rb

@@ -1,100 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-if defined?(Delayed)
-  module SolarWindsAPM
-    module Inst
-      module DelayedJob
-        ##
-        # ForkHandler
-        #
-        # Since delayed job doesn't offer a hook into `after_fork`, we alias the method
-        # here to do our magic after a fork happens.
-        #
-        module ForkHandler
-          def self.extended(klass)
-            SolarWindsAPM::Util.class_method_alias(klass, :after_fork, ::Delayed::Worker)
-          end
-
-          def after_fork_with_sw_apm
-            SolarWindsAPM.logger.info '[solarwinds_apm/delayed_job] Detected fork.  Restarting SolarWindsAPM reporter.' if SolarWindsAPM::Config[:verbose]
-            SolarWindsAPM::Reporter.restart unless ENV.key?('SW_APM_GEM_TEST')
-
-            after_fork_without_sw_apm
-          end
-        end
-
-        ##
-        # SolarWindsAPM::Inst::DelayedJob::Plugin
-        #
-        # The SolarWindsAPM DelayedJob plugin.  Here we wrap `enqueue` and
-        # `perform` to capture the timing of the bits we're interested in.
-        #
-        # Traces from the client are not continued in the consumer for a number
-        # of reasons:
-        # - no context propagation for delayed_job in OTEL
-        # - there is no reliable way to for the job to carry trace information. It
-        #   is an instance of a shared class they share,
-        #   often: Delayed::Backend::ActiveRecord::Job, but could be something else
-        # - It can also be too asynchronous for tracing to make sense. The worker can be
-        #   delayed by seconds/minutes/hours and the trace processing completed already
-        #
-        class Plugin < Delayed::Plugin
-          callbacks do |lifecycle|
-
-            # enqueue
-            if SolarWindsAPM::Config[:delayed_jobclient][:enabled]
-              lifecycle.around(:enqueue) do |job, &block|
-                begin
-                  report_kvs = {}
-                  report_kvs[:Spec] = :pushq
-                  report_kvs[:Flavor] = :DelayedJob
-                  report_kvs[:JobName] = job.name
-                  report_kvs[:MsgID] = job.id
-                  report_kvs[:Queue] = job.queue if job.queue
-                  report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:delayed_jobclient][:collect_backtraces]
-
-                  SolarWindsAPM::SDK.trace(:'delayed_job-client', kvs: report_kvs) do
-                    block.call(job)
-                  end
-                end
-              end
-            end
-
-            # invoke_job
-            if SolarWindsAPM::Config[:delayed_jobworker][:enabled]
-              lifecycle.around(:perform) do |worker, job, &block|
-                begin
-                  report_kvs = {}
-                  report_kvs[:Spec] = :job
-                  report_kvs[:Flavor] = :DelayedJob
-                  report_kvs[:JobName] = job.name
-                  report_kvs[:MsgID] = job.id
-                  report_kvs[:Queue] = job.queue if job.queue
-                  report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:delayed_jobworker][:collect_backtraces]
-
-                  # DelayedJob Specific KVs
-                  report_kvs[:priority] = job.priority
-                  report_kvs[:attempts] = job.attempts
-                  report_kvs[:WorkerName] = job.locked_by
-                rescue => e
-                  SolarWindsAPM.logger.warn "[solarwinds_apm/warning] inst/delayed_job.rb: #{e.message}"
-                end
-
-                SolarWindsAPM::SDK.start_trace(:'delayed_job-worker', kvs: report_kvs) do
-                  result = block.call(worker, job)
-                  SolarWindsAPM::API.log_exception(:'delayed_job-worker', job.error) if job.error
-                  result
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting delayed_job' if SolarWindsAPM::Config[:verbose]
-  SolarWindsAPM::Util.send_extend(::Delayed::Worker, SolarWindsAPM::Inst::DelayedJob::ForkHandler)
-  Delayed::Worker.plugins << SolarWindsAPM::Inst::DelayedJob::Plugin
-end

data/lib/solarwinds_apm/inst/excon.rb

@@ -1,113 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module ExconConnection
-      include SolarWindsAPM::SDK::TraceContextHeaders
-
-      private
-
-      def sw_apm_collect(params)
-        kvs = {}
-        kvs[:Spec] = 'rsc'
-        kvs[:IsService] = 1
-
-        # Conditionally log query args
-        if SolarWindsAPM::Config[:excon][:log_args] && @data[:query]
-          if @data[:query].is_a?(Hash)
-            service_arg = "#{@data[:path]}?#{URI.encode_www_form(@data[:query])}"
-          else
-            service_arg = "#{@data[:path]}?#{@data[:query]}"
-          end
-        else
-          service_arg = @data[:path]
-        end
-        kvs[:RemoteURL] = "#{@data[:scheme]}://#{@data[:host]}:#{@data[:port]}#{service_arg}"
-
-        # In the case of HTTP pipelining, params could be an array of
-        # request hashes.
-        if params.is_a?(Array)
-          methods = []
-          params.each do |p|
-            methods << SolarWindsAPM::Util.upcase(p[:method])
-          end
-          kvs[:HTTPMethods] = methods.join(',')[0..1024]
-          kvs[:Pipeline] = true
-        else
-          kvs[:HTTPMethod] = SolarWindsAPM::Util.upcase(params[:method])
-        end
-        kvs
-      rescue => e
-        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Error capturing excon KVs: #{e.message}"
-        SolarWindsAPM.logger.debug e.backtrace.join('\n') if SolarWindsAPM::Config[:verbose]
-      ensure
-        return kvs
-      end
-
-      public
-
-      def requests(pipeline_params)
-        responses = nil
-        kvs = sw_apm_collect(pipeline_params)
-        SolarWindsAPM::SDK.trace(:excon, kvs: kvs) do
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:excon][:collect_backtraces]
-          responses = super(pipeline_params)
-          kvs[:HTTPStatuses] = responses.map { |r| r.status }.join(',')
-        end
-        responses
-      end
-
-      def request(params = {}, &block)
-        # If we're not tracing, just do a fast return.
-        # If making HTTP pipeline requests (ordered batched)
-        # then just return as we're tracing from parent
-        # <tt>requests</tt>
-        if !SolarWindsAPM.tracing? || params[:pipeline]
-          add_tracecontext_headers(@data[:headers])
-          return super(params, &block)
-        end
-
-        begin
-          response_context = nil
-
-          kvs = sw_apm_collect(params)
-
-          SolarWindsAPM::API.log_entry(:excon, kvs)
-          kvs.clear
-
-          req_context = SolarWindsAPM::Context.toString
-
-          # The core excon call
-          add_tracecontext_headers(@data[:headers])
-          response = super(params, &block)
-
-          # excon only passes back a hash (datum) for HTTP pipelining...
-          # In that case, we should never arrive here but for the OCD, double check
-          # the datatype before trying to extract pertinent info
-          if response.is_a?(Excon::Response)
-            kvs[:HTTPStatus] = response.status
-
-            # If we get a redirect, report the location header
-            if ((300..308).to_a.include? response.status.to_i) && response.headers.key?('Location')
-              kvs[:Location] = response.headers['Location']
-            end
-          end
-
-          response
-        rescue => e
-          SolarWindsAPM::API.log_exception(:excon, e)
-          raise e
-        ensure
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:excon][:collect_backtraces]
-          SolarWindsAPM::API.log_exit(:excon, kvs) unless params[:pipeline]
-        end
-      end
-    end
-  end
-end
-
-if SolarWindsAPM::Config[:excon][:enabled] && defined?(Excon)
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting excon' if SolarWindsAPM::Config[:verbose]
-  Excon::Connection.prepend(SolarWindsAPM::Inst::ExconConnection)
-end

data/lib/solarwinds_apm/inst/faraday.rb

@@ -1,96 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-#####################################################
-# FYI:
-# Faraday only adds tracing when it is
-# not using an adapter that is instrumented
-#
-# otherwise we would get two spans for the same call
-#####################################################
-
-module SolarWindsAPM
-  module Inst
-    module FaradayConnection
-      include SolarWindsAPM::SDK::TraceContextHeaders
-
-      def run_request(method, url, body, headers, &block)
-        remote_call = remote_call?
-        unless SolarWindsAPM.tracing?
-          if remote_call
-            add_tracecontext_headers(@headers)
-          end
-          return super(method, url, body, headers, &block)
-        end
-
-        begin
-          SolarWindsAPM::API.log_entry(:faraday)
-          if remote_call # nothing else is instrumented that could add the w3c context
-            add_tracecontext_headers(@headers)
-          end
-
-          result = super(method, url, body, headers, &block)
-
-          kvs = {}
-
-          # this seems the safer condition than trying to identify the
-          # faraday version when adapter started to work without arg
-          # and handlers don't include the adapter anymore
-          if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
-            kvs[:Middleware] = @builder.handlers
-          else
-            kvs[:Middleware] = [@builder.adapter] + @builder.handlers
-          end
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:faraday][:collect_backtraces]
-
-          # Only send service KVs if we're not using an adapter
-          # Otherwise, the adapter instrumentation will send the service KVs
-          if remote_call
-            kvs.merge!(rsc_kvs(url, method, result))
-          end
-
-          result
-        rescue => e
-          SolarWindsAPM::API.log_exception(:faraday, e)
-          raise e
-        ensure
-          SolarWindsAPM::API.log_exit(:faraday, kvs)
-        end
-      end
-
-      private
-
-      # This is only considered a remote service call if the middleware/adapter is not instrumented
-      def remote_call?
-        if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
-          (@builder.handlers.map(&:name) & SW_APM_INSTR_ADAPTERS).count == 0
-        else
-          ((@builder.handlers.map(&:name) << @builder.adapter.name) & SW_APM_INSTR_ADAPTERS).count == 0
-        end
-      end
-
-      def rsc_kvs(_url, method, result)
-        kvs = { :Spec => 'rsc',
-                :IsService => 1,
-                :HTTPMethod => method.upcase,
-                :HTTPStatus => result.status, }
-        kvs[:RemoteURL] = result.env.to_hash[:url].to_s
-        kvs[:RemoteURL].split('?').first unless SolarWindsAPM::Config[:faraday][:log_args]
-
-        kvs
-      end
-    end
-  end
-end
-
-if defined?(Faraday) && SolarWindsAPM::Config[:faraday][:enabled]
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting faraday' if SolarWindsAPM::Config[:verbose]
-  Faraday::Connection.prepend(SolarWindsAPM::Inst::FaradayConnection)
-
-  SW_APM_INSTR_ADAPTERS = [] # ["Faraday::Adapter::NetHttp", "Faraday::Adapter::Excon", "Faraday::Adapter::Typhoeus"]
-
-  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::Typhoeus" if defined? Faraday::Adapter::Typhoeus
-  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::NetHttp" if defined? Faraday::Adapter::NetHttp
-  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::Excon" if defined? Faraday::Adapter::Excon
-  SW_APM_INSTR_ADAPTERS << "Faraday::Adapter::HTTPClient" if defined? Faraday::Adapter::HTTPClient
-end

data/lib/solarwinds_apm/inst/graphql.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# Copyright (c) 2019 SolarWinds, LLC.
-# All rights reserved.
-#++
-#
-
-##
-# Tracing for the graphql gem
-#
-# This instrumentation is autoloaded when a class inherits GraphQL::Schema
-# no need to call `tracer` or `use`
-
-
-if defined?(GraphQL::Tracing) && !(SolarWindsAPM::Config[:graphql][:enabled] == false)
-  module GraphQL
-    module Tracing
-
-      class SolarWindsAPMTracing < GraphQL::Tracing::PlatformTracing
-        # These GraphQL events will show up as 'graphql.prep' spans
-        PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
-        EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
-
-        self.platform_keys = {
-          'lex' => 'lex',
-          'parse' => 'parse',
-          'validate' => 'validate',
-          'analyze_query' => 'analyze_query',
-          'analyze_multiplex' => 'analyze_multiplex',
-          'execute_multiplex' => 'execute_multiplex',
-          'execute_query' => 'execute_query',
-          'execute_query_lazy' => 'execute_query_lazy'
-        }
-
-        def platform_trace(platform_key, _key, data)
-          return yield if gql_config[:enabled] == false
-
-          layer = span_name(platform_key)
-          kvs = metadata(data, layer)
-          kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
-
-          transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
-
-          ::SolarWindsAPM::SDK.trace(layer, kvs: kvs) do
-            kvs.clear # we don't have to send them twice
-            yield
-          end
-        end
-
-        def platform_field_key(type, field)
-          "graphql.#{type.graphql_name}.#{field.name}"
-        end
-
-        def platform_authorized_key(type)
-          "graphql.#{type.graphql_name}.authorized"
-        end
-
-        def platform_resolve_type_key(type)
-          "graphql.#{type.graphql_name}.resolve_type"
-        end
-
-        private
-
-        def gql_config
-          ::SolarWindsAPM::Config[:graphql] ||= {}
-        end
-
-        def transaction_name(query)
-          return if gql_config[:transaction_name] == false ||
-            ::SolarWindsAPM::SDK.get_transaction_name
-
-          split_query = query.strip.split(/\W+/, 3)
-          split_query[0] = 'query' if split_query[0].empty?
-          name = "graphql.#{split_query[0..1].join('.')}"
-
-          ::SolarWindsAPM::SDK.set_transaction_name(name)
-        end
-
-        def multiplex_transaction_name(names)
-          return if gql_config[:transaction_name] == false ||
-            ::SolarWindsAPM::SDK.get_transaction_name
-
-          name = "graphql.multiplex.#{names.join('.')}"
-          name = "#{name[0..251]}..." if name.length > 254
-
-          ::SolarWindsAPM::SDK.set_transaction_name(name)
-        end
-
-        def span_name(key)
-          return 'graphql.prep' if PREP_KEYS.include?(key)
-          return 'graphql.execute' if EXEC_KEYS.include?(key)
-
-          key[/^graphql\./] ? key : "graphql.#{key}"
-        end
-
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        def metadata(data, layer)
-          kvs = data.keys.map do |key|
-            case key
-            when :context
-              graphql_context(data[:context], layer)
-            when :query
-              graphql_query(data[:query])
-            when :query_string
-              graphql_query_string(data[:query_string])
-            when :multiplex
-              graphql_multiplex(data[:multiplex])
-            else
-              [key, data[key]] unless key == :path # we get the path from context
-            end
-          end
-
-          kvs.compact.flatten.each_slice(2).to_h.merge(Spec: 'graphql')
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-        def graphql_context(context, layer)
-          context.errors && context.errors.each do |err|
-            SolarWindsAPM::API.log_exception(layer, err)
-          end
-
-          [[:Path, context.path.join('.')]]
-        end
-
-        def graphql_query(query)
-          return [] unless query
-
-          query_string = query.query_string
-          query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
-          query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
-
-          [[:InboundQuery, query_string],
-           [:Operation, query.selected_operation_name]]
-        end
-
-        def graphql_query_string(query_string)
-          query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
-          query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
-
-          [:InboundQuery, query_string]
-        end
-
-        def graphql_multiplex(data)
-          names = data.queries.map(&:operations).map(&:keys).flatten.compact
-          multiplex_transaction_name(names) if names.size > 1
-
-          [:Operations, names.join(', ')]
-        end
-
-        def sanitize(query)
-          return unless query
-
-          # remove arguments
-          query.gsub(/"[^"]*"/, '"?"')                 # strings
-               .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
-               .gsub(/\[[^\]]*\]/, '[?]')              # arrays
-        end
-
-        def remove_comments(query)
-          return unless query
-
-          query.gsub(/#[^\n\r]*/, '')
-        end
-      end
-    end
-  end
-
-  module SolarWindsAPM
-    module GraphQLSchemaPrepend
-
-      # Graphql doesn't check if a plugin is added twice
-      # we would get double traces
-      def use(plugin, **options)
-        super unless self.plugins.find { |pl| pl[0].to_s == plugin.to_s }
-
-        self.plugins
-      end
-
-      def inherited(subclass)
-        subclass.use(GraphQL::Tracing::SolarWindsAPMTracing)
-        super
-      end
-    end
-
-    module GraphQLErrorPrepend
-      def initialize(*args)
-        super
-        bt = SolarWindsAPM::API.backtrace(1)
-        set_backtrace(bt) unless self.backtrace
-      end
-    end
-  end
-
-
-  if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.8.0')
-    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting GraphQL' if SolarWindsAPM::Config[:verbose]
-    if defined?(GraphQL::Schema)
-      GraphQL::Schema.singleton_class.prepend(SolarWindsAPM::GraphQLSchemaPrepend)
-    end
-
-    if defined?(GraphQL::Error)
-      GraphQL::Error.prepend(SolarWindsAPM::GraphQLErrorPrepend)
-    end
-  end
-end