oneapm_rpm 1.1.0

data/lib/one_apm/agent/cross_app/cross_app_monitor.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+require 'digest'
+
+require 'one_apm/agent/inbound_request_monitor'
+require 'one_apm/agent/threading/agent_thread'
+require 'one_apm/transaction/transaction_state'
+
+module OneApm
+  module Agent
+    class CrossAppMonitor < InboundRequestMonitor
+
+      ONEAPM_ID_HEADER      = 'X-OneApm-ID'
+      ONEAPM_TXN_HEADER     = 'X-OneApm-Transaction'
+      ONEAPM_APPDATA_HEADER = 'X-OneApm-App-Data'
+
+      ONEAPM_ID_HEADER_KEY      = 'HTTP_X_ONEAPM_ID'.freeze
+      ONEAPM_TXN_HEADER_KEY     = 'HTTP_X_ONEAPM_TRANSACTION'.freeze
+      CONTENT_LENGTH_HEADER_KEY = 'HTTP_CONTENT_LENGTH'.freeze
+
+      def on_finished_configuring(events)
+        register_event_listeners(events)
+      end
+
+      # Expected sequence of events:
+      #   :before_call will save our cross application request id to the thread
+      #   :after_call will write our response headers/metrics and clean up the thread
+      def register_event_listeners(events)
+        OneApm::Agent.logger.
+          debug("Wiring up Cross Application Tracing to events after finished configuring")
+
+        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
+          if should_process_request(env)
+            state = OneApm::TransactionState.tl_get
+
+            save_client_cross_app_id(state, env)
+            save_referring_transaction_info(state, env)
+            set_transaction_custom_parameters(state)
+          end
+        end
+
+        events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
+          state = OneApm::TransactionState.tl_get
+
+          insert_response_header(state, env, headers)
+        end
+
+        events.subscribe(:notice_error) do |_, options| #THREAD_LOCAL_ACCESS
+          state = OneApm::TransactionState.tl_get
+
+          set_error_custom_parameters(state, options)
+        end
+      end
+
+      def save_client_cross_app_id(state, request_headers)
+        state.client_cross_app_id = decoded_id(request_headers)
+      end
+
+      def clear_client_cross_app_id(state)
+        state.client_cross_app_id = nil
+      end
+
+      def save_referring_transaction_info(state, request_headers)
+        txn_header = request_headers[ONEAPM_TXN_HEADER_KEY] or return
+        txn_info = deserialize_header(txn_header, ONEAPM_TXN_HEADER)
+        state.referring_transaction_info = txn_info
+      end
+
+      def client_referring_transaction_guid(state)
+        info = state.referring_transaction_info or return nil
+        return info[0]
+      end
+
+      def client_referring_transaction_record_flag(state)
+        info = state.referring_transaction_info or return nil
+        return info[1]
+      end
+
+      def client_referring_transaction_trip_id(state)
+        info = state.referring_transaction_info or return nil
+        return info[2].is_a?(String) && info[2]
+      end
+
+      def client_referring_transaction_path_hash(state)
+        info = state.referring_transaction_info or return nil
+        return info[3].is_a?(String) && info[3]
+      end
+
+      def insert_response_header(state, request_headers, response_headers)
+        unless state.client_cross_app_id.nil?
+          txn = state.current_transaction
+          unless txn.nil?
+            txn.freeze_name_and_execute_if_not_ignored do
+              timings = state.timings
+              content_length = content_length_from_request(request_headers)
+
+              set_response_headers(state, response_headers, timings, content_length)
+              set_metrics(state.client_cross_app_id, timings)
+            end
+          end
+          clear_client_cross_app_id(state)
+        end
+      end
+
+      def should_process_request(request_headers)
+        return cross_app_enabled? && trusts?(request_headers)
+      end
+
+      def cross_app_enabled?
+        OneApm::Agent::CrossAppTracing.cross_app_enabled?
+      end
+
+      # Expects an ID of format "12#345", and will only accept that!
+      def trusts?(request)
+        id = decoded_id(request)
+        split_id = id.match(/(\d+)#\d+/)
+        return false if split_id.nil?
+
+        OneApm::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
+      end
+
+      def set_response_headers(state, response_headers, timings, content_length)
+        response_headers[ONEAPM_APPDATA_HEADER] = build_payload(state, timings, content_length)
+      end
+
+      def build_payload(state, timings, content_length)
+        payload = [
+          OneApm::Agent.config[:cross_process_id],
+          timings.transaction_name,
+          timings.queue_time_in_seconds.to_f,
+          timings.app_time_in_seconds.to_f,
+          content_length,
+          state.request_guid
+        ]
+        payload = obfuscator.obfuscate(OneApm::JSONWrapper.dump(payload))
+      end
+
+      def set_transaction_custom_parameters(state)
+        # We expect to get the before call to set the id (if we have it) before
+        # this, and then write our custom parameter when the transaction starts
+        OneApm::Agent.add_custom_parameters(:client_cross_process_id => state.client_cross_app_id) if state.client_cross_app_id
+
+        referring_guid = client_referring_transaction_guid(state)
+        if referring_guid
+          OneApm::Agent.add_custom_parameters(:referring_transaction_guid => referring_guid)
+        end
+      end
+
+      def set_error_custom_parameters(state, options)
+        options[:client_cross_process_id] = state.client_cross_app_id if state.client_cross_app_id
+      end
+
+      def set_metrics(id, timings)
+        metric_name = "ClientApplication/#{id}/all"
+        OneApm::Agent.record_metric(metric_name, timings.app_time_in_seconds)
+      end
+
+      def decoded_id(request)
+        encoded_id = request[ONEAPM_ID_HEADER_KEY]
+        return "" if encoded_id.nil?
+
+        obfuscator.deobfuscate(encoded_id)
+      end
+
+      def content_length_from_request(request)
+        request[CONTENT_LENGTH_HEADER_KEY] || -1
+      end
+
+      def hash_transaction_name(identifier)
+        Digest::MD5.digest(identifier).unpack("@12N").first & 0xffffffff
+      end
+
+      def path_hash(txn_name, seed)
+        rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
+        app_name   = OneApm::Agent.config.app_names.first
+        identifier = "#{app_name};#{txn_name}"
+        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
+      end
+    end
+  end
+end

data/lib/one_apm/agent/cross_app/cross_app_tracing.rb

@@ -0,0 +1,336 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module CrossAppTracing
+
+      # Exception raised if there is a problem with cross app transactions.
+      class Error < RuntimeError; end
+
+      # The cross app response header for "outgoing" calls
+      OA_APPDATA_HEADER = 'X-OneApm-App-Data'
+
+      # The cross app id header for "outgoing" calls
+      OA_ID_HEADER = 'X-OneApm-ID'
+
+      # The cross app transaction header for "outgoing" calls
+      OA_TXN_HEADER = 'X-OneApm-Transaction'
+
+      # The cross app synthetics header
+      OA_SYNTHETICS_HEADER = 'X-OneApm-Synthetics'
+
+      # The index of the transaction GUID in the appdata header of responses
+      APPDATA_TXN_GUID_INDEX = 5
+
+
+      ###############
+      module_function
+      ###############
+
+      # Send the given +request+, adding metrics appropriate to the
+      # response when it comes back.
+      #
+      # See the documentation for +start_trace+ for an explanation of what
+      # +request+ should look like.
+      #
+      def tl_trace_http_request(request)
+        state = OneApm::TransactionState.tl_get
+        return yield unless state.is_execution_traced?
+
+        # It's important to set t0 outside the ensured block, otherwise there's
+        # a race condition if we raise after begin but before t0's set.
+        t0 = Time.now
+        begin
+          segment = start_trace(state, t0, request)
+          response = yield
+        ensure
+          finish_trace(state, t0, segment, request, response)
+        end
+
+        return response
+      end
+
+      # Set up the necessary state for cross-application tracing before the
+      # given +request+ goes out.
+      #
+      # The +request+ object passed in must respond to the following methods:
+      #
+      # * type - Return a String describing the underlying library being used
+      #          to make the request (e.g. 'Net::HTTP' or 'Typhoeus')
+      # * host - Return a String with the hostname or IP of the host being
+      #          communicated with.
+      # * method  - Return a String with the HTTP method name for this request
+      # * [](key) - Lookup an HTTP request header by name
+      # * []=(key, val) - Set an HTTP request header by name
+      # * uri  - Full URI of the request
+      #
+      # This method returns the transaction segment if it was sucessfully pushed.
+      def start_trace(state, t0, request)
+        inject_request_headers(state, request) if cross_app_enabled?
+        stack = state.traced_method_stack
+        segment = stack.push_frame(state, :http_request, t0)
+
+        return segment
+      rescue => err
+        OneApm::Agent.logger.error "Uncaught exception while tracing HTTP request", err
+        return nil
+      rescue Exception => e
+        OneApm::Agent.logger.debug "Unexpected exception raised while tracing HTTP request", e
+
+        raise e
+      end
+
+
+      # Finish tracing the HTTP +request+ that started at +t0+ with the information in
+      # +response+ and the given +http+ connection.
+      #
+      # The +request+ must conform to the same interface described in the documentation
+      # for +start_trace+.
+      #
+      # The +response+ must respond to the following methods:
+      #
+      # * [](key) - Reads response headers.
+      # * to_hash - Converts response headers to a Hash
+      #
+      def finish_trace(state, t0, segment, request, response)
+        unless t0
+          OneApm::Agent.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
+          return
+        end
+
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+
+        begin
+          if request
+            # Figure out which metrics we need to report based on the request and response
+            # The last (most-specific) one is scoped.
+            metrics = metrics_for(request, response)
+            scoped_metric = metrics.pop
+
+            stats_engine.record_scoped_and_unscoped_metrics(
+              state, scoped_metric, metrics, duration)
+
+            # If we don't have segment, something failed during start_trace so
+            # the current segment isn't the HTTP call it should have been.
+            if segment
+              segment.name = scoped_metric
+              add_transaction_trace_parameters(request, response)
+            end
+          end
+        ensure
+          # If we have a segment, always pop the traced method stack to avoid
+          # an inconsistent state, which prevents tracing of whole transaction.
+          if segment
+            stack = state.traced_method_stack
+            stack.pop_frame(state, segment, scoped_metric, t1)
+          end
+        end
+      rescue OneApm::Agent::CrossAppTracing::Error => err
+        OneApm::Agent.logger.debug "while cross app tracing", err
+      rescue => err
+        OneApm::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
+      end
+
+      # Return +true+ if cross app tracing is enabled in the config.
+      def cross_app_enabled?
+        valid_cross_process_id? &&
+          valid_encoding_key? &&
+          cross_application_tracer_enabled?
+      end
+
+      def valid_cross_process_id?
+        OneApm::Agent.config[:cross_process_id] && OneApm::Agent.config[:cross_process_id].length > 0
+      end
+
+      def valid_encoding_key?
+        OneApm::Agent.config[:encoding_key] && OneApm::Agent.config[:encoding_key].length > 0
+      end
+
+      def cross_application_tracer_enabled?
+        OneApm::Agent.config[:"cross_application_tracer.enabled"]
+      end
+
+      # Fetcher for the cross app encoding key. Raises a
+      # OneApm::Agent::CrossAppTracing::Error if the key isn't configured.
+      def cross_app_encoding_key
+        OneApm::Agent.config[:encoding_key] or
+          raise OneApm::Agent::CrossAppTracing::Error, "No encoding_key set."
+      end
+
+      def obfuscator
+        @obfuscator ||= OneApm::Agent::Obfuscator.new(cross_app_encoding_key)
+      end
+
+      # Inject the X-Process header into the outgoing +request+.
+      def inject_request_headers(state, request)
+        cross_app_id = OneApm::Agent.config[:cross_process_id] or
+          raise OneApm::Agent::CrossAppTracing::Error, "no cross app ID configured"
+
+        state.is_cross_app_caller = true
+        txn_guid = state.request_guid
+        txn = state.current_transaction
+        if txn
+          trip_id   = txn.cat_trip_id(state)
+          path_hash = txn.cat_path_hash(state)
+
+          if txn.raw_synthetics_header
+            request[OA_SYNTHETICS_HEADER] = txn.raw_synthetics_header
+          end
+        end
+        txn_data  = OneApm::JSONWrapper.dump([txn_guid, false, trip_id, path_hash])
+
+        request[OA_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
+        request[OA_TXN_HEADER] = obfuscator.obfuscate(txn_data)
+
+      rescue OneApm::Agent::CrossAppTracing::Error => err
+        OneApm::Agent.logger.debug "Not injecting x-process header", err
+      end
+
+      def add_transaction_trace_parameters(request, response)
+        filtered_uri = ::OneApm::Support::HTTPClients::URIUtil.filter_uri(request.uri)
+        transaction_sampler.add_segment_parameters(:uri => filtered_uri)
+        if response && response_is_crossapp?(response)
+          add_cat_transaction_trace_parameters(response)
+        end
+      end
+
+
+      # Extract any custom parameters from +response+ if it's cross-application and
+      # add them to the current TT node.
+      def add_cat_transaction_trace_parameters( response )
+        appdata = extract_appdata( response )
+        transaction_sampler.add_segment_parameters( \
+          :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
+      end
+
+
+      # Return the set of metric names that correspond to
+      # the given +request+ and +response+.
+      # +response+ may be nil in the case that the request produced an error
+      # without ever receiving an HTTP response.
+      def metrics_for( request, response )
+        metrics = common_metrics( request )
+
+        if response && response_is_crossapp?( response )
+          begin
+            metrics.concat metrics_for_crossapp_response( request, response )
+          rescue => err
+            # Fall back to regular metrics if there's a problem with x-process metrics
+            OneApm::Agent.logger.debug "%p while fetching x-process metrics: %s" %
+              [ err.class, err.message ]
+            metrics.concat metrics_for_regular_request( request )
+          end
+        else
+          metrics.concat metrics_for_regular_request( request )
+        end
+
+        return metrics
+      end
+
+
+      # Return an Array of metrics used for every response.
+      def common_metrics( request )
+        metrics = [ "External/all" ]
+        metrics << "External/#{request.host}/all"
+
+        if OneApm::Transaction.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+
+        return metrics
+      end
+
+
+      # Returns +true+ if Cross Application Tracing is enabled, and the given +response+
+      # has the appropriate headers.
+      def response_is_crossapp?( response )
+        return false unless cross_app_enabled?
+        unless response[OA_APPDATA_HEADER]
+          return false
+        end
+
+        return true
+      end
+
+
+      # Return the set of metric objects appropriate for the given cross app
+      # +response+.
+      def metrics_for_crossapp_response( request, response )
+        xp_id, txn_name, _q_time, _r_time, _req_len, _ = extract_appdata( response )
+
+        check_crossapp_id( xp_id )
+        check_transaction_name( txn_name )
+
+        metrics = []
+        metrics << "ExternalApp/#{request.host}/#{xp_id}/all"
+        metrics << "ExternalTransaction/#{request.host}/#{xp_id}/#{txn_name}"
+
+        return metrics
+      end
+
+
+      # Extract x-process application data from the specified +response+ and return
+      # it as an array of the form:
+      #
+      #  [
+      #    <cross app ID>,
+      #    <transaction name>,
+      #    <queue time in seconds>,
+      #    <response time in seconds>,
+      #    <request content length in bytes>,
+      #    <transaction GUID>
+      #  ]
+      def extract_appdata( response )
+        appdata = response[OA_APPDATA_HEADER] or
+          raise OneApm::Agent::CrossAppTracing::Error,
+            "Can't derive metrics for response: no #{OA_APPDATA_HEADER} header!"
+
+        decoded_appdata = obfuscator.deobfuscate( appdata )
+        decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
+          decoded_appdata.respond_to?( :set_encoding )
+
+        return OneApm::JSONWrapper.load( decoded_appdata )
+      end
+
+
+      # Return the set of metric objects appropriate for the given (non-cross app)
+      # +request+.
+      def metrics_for_regular_request( request )
+        metrics = []
+        metrics << "External/#{request.host}/#{request.type}/#{request.method}"
+
+        return metrics
+      end
+
+
+      # Fetch a reference to the stats engine.
+      def stats_engine
+        OneApm::Agent.instance.stats_engine
+      end
+
+      def transaction_sampler
+        OneApm::Agent.instance.transaction_sampler
+      end
+
+      # Check the given +id+ to ensure it conforms to the format of a cross-application
+      # ID. Raises an OneApm::Agent::CrossAppTracing::Error if it doesn't.
+      def check_crossapp_id( id )
+        id =~ /\A\d+#\d+\z/ or
+          raise OneApm::Agent::CrossAppTracing::Error,
+            "malformed cross application ID %p" % [ id ]
+      end
+
+
+      # Check the given +name+ to ensure it conforms to the format of a valid transaction
+      # name.
+      def check_transaction_name( name )
+        # No-op -- apparently absolutely anything is a valid transaction name?
+        # This is here for when that inevitably comes back to haunt us.
+      end
+
+    end
+  end
+end