appoptics_apm_mnfst 4.5.2

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,73 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'net/http'
+
+if AppOpticsAPM::Config[:nethttp][:enabled]
+
+  Net::HTTP.class_eval do
+    def request_with_appoptics(*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?
+        unless blacklisted
+          xtrace = AppOpticsAPM::Context.toString
+          args[0]['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+        end
+        return request_without_appoptics(*args, &block)
+      end
+
+      opts = {}
+      AppOpticsAPM::API.trace(:'net-http', opts) do
+        context = AppOpticsAPM::Context.toString
+        # task_id = AppOpticsAPM::XTrace.task_id(context)
+
+        # Collect KVs to report in the info 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 = request_without_appoptics(*args, &block)
+
+          # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+          unless blacklisted
+            xtrace = resp.get_fields('X-Trace')
+            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
+
+    alias request_without_appoptics request
+    alias request request_with_appoptics
+
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting net/http' if AppOpticsAPM::Config[:verbose]
+  end
+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/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