appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/inst/grpc_server.rb

@@ -0,0 +1,120 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  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)
+        ::AppOpticsAPM::Util.method_alias(klass, :handle_request_response, ::GRPC::RpcDesc)
+        ::AppOpticsAPM::Util.method_alias(klass, :handle_client_streamer, ::GRPC::RpcDesc)
+        ::AppOpticsAPM::Util.method_alias(klass, :handle_server_streamer, ::GRPC::RpcDesc)
+        ::AppOpticsAPM::Util.method_alias(klass, :handle_bidi_streamer, ::GRPC::RpcDesc)
+        ::AppOpticsAPM::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_appoptics(active_call, mth, inter_ctx)
+        handle_call('handle_request_response_without_appoptics', active_call, mth, inter_ctx)
+      end
+
+      def handle_client_streamer_with_appoptics(active_call, mth, inter_ctx)
+        handle_call('handle_client_streamer_without_appoptics', active_call, mth, inter_ctx)
+      end
+
+      def handle_server_streamer_with_appoptics(active_call, mth, inter_ctx)
+        handle_call('handle_server_streamer_without_appoptics', active_call, mth, inter_ctx)
+      end
+
+      def handle_bidi_streamer_with_appoptics(active_call, mth, inter_ctx)
+        handle_call('handle_bidi_streamer_without_appoptics', 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_appoptics(active_call, mth, inter_ctx)
+        tags = grpc_tags(active_call, mth)
+        AppOpticsAPM::API.log_start('grpc-server', active_call.metadata['x-trace'], tags)
+
+        exit_event = AppOpticsAPM::Event.startTrace(AppOpticsAPM::Context.get)
+        active_call.merge_metadata_to_send({ 'x-trace' => exit_event.metadataString })
+        begin
+          AppOpticsAPM::API.send_metrics('grpc-server', tags) do
+            run_server_method_without_appoptics(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 ? AppOpticsAPM::GRPC::STATUSCODES[active_call.status.code].to_s : 'OK'
+          tags['Backtrace'] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grpc_server][:collect_backtraces]
+
+          exit_event.addEdge(AppOpticsAPM::Context.get)
+          AppOpticsAPM::API.log_end('grpc-server', tags, exit_event)
+        end
+      end
+
+      private
+
+      def log_grpc_exception(active_call, e)
+        unless e.instance_variable_get(:@exn_logged)
+          AppOpticsAPM::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' =>  AppOpticsAPM::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) && AppOpticsAPM::Config['grpc_server'][:enabled]
+  # server side is instrumented in RpcDesc
+  AppOpticsAPM::Util.send_include(GRPC::RpcDesc, AppOpticsAPM::GRPC::RpcDesc)
+end

data/lib/appoptics_apm/inst/http.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'net/http'
+
+if AppOpticsAPM::Config[:nethttp][:enabled]
+  module AppOpticsAPM
+    module Inst
+      module NetHttp
+        # Net::HTTP.class_eval do
+        # def request_with_appoptics(*args, &block)
+        def request(*args, &block)
+          # Avoid cross host tracing for blacklisted domains
+          blacklisted = AppOpticsAPM::API.blacklisted?(addr_port)
+
+          # If we're not tracing, just do a fast return. Since
+          # net/http.request calls itself, only trace
+          # once the http session has been started.
+          if !AppOpticsAPM.tracing? || !started?
+            if blacklisted # if the other site is blacklisted, we don't want to leak its X-trace
+              resp = super
+              resp.delete('X-Trace') # if resp['X-Trace']
+              return resp
+            else
+              xtrace = AppOpticsAPM::Context.toString
+              args[0]['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+              return super
+            end
+          end
+
+          opts = {}
+          AppOpticsAPM::API.trace(:'net-http', opts) do
+            context = AppOpticsAPM::Context.toString
+
+            # Collect KVs to report in the exit event
+            if args.respond_to?(:first) && args.first
+              req = args.first
+
+              opts[:Spec] = 'rsc'
+              opts[:IsService] = 1
+              opts[:RemoteURL] = "#{use_ssl? ? 'https' : 'http'}://#{addr_port}"
+              opts[:RemoteURL] << (AppOpticsAPM::Config[:nethttp][:log_args] ? req.path : req.path.split('?').first)
+              opts[:HTTPMethod] = req.method
+              opts[:Blacklisted] = true if blacklisted
+              opts[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:nethttp][:collect_backtraces]
+
+              req['X-Trace'] = context unless blacklisted
+            end
+
+            begin
+              # The actual net::http call
+              resp = super
+              # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+              xtrace = resp.get_fields('X-Trace')
+              if blacklisted
+                # we don't want the x-trace if it is from a blacklisted address
+                resp.delete('X-Trace') # if xtrace
+              else
+                xtrace = xtrace[0] if xtrace && xtrace.is_a?(Array)
+                AppOpticsAPM::XTrace.continue_service_context(context, xtrace)
+              end
+
+              opts[:HTTPStatus] = resp.code
+
+              # If we get a redirect, report the location header
+              if ((300..308).to_a.include? resp.code.to_i) && resp.header["Location"]
+                opts[:Location] = resp.header["Location"]
+              end
+
+              next resp
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  Net::HTTP.prepend(AppOpticsAPM::Inst::NetHttp)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting net/http' if AppOpticsAPM::Config[:verbose]
+end

data/lib/appoptics_apm/inst/httpclient.rb

@@ -0,0 +1,174 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module HTTPClient
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :do_request, ::HTTPClient)
+        AppOpticsAPM::Util.method_alias(klass, :do_request_async, ::HTTPClient)
+        AppOpticsAPM::Util.method_alias(klass, :do_get_stream, ::HTTPClient)
+      end
+
+      def appoptics_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 AppOpticsAPM::Config[:httpclient][:log_args]
+          if query
+            kvs[:RemoteURL] = uri.to_s + '?' + AppOpticsAPM::Util.to_query(query)
+          else
+            kvs[:RemoteURL] = uri.to_s
+          end
+        else
+          kvs[:RemoteURL] = uri.to_s.split('?').first
+        end
+
+        kvs[:HTTPMethod] = AppOpticsAPM::Util.upcase(method)
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing httpclient KVs: #{e.message}"
+        AppOpticsAPM.logger.debug e.backtrace.join('\n') if AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      def do_request_with_appoptics(method, uri, query, body, header, &block)
+        # Avoid cross host tracing for blacklisted domains
+        blacklisted = AppOpticsAPM::API.blacklisted?(uri.hostname)
+
+        # If we're not tracing, just do a fast return.
+        unless AppOpticsAPM.tracing?
+          add_xtrace_header(header) unless blacklisted
+          return do_request_without_appoptics(method, uri, query, body, header, &block)
+        end
+
+        begin
+          req_context = nil
+          response_context = nil
+
+          kvs = appoptics_collect(method, uri, query)
+          kvs[:Blacklisted] = true if blacklisted
+
+          AppOpticsAPM::API.log_entry(:httpclient, kvs)
+          kvs.clear
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:httpclient][:collect_backtraces]
+
+          req_context = add_xtrace_header(header) unless blacklisted
+
+          # The core httpclient call
+          response = do_request_without_appoptics(method, uri, query, body, header, &block)
+
+          response_context = response.headers['X-Trace']
+          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
+
+          if response_context && !blacklisted
+            AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:httpclient, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:httpclient, kvs)
+        end
+      end
+
+      def do_request_async_with_appoptics(method, uri, query, body, header)
+        add_xtrace_header(header)
+        do_request_async_without_appoptics(method, uri, query, body, header)
+      end
+
+      def do_get_stream_with_appoptics(req, proxy, conn)
+        AppOpticsAPM::Context.fromString(req.header['X-Trace'].first) unless req.header['X-Trace'].empty?
+        # Avoid cross host tracing for blacklisted domains
+        uri = req.http_header.request_uri
+        blacklisted = AppOpticsAPM::API.blacklisted?(uri.hostname)
+
+        unless AppOpticsAPM.tracing?
+          req.header.delete('X-Trace') if blacklisted
+          return do_get_stream_without_appoptics(req, proxy, conn)
+        end
+
+        begin
+          response = nil
+          req_context = nil
+          method = req.http_header.request_method
+
+          kvs = appoptics_collect(method, uri)
+          kvs[:Blacklisted] = true if blacklisted
+          kvs[:Async] = 1
+
+          AppOpticsAPM::API.log_entry(:httpclient, kvs)
+          kvs.clear
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:httpclient][:collect_backtraces]
+
+          blacklisted ? req.header.delete('X-Trace') : req_context = add_xtrace_header(req.header)
+
+          # The core httpclient call
+          result = do_get_stream_without_appoptics(req, proxy, conn)
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          if result.is_a?(::HTTP::Message)
+            response = result
+          else
+            response = conn.pop
+          end
+
+          response_context = response.headers['X-Trace']
+          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
+
+          if response_context && !blacklisted
+            AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          conn.push response if result.is_a?(::HTTPClient::Connection)
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(:httpclient, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:httpclient, kvs)
+        end
+      end
+
+      private
+
+      def add_xtrace_header(headers)
+        req_context = AppOpticsAPM::Context.toString
+        return nil unless AppOpticsAPM::XTrace.valid?(req_context)
+        # Be aware of various ways to call/use httpclient
+        if headers.is_a?(Array)
+          headers.delete_if { |kv| kv[0] == 'X-Trace' }
+          headers.push ['X-Trace', req_context]
+        elsif headers.is_a?(Hash)
+          headers['X-Trace'] = req_context
+        elsif headers.is_a? HTTP::Message::Headers
+          headers.set('X-Trace', req_context)
+        end
+        req_context
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:httpclient][:enabled] && defined?(HTTPClient)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting httpclient' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(HTTPClient, AppOpticsAPM::Inst::HTTPClient)
+end

data/lib/appoptics_apm/inst/logger_formatter.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+require 'logger'
+
+module AppOpticsAPM
+  module Logger
+    module Formatter
+
+      def call(severity, time, progname, msg)
+        return super if AppOpticsAPM::Config[:log_traceId] == :never
+
+        msg = insert_trace_id(msg)
+        super
+      end
+
+      private
+
+      def insert_trace_id(msg)
+        return msg if msg =~ /ao(=>{:|\.){1}traceId/
+
+        current_trace = AppOpticsAPM::SDK.current_trace
+        if current_trace.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 AppOpticsAPM.loaded
+  class Logger
+    class Formatter
+      prepend AppOpticsAPM::Logger::Formatter
+    end
+  end
+end

data/lib/appoptics_apm/inst/logging_log_event.rb

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

data/lib/appoptics_apm/inst/lumberjack_formatter.rb

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

data/lib/appoptics_apm/inst/memcached.rb

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