newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/instrumentation/tilt.rb

@@ -0,0 +1,25 @@
+# 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 'tilt/instrumentation'
+require_relative 'tilt/chain'
+require_relative 'tilt/prepend'
+
+DependencyDetection.defer do
+  named :tilt
+
+  depends_on { defined?(Tilt) }
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Tilt instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Tilt::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/typhoeus/chain.rb

@@ -0,0 +1,22 @@
+# 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::Agent::Instrumentation
+  module Typhoeus
+    module Chain
+      def self.instrument!
+        ::Typhoeus::Hydra.class_eval do
+          include NewRelic::Agent::Instrumentation::Typhoeus
+
+          def run_with_newrelic(*args)
+            with_tracing { run_without_newrelic(*args) }
+          end
+
+          alias run_without_newrelic run
+          alias run run_with_newrelic
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/typhoeus/instrumentation.rb

@@ -0,0 +1,80 @@
+# 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 Instrumentation
+      module Typhoeus
+        HYDRA_SEGMENT_NAME = "External/Multiple/Typhoeus::Hydra/run"
+        NOTICEABLE_ERROR_CLASS = "Typhoeus::Errors::TyphoeusError"
+
+        EARLIEST_VERSION = Gem::Version.new("0.5.3")
+
+        def self.is_supported_version?
+          Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
+        end
+
+        def self.request_is_hydra_enabled?(request)
+          request.respond_to?(:hydra) && request.hydra
+        end
+
+        def self.response_message(response)
+          if response.respond_to?(:response_message)
+            response.response_message
+          elsif response.respond_to?(:return_message)
+            response.return_message
+          else
+            # 0.5.4 seems to have lost xxxx_message methods altogether.
+            "timeout"
+          end
+        end
+
+        def with_tracing
+          segment = NewRelic::Agent::Tracer.start_segment(name: HYDRA_SEGMENT_NAME)
+          instance_variable_set(:@__newrelic_hydra_segment, segment)
+          begin
+            yield
+          ensure
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
+          end
+        end
+
+        def self.trace(request)
+          state = NewRelic::Agent::Tracer.state
+          return unless state.is_execution_traced?
+
+          wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
+
+          parent = if request_is_hydra_enabled?(request)
+            request.hydra.instance_variable_get(:@__newrelic_hydra_segment)
+          end
+
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method,
+            parent: parent
+          )
+
+          segment.add_request_headers(wrapped_request)
+
+          callback = proc do
+            wrapped_response = HTTPClients::TyphoeusHTTPResponse.new(request.response)
+
+            segment.process_response_headers(wrapped_response)
+
+            if request.response.code == 0
+              segment.notice_error(NoticeableError.new(NOTICEABLE_ERROR_CLASS, response_message(request.response)))
+            end
+
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
+          end
+          request.on_complete.unshift(callback)
+        rescue => e
+          NewRelic::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/typhoeus/prepend.rb

@@ -0,0 +1,14 @@
+# 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::Agent::Instrumentation
+  module Typhoeus
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Typhoeus
+      def run(*args)
+        with_tracing { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/typhoeus.rb

@@ -1,6 +1,10 @@
-# 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_relative 'typhoeus/instrumentation'
+require_relative 'typhoeus/chain'
+require_relative 'typhoeus/prepend'
 
 DependencyDetection.defer do
   named :typhoeus
@@ -10,19 +14,19 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
+    NewRelic::Agent::Instrumentation::Typhoeus.is_supported_version?
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Typhoeus instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    NewRelic::Agent.logger.info('Installing Typhoeus instrumentation')
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/typhoeus_wrappers'
   end
 
   # Basic request tracing
   executes do
     Typhoeus.before do |request|
-      NewRelic::Agent::Instrumentation::TyphoeusTracing.trace(request)
+      NewRelic::Agent::Instrumentation::Typhoeus.trace(request)
 
       # Ensure that we always return a truthy value from the before block,
       # otherwise Typhoeus will bail out of the instrumentation.
@@ -32,76 +36,10 @@ DependencyDetection.defer do
 
   # Apply single TT node for Hydra requests until async support
   executes do
-    class Typhoeus::Hydra
-
-      def run_with_newrelic(*args)
-        segment = NewRelic::Agent::Transaction.start_segment(
-          name: NewRelic::Agent::Instrumentation::TyphoeusTracing::HYDRA_SEGMENT_NAME
-        )
-
-        instance_variable_set :@__newrelic_hydra_segment, segment
-
-        begin
-          run_without_newrelic(*args)
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias run_without_newrelic run
-      alias run run_with_newrelic
-    end
-  end
-end
-
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module TyphoeusTracing
-
-        HYDRA_SEGMENT_NAME = "External/Multiple/Typhoeus::Hydra/run"
-
-        EARLIEST_VERSION = Gem::Version.new("0.5.3")
-
-        def self.is_supported_version?
-          Gem::Version.new(Typhoeus::VERSION) >= NewRelic::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
-        end
-
-        def self.request_is_hydra_enabled?(request)
-          request.respond_to?(:hydra) && request.hydra
-        end
-
-        def self.trace(request)
-          state = NewRelic::Agent::TransactionState.tl_get
-          return unless state.is_execution_traced?
-
-          wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
-
-          parent = if request_is_hydra_enabled?(request)
-            request.hydra.instance_variable_get(:@__newrelic_hydra_segment)
-          end
-
-          segment = NewRelic::Agent::Transaction.start_external_request_segment(
-            library: wrapped_request.type,
-            uri: wrapped_request.uri,
-            procedure: wrapped_request.method,
-            parent: parent
-          )
-
-          segment.add_request_headers wrapped_request
-
-          callback = Proc.new do
-            wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-            segment.read_response_headers wrapped_response
-            segment.finish if segment
-          end
-          request.on_complete.unshift(callback)
-
-        rescue => e
-          NewRelic::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
-        end
-      end
+    if use_prepend?
+      prepend_instrument Typhoeus::Hydra, NewRelic::Agent::Instrumentation::Typhoeus::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Typhoeus::Chain
     end
   end
 end

data/lib/new_relic/agent/instrumentation.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 'new_relic/agent'
 module NewRelic

data/lib/new_relic/agent/internal_agent_error.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 is the base class for all errors that we want to record through the
 # NewRelic::Agent::ErrorCollector#notice_agent_error API. It provides the
@@ -10,7 +10,7 @@
 module NewRelic
   module Agent
     class InternalAgentError < StandardError
-      def initialize(msg=nil)
+      def initialize(msg = nil)
         super("Ruby agent internal error. Please contact support referencing this error.\n #{msg}")
       end
     end

data/lib/new_relic/agent/javascript_instrumentor.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'
@@ -8,19 +8,19 @@ require 'new_relic/agent/obfuscator'
 
 module NewRelic
   module Agent
-    class JavascriptInstrumentor
+    class JavaScriptInstrumentor
       include NewRelic::Coerce
 
       RUM_KEY_LENGTH = 13
 
       def initialize(event_listener)
-        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+        event_listener.subscribe(:initial_configuration_complete, &method(:log_configuration))
       end
 
       def log_configuration
         NewRelic::Agent.logger.debug("JS agent loader requested: #{NewRelic::Agent.config[:'browser_monitoring.loader']}",
-                                     "JS agent loader debug: #{NewRelic::Agent.config[:'browser_monitoring.debug']}",
-                                     "JS agent loader version: #{NewRelic::Agent.config[:'browser_monitoring.loader_version']}")
+          "JS agent loader debug: #{NewRelic::Agent.config[:'browser_monitoring.debug']}",
+          "JS agent loader version: #{NewRelic::Agent.config[:'browser_monitoring.loader_version']}")
 
         if !NewRelic::Agent.config[:'rum.enabled']
           NewRelic::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
@@ -38,43 +38,43 @@ module NewRelic
       def js_enabled_and_ready?
         if !enabled?
           ::NewRelic::Agent.logger.log_once(:debug, :js_agent_disabled,
-                                            "JS agent instrumentation is disabled.")
+            "JS agent instrumentation is disabled.")
           false
         elsif missing_config?(:js_agent_loader)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_js_agent_loader,
-                                            "Missing :js_agent_loader. Skipping browser instrumentation.")
+            "Missing :js_agent_loader. Skipping browser instrumentation.")
           false
         elsif missing_config?(:beacon)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_beacon,
-                                            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
+            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
           false
         elsif missing_config?(:browser_key)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_browser_key,
-                                            "Browser key is not set. Skipping browser instrumentation.")
+            "Browser key is not set. Skipping browser instrumentation.")
           false
         else
           true
         end
       rescue => e
-        ::NewRelic::Agent.logger.debug "Failure during 'js_enabled_and_ready?'", e
+        ::NewRelic::Agent.logger.debug("Failure during 'js_enabled_and_ready?'", e)
         false
       end
 
       def insert_js?(state)
         if !state.current_transaction
-          ::NewRelic::Agent.logger.debug "Not in transaction. Skipping browser instrumentation."
+          ::NewRelic::Agent.logger.debug("Not in transaction. Skipping browser instrumentation.")
           false
         elsif !state.is_execution_traced?
-          ::NewRelic::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
+          ::NewRelic::Agent.logger.debug("Execution is not traced. Skipping browser instrumentation.")
           false
         elsif state.current_transaction.ignore_enduser?
-          ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
+          ::NewRelic::Agent.logger.debug("Ignore end user for this transaction is set. Skipping browser instrumentation.")
           false
         else
           true
         end
       rescue => e
-        ::NewRelic::Agent.logger.debug "Failure during insert_js", e
+        ::NewRelic::Agent.logger.debug("Failure during insert_js", e)
         false
       end
 
@@ -83,72 +83,78 @@ module NewRelic
         value.nil? || value.empty?
       end
 
-      def browser_timing_header #THREAD_LOCAL_ACCESS
+      def browser_timing_header(nonce = nil) # THREAD_LOCAL_ACCESS
         return '' unless js_enabled_and_ready? # fast exit
 
-        state = NewRelic::Agent::TransactionState.tl_get
+        state = NewRelic::Agent::Tracer.state
 
         return '' unless insert_js?(state) # slower exit
 
-        bt_config = browser_timing_config(state)
+        bt_config = browser_timing_config(state, nonce)
         return '' if bt_config.empty?
 
-        bt_config + browser_timing_loader
+        bt_config + browser_timing_loader(nonce)
       rescue => e
-        ::NewRelic::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
+        ::NewRelic::Agent.logger.debug("Failure during RUM browser_timing_header construction", e)
         ''
       end
 
-      def browser_timing_loader
-        html_safe_if_needed("\n<script>#{Agent.config[:js_agent_loader]}</script>")
+      def browser_timing_loader(nonce = nil)
+        html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>#{Agent.config[:js_agent_loader]}</script>")
       end
 
-      def browser_timing_config(state)
+      def browser_timing_config(state, nonce = nil)
         txn = state.current_transaction
         return '' if txn.nil?
 
         txn.freeze_name_and_execute_if_not_ignored do
           data = data_for_js_agent(txn)
           json = ::JSON.dump(data)
-          return html_safe_if_needed("\n<script>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+          return html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
         end
 
         ''
       end
 
-      BEACON_KEY           = "beacon".freeze
-      ERROR_BEACON_KEY     = "errorBeacon".freeze
-      LICENSE_KEY_KEY      = "licenseKey".freeze
-      APPLICATIONID_KEY    = "applicationID".freeze
+      def create_nonce(nonce = nil)
+        return '' unless nonce
+
+        " nonce=\"#{nonce.to_s}\""
+      end
+
+      BEACON_KEY = "beacon".freeze
+      ERROR_BEACON_KEY = "errorBeacon".freeze
+      LICENSE_KEY_KEY = "licenseKey".freeze
+      APPLICATIONID_KEY = "applicationID".freeze
       TRANSACTION_NAME_KEY = "transactionName".freeze
-      QUEUE_TIME_KEY       = "queueTime".freeze
+      QUEUE_TIME_KEY = "queueTime".freeze
       APPLICATION_TIME_KEY = "applicationTime".freeze
-      AGENT_KEY            = "agent".freeze
-      SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
-      ATTS_KEY             = "atts".freeze
-      ATTS_USER_SUBKEY     = "u".freeze
-      ATTS_AGENT_SUBKEY    = "a".freeze
+      AGENT_KEY = "agent".freeze
+      SSL_FOR_HTTP_KEY = "sslForHttp".freeze
+      ATTS_KEY = "atts".freeze
+      ATTS_USER_SUBKEY = "u".freeze
+      ATTS_AGENT_SUBKEY = "a".freeze
 
       # NOTE: Internal prototyping may override this, so leave name stable!
       def data_for_js_agent(transaction)
-        queue_time_in_seconds = [transaction.queue_time.to_f, 0.0].max
-        start_time_in_seconds = [transaction.start_time.to_f, 0.0].max
-        app_time_in_seconds   = Time.now.to_f - start_time_in_seconds
+        queue_time_in_seconds = [transaction.queue_time, 0.0].max
+        start_time_in_seconds = [transaction.start_time, 0.0].max
+        app_time_in_seconds = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
-        queue_time_in_millis = (1000.0 * queue_time_in_seconds).round
-        app_time_in_millis   = (1000.0 * app_time_in_seconds).round
+        queue_time_in_millis = (queue_time_in_seconds * 1000.0).round
+        app_time_in_millis = (app_time_in_seconds * 1000.0).round
 
         transaction_name = transaction.best_name || ::NewRelic::Agent::UNKNOWN_METRIC
 
         data = {
-          BEACON_KEY           => NewRelic::Agent.config[:beacon],
-          ERROR_BEACON_KEY     => NewRelic::Agent.config[:error_beacon],
-          LICENSE_KEY_KEY      => NewRelic::Agent.config[:browser_key],
-          APPLICATIONID_KEY    => NewRelic::Agent.config[:application_id],
+          BEACON_KEY => NewRelic::Agent.config[:beacon],
+          ERROR_BEACON_KEY => NewRelic::Agent.config[:error_beacon],
+          LICENSE_KEY_KEY => NewRelic::Agent.config[:browser_key],
+          APPLICATIONID_KEY => NewRelic::Agent.config[:application_id],
           TRANSACTION_NAME_KEY => obfuscator.obfuscate(transaction_name),
-          QUEUE_TIME_KEY       => queue_time_in_millis,
+          QUEUE_TIME_KEY => queue_time_in_millis,
           APPLICATION_TIME_KEY => app_time_in_millis,
-          AGENT_KEY            => NewRelic::Agent.config[:js_agent_file]
+          AGENT_KEY => NewRelic::Agent.config[:js_agent_file]
         }
 
         add_ssl_for_http(data)

data/lib/new_relic/agent/linking_metadata.rb

@@ -0,0 +1,44 @@
+# 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
+    #
+    # This module contains helper methods related to gathering linking
+    # metadata for use with logs in context.
+    module LinkingMetadata
+      extend self
+
+      def append_service_linking_metadata(metadata)
+        raise ArgumentError, "Missing argument `metadata`" if metadata.nil?
+
+        config = ::NewRelic::Agent.config
+
+        metadata[ENTITY_NAME_KEY] = config[:app_name][0]
+        metadata[ENTITY_TYPE_KEY] = ENTITY_TYPE
+        metadata[HOSTNAME_KEY] = Hostname.get
+
+        if entity_guid = config[:entity_guid]
+          metadata[ENTITY_GUID_KEY] = entity_guid
+        end
+
+        metadata
+      end
+
+      def append_trace_linking_metadata(metadata)
+        raise ArgumentError, "Missing argument `metadata`" if metadata.nil?
+
+        if trace_id = Tracer.current_trace_id
+          metadata[TRACE_ID_KEY] = trace_id
+        end
+
+        if span_id = Tracer.current_span_id
+          metadata[SPAN_ID_KEY] = span_id
+        end
+
+        metadata
+      end
+    end
+  end
+end

data/lib/new_relic/agent/local_log_decorator.rb

@@ -0,0 +1,37 @@
+# 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
+    # This module contains helper methods related to decorating log messages
+    module LocalLogDecorator
+      extend self
+
+      def decorate(message)
+        return message unless decorating_enabled?
+
+        metadata = NewRelic::Agent.linking_metadata
+        formatted_metadata = " NR-LINKING|#{metadata[ENTITY_GUID_KEY]}|#{metadata[HOSTNAME_KEY]}|" \
+                             "#{metadata[TRACE_ID_KEY]}|#{metadata[SPAN_ID_KEY]}|" \
+                             "#{escape_entity_name(metadata[ENTITY_NAME_KEY])}|"
+
+        message.partition("\n").insert(1, formatted_metadata).join
+      end
+
+      private
+
+      def decorating_enabled?
+        NewRelic::Agent.config[:'application_logging.enabled'] &&
+          NewRelic::Agent::Instrumentation::Logger.enabled? &&
+          NewRelic::Agent.config[:'application_logging.local_decorating.enabled']
+      end
+
+      def escape_entity_name(entity_name)
+        return unless entity_name
+
+        URI::DEFAULT_PARSER.escape(entity_name)
+      end
+    end
+  end
+end