solarwinds_apm 5.0.0

data/lib/solarwinds_apm/inst/grpc_server.rb

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

@@ -0,0 +1,181 @@
+# 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[: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/logger_formatter.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+require 'logger'
+
+module SolarWindsAPM
+  module Logger
+    module Formatter
+
+      def call(severity, time, progname, msg)
+        return super if SolarWindsAPM::Config[:log_traceId] == :never
+
+        msg = insert_trace_id(msg)
+        super
+      end
+
+      private
+
+      def insert_trace_id(msg)
+        return msg if msg =~ /trace_id=/
+
+        current_trace = SolarWindsAPM::SDK.current_trace_info
+        if current_trace.do_log
+          case msg
+          when ::String
+            msg = msg.strip.empty? ? msg : insert_before_empty_lines(msg, current_trace.for_log)
+          when ::Exception
+            # conversion to String copied from Logger::Formatter private method #msg2str
+            msg = ("#{msg.message} (#{msg.class}) #{current_trace.for_log}\n" <<
+              (msg.backtrace || []).join("\n"))
+          end
+        end
+        msg
+      end
+
+      def insert_before_empty_lines(msg, for_log)
+        stripped = msg.rstrip
+        "#{stripped} #{for_log}#{msg[stripped.length..-1]}"
+      end
+    end
+  end
+end
+
+if SolarWindsAPM.loaded
+  Logger::Formatter.send(:prepend, SolarWindsAPM::Logger::Formatter)
+end

data/lib/solarwinds_apm/inst/logging_log_event.rb

@@ -0,0 +1,24 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+require_relative 'logger_formatter'
+
+module SolarWindsAPM
+  module Logging
+    module LogEvent
+      include SolarWindsAPM::Logger::Formatter # provides #insert_trace_id
+
+      def initialize(logger, level, data, caller_tracing )
+        return super if SolarWindsAPM::Config[:log_traceId] == :never
+
+        data = insert_trace_id(data)
+        super
+      end
+
+    end
+  end
+end
+
+if SolarWindsAPM.loaded && defined?(Logging::LogEvent)
+  Logging::LogEvent.send(:prepend, SolarWindsAPM::Logging::LogEvent)
+end

data/lib/solarwinds_apm/inst/lumberjack_formatter.rb

@@ -0,0 +1,9 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+require_relative 'logger_formatter'
+
+if SolarWindsAPM.loaded && defined?(Lumberjack::Formatter)
+  Lumberjack::Formatter.send(:prepend, SolarWindsAPM::Logger::Formatter)
+end
+

data/lib/solarwinds_apm/inst/memcached.rb

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