newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -1,178 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'digest'
-
-require 'new_relic/agent/inbound_request_monitor'
-require 'new_relic/agent/transaction_state'
-require 'new_relic/agent/threading/agent_thread'
-
-module NewRelic
-  module Agent
-    class CrossAppMonitor < InboundRequestMonitor
-
-      NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'
-      NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'
-      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'
-
-      NEWRELIC_ID_HEADER_KEY    = 'HTTP_X_NEWRELIC_ID'.freeze
-      NEWRELIC_TXN_HEADER_KEY   = 'HTTP_X_NEWRELIC_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)
-        NewRelic::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 = NewRelic::Agent::TransactionState.tl_get
-
-            save_client_cross_app_id(state, env)
-            save_referring_transaction_info(state, env)
-            set_transaction_attributes(state)
-          end
-        end
-
-        events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-
-          insert_response_header(state, env, headers)
-        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[NEWRELIC_TXN_HEADER_KEY] or return
-        txn_info = deserialize_header(txn_header, NEWRELIC_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?
-        NewRelic::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?
-
-        NewRelic::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[NEWRELIC_APPDATA_HEADER] = build_payload(state, timings, content_length)
-      end
-
-      def build_payload(state, timings, content_length)
-        payload = [
-          NewRelic::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(NewRelic::JSONWrapper.dump(payload))
-      end
-
-      def set_transaction_attributes(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
-        return unless txn = state.current_transaction
-
-        if state.client_cross_app_id
-          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, state.client_cross_app_id)
-        end
-
-        referring_guid = client_referring_transaction_guid(state)
-        if referring_guid
-          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
-        end
-      end
-
-      def set_metrics(id, timings)
-        metric_name = "ClientApplication/#{id}/all"
-        NewRelic::Agent.record_metric(metric_name, timings.app_time_in_seconds)
-      end
-
-      def decoded_id(request)
-        encoded_id = request[NEWRELIC_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   = NewRelic::Agent.config.app_names.first
-        identifier = "#{app_name};#{txn_name}"
-        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
-      end
-    end
-  end
-end

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -1,339 +0,0 @@
-# -*- ruby -*-
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  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
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
-
-      # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'
-
-      # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'
-
-      # The cross app synthetics header
-      NR_SYNTHETICS_HEADER = 'X-NewRelic-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 = NewRelic::Agent::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
-          node = start_trace(state, t0, request)
-          response = yield
-        ensure
-          finish_trace(state, t0, node, 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 node 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
-        node = stack.push_frame(state, :http_request, t0)
-
-        return node
-      rescue => err
-        NewRelic::Agent.logger.error "Uncaught exception while tracing HTTP request", err
-        return nil
-      rescue Exception => e
-        NewRelic::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, node, request, response)
-        unless t0
-          NewRelic::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 node, something failed during start_trace so
-            # the current node isn't the HTTP call it should have been.
-            if node
-              node.name = scoped_metric
-              add_transaction_trace_parameters(request, response)
-            end
-          end
-        ensure
-          # If we have a node, always pop the traced method stack to avoid
-          # an inconsistent state, which prevents tracing of whole transaction.
-          if node
-            stack = state.traced_method_stack
-            stack.pop_frame(state, node, scoped_metric, t1)
-          end
-        end
-      rescue NewRelic::Agent::CrossAppTracing::Error => err
-        NewRelic::Agent.logger.debug "while cross app tracing", err
-      rescue => err
-        NewRelic::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?
-        NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
-      end
-
-      def valid_encoding_key?
-        NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
-      end
-
-      def cross_application_tracer_enabled?
-        NewRelic::Agent.config[:"cross_application_tracer.enabled"] || NewRelic::Agent.config[:cross_application_tracing]
-      end
-
-      # Fetcher for the cross app encoding key. Raises a
-      # NewRelic::Agent::CrossAppTracing::Error if the key isn't configured.
-      def cross_app_encoding_key
-        NewRelic::Agent.config[:encoding_key] or
-          raise NewRelic::Agent::CrossAppTracing::Error, "No encoding_key set."
-      end
-
-      def obfuscator
-        @obfuscator ||= NewRelic::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 = NewRelic::Agent.config[:cross_process_id] or
-          raise NewRelic::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[NR_SYNTHETICS_HEADER] = txn.raw_synthetics_header
-          end
-        end
-        txn_data  = NewRelic::JSONWrapper.dump([txn_guid, false, trip_id, path_hash])
-
-        request[NR_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
-        request[NR_TXN_HEADER] = obfuscator.obfuscate(txn_data)
-
-      rescue NewRelic::Agent::CrossAppTracing::Error => err
-        NewRelic::Agent.logger.debug "Not injecting x-process header", err
-      end
-
-      def add_transaction_trace_parameters(request, response)
-        filtered_uri = ::NewRelic::Agent::HTTPClients::URIUtil.filter_uri(request.uri)
-        transaction_sampler.add_node_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_node_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
-            NewRelic::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 NewRelic::Agent::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[NR_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[NR_APPDATA_HEADER] or
-          raise NewRelic::Agent::CrossAppTracing::Error,
-            "Can't derive metrics for response: no #{NR_APPDATA_HEADER} header!"
-
-        decoded_appdata = obfuscator.deobfuscate( appdata )
-        decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
-          decoded_appdata.respond_to?( :set_encoding )
-
-        return NewRelic::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
-        NewRelic::Agent.instance.stats_engine
-      end
-
-      def transaction_sampler
-        NewRelic::Agent.instance.transaction_sampler
-      end
-
-      # Check the given +id+ to ensure it conforms to the format of a cross-application
-      # ID. Raises an NewRelic::Agent::CrossAppTracing::Error if it doesn't.
-      def check_crossapp_id( id )
-        id =~ /\A\d+#\d+\z/ or
-          raise NewRelic::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

data/lib/new_relic/agent/datastores/mongo/obfuscator.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        module Obfuscator
-
-          WHITELIST = [:operation].freeze
-
-          def self.obfuscate_statement(source, whitelist=WHITELIST)
-            obfuscated = {}
-            source.each do |key, value|
-              if whitelist.include?(key)
-                obfuscated[key] = value
-              else
-                obfuscated[key] = obfuscate_value(value, whitelist)
-              end
-            end
-
-            obfuscated
-          end
-
-          def self.obfuscate_value(value, whitelist)
-            if value.is_a?(Hash)
-              obfuscate_statement(value, whitelist)
-            elsif value.is_a?(Array)
-              value.map {|v| obfuscate_value(v, whitelist)}
-            else
-              '?'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/datastores/mongo/statement_formatter.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/datastores/mongo/obfuscator'
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        module StatementFormatter
-
-          PLAINTEXT_KEYS = [
-            :database,
-            :collection,
-            :operation,
-            :fields,
-            :skip,
-            :limit,
-            :order
-          ]
-
-          OBFUSCATE_KEYS = [
-            :selector
-          ]
-
-          def self.format(statement, operation)
-            return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
-
-            result = { :operation => operation }
-
-            PLAINTEXT_KEYS.each do |key|
-              result[key] = statement[key] if statement.key?(key)
-            end
-
-            OBFUSCATE_KEYS.each do |key|
-              if statement.key?(key) && statement[key]
-                obfuscated = obfuscate(statement[key])
-                result[key] = obfuscated if obfuscated
-              end
-            end
-            result
-          end
-
-          def self.obfuscate(statement)
-            statement = Obfuscator.obfuscate_statement(statement) if NewRelic::Agent.config[:'mongo.obfuscate_queries']
-            statement
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/hash_extensions.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module Agent
-    module HashExtensions
-      module_function
-
-      # recurses through hashes and arrays and stringifies keys
-      def stringify_keys_in_object(object)
-        case object
-        when Hash
-          object.inject({}) do |memo, (k, v)|
-            memo[k.to_s] = stringify_keys_in_object(v)
-            memo
-          end
-        when Array
-          object.map {|o| stringify_keys_in_object(o)}
-        else
-          object
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/inbound_request_monitor.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-# This class serves as the base for objects wanting to monitor and respond to
-# incoming web requests. Examples include cross application tracing and
-# synthetics.
-#
-# Subclasses are expected to define on_finished_configuring(events) which will
-# be called when the agent is fully configured. That method is expected to
-# subscribe to the necessary request events, such as before_call and after_call
-# for the monitor to do its work.
-module NewRelic
-  module Agent
-    class InboundRequestMonitor
-
-      attr_reader :obfuscator
-
-      def initialize(events)
-        events.subscribe(:finished_configuring) do
-          # This requires :encoding_key, so must wait until :finished_configuring
-          setup_obfuscator
-          on_finished_configuring(events)
-        end
-      end
-
-      def setup_obfuscator
-        @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
-      end
-
-      def deserialize_header(encoded_header, key)
-        decoded_header = obfuscator.deobfuscate(encoded_header)
-        NewRelic::JSONWrapper.load(decoded_header)
-      rescue => err
-        # If we have a failure of any type here, just return nil and carry on
-        NewRelic::Agent.logger.debug("Failure deserializing encoded header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
-        nil
-      end
-    end
-  end
-end