newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -1,140 +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 'json'
-
-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 id = decoded_id(env) and should_process_request?(id)
-            state = NewRelic::Agent::TransactionState.tl_get
-
-            state.client_cross_app_id = id
-            save_referring_transaction_info(state, env)
-            CrossAppTracing.assign_intrinsic_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_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)
-            end
-          end
-        end
-      end
-
-      def should_process_request? id
-        return cross_app_enabled? && CrossAppTracing.trusts?(id)
-      end
-
-      def cross_app_enabled?
-        NewRelic::Agent::CrossAppTracing.cross_app_enabled?
-      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(::JSON.dump(payload))
-      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,143 +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.
-
-require 'json'
-
-module NewRelic
-  module Agent
-    module CrossAppTracing
-
-      # The cross app response header for "outgoing" calls
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
-
-      # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'.freeze
-
-      # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
-
-      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'.freeze
-      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
-      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
-
-      ###############
-      module_function
-      ###############
-
-      def cross_app_enabled?
-        valid_cross_process_id? &&
-          valid_encoding_key? &&
-          cross_application_tracer_enabled?
-      end
-
-      def valid_cross_process_id?
-        if NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
-          true
-        else
-          NewRelic::Agent.logger.debug "No cross_process_id configured"
-          false
-        end
-      end
-
-      def valid_encoding_key?
-        if NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
-          true
-        else
-          NewRelic::Agent.logger.debug "No encoding_key set"
-          false
-        end
-      end
-
-      def cross_application_tracer_enabled?
-        NewRelic::Agent.config[:"cross_application_tracer.enabled"] || NewRelic::Agent.config[:cross_application_tracing]
-      end
-
-      def obfuscator
-        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
-      end
-
-      def insert_request_headers request, txn_guid, trip_id, path_hash
-        cross_app_id = NewRelic::Agent.config[:cross_process_id]
-        txn_data  = ::JSON.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)
-      end
-
-      def response_has_crossapp_header?(response)
-        if !!response[NR_APPDATA_HEADER]
-          true
-        else
-          NewRelic::Agent.logger.debug "No #{NR_APPDATA_HEADER} header"
-          false
-        end
-      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]
-
-        decoded_appdata = obfuscator.deobfuscate(appdata)
-        decoded_appdata.set_encoding(::Encoding::UTF_8) if
-          decoded_appdata.respond_to?(:set_encoding)
-
-        ::JSON.load(decoded_appdata)
-      end
-
-      def valid_cross_app_id?(xp_id)
-        !!(xp_id =~ /\A\d+#\d+\z/)
-      end
-
-      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
-        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(NewRelic::Agent.config[:cross_process_id])
-        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
-        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
-      end
-
-      def message_has_crossapp_request_header? headers
-        !!headers[NR_MESSAGE_BROKER_ID_HEADER]
-      end
-
-      def reject_messaging_cat_headers headers
-        headers.reject {|k,_| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER}
-      end
-
-      def trusts? id
-        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 trusted_valid_cross_app_id? id
-        valid_cross_app_id?(id) && trusts?(id)
-      end
-
-      def assign_intrinsic_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 transaction = state.current_transaction
-
-        if state.client_cross_app_id
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, state.client_cross_app_id)
-        end
-
-        if referring_guid = state.referring_transaction_info && state.referring_transaction_info[0]
-          transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/distributed_trace_monitor.rb

@@ -1,29 +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/inbound_request_monitor'
-require 'new_relic/agent/cross_app_tracing'
-
-module NewRelic
-  module Agent
-    class DistributedTraceMonitor < InboundRequestMonitor
-      NEWRELIC_TRACE_KEY  = 'HTTP_X_NEWRELIC_TRACE'.freeze
-      HTTP_TRANSPORT_TYPE = 'HTTP'.freeze
-
-      def on_finished_configuring(events)
-        return unless NewRelic::Agent.config[:'distributed_tracing.enabled']
-        events.subscribe(:before_call, &method(:on_before_call))
-      end
-
-      def on_before_call(request)
-        return unless CrossAppTracing.cross_app_enabled?
-        return unless payload = request[NEWRELIC_TRACE_KEY]
-
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        txn.accept_distributed_trace_payload HTTP_TRANSPORT_TYPE, payload
-      end
-    end
-  end
-end

data/lib/new_relic/agent/distributed_trace_payload.rb

@@ -1,223 +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 'json'
-require 'base64'
-
-module NewRelic
-  module Agent
-    class DistributedTracePayload
-      VERSION =[0, 0].freeze
-      CALLER_TYPE = "App".freeze
-      POUND = '#'.freeze
-
-      # Key names for serialization
-      VERSION_KEY             = 'v'.freeze
-      DATA_KEY                = 'd'.freeze
-      CALLER_TYPE_KEY         = 'ty'.freeze
-      CALLER_ACCOUNT_KEY      = 'ac'.freeze
-      CALLER_APP_KEY          = 'ap'.freeze
-      ID_KEY                  = 'id'.freeze
-      TRIP_ID_KEY             = 'tr'.freeze
-      SAMPLED_KEY             = 'sa'.freeze
-      PARENT_IDS_KEY          = 'pa'.freeze
-      DEPTH_KEY               = 'de'.freeze
-      ORDER_KEY               = 'or'.freeze
-      TIMESTAMP_KEY           = 'ti'.freeze
-      HOST_KEY                = 'ho'.freeze
-      SYNTHETICS_KEY          = 'sy'.freeze
-      SYNTHETICS_RESOURCE_KEY = 'r'.freeze
-      SYNTHETICS_JOB_KEY      = 'j'.freeze
-      SYNTHETICS_MONITOR_KEY  = 'm'.freeze
-
-      # Intrinsic Keys
-      CALLER_TYPE_INTRINSIC_KEY                = "caller.type".freeze
-      CALLER_APP_INTRINSIC_KEY                 = "caller.app".freeze
-      CALLER_ACCOUNT_ID_INTRINSIC_KEY          = "caller.account".freeze
-      CALLER_TRANSPORT_TYPE_INTRINSIC_KEY      = "caller.transportType".freeze
-      CALLER_TRANSPORT_DURATION_INTRINSIC_KEY  = "caller.transportDuration".freeze
-      CALLER_HOST_INTRINSIC_KEY                = "caller.host".freeze
-      DEPTH_INTRINSIC_KEY                      = "nr.depth".freeze
-      ORDER_INTRINSIC_KEY                      = "nr.order".freeze
-      GUID_INTRINSIC_KEY                       = "nr.guid".freeze
-      REFERRING_TRANSACTION_GUID_INTRINSIC_KEY = "nr.referringTransactionGuid".freeze
-      TRIP_ID_INTRINSIC_KEY                    = "nr.tripId".freeze
-      PARENT_IDS_INTRINSIC_KEY                 = "nr.parentIds".freeze
-      COMMA                                    = ",".freeze
-
-      INTRINSIC_KEYS = [
-        CALLER_TYPE_INTRINSIC_KEY,
-        CALLER_APP_INTRINSIC_KEY,
-        CALLER_ACCOUNT_ID_INTRINSIC_KEY,
-        CALLER_TRANSPORT_TYPE_INTRINSIC_KEY,
-        CALLER_TRANSPORT_DURATION_INTRINSIC_KEY,
-        CALLER_HOST_INTRINSIC_KEY,
-        DEPTH_INTRINSIC_KEY,
-        ORDER_INTRINSIC_KEY,
-        GUID_INTRINSIC_KEY,
-        REFERRING_TRANSACTION_GUID_INTRINSIC_KEY,
-        TRIP_ID_INTRINSIC_KEY,
-        PARENT_IDS_INTRINSIC_KEY
-      ].freeze
-
-      class << self
-        def for_transaction transaction, uri=nil
-          payload = new
-          return payload unless connected?
-
-          payload.version = VERSION
-          payload.caller_type = CALLER_TYPE
-
-          # We should not rely on the xp_id being formulated this way, but we have
-          # seen nil account ids coming down in staging for some accounts
-          account_id, fallback_app_id = Agent.config[:cross_process_id].split(POUND)
-          payload.caller_account_id = account_id
-
-          payload.caller_app_id =  if Agent.config[:application_id].empty?
-            fallback_app_id
-          else
-            Agent.config[:application_id]
-          end
-
-          payload.timestamp = (Time.now.to_f * 1000).round
-          payload.id = transaction.guid
-          payload.trip_id = transaction.distributed_tracing_trip_id
-          payload.sampled = transaction.sampled?
-          payload.parent_ids = transaction.parent_ids
-          payload.depth = transaction.depth + 1
-          payload.order = transaction.order
-          payload.host = uri.host if uri
-
-          if transaction.synthetics_payload
-            payload.synthetics_resource = transaction.synthetics_payload[2]
-            payload.synthetics_job = transaction.synthetics_payload[3]
-            payload.synthetics_monitor = transaction.synthetics_payload[4]
-          end
-
-          payload
-        end
-
-        def from_json serialized_payload
-          raw_payload = JSON.parse serialized_payload
-          payload_data = raw_payload[DATA_KEY]
-
-          payload = new
-          payload.version           = raw_payload[VERSION_KEY]
-          payload.caller_type       = payload_data[CALLER_TYPE_KEY]
-          payload.caller_account_id = payload_data[CALLER_ACCOUNT_KEY]
-          payload.caller_app_id     = payload_data[CALLER_APP_KEY]
-          payload.timestamp         = payload_data[TIMESTAMP_KEY]
-          payload.id                = payload_data[ID_KEY]
-          payload.trip_id           = payload_data[TRIP_ID_KEY]
-          payload.sampled           = payload_data[SAMPLED_KEY]
-          payload.parent_ids        = payload_data[PARENT_IDS_KEY]
-          payload.depth             = payload_data[DEPTH_KEY]
-          payload.order             = payload_data[ORDER_KEY]
-          payload.host              = payload_data[HOST_KEY]
-
-          if payload_synthetics = payload_data[SYNTHETICS_KEY]
-            payload.synthetics_resource = payload_synthetics[SYNTHETICS_RESOURCE_KEY]
-            payload.synthetics_job      = payload_synthetics[SYNTHETICS_JOB_KEY]
-            payload.synthetics_monitor  = payload_synthetics[SYNTHETICS_MONITOR_KEY]
-          end
-
-          payload
-        end
-
-        def from_http_safe http_safe_payload
-          decoded_payload = Base64.strict_decode64 http_safe_payload
-          from_json decoded_payload
-        end
-
-        #assigns intrinsics for the first distributed trace in a trip
-        def assign_initial_intrinsics transaction, payload
-          payload[TRIP_ID_INTRINSIC_KEY] = transaction.distributed_tracing_trip_id
-          payload[DEPTH_INTRINSIC_KEY] = transaction.depth
-          payload[PARENT_IDS_INTRINSIC_KEY] = transaction.parent_ids
-        end
-
-        private
-
-        # We use the presence of the cross_process_id in the config to tell if we
-        # have connected yet.
-        def connected?
-          !!Agent.config[:'cross_process_id']
-        end
-      end
-
-      attr_accessor :version,
-                    :caller_type,
-                    :caller_transport_type,
-                    :caller_account_id,
-                    :caller_app_id,
-                    :id,
-                    :trip_id,
-                    :sampled,
-                    :parent_ids,
-                    :synthetics_resource,
-                    :synthetics_job,
-                    :synthetics_monitor,
-                    :order,
-                    :depth,
-                    :timestamp,
-                    :host
-
-      alias_method :sampled?, :sampled
-
-      def synthetics?
-        !!(synthetics_resource || synthetics_job || synthetics_monitor)
-      end
-
-      def to_json
-        result = {
-          VERSION_KEY => version
-        }
-
-        result[DATA_KEY] = {
-          CALLER_TYPE_KEY    => caller_type,
-          CALLER_ACCOUNT_KEY => caller_account_id,
-          CALLER_APP_KEY     => caller_app_id,
-          ID_KEY             => id,
-          TRIP_ID_KEY        => trip_id,
-          SAMPLED_KEY        => sampled,
-          PARENT_IDS_KEY     => parent_ids,
-          DEPTH_KEY          => depth,
-          ORDER_KEY          => order,
-          HOST_KEY           => host,
-          TIMESTAMP_KEY      => timestamp,
-        }
-
-        if synthetics?
-          result[DATA_KEY][SYNTHETICS_KEY] = {
-            SYNTHETICS_RESOURCE_KEY => synthetics_resource,
-            SYNTHETICS_JOB_KEY      => synthetics_job,
-            SYNTHETICS_MONITOR_KEY  => synthetics_monitor
-          }
-        end
-
-        JSON.dump(result)
-      end
-
-      alias_method :text, :to_json
-
-      def http_safe
-        Base64.strict_encode64 to_json
-      end
-
-      def assign_intrinsics transaction, payload
-        payload[CALLER_TYPE_INTRINSIC_KEY] = caller_type
-        payload[CALLER_APP_INTRINSIC_KEY] = caller_app_id
-        payload[CALLER_ACCOUNT_ID_INTRINSIC_KEY] = caller_account_id
-        payload[CALLER_TRANSPORT_TYPE_INTRINSIC_KEY] = caller_transport_type
-        payload[CALLER_TRANSPORT_DURATION_INTRINSIC_KEY] = transaction.transport_duration
-        payload[CALLER_HOST_INTRINSIC_KEY] = host
-        payload[DEPTH_INTRINSIC_KEY] = depth
-        payload[ORDER_INTRINSIC_KEY] = order
-        payload[GUID_INTRINSIC_KEY] = transaction.guid
-        payload[REFERRING_TRANSACTION_GUID_INTRINSIC_KEY] = id
-        payload[TRIP_ID_INTRINSIC_KEY] = trip_id
-        payload[PARENT_IDS_INTRINSIC_KEY] = parent_ids.join COMMA if parent_ids
-      end
-    end
-  end
-end