solarwinds_apm 5.1.9 → 6.0.0.preV1

data/lib/solarwinds_apm/inst/grpc_client.rb

@@ -1,147 +0,0 @@
-# Copyright (c) 2018 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module GRPC
-
-    module ActiveCall
-      include SolarWindsAPM::SDK::TraceContextHeaders
-
-      if defined? ::GRPC
-        StatusCodes = {}
-        ::GRPC::Core::StatusCodes.constants.each { |code| StatusCodes[::GRPC::Core::StatusCodes.const_get(code)] = code }
-      end
-
-      def self.included(klass)
-        SolarWindsAPM::Util.method_alias(klass, :request_response, ::GRPC::ActiveCall)
-        SolarWindsAPM::Util.method_alias(klass, :client_streamer, ::GRPC::ActiveCall)
-        SolarWindsAPM::Util.method_alias(klass, :server_streamer, ::GRPC::ActiveCall)
-        SolarWindsAPM::Util.method_alias(klass, :bidi_streamer, ::GRPC::ActiveCall)
-      end
-
-      def grpc_tags(method_type, method)
-        tags = { 'Spec' => 'rsc',
-                 'RemoteURL' => "grpc://#{peer}#{method}",
-                 'GRPCMethodType' => method_type,
-                 'IsService' => 'True'
-        }
-        tags
-      end
-
-      def request_response_with_sw_apm(req, metadata: {})
-        unary_response(req, type: 'UNARY', metadata: metadata, without: :request_response_without_sw_apm)
-      end
-
-      def client_streamer_with_sw_apm(req, metadata: {})
-        unary_response(req, type: 'CLIENT_STREAMING', metadata: metadata, without: :client_streamer_without_sw_apm)
-      end
-
-      def server_streamer_with_sw_apm(req, metadata: {}, &blk)
-        @tags = grpc_tags('SERVER_STREAMING', metadata['method'] || metadata_to_send['method'])
-        SolarWindsAPM::API.log_entry('grpc-client', @tags)
-        add_tracecontext_headers(metadata)
-
-        patch_receive_and_check_status # need to patch this so that log_exit can be called after the enum is consumed
-
-        response = server_streamer_without_sw_apm(req, metadata: metadata)
-        block_given? ? response.each { |r| yield r } : response
-      rescue => e
-        # this check is needed because the exception may have been logged in patch_receive_and_check_status
-        unless e.instance_variable_get(:@exn_logged)
-          SolarWindsAPM::API.log_exception('grpc-client', e)
-          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
-        end
-        raise e
-      end
-
-      def bidi_streamer_with_sw_apm(req, metadata: {}, &blk)
-        @tags = grpc_tags('BIDI_STREAMING', metadata['method'] || metadata_to_send['method'])
-        SolarWindsAPM::API.log_entry('grpc-client', @tags)
-        add_tracecontext_headers(metadata)
-
-        patch_set_input_stream_done
-
-        response = bidi_streamer_without_sw_apm(req, metadata: metadata)
-        block_given? ? response.each { |r| yield r } : response
-      rescue => e
-        unless e.instance_variable_get(:@exn_logged)
-          SolarWindsAPM::API.log_exception('grpc-client', e)
-          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
-        end
-        raise e
-      end
-
-      private
-
-      def unary_response(req, type:, metadata:, without:)
-        tags = grpc_tags(type, metadata['method'] || metadata_to_send['method'])
-        SolarWindsAPM::SDK.trace('grpc-client', kvs: tags) do
-          add_tracecontext_headers(metadata)
-          begin
-            send(without, req, metadata: metadata)
-          ensure
-            exit_tags(tags)
-          end
-        end
-      end
-
-      def patch_receive_and_check_status
-        def self.receive_and_check_status # need to patch this so that log_exit can be called after the enum is consumed
-          super
-        rescue => e
-          SolarWindsAPM::API.log_exception('grpc-client', e)
-          raise e
-        ensure
-          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
-        end
-      end
-
-      def patch_set_input_stream_done
-        # need to patch this instance method so that log_exit can be called after the enum is consumed
-        def self.set_input_stream_done
-          return if status.nil?
-          if status.code > 0
-            SolarWindsAPM::API.log_exception('grpc-client', $!)
-          end
-          SolarWindsAPM::API.log_exit('grpc-client', exit_tags(@tags))
-          super
-        end
-      end
-
-      def exit_tags(tags)
-        # we need to translate the status.code, it is not the status.details we want, they are not matching 1:1
-        tags['GRPCStatus'] ||= @call.status ? StatusCodes[@call.status.code].to_s : 'UNKNOWN'
-        tags['Backtrace'] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:grpc_client][:collect_backtraces]
-        tags
-      end
-    end
-
-  end
-end
-
-if defined?(GRPC) && SolarWindsAPM::Config[:grpc_client][:enabled]
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting GRPC' if SolarWindsAPM::Config[:verbose]
-
-  # Client side is instrumented in ActiveCall and ClientStub
-  SolarWindsAPM::Util.send_include(GRPC::ActiveCall, SolarWindsAPM::GRPC::ActiveCall)
-
-  GRPC_ClientStub_ops = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
-  module GRPC
-    class ClientStub
-      GRPC_ClientStub_ops.reject { |m| !method_defined?(m) }.each do |m|
-        define_method("#{m}_with_sw_apm") do |method, req, marshal, unmarshal, deadline: nil,
-          return_op: false, parent: nil,
-          credentials: nil, metadata: {}, &blk|
-
-          metadata['method'] = method
-          return send("#{m}_without_sw_apm", method, req, marshal, unmarshal, deadline: deadline,
-                      return_op: return_op, parent: parent,
-                      credentials: credentials, metadata: metadata, &blk)
-        end
-
-        SolarWindsAPM::Util.method_alias(GRPC::ClientStub, m)
-      end
-
-    end
-  end
-end

data/lib/solarwinds_apm/inst/grpc_server.rb

@@ -1,119 +0,0 @@
-# Copyright (c) 2018 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module GRPC
-
-    if defined? ::GRPC
-      STATUSCODES = {}
-      ::GRPC::Core::StatusCodes.constants.each { |code| STATUSCODES[::GRPC::Core::StatusCodes.const_get(code)] = code }
-    end
-
-    module RpcDesc
-
-      def self.included(klass)
-        ::SolarWindsAPM::Util.method_alias(klass, :handle_request_response, ::GRPC::RpcDesc)
-        ::SolarWindsAPM::Util.method_alias(klass, :handle_client_streamer, ::GRPC::RpcDesc)
-        ::SolarWindsAPM::Util.method_alias(klass, :handle_server_streamer, ::GRPC::RpcDesc)
-        ::SolarWindsAPM::Util.method_alias(klass, :handle_bidi_streamer, ::GRPC::RpcDesc)
-        ::SolarWindsAPM::Util.method_alias(klass, :run_server_method, ::GRPC::RpcDesc)
-      end
-
-      def grpc_tags(active_call, mth)
-        tags = {
-          'Spec' => 'grpc_server',
-          'URL' => active_call.metadata['method'],
-          'Controller' => mth.owner.to_s,
-          'Action' => mth.name.to_s,
-          'HTTP-Host' => active_call.peer
-        }
-
-        if request_response?
-          tags['GRPCMethodType'] = 'UNARY'
-        elsif client_streamer?
-          tags['GRPCMethodType'] = 'CLIENT_STREAMING'
-        elsif server_streamer?
-          tags['GRPCMethodType'] = 'SERVER_STREAMING'
-        else
-          # is a bidi_stream
-          tags['GRPCMethodType'] = 'BIDI_STREAMING'
-        end
-
-        tags
-      end
-
-      def handle_request_response_with_sw_apm(active_call, mth, inter_ctx)
-        handle_call('handle_request_response_without_sw_apm', active_call, mth, inter_ctx)
-      end
-
-      def handle_client_streamer_with_sw_apm(active_call, mth, inter_ctx)
-        handle_call('handle_client_streamer_without_sw_apm', active_call, mth, inter_ctx)
-      end
-
-      def handle_server_streamer_with_sw_apm(active_call, mth, inter_ctx)
-        handle_call('handle_server_streamer_without_sw_apm', active_call, mth, inter_ctx)
-      end
-
-      def handle_bidi_streamer_with_sw_apm(active_call, mth, inter_ctx)
-        handle_call('handle_bidi_streamer_without_sw_apm', active_call, mth, inter_ctx)
-      end
-
-      # status codes need to be determined in this lower method, because they may not get raised to the
-      # next instrumented method
-      def handle_call(without, active_call, mth, inter_ctx)
-        begin
-          send(without, active_call, mth, inter_ctx)
-        rescue ::GRPC::Core::CallError, ::GRPC::BadStatus, ::GRPC::Core::OutOfTime, StandardError, NotImplementedError => e
-          log_grpc_exception(active_call, e)
-          raise e
-        end
-      end
-
-      def run_server_method_with_sw_apm(active_call, mth, inter_ctx)
-        tags = grpc_tags(active_call, mth)
-
-        SolarWindsAPM::API.log_start('grpc-server', tags, active_call.metadata)
-
-        begin
-          SolarWindsAPM::API.send_metrics('grpc-server', tags) do
-            run_server_method_without_sw_apm(active_call, mth, inter_ctx)
-          end
-        rescue => e
-          log_grpc_exception(active_call, e)
-          raise e
-        ensure
-          tags['GRPCStatus'] = active_call.metadata_to_send.delete('grpc_status')
-          tags['GRPCStatus'] ||= active_call.status ? SolarWindsAPM::GRPC::STATUSCODES[active_call.status.code].to_s : 'OK'
-          tags['Backtrace'] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:grpc_server][:collect_backtraces]
-
-          SolarWindsAPM::API.log_end('grpc-server', tags)
-        end
-      end
-
-      private
-
-      def log_grpc_exception(active_call, e)
-        unless e.instance_variable_get(:@exn_logged)
-          SolarWindsAPM::API.log_exception('grpc-server', e)
-
-          unless active_call.metadata_sent
-            if e.class == ::GRPC::Core::OutOfTime
-              active_call.merge_metadata_to_send({ 'grpc_status' => 'DEADLINE_EXCEEDED' })
-            elsif e.respond_to?(:code)
-              active_call.merge_metadata_to_send({ 'grpc_status' => SolarWindsAPM::GRPC::STATUSCODES[e.code].to_s })
-            else
-              active_call.merge_metadata_to_send({ 'grpc_status' => 'UNKNOWN' })
-            end
-          end
-        end
-      end
-
-    end
-
-  end
-end
-
-if defined?(GRPC) && SolarWindsAPM::Config['grpc_server'][:enabled]
-  # server side is instrumented in RpcDesc
-  SolarWindsAPM::Util.send_include(GRPC::RpcDesc, SolarWindsAPM::GRPC::RpcDesc)
-end

data/lib/solarwinds_apm/inst/httpclient.rb

@@ -1,182 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module HTTPClient
-
-      def sw_apm_collect(method, uri, query = nil)
-        kvs = {}
-        kvs[:Spec] = 'rsc'
-        kvs[:IsService] = 1
-
-        # Conditionally log URL query params
-        # Because of the hook points, the query arg can come in under <tt>query</tt>
-        # or as a part of <tt>uri</tt> (not both).  Here we handle both cases.
-        if SolarWindsAPM::Config[:httpclient][:log_args]
-          if query
-            kvs[:RemoteURL] = uri.to_s + '?' + SolarWindsAPM::Util.to_query(query)
-          else
-            kvs[:RemoteURL] = uri.to_s
-          end
-        else
-          kvs[:RemoteURL] = uri.to_s.split('?').first
-        end
-
-        kvs[:RemoteURL] = SolarWindsAPM::Util.sanitize_uri(kvs[:RemoteURL])
-        kvs[:HTTPMethod] = SolarWindsAPM::Util.upcase(method)
-        kvs
-      rescue => e
-        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Error capturing httpclient KVs: #{e.message}"
-        SolarWindsAPM.logger.debug e.backtrace.join('\n') if SolarWindsAPM::Config[:verbose]
-      ensure
-        return kvs
-      end
-
-      def do_request(method, uri, query, body, header, &block)
-        # If we're not tracing, just do a fast return.
-        unless SolarWindsAPM.tracing?
-          add_trace_header(header)
-          return super(method, uri, query, body, header, &block)
-        end
-
-        begin
-          kvs = sw_apm_collect(method, uri, query)
-
-          SolarWindsAPM::API.log_entry(:httpclient, kvs)
-          kvs.clear
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:httpclient][:collect_backtraces]
-
-          add_trace_header(header)
-
-          # The core httpclient call
-          response = super(method, uri, query, body, header, &block)
-          kvs[:HTTPStatus] = response.status_code
-
-          # 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
-
-          response
-        rescue => e
-          SolarWindsAPM::API.log_exception(:httpclient, e)
-          raise e
-        ensure
-          SolarWindsAPM::API.log_exit(:httpclient, kvs)
-        end
-      end
-
-      def do_request_async(method, uri, query, body, header)
-        add_trace_header(header)
-        # added headers because this calls `do_get_stream` in a new thread
-        # threads do not inherit thread local variables like SolarWindsAPM.trace_context
-        super(method, uri, query, body, header)
-      end
-
-      def do_get_stream(req, proxy, conn)
-        # called from `do_request_async` in a new thread
-        # threads do not inherit thread local variables
-        # therefore we use headers to continue context
-        w3c_headers = get_trace_headers(req.headers)
-        SolarWindsAPM.trace_context = TraceContext.new(w3c_headers)
-        unless SolarWindsAPM::TraceString.sampled?(SolarWindsAPM.trace_context.tracestring)
-          # trace headers already included
-          return super(req, proxy, conn)
-        end
-
-        begin
-          method = req.http_header.request_method
-
-          uri = req.http_header.request_uri
-          kvs = sw_apm_collect(method, uri)
-          kvs[:Async] = 1
-
-          SolarWindsAPM::Context.fromString(SolarWindsAPM.trace_context.tracestring)
-          SolarWindsAPM::API.log_entry(:httpclient, kvs)
-          kvs.clear
-          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:httpclient][:collect_backtraces]
-
-          add_trace_header(req.header)
-
-          # The core httpclient call
-          result = super(req, proxy, conn)
-
-          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
-          if result.is_a?(::HTTP::Message)
-            response = result
-          else
-            response = conn.pop
-          end
-
-          kvs[:HTTPStatus] = response.status_code
-
-          # 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
-
-          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
-          conn.push response if result.is_a?(::HTTPClient::Connection)
-          result
-        rescue => e
-          SolarWindsAPM::API.log_exception(:httpclient, e)
-          raise e
-        ensure
-          SolarWindsAPM::API.log_exit(:httpclient, kvs)
-        end
-      end
-
-      private
-
-      def get_trace_headers(headers)
-        if headers.is_a?(Array)
-          traceparent = headers.find { |ele| ele.first =~ /[Tt]raceparent/ }
-          tracestate = headers.find { |ele| ele.first =~ /[Tt]racestate/ }
-          return { traceparent: traceparent, tracestate: tracestate }
-        elsif headers.is_a?(Hash)
-          return { traceparent: headers['traceparent'], tracestate: headers['tracestate'] }
-        elsif headers.is_a? HTTP::Message::Headers
-          return { traceparent: headers['traceparent'].first,
-                   tracestate: headers['tracestate'].first }
-        end
-        {}
-      end
-
-      def add_trace_header(headers)
-        tracestring, tracestate = w3c_context
-        # Be aware of various ways to call/use httpclient
-        if headers.is_a?(Array)
-          headers.delete_if { |kv| kv[0] =~ /^([Tt]raceparent|[Tt]racestate)$/ }
-          headers.push ['traceparent', tracestring] if tracestring
-          headers.push ['tracestate', tracestate] if tracestate
-        elsif headers.is_a?(Hash)
-          headers['traceparent'] = tracestring if tracestring
-          headers['tracestate'] = tracestate if tracestate
-        elsif headers.is_a? HTTP::Message::Headers
-          headers.set('traceparent', tracestring) if tracestring
-          headers.set('tracestate', tracestate) if tracestate
-        end
-      end
-
-      # !! this is a private method, only used in add_trace_header above
-      def w3c_context
-        tracestring = SolarWindsAPM::Context.toString
-
-        unless SolarWindsAPM::TraceString.valid?(tracestring)
-          return [SolarWindsAPM.trace_context&.traceparent, SolarWindsAPM.trace_context&.tracestate]
-        end
-
-        parent_id_flags = SolarWindsAPM::TraceString.span_id_flags(tracestring)
-        tracestate = SolarWindsAPM::TraceState.add_sw_member(SolarWindsAPM.trace_context&.tracestate, parent_id_flags)
-        [tracestring, tracestate]
-      end
-
-    end
-  end
-end
-
-if SolarWindsAPM::Config[:httpclient][:enabled] && defined?(HTTPClient)
-  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting httpclient' if SolarWindsAPM::Config[:verbose]
-  HTTPClient.prepend(SolarWindsAPM::Inst::HTTPClient)
-end

data/lib/solarwinds_apm/inst/memcached.rb

@@ -1,86 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module SolarWindsAPM
-  module Inst
-    module Memcached
-      include SolarWindsAPM::API::Memcache
-
-      def self.included(cls)
-        SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting memcached' if SolarWindsAPM::Config[:verbose]
-
-        cls.class_eval do
-          MEMCACHE_OPS.reject { |m| !method_defined?(m) }.each do |m|
-            define_method("#{m}_with_sw_apm") do |*args|
-              kvs = { :KVOp => m }
-
-              if args.length && !args[0].is_a?(Array)
-                kvs[:KVKey] = args[0].to_s
-                rhost = remote_host(args[0].to_s)
-                kvs[:RemoteHost] = rhost if rhost
-              end
-
-              SolarWindsAPM::SDK.trace(:memcache, kvs: kvs) do
-                result = send("#{m}_without_sw_apm", *args)
-
-                kvs[:KVHit] = memcache_hit?(result) if m == :get && args.length && args[0].class == String
-                kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:memcached][:collect_backtraces]
-
-                result
-              end
-            end
-
-            class_eval "alias #{m}_without_sw_apm #{m}"
-            class_eval "alias #{m} #{m}_with_sw_apm"
-          end
-        end
-      end
-
-    end # module Memcached
-
-    module MemcachedRails
-      def self.included(cls)
-        cls.class_eval do
-          if ::Memcached::Rails.method_defined? :get_multi
-            alias get_multi_without_sw_apm get_multi
-            alias get_multi get_multi_with_sw_apm
-          elsif SolarWindsAPM::Config[:verbose]
-            SolarWindsAPM.logger.warn '[solarwinds_apm/loading] Couldn\'t properly instrument Memcached.  Partial traces may occur.'
-          end
-        end
-      end
-
-      def get_multi_with_sw_apm(keys, raw = false)
-        if SolarWindsAPM.tracing?
-          layer_kvs = {}
-          layer_kvs[:KVOp] = :get_multi
-
-          SolarWindsAPM::SDK.trace(:memcache, kvs: layer_kvs, protect_op: :get_multi) do
-            layer_kvs[:KVKeyCount] = keys.flatten.length
-
-            values = get_multi_without_sw_apm(keys, raw)
-
-            layer_kvs[:KVHitCount] = values.length
-            layer_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:memcached][:collect_backtraces]
-
-            values
-          end
-        else
-          get_multi_without_sw_apm(keys, raw)
-        end
-      end
-    end # module MemcachedRails
-  end # module Inst
-end # module SolarWindsAPM
-
-if defined?(Memcached) && SolarWindsAPM::Config[:memcached][:enabled]
-  Memcached.class_eval do
-    include SolarWindsAPM::Inst::Memcached
-  end
-
-  if defined?(Memcached::Rails)
-    Memcached::Rails.class_eval do
-      include SolarWindsAPM::Inst::MemcachedRails
-    end
-  end
-end