newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/monitors/cross_app_monitor.rb

@@ -0,0 +1,117 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+require 'new_relic/agent/tracer'
+require 'new_relic/agent/threading/agent_thread'
+
+module NewRelic
+  module Agent
+    module DistributedTracing
+      class CrossAppMonitor < InboundRequestMonitor
+        NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
+        NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
+
+        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)
+          if CrossAppTracing.cross_app_enabled?
+            Deprecator.deprecate('cross_application_tracer')
+            ::NewRelic::Agent.logger.warn(
+              "[DEPRECATED] Cross application tracing is enabled. Distributed tracing is replacing cross application tracing as the default means of tracing between services. To continue using cross application tracing, enable it with `cross_application_tracer.enabled: true` and `distributed_tracing.enabled: false`"
+            )
+          end
+
+          register_event_listeners(events)
+        end
+
+        def path_hash(txn_name, seed)
+          rotated = ((seed << 1) | (seed >> 31)) & 0xffffffff
+          app_name = NewRelic::Agent.config[:app_name].first
+          identifier = "#{app_name};#{txn_name}"
+          sprintf("%08x", rotated ^ hash_transaction_name(identifier))
+        end
+
+        private
+
+        # 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::Tracer.state
+
+              if (txn = state.current_transaction)
+                transaction_info = referring_transaction_info(state, env)
+
+                payload = CrossAppPayload.new(id, txn, transaction_info)
+                txn.distributed_tracer.cross_app_payload = payload
+              end
+
+              CrossAppTracing.assign_intrinsic_transaction_attributes(state)
+            end
+          end
+
+          events.subscribe(:after_call) do |env, (_status_code, headers, _body)| # THREAD_LOCAL_ACCESS
+            state = NewRelic::Agent::Tracer.state
+
+            insert_response_header(state, env, headers)
+          end
+        end
+
+        def referring_transaction_info(state, request_headers)
+          txn_header = request_headers[NEWRELIC_TXN_HEADER_KEY] or return
+          deserialize_header(txn_header, NEWRELIC_TXN_HEADER)
+        end
+
+        def insert_response_header(state, request_headers, response_headers)
+          txn = state.current_transaction
+          unless txn.nil? || txn.distributed_tracer.cross_app_payload.nil?
+            txn.freeze_name_and_execute_if_not_ignored do
+              content_length = content_length_from_request(request_headers)
+              set_response_headers(txn, response_headers, content_length)
+            end
+          end
+        end
+
+        def should_process_request?(id)
+          CrossAppTracing.cross_app_enabled? && CrossAppTracing.trusts?(id)
+        end
+
+        def set_response_headers(transaction, response_headers, content_length)
+          payload = obfuscator.obfuscate(
+            ::JSON.dump(
+              transaction.distributed_tracer.cross_app_payload.as_json_array(content_length)
+            )
+          )
+
+          response_headers[NEWRELIC_APPDATA_HEADER] = payload
+        end
+
+        def decoded_id(request)
+          encoded_id = request[NEWRELIC_ID_HEADER_KEY]
+          return NewRelic::EMPTY_STR if encoded_id.nil? || encoded_id.empty?
+
+          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
+      end
+    end
+  end
+end

data/lib/new_relic/agent/monitors/distributed_tracing_monitor.rb

@@ -0,0 +1,28 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTracing
+      class Monitor < InboundRequestMonitor
+        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)
+          unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+            NewRelic::Agent.logger.warn("Not configured to accept distributed trace headers")
+            return
+          end
+
+          return unless txn = Tracer.current_transaction
+
+          txn.distributed_tracer.accept_incoming_request(request)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/{inbound_request_monitor.rb → monitors/inbound_request_monitor.rb}

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This class serves as the base for objects wanting to monitor and respond to
 # incoming web requests. Examples include cross application tracing and
@@ -16,19 +16,18 @@ require 'json'
 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
+        events.subscribe(:initial_configuration_complete) do
+          # This requires :encoding_key, so must wait until :initial_configuration_complete
           setup_obfuscator
           on_finished_configuring(events)
         end
       end
 
       def setup_obfuscator
-        @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator = Obfuscator.new(Agent.config[:encoding_key])
       end
 
       def deserialize_header(encoded_header, key)

data/lib/new_relic/agent/{synthetics_monitor.rb → monitors/synthetics_monitor.rb}

@@ -1,13 +1,11 @@
-# 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'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class SyntheticsMonitor < InboundRequestMonitor
-      SYNTHETICS_HEADER_KEY  = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
+      SYNTHETICS_HEADER_KEY = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
 
       SUPPORTED_VERSION = 1
       EXPECTED_PAYLOAD_LENGTH = 5
@@ -16,7 +14,7 @@ module NewRelic
         events.subscribe(:before_call, &method(:on_before_call))
       end
 
-      def on_before_call(request) #THREAD_LOCAL_ACCESS
+      def on_before_call(request) # THREAD_LOCAL_ACCESS
         encoded_header = request[SYNTHETICS_HEADER_KEY]
         return unless encoded_header
 
@@ -27,33 +25,29 @@ module NewRelic
           SyntheticsMonitor.is_supported_version?(incoming_payload) &&
           SyntheticsMonitor.is_trusted?(incoming_payload)
 
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
+        txn = Tracer.current_transaction
         txn.raw_synthetics_header = encoded_header
-        txn.synthetics_payload    = incoming_payload
+        txn.synthetics_payload = incoming_payload
       end
 
       class << self
-
         def is_supported_version?(incoming_payload)
           incoming_payload.first == SUPPORTED_VERSION
         end
 
         def is_trusted?(incoming_payload)
           account_id = incoming_payload[1]
-          NewRelic::Agent.config[:trusted_account_ids].include?(account_id)
+          Agent.config[:trusted_account_ids].include?(account_id)
         end
 
         def is_valid_payload?(incoming_payload)
           incoming_payload.length == EXPECTED_PAYLOAD_LENGTH
         end
 
-        def reject_messaging_synthetics_header headers
-          headers.reject {|k,_| k == NewRelic::Agent::CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER}
+        def reject_messaging_synthetics_header(headers)
+          headers.reject { |k, _| k == CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER }
         end
-
       end
-
     end
   end
 end

data/lib/new_relic/agent/monitors.rb

@@ -0,0 +1,26 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'monitors/inbound_request_monitor'
+
+require_relative 'monitors/synthetics_monitor'
+
+require_relative 'monitors/cross_app_monitor'
+require_relative 'monitors/distributed_tracing_monitor'
+
+module NewRelic
+  module Agent
+    class Monitors
+      attr_reader :cross_app_monitor
+      attr_reader :synthetics_monitor
+      attr_reader :distributed_tracing_monitor
+
+      def initialize(events)
+        @synthetics_monitor = NewRelic::Agent::SyntheticsMonitor.new(events)
+        @cross_app_monitor = NewRelic::Agent::DistributedTracing::CrossAppMonitor.new(events)
+        @distributed_tracing_monitor = NewRelic::Agent::DistributedTracing::Monitor.new(events)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service/encoders.rb

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'base64'
 require 'json'
@@ -12,14 +12,14 @@ module NewRelic
     class NewRelicService
       module Encoders
         module Identity
-          def self.encode(data, opts=nil)
+          def self.encode(data, opts = nil)
             data
           end
         end
 
         module Compressed
           module Deflate
-            def self.encode(data, opts=nil)
+            def self.encode(data, opts = nil)
               Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
             end
           end
@@ -27,9 +27,9 @@ module NewRelic
           module Gzip
             BINARY = "BINARY".freeze
 
-            def self.encode(data, opts=nil)
+            def self.encode(data, opts = nil)
               output = StringIO.new
-              output.set_encoding BINARY
+              output.set_encoding(BINARY)
               gz = Zlib::GzipWriter.new(output, Zlib::DEFAULT_COMPRESSION, Zlib::DEFAULT_STRATEGY)
               gz.write(data)
               gz.close
@@ -40,7 +40,7 @@ module NewRelic
         end
 
         module Base64CompressedJSON
-          def self.encode(data, opts={})
+          def self.encode(data, opts = {})
             if !opts[:skip_normalization] && Agent.config[:normalize_json_string_encodings]
               data = NewRelic::Agent::EncodingNormalizer.normalize_object(data)
             end

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'json'
 require 'new_relic/agent/new_relic_service/marshaller'
@@ -20,14 +20,14 @@ module NewRelic
           if defined?(::Yajl)
             require 'yajl/version'
             if Gem::Version.new(::Yajl::VERSION) < OK_YAJL_VERSION
-              ::NewRelic::Agent.logger.warn "Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available."
+              ::NewRelic::Agent.logger.warn("Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available.")
             end
           end
         rescue => err
-          ::NewRelic::Agent.logger.warn "Failed trying to watch for problematic yajl-ruby version.", err
+          ::NewRelic::Agent.logger.warn("Failed trying to watch for problematic yajl-ruby version.", err)
         end
 
-        def dump(ruby, opts={})
+        def dump(ruby, opts = {})
           prepared = prepare(ruby, opts)
 
           if !opts[:skip_normalization] && Agent.config[:normalize_json_string_encodings]
@@ -39,13 +39,12 @@ module NewRelic
 
         def load(data)
           if data.nil? || data.empty?
-            ::NewRelic::Agent.logger.error "Empty JSON response from collector: '#{data.inspect}'"
             return nil
           end
 
           return_value(::JSON.load(data))
         rescue => e
-          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
+          ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} encountered loading collector response: #{data}")
           raise
         end
 

data/lib/new_relic/agent/new_relic_service/marshaller.rb

@@ -1,30 +1,12 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class NewRelicService
       class Marshaller
-        def parsed_error(error)
-          error_type    = error['error_type']
-          error_message = error['message']
-
-          exception = case error_type
-          when 'NewRelic::Agent::LicenseException'
-            LicenseException.new(error_message)
-          when 'NewRelic::Agent::ForceRestartException'
-            ForceRestartException.new(error_message)
-          when 'NewRelic::Agent::ForceDisconnectException'
-            ForceDisconnectException.new(error_message)
-          else
-            CollectorError.new("#{error['error_type']}: #{error['message']}")
-          end
-
-          exception
-        end
-
-        def prepare(data, options={})
+        def prepare(data, options = {})
           encoder = options[:encoder] || default_encoder
           if data.respond_to?(:to_collector_array)
             data.to_collector_array(encoder)
@@ -46,15 +28,12 @@ module NewRelic
         protected
 
         def return_value(data)
-          if data.respond_to?(:has_key?)
-            if data.has_key?('exception')
-              raise parsed_error(data['exception'])
-            elsif data.has_key?('return_value')
-              return data['return_value']
-            end
+          if data.respond_to?(:has_key?) && data.has_key?('return_value')
+            data['return_value']
+          else
+            ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
+            nil
           end
-          ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
-          nil
         end
       end
     end

data/lib/new_relic/agent/new_relic_service/security_policy_settings.rb

@@ -1,12 +1,12 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class NewRelicService
       module SecurityPolicySettings
-        EXPECTED_SECURITY_POLICIES = %w(
+        EXPECTED_SECURITY_POLICIES = %w[
           record_sql
           attributes_include
           allow_raw_exception_messages
@@ -14,12 +14,12 @@ module NewRelic
           custom_parameters
           custom_instrumentation_editor
           message_parameters
-          job_arguments).map(&:freeze)
+        ].map(&:freeze)
 
         def self.preliminary_settings(security_policies)
           enabled_key = 'enabled'.freeze
           settings = EXPECTED_SECURITY_POLICIES.inject({}) do |memo, policy_name|
-            memo[policy_name] =  {enabled_key => security_policies[policy_name][enabled_key]}
+            memo[policy_name] = {enabled_key => security_policies[policy_name][enabled_key]}
             memo
           end
           {'security_policies' => settings}