newrelic_rpm 6.3.0.355 → 9.2.0

data/lib/new_relic/rack/browser_monitoring.rb

@@ -1,150 +1,171 @@
-# 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 'rack'
 require 'new_relic/rack/agent_middleware'
 require 'new_relic/agent/instrumentation/middleware_proxy'
 
-module NewRelic::Rack
-  # This middleware is used by the agent for the Real user monitoring (RUM)
-  # feature, and will usually be automatically injected in the middleware chain.
-  # If automatic injection is not working, you may manually use it in your
-  # middleware chain instead.
-  #
-  # @api public
-  #
-  class BrowserMonitoring < AgentMiddleware
-    # The maximum number of bytes of the response body that we will
-    # examine in order to look for a RUM insertion point.
-    SCAN_LIMIT = 50_000
-
-    CONTENT_TYPE        = 'Content-Type'.freeze
-    CONTENT_DISPOSITION = 'Content-Disposition'.freeze
-    ATTACHMENT          = 'attachment'.freeze
-    TEXT_HTML           = 'text/html'.freeze
-
-    BODY_START          = "<body".freeze
-    HEAD_START          = "<head".freeze
-    GT                  = ">".freeze
-
-    def traced_call(env)
-      result = @app.call(env)   # [status, headers, response]
-
-      js_to_inject = NewRelic::Agent.browser_timing_header
-      if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
-        response_string = autoinstrument_source(result[2], result[1], js_to_inject)
-
-        env[ALREADY_INSTRUMENTED_KEY] = true
-        if response_string
-          response = Rack::Response.new(response_string, result[0], result[1])
-          response.finish
+module NewRelic
+  module Rack
+    # This middleware is used by the agent for the Real user monitoring (RUM)
+    # feature, and will usually be automatically injected in the middleware chain.
+    # If automatic injection is not working, you may manually use it in your
+    # middleware chain instead.
+    #
+    # @api public
+    #
+    class BrowserMonitoring < AgentMiddleware
+      # The maximum number of bytes of the response body that we will
+      # examine in order to look for a RUM insertion point.
+      SCAN_LIMIT = 50_000
+
+      CONTENT_TYPE = 'Content-Type'.freeze
+      CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+      ATTACHMENT = 'attachment'.freeze
+      TEXT_HTML = 'text/html'.freeze
+
+      BODY_START = '<body'.freeze
+      HEAD_START = '<head'.freeze
+      GT = '>'.freeze
+
+      ALREADY_INSTRUMENTED_KEY = 'newrelic.browser_monitoring_already_instrumented'
+      CHARSET_RE = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
+      X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
+
+      def traced_call(env)
+        result = @app.call(env)
+        (status, headers, response) = result
+
+        js_to_inject = NewRelic::Agent.browser_timing_header
+        if (js_to_inject != NewRelic::EMPTY_STR) && should_instrument?(env, status, headers)
+          response_string = autoinstrument_source(response, js_to_inject)
+          if headers.key?(CONTENT_LENGTH)
+            content_length = response_string ? response_string.bytesize : 0
+            headers[CONTENT_LENGTH] = content_length.to_s
+          end
+
+          env[ALREADY_INSTRUMENTED_KEY] = true
+          if response_string
+            response = ::Rack::Response.new(response_string, status, headers)
+            response.finish
+          else
+            result
+          end
         else
           result
         end
-      else
-        result
       end
-    end
-
-    ALREADY_INSTRUMENTED_KEY = "newrelic.browser_monitoring_already_instrumented"
 
-    def should_instrument?(env, status, headers)
-      NewRelic::Agent.config[:'browser_monitoring.auto_instrument'] &&
-        status == 200 &&
-        !env[ALREADY_INSTRUMENTED_KEY] &&
-        is_html?(headers) &&
-        !is_attachment?(headers) &&
-        !is_streaming?(env)
-    end
+      def should_instrument?(env, status, headers)
+        NewRelic::Agent.config[:'browser_monitoring.auto_instrument'] &&
+          status == 200 &&
+          !env[ALREADY_INSTRUMENTED_KEY] &&
+          html?(headers) &&
+          !attachment?(headers) &&
+          !streaming?(env, headers)
+      end
 
-    def is_html?(headers)
-      headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML)
-    end
+      private
 
-    def is_attachment?(headers)
-      headers[CONTENT_DISPOSITION] && headers[CONTENT_DISPOSITION].include?(ATTACHMENT)
-    end
+      def autoinstrument_source(response, js_to_inject)
+        source = gather_source(response)
+        close_old_response(response)
+        return unless source
 
-    def is_streaming?(env)
-      return false unless defined?(ActionController::Live)
+        modify_source(source, js_to_inject)
+      rescue => e
+        NewRelic::Agent.logger.debug("Skipping RUM instrumentation on exception: #{e.class} - #{e.message}")
+      end
 
-      env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
-    end
+      def modify_source(source, js_to_inject)
+        # Only scan the first 50k (roughly) then give up.
+        beginning_of_source = source[0..SCAN_LIMIT]
+        meta_tag_positions = find_meta_tag_positions(beginning_of_source)
+        if body_start = find_body_start(beginning_of_source)
+          if insertion_index = find_insertion_index(meta_tag_positions, beginning_of_source, body_start)
+            source = source_injection(source, insertion_index, js_to_inject)
+          else
+            NewRelic::Agent.logger.debug('Skipping RUM instrumentation. Could not properly determine location to ' \
+                                         'inject script.')
+          end
+        else
+          msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
+          NewRelic::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
+          NewRelic::Agent.logger.debug(msg)
+        end
+        source
+      end
 
-    CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
-    X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
+      def html?(headers)
+        # needs else branch coverage
+        headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML) # rubocop:disable Style/SafeNavigation
+      end
 
-    def autoinstrument_source(response, headers, js_to_inject)
-      source = gather_source(response)
-      close_old_response(response)
-      return nil unless source
+      def attachment?(headers)
+        headers[CONTENT_DISPOSITION]&.include?(ATTACHMENT)
+      end
 
-      # Only scan the first 50k (roughly) then give up.
-      beginning_of_source = source[0..SCAN_LIMIT]
+      def streaming?(env, headers)
+        # Chunked transfer encoding is a streaming data transfer mechanism available only in HTTP/1.1
+        return true if headers && headers['Transfer-Encoding'] == 'chunked'
 
-      if body_start = find_body_start(beginning_of_source)
-        meta_tag_positions = [
-          find_x_ua_compatible_position(beginning_of_source),
-          find_charset_position(beginning_of_source)
-        ].compact
+        defined?(ActionController::Live) &&
+          env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
+      end
 
-        if !meta_tag_positions.empty?
-          insertion_index = meta_tag_positions.max
-        else
-          insertion_index = find_end_of_head_open(beginning_of_source) || body_start
-        end
+      def source_injection(source, insertion_index, js_to_inject)
+        source[0...insertion_index] <<
+          js_to_inject <<
+          source[insertion_index..-1]
+      end
 
-        if insertion_index
-          source = source[0...insertion_index] <<
-            js_to_inject <<
-            source[insertion_index..-1]
+      def find_insertion_index(tag_positions, source_beginning, body_start)
+        if !tag_positions.empty?
+          tag_positions.max
         else
-          NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
+          find_end_of_head_open(source_beginning) || body_start
         end
-      else
-        msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
-        NewRelic::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
-        NewRelic::Agent.logger.debug(msg)
       end
 
-      source
-    rescue => e
-      NewRelic::Agent.logger.debug "Skipping RUM instrumentation on exception.", e
-      nil
-    end
+      def find_meta_tag_positions(source_beginning)
+        [
+          find_x_ua_compatible_position(source_beginning),
+          find_charset_position(source_beginning)
+        ].compact
+      end
 
-    def gather_source(response)
-      source = nil
-      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
-      source
-    end
+      def gather_source(response)
+        source = nil
+        response.each { |fragment| source ? (source << fragment.to_s) : (source = fragment.to_s) }
+        source
+      end
 
-    # Per "The Response > The Body" section of Rack spec, we should close
-    # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
-    def close_old_response(response)
-      if response.respond_to?(:close)
-        response.close
+      # Per "The Response > The Body" section of Rack spec, we should close
+      # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
+      def close_old_response(response)
+        response.close if response.respond_to?(:close)
       end
-    end
 
-    def find_body_start(beginning_of_source)
-      beginning_of_source.index(BODY_START)
-    end
+      def find_body_start(beginning_of_source)
+        beginning_of_source.index(BODY_START)
+      end
 
-    def find_x_ua_compatible_position(beginning_of_source)
-      match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
-      match.end(0) if match
-    end
+      def find_x_ua_compatible_position(beginning_of_source)
+        match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
+        match&.end(0)
+      end
 
-    def find_charset_position(beginning_of_source)
-      match = CHARSET_RE.match(beginning_of_source)
-      match.end(0) if match
-    end
+      def find_charset_position(beginning_of_source)
+        match = CHARSET_RE.match(beginning_of_source)
+        match&.end(0)
+      end
 
-    def find_end_of_head_open(beginning_of_source)
-      head_open = beginning_of_source.index(HEAD_START)
-      beginning_of_source.index(GT, head_open) + 1 if head_open
+      def find_end_of_head_open(beginning_of_source)
+        head_open = beginning_of_source.index(HEAD_START)
+        beginning_of_source.index(GT, head_open) + 1 if head_open
+      end
     end
   end
 end

data/lib/new_relic/rack.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
 
 # @api public
 module NewRelic

data/lib/new_relic/recipes/capistrano3.rb

@@ -1,13 +1,14 @@
-# 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 'capistrano/framework'
+require_relative 'helpers/send_deployment'
 
 namespace :newrelic do
-
+  include SendDeployment
   # notifies New Relic of a deployment
-  desc "Record a deployment in New Relic (newrelic.com)"
+  desc 'Record a deployment in New Relic (newrelic.com)'
   task :notice_deployment do
     if fetch(:newrelic_role)
       on roles(fetch(:newrelic_role)) do
@@ -19,63 +20,4 @@ namespace :newrelic do
       end
     end
   end
-
-  def send_deployment_notification_to_newrelic
-    environment = fetch(:newrelic_rails_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage, "production"))))
-
-    require 'new_relic/cli/command.rb'
-
-    begin
-      # allow overrides to be defined for revision, description, changelog, appname, and user
-      rev         = fetch(:newrelic_revision)
-      description = fetch(:newrelic_desc)
-      changelog   = fetch(:newrelic_changelog)
-      appname     = fetch(:newrelic_appname)
-      user        = fetch(:newrelic_user)
-      license_key = fetch(:newrelic_license_key)
-
-      has_scm_from_plugin = respond_to?(:scm_plugin_installed?) && scm_plugin_installed?
-      has_scm_from_config = defined?(scm) && !scm.nil? && scm != :none
-
-      if has_scm_from_plugin || has_scm_from_config
-        changelog ||= lookup_changelog
-        rev       ||= fetch(:current_revision)
-      end
-
-      new_revision = rev
-      deploy_options = {
-        :environment => environment,
-        :revision    => new_revision,
-        :changelog   => changelog,
-        :description => description,
-        :appname     => appname,
-        :user        => user,
-        :license_key => license_key
-      }
-
-      debug "Uploading deployment to New Relic"
-      deployment = NewRelic::Cli::Deployments.new deploy_options
-      deployment.run
-      info "Uploaded deployment information to New Relic"
-
-    rescue NewRelic::Cli::Command::CommandFailure => e
-      info e.message
-    rescue => e
-      info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
-    end
-  end
-
-  def lookup_changelog
-    previous_revision = fetch(:previous_revision)
-    current_revision = fetch(:current_revision)
-    return unless current_revision && previous_revision
-
-    debug "Retrieving changelog for New Relic Deployment details"
-
-    if Rake::Task.task_defined?("git:check")
-      log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
-                    "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
-      `#{log_command}`
-    end
-  end
 end

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -1,60 +1,57 @@
-# 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.
-
-make_notify_task = Proc.new do
-
-  namespace :newrelic do
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
+make_notify_task = proc do
+  namespace(:newrelic) do
     # on all deployments, notify New Relic
-    desc "Record a deployment in New Relic (newrelic.com)"
-    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
-      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
+    desc('Record a deployment in New Relic (newrelic.com)')
+    task(:notice_deployment, :roles => :app, :except => {:no_release => true}) do
+      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, 'production'))
 
       require 'new_relic/cli/command'
 
       begin
         # allow overrides to be defined for revision, description, changelog, appname, and user
-        rev         = fetch(:newrelic_revision)    if exists?(:newrelic_revision)
-        description = fetch(:newrelic_desc)        if exists?(:newrelic_desc)
-        changelog   = fetch(:newrelic_changelog)   if exists?(:newrelic_changelog)
-        appname     = fetch(:newrelic_appname)     if exists?(:newrelic_appname)
-        user        = fetch(:newrelic_user)        if exists?(:newrelic_user)
+        rev = fetch(:newrelic_revision) if exists?(:newrelic_revision)
+        description = fetch(:newrelic_desc) if exists?(:newrelic_desc)
+        changelog = fetch(:newrelic_changelog) if exists?(:newrelic_changelog)
+        appname = fetch(:newrelic_appname) if exists?(:newrelic_appname)
+        user = fetch(:newrelic_user) if exists?(:newrelic_user)
         license_key = fetch(:newrelic_license_key) if exists?(:newrelic_license_key)
 
         unless scm == :none
           changelog = lookup_changelog(changelog)
-          rev       = lookup_rev(rev)
+          rev = lookup_rev(rev)
         end
 
         new_revision = rev
         deploy_options = {
           :environment => rails_env,
-          :revision    => new_revision,
-          :changelog   => changelog,
+          :revision => new_revision,
+          :changelog => changelog,
           :description => description,
-          :appname     => appname,
-          :user        => user,
+          :appname => appname,
+          :user => user,
           :license_key => license_key
         }
 
-        logger.debug "Uploading deployment to New Relic"
-        deployment = NewRelic::Cli::Deployments.new deploy_options
+        logger.debug('Uploading deployment to New Relic')
+        deployment = NewRelic::Cli::Deployments.new(deploy_options)
         deployment.run
-        logger.info "Uploaded deployment information to New Relic"
-
+        logger.info('Uploaded deployment information to New Relic')
       rescue NewRelic::Cli::Command::CommandFailure => e
-        logger.info e.message
+        logger.info(e.message)
       rescue Capistrano::CommandError
-        logger.info "Unable to notify New Relic of the deployment... skipping"
+        logger.info('Unable to notify New Relic of the deployment... skipping')
       rescue => e
-        logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
+        logger.info("Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}")
       end
     end
 
     def lookup_changelog(changelog)
       if !changelog
-        logger.debug "Getting log of changes for New Relic Deployment details"
+        logger.debug('Getting log of changes for New Relic Deployment details')
         from_revision = source.next_revision(current_revision)
 
         if scm == :git
@@ -72,7 +69,7 @@ make_notify_task = Proc.new do
     def lookup_rev(rev)
       if rev.nil?
         rev = source.query_revision(source.head()) do |cmd|
-          logger.debug "executing locally: '#{cmd}'"
+          logger.debug("executing locally: '#{cmd}'")
           `#{cmd}`
         end
 

data/lib/new_relic/recipes/helpers/send_deployment.rb

@@ -0,0 +1,70 @@
+# 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 SendDeployment
+  def send_deployment_notification_to_newrelic
+    require 'new_relic/cli/command'
+    debug('Uploading deployment to New Relic')
+    NewRelic::Cli::Deployments.new(deploy_options).run
+    info('Uploaded deployment information to New Relic')
+  rescue NewRelic::Cli::Command::CommandFailure => e
+    info(e.message)
+  rescue => e
+    info("Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}")
+  end
+
+  private
+
+  def deploy_options
+    {
+      :environment => fetch_environment,
+      :revision => fetch_rev,
+      :changelog => fetch_changelog,
+      :description => fetch(:newrelic_desc),
+      :appname => fetch(:newrelic_appname),
+      :user => fetch(:newrelic_user),
+      :license_key => fetch(:newrelic_license_key)
+    }
+  end
+
+  def fetch_changelog
+    newrelic_changelog = fetch(:newrelic_changelog)
+    has_scm? && !newrelic_changelog ? lookup_changelog : newrelic_changelog
+  end
+
+  def fetch_environment
+    fetch(:newrelic_rails_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage, 'production'))))
+  end
+
+  def fetch_rev
+    newrelic_rev = fetch(:newrelic_revision)
+    has_scm? && !newrelic_rev ? fetch(:current_revision) : newrelic_rev
+  end
+
+  def has_scm?
+    has_scm_from_plugin? || has_scm_from_config?
+  end
+
+  def has_scm_from_config?
+    defined?(scm) && !scm.nil? && scm != :none
+  end
+
+  def has_scm_from_plugin?
+    respond_to?(:scm_plugin_installed?) && scm_plugin_installed?
+  end
+
+  def lookup_changelog
+    previous_revision = fetch(:previous_revision)
+    current_revision = fetch(:current_revision)
+    return unless current_revision && previous_revision
+
+    debug('Retrieving changelog for New Relic Deployment details')
+
+    if Rake::Task.task_defined?('git:check')
+      log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
+        "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
+      `#{log_command}`
+    end
+  end
+end

data/lib/new_relic/recipes.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
 
 # When installed as a plugin, this is loaded automatically.
 #

data/lib/new_relic/supportability_helper.rb

@@ -1,17 +1,19 @@
-# 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 SupportabilityHelper
-
     API_SUPPORTABILITY_PREFIX = 'Supportability/API/'.freeze
 
     # pre-instantiate these strings as they may be used multiple times per
     # transaction, just to eke out a bit less performance hit
     #
     API_SUPPORTABILITY_METRICS = [
+      :insert_distributed_trace_headers,
+      :accept_distributed_trace_headers,
       :add_custom_attributes,
+      :add_custom_span_attributes,
       :add_instrumentation,
       :add_method_tracer,
       :add_transaction_tracer,
@@ -19,7 +21,6 @@ module NewRelic
       :browser_timing_header,
       :disable_all_tracing,
       :disable_sql_recording,
-      :disable_transaction_tracing,
       :drop_buffered_data,
       :get_request_metadata,
       :get_response_metadata,
@@ -43,15 +44,18 @@ module NewRelic
       :record_metric,
       :recording_web_transaction?,
       :require_test_helper,
+      :set_error_group_callback,
       :set_sql_obfuscator,
       :set_transaction_name,
+      :set_user_id,
       :shutdown,
       :start_segment,
       :trace,
+      :traced_thread,
       :trace_execution_scoped,
       :trace_execution_unscoped,
       :wrap
-    ].reduce({}) do |h,o|
+    ].reduce({}) do |h, o|
       h[o] = API_SUPPORTABILITY_PREFIX + o.to_s
       h
     end
@@ -59,10 +63,22 @@ module NewRelic
     def record_api_supportability_metric(method_name)
       agent = NewRelic::Agent.agent or return
       if metric = API_SUPPORTABILITY_METRICS[method_name]
-        agent.stats_engine.tl_record_unscoped_metrics metric, &:increment_count
+        agent.stats_engine.tl_record_unscoped_metrics(metric, &:increment_count)
       else
-        NewRelic::Agent.logger.debug "API supportability metric not found for :#{method_name}"
+        NewRelic::Agent.logger.debug("API supportability metric not found for :#{method_name}")
       end
     end
+
+    def valid_api_argument_class?(arg, name, klass)
+      return true if arg.is_a?(klass)
+
+      caller_location = caller_locations(1..1).first.label
+
+      message = "Bad argument passed to ##{caller_location}. " \
+        "Expected #{klass} for `#{name}` but got #{arg.class}"
+
+      NewRelic::Agent.logger.warn(message)
+      nil
+    end
   end
 end