appoptics_apm_mnfst 4.5.2

data/lib/appoptics_apm/inst/em-http-request.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module EventMachine
+      module HttpConnection
+        def setup_request_with_appoptics(*args, &block)
+          context = AppOpticsAPM::Context.toString
+          blacklisted = AppOpticsAPM::API.blacklisted?(@uri)
+
+          if AppOpticsAPM.tracing?
+            report_kvs = {}
+
+            begin
+              report_kvs[:Spec] = 'rsc'
+              report_kvs[:IsService] = 1
+              report_kvs[:RemoteURL] = @uri
+              report_kvs[:HTTPMethod] = args[0]
+              report_kvs[:Blacklisted] = true if blacklisted
+              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:em_http_request][:collect_backtraces]
+            rescue => e
+              AppOpticsAPM.logger.debug "[appoptics_apm/debug] em-http-request KV error: #{e.inspect}"
+            end
+
+            context = AppOpticsAPM::API.log_entry('em-http-request', report_kvs)
+          end
+          client = setup_request_without_appoptics(*args, &block)
+          client.req.headers['X-Trace'] = context unless blacklisted
+          client
+        end
+      end
+
+      module HttpClient
+        def parse_response_header_with_appoptics(*args, &block)
+          report_kvs = {}
+          xtrace = nil
+          blacklisted = AppOpticsAPM::API.blacklisted?(@uri)
+
+          begin
+            report_kvs[:HTTPStatus] = args[2]
+            report_kvs[:Async] = 1
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] em-http-request KV error: #{e.inspect}"
+          end
+
+          parse_response_header_without_appoptics(*args, &block)
+
+          unless blacklisted
+            headers = args[0]
+            context = AppOpticsAPM::Context.toString
+            task_id = AppOpticsAPM::XTrace.task_id(context)
+
+            if headers.is_a?(Hash) && headers.key?('X-Trace')
+              xtrace = headers['X-Trace']
+            end
+
+            if AppOpticsAPM::XTrace.valid?(xtrace) && AppOpticsAPM.tracing?
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == AppOpticsAPM::XTrace.task_id(xtrace)
+                AppOpticsAPM::Context.fromString(xtrace)
+              else
+                AppOpticsAPM.logger.debug "[appoptics_apm/em-http] Mismatched returned X-Trace ID : #{xtrace}"
+              end
+            end
+
+          end
+        ensure
+          AppOpticsAPM::API.log_exit(:'em-http-request', report_kvs)
+        end
+      end
+    end
+  end
+end
+
+if defined?(EventMachine::HttpConnection) && defined?(EventMachine::HttpClient) && AppOpticsAPM::Config[:em_http_request][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting em-http-request' if AppOpticsAPM::Config[:verbose]
+
+  class EventMachine::HttpConnection
+    include AppOpticsAPM::Inst::EventMachine::HttpConnection
+
+    if method_defined?(:setup_request)
+      class_eval 'alias :setup_request_without_appoptics :setup_request'
+      class_eval 'alias :setup_request :setup_request_with_appoptics'
+    else
+      AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument em-http-request (:setup_request).  Partial traces may occur.'
+    end
+  end
+
+  class EventMachine::HttpClient
+    include AppOpticsAPM::Inst::EventMachine::HttpClient
+
+    if method_defined?(:parse_response_header)
+      class_eval 'alias :parse_response_header_without_appoptics :parse_response_header'
+      class_eval 'alias :parse_response_header :parse_response_header_with_appoptics'
+    else
+      AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument em-http-request (:parse_response_header).  Partial traces may occur.'
+    end
+  end
+end

data/lib/appoptics_apm/inst/excon.rb

@@ -0,0 +1,125 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ExconConnection
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :request, ::Excon::Connection)
+        AppOpticsAPM::Util.method_alias(klass, :requests, ::Excon::Connection)
+      end
+
+      private
+
+      def appoptics_collect(params)
+        kvs = {}
+        kvs[:Spec] = 'rsc'
+        kvs[:IsService] = 1
+
+        # Conditionally log query args
+        if AppOpticsAPM::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 << AppOpticsAPM::Util.upcase(p[:method])
+          end
+          kvs[:HTTPMethods] = methods.join(',')[0..1024]
+          kvs[:Pipeline] = true
+        else
+          kvs[:HTTPMethod] = AppOpticsAPM::Util.upcase(params[:method])
+        end
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing excon KVs: #{e.message}"
+        AppOpticsAPM.logger.debug e.backtrace.join('\n') if AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      public
+
+      def requests_with_appoptics(pipeline_params)
+        responses = nil
+        kvs = appoptics_collect(pipeline_params)
+        AppOpticsAPM::API.trace(:excon, kvs) do
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:excon][:collect_backtraces]
+          responses = requests_without_appoptics(pipeline_params)
+          kvs[:HTTPStatuses] = responses.map { |r| r.status }.join(',')
+        end
+        responses
+      end
+
+      def request_with_appoptics(params={}, &block)
+        # Avoid cross host tracing for blacklisted domains
+        blacklisted = AppOpticsAPM::API.blacklisted?(@data[:hostname] || @data[:host])
+
+        # 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 !AppOpticsAPM.tracing? || params[:pipeline]
+          @data[:headers]['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid && !blacklisted
+          return request_without_appoptics(params, &block)
+        end
+
+        begin
+          response_context = nil
+
+          kvs = appoptics_collect(params)
+          kvs[:Blacklisted] = true if blacklisted
+
+          AppOpticsAPM::API.log_entry(:excon, kvs)
+          kvs.clear
+
+          req_context = AppOpticsAPM::Context.toString
+          @data[:headers]['X-Trace'] = req_context unless blacklisted
+
+          # The core excon call
+          response = request_without_appoptics(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)
+            response_context = response.headers['X-Trace']
+            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
+
+            if response_context && !blacklisted
+              AppOpticsAPM::XTrace.continue_service_context(req_context, response_context)
+            end
+          end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:excon, e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:excon][:collect_backtraces]
+          AppOpticsAPM::API.log_exit(:excon, kvs) unless params[:pipeline]
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:excon][:enabled] && defined?(Excon)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting excon' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Excon::Connection, AppOpticsAPM::Inst::ExconConnection)
+end

data/lib/appoptics_apm/inst/faraday.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module FaradayConnection
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run_request, ::Faraday::Connection)
+      end
+
+      def run_request_with_appoptics(method, url, body, headers, &block)
+        blacklisted = url_blacklisted?
+        remote_call = remote_call?
+
+        unless AppOpticsAPM.tracing?
+          if remote_call && !blacklisted
+            xtrace = AppOpticsAPM::Context.toString
+            @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+          end
+          return run_request_without_appoptics(method, url, body, headers, &block)
+        end
+
+        begin
+          AppOpticsAPM::API.log_entry(:faraday)
+          xtrace = nil
+          if remote_call && !blacklisted
+            xtrace = AppOpticsAPM::Context.toString
+            @headers['X-Trace'] = xtrace if AppOpticsAPM::XTrace.valid?(xtrace)
+          end
+
+          result = run_request_without_appoptics(method, url, body, headers, &block)
+
+          # Re-attach edge unless it's blacklisted
+          # or if we don't have a valid X-Trace header
+          if remote_call && !blacklisted
+            xtrace_new = result.headers['X-Trace']
+            AppOpticsAPM::XTrace.continue_service_context(xtrace, xtrace_new)
+          end
+          kvs = {}
+          kvs[:Middleware] = @builder.handlers
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::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))
+            unless blacklisted
+              xtrace_new = result.headers['X-Trace']
+              AppOpticsAPM::XTrace.continue_service_context(xtrace, xtrace_new)
+            end
+          end
+
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(:faraday, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:faraday, kvs)
+        end
+      end
+
+      private
+
+      def url_blacklisted?
+        url = @url_prefix ? @url_prefix.to_s : @host
+        AppOpticsAPM::API.blacklisted?(url)
+      end
+
+      # This is only considered a remote service call if the middleware/adapter is not instrumented
+      def remote_call?
+        (@builder.handlers.map(&:name) & APPOPTICS_INSTR_ADAPTERS).count == 0
+      end
+
+      def rsc_kvs(url, method, result)
+        kvs = { :Spec => 'rsc',
+                :IsService => 1,
+                :HTTPMethod => method.upcase,
+                :HTTPStatus => result.status, }
+        kvs[:Blacklisted] = true if url_blacklisted?
+        kvs[:RemoteURL] = result.to_hash[:url].to_s
+        kvs[:RemoteURL].split('?').first unless AppOpticsAPM::Config[:faraday][:log_args]
+
+        kvs
+      end
+    end
+  end
+end
+
+if defined?(Faraday) && AppOpticsAPM::Config[:faraday][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting faraday' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Faraday::Connection, AppOpticsAPM::Inst::FaradayConnection)
+  APPOPTICS_INSTR_ADAPTERS = ["Faraday::Adapter::NetHttp", "Faraday::Adapter::Excon", "Faraday::Adapter::Typhoeus"]
+  APPOPTICS_INSTR_ADAPTERS << "Faraday::Adapter::HTTPClient" if defined?Faraday::Adapter::HTTPClient
+end

data/lib/appoptics_apm/inst/grpc_client.rb

@@ -0,0 +1,162 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module GRPC
+
+    module ActiveCall
+      if defined? ::GRPC
+        StatusCodes = {}
+        ::GRPC::Core::StatusCodes.constants.each { |code| StatusCodes[::GRPC::Core::StatusCodes.const_get(code)] = code }
+      end
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :request_response, ::GRPC::ActiveCall)
+        AppOpticsAPM::Util.method_alias(klass, :client_streamer, ::GRPC::ActiveCall)
+        AppOpticsAPM::Util.method_alias(klass, :server_streamer, ::GRPC::ActiveCall)
+        AppOpticsAPM::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_appoptics(req, metadata: {})
+        unary_response(req, type: 'UNARY', metadata: metadata, without: :request_response_without_appoptics)
+      end
+
+      def client_streamer_with_appoptics(req, metadata: {})
+        unary_response(req, type: 'CLIENT_STREAMING', metadata: metadata, without: :client_streamer_without_appoptics)
+      end
+
+      def server_streamer_with_appoptics(req, metadata: {}, &blk)
+        @tags = grpc_tags('SERVER_STREAMING', metadata[:method] || metadata_to_send[:method])
+        AppOpticsAPM::API.log_entry('grpc-client', @tags)
+        metadata['x-trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+        AppOpticsAPM::SDK.set_transaction_name(metadata[:method]) if AppOpticsAPM.transaction_name.nil?
+
+        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_appoptics(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)
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          AppOpticsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+        end
+        raise e
+      end
+
+      def bidi_streamer_with_appoptics(req, metadata: {}, &blk)
+        @tags = grpc_tags('BIDI_STREAMING', metadata[:method] || metadata_to_send[:method])
+        AppOpticsAPM::API.log_entry('grpc-client', @tags)
+        metadata['x-trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+        AppOpticsAPM::SDK.set_transaction_name(metadata[:method]) if AppOpticsAPM.transaction_name.nil?
+
+        patch_set_input_stream_done
+
+        response = bidi_streamer_without_appoptics(req, metadata: metadata)
+        block_given? ? response.each { |r| yield r } : response
+      rescue => e
+        unless e.instance_variable_get(:@exn_logged)
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          AppOpticsAPM::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])
+        AppOpticsAPM::SDK.trace('grpc-client', tags) do
+          metadata['x-trace'] = AppOpticsAPM::Context.toString  if AppOpticsAPM::Context.isValid
+          AppOpticsAPM::SDK.set_transaction_name(metadata[:method]) if AppOpticsAPM.transaction_name.nil?
+          begin
+            send(without, req, metadata: metadata)
+          ensure
+            exit_tags(tags)
+            context_from_incoming
+          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
+          context_from_incoming
+        rescue => e
+          context_from_incoming
+          AppOpticsAPM::API.log_exception('grpc-client', e)
+          raise e
+        ensure
+          AppOpticsAPM::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?
+          context_from_incoming
+          if status.code > 0
+            AppOpticsAPM::API.log_exception('grpc-client', $!)
+          end
+          AppOpticsAPM::API.log_exit('grpc-client', exit_tags(@tags))
+          super
+        end
+      end
+
+      def context_from_incoming
+        if AppOpticsAPM::Context.isValid
+          xtrace ||= @call.trailing_metadata['x-trace'] if @call.trailing_metadata && @call.trailing_metadata['x-trace']
+          xtrace ||= @call.metadata['x-trace'] if @call.metadata && @call.metadata['x-trace']
+          AppOpticsAPM::Context.fromString(xtrace) if xtrace
+        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'] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grpc_client][:collect_backtraces]
+        tags
+      end
+    end
+
+  end
+end
+
+if defined?(GRPC) && AppOpticsAPM::Config[:grpc_client][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GRPC' if AppOpticsAPM::Config[:verbose]
+
+  # Client side is instrumented in ActiveCall and ClientStub
+  AppOpticsAPM::Util.send_include(GRPC::ActiveCall, AppOpticsAPM::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_appoptics") do |method, req, marshal, unmarshal, deadline: nil,
+            return_op: false, parent: nil,
+            credentials: nil, metadata: {}, &blk|
+
+          metadata[:method] = method
+          return send("#{m}_without_appoptics", method, req, marshal, unmarshal, deadline: deadline,
+                      return_op: return_op, parent: parent,
+                      credentials: credentials, metadata: metadata, &blk)
+        end
+
+        AppOpticsAPM::Util.method_alias(GRPC::ClientStub, m)
+      end
+
+    end
+  end
+end