newrelic_rpm 8.8.0 → 8.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eb3871a3ff66d8707dd01f40025d812d34904c02631d3a83af046bdbaeacdeb
-  data.tar.gz: 4e73dfe935bcd268ad0969a2c076e83313e75c3f3f0b711a7cba8c3af1327677
+  metadata.gz: e16c313766a7d9c51bc1a1c3031f666747b4a3aefa773cf226d28510d90d6658
+  data.tar.gz: cb464a40400ce3b4a41178f737fa804952bfe22de66dc88f73deccaa256520a6
 SHA512:
-  metadata.gz: 07566af3aff20a1fe5951fb36e34086f665e8788ecb7edfd2664213e73877e7a1c58d4447f2dd85efb75beeda0ce2f484c513d4a7a09c01bcbe4c20e8a5cba1a
-  data.tar.gz: 577944d3712cdd9908d4a564346e7f4bd6fd5772fa00069d73acdb3d8a033621042c72346ddd4ca22585910f035116701f0f904dd8f40c8f0b1e9934bd787705
+  metadata.gz: 93915783c6110bbc027d03d614b5ad582ba0bf73b93933d4a93f11a7e698fd82436c74b3b941c27846e6e1ae408b7d8929b9c1d7dcae0e6103ed3ded2836c9c2
+  data.tar.gz: f7a5196e10ecd5dd88ed16b218cdcb760511d3747f1c821ccc7f4b6c5e22c28a1e08d581022513d04e6540d6d5cd62419cc587c05c8154d4a7abe6a574944a97

data/.gitignore

@@ -15,6 +15,7 @@ tags
 *.swp
 *.swo
 
+coverage
 /doc/
 /log/
 /lerg/
@@ -33,7 +34,9 @@ infinite_tracing/test/new_relic/infinite_tracing/log
 test/fixtures/cross_agent_tests/*/README.md
 node_modules/
 yarn.lock
+package-lock.json
 errors.txt
 .history/
 vendor/
 Brewfile.lock.json
+.github/actions/simplecov-report/lib/

data/.rubocop.yml

@@ -2,9 +2,9 @@ require:
   - rubocop-performance
 
 AllCops:
-  # Prevent RuboCop from exploding when it finds an older-than-2.4 .ruby-version
   TargetRubyVersion: 2.7
   Exclude: []
+  NewCops: enable
 
 Bundler/DuplicatedGem:
   Enabled: true
@@ -33,7 +33,7 @@ Bundler/InsecureProtocolSource:
 Bundler/OrderedGems:
   Enabled: false
 
-Gemspec/DateAssignment:
+Gemspec/DeprecatedAttributeAssignment:
   Enabled: true
 
 Gemspec/DuplicatedAssignment:
@@ -44,6 +44,9 @@ Gemspec/DuplicatedAssignment:
 Gemspec/OrderedDependencies:
   Enabled: false
 
+Gemspec/RequireMFA:
+  Enabled: false
+
 Gemspec/RequiredRubyVersion:
   Enabled: false
 
@@ -238,7 +241,7 @@ Layout/IndentationStyle:
 Layout/IndentationWidth:
   Enabled: true
   Width: 2
-  IgnoredPatterns: []
+  AllowedPatterns: []
 
 Layout/InitialIndentation:
   Enabled: true
@@ -1317,6 +1320,12 @@ Style/EndBlock:
 Style/EndlessMethod:
   Enabled: false
 
+# The use of Dir.home should be preferred over ENV['HOME'], but as of
+# JRuby 9.3.3.0 the use of ENV['HOME'] is required to deliver the desired
+# functionality
+Style/EnvHome:
+  Enabled: false
+
 # Disabling for now
 Style/EvalWithLocation:
   Enabled: false
@@ -1333,6 +1342,11 @@ Style/ExplicitBlockArgument:
 Style/ExponentialNotation:
   Enabled: false
 
+# TODO: MAJOR VERSION - Re-enable FetchEnvVar after dropping support for Ruby 2.2
+#                       Ruby 2.3+ allows for ENV.fetch('KEY') { default }
+Style/FetchEnvVar:
+  Enabled: false
+
 Style/FloatDivision:
   Enabled: false
 
@@ -1446,6 +1460,13 @@ Style/LineEndConcatenation:
   Enabled: false
   # SafeAutoCorrect: false
 
+# TODO: OLD RUBIES - enable this cop after support for Ruby <= 2.5 has been
+#                    dropped. NewRelic::Agent::InfiniteTracing::Transformer.hash_to_attributes
+#                    currently does `values.map {}.to_h`. Newer Rubies should
+#                    use `values.to_h {}` instead.
+Style/MapToHash:
+  Enabled: false
+
 Style/MethodCallWithArgsParentheses:
   Enabled: false
 
@@ -1589,6 +1610,13 @@ Style/NumericPredicate:
 Style/OneLineConditional:
   Enabled: true
 
+# TODO: UNIT TESTS - tests relying on OpenStruct should be refactored to not
+#                    do so, given that the use of OpenStruct instances can
+#                    give a false sense of security with their extreme
+#                    flexibility that may not match realistic code behavior.
+Style/OpenStructUse:
+  Enabled: false
+
 Style/OptionHash:
   Enabled: false
 

data/.simplecov

@@ -0,0 +1,5 @@
+SimpleCov.start do
+  enable_coverage :branch
+  SimpleCov.root(File.join(File.dirname(__FILE__), '/lib'))
+  track_files "**/*.rb"
+end

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # New Relic Ruby Agent Release Notes #
 
+
+  ## v8.9.0
+  
+  
+  * **Add support for Dalli 3.1.0 to Dalli 3.2.2**
+
+    Dalli versions 3.1.0 and above include breaking changes where the agent previously hooked into the gem. We have updated our instrumentation to correctly hook into Dalli 3.1.0 and above. At this time, 3.2.2 is the latest Dalli version and is confirmed to be supported.
+
+
+  * **Bugfix: Infinite Tracing hung on connection restart**
+
+    Previously, when using infinite tracing, the agent would intermittently encounter a deadlock when attempting to restart the infinite tracing connection. This bug would prevent the agent from sending all data types, including non-infinite-tracing-related data. This change reworks how we restart infinite tracing to prevent potential deadlocks.
+
+  * **Bugfix: Use read_nonblock instead of read on pipe**
+
+    Previously, our PipeChannelManager was using read which could cause Resque jobs to get stuck in some versions. This change updates the PipeChannelManager to use read_nonblock instead. This method can leverage error handling to allow the instrumentation to gracefully log a message and exit the stuck Resque job. 
+
+    
   ## v8.8.0
 
   * **Support Makara database adapters with ActiveRecord**

data/lib/new_relic/agent/agent/shutdown.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Shutdown
+      # Attempt a graceful shutdown of the agent, flushing any remaining
+      # data.
+      def shutdown
+        return unless started?
+        ::NewRelic::Agent.logger.info "Starting Agent shutdown"
+
+        stop_event_loop
+        trap_signals_for_litespeed
+        untraced_graceful_disconnect
+        revert_to_default_configuration
+
+        @started = nil
+        Control.reset
+      end
+
+      def untraced_graceful_disconnect
+        begin
+          NewRelic::Agent.disable_all_tracing do
+            graceful_disconnect
+          end
+        rescue => e
+          ::NewRelic::Agent.logger.error e
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent/special_startup.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module SpecialStartup
+      # If we're using a dispatcher that forks before serving
+      # requests, we need to wait until the children are forked
+      # before connecting, otherwise the parent process sends useless data
+      def using_forking_dispatcher?
+        # TODO: MAJOR VERSION - remove :rainbows
+        if [:puma, :passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
+          ::NewRelic::Agent.logger.info "Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork."
+          true
+        else
+          false
+        end
+      end
+
+      # Return true if we're using resque and it hasn't had a chance to (potentially)
+      # daemonize itself. This avoids hanging when there's a Thread started
+      # before Resque calls Process.daemon (Jira RUBY-857)
+      def defer_for_resque?
+        NewRelic::Agent.config[:dispatcher] == :resque &&
+          NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
+          !PipeChannelManager.listener.started?
+      end
+
+      def in_resque_child_process?
+        defined?(@service) && @service.is_a?(PipeService)
+      end
+
+      def defer_for_delayed_job?
+        NewRelic::Agent.config[:dispatcher] == :delayed_job &&
+          !NewRelic::DelayedJobInjection.worker_name
+      end
+
+      # This matters when the following three criteria are met:
+      #
+      # 1. A Sinatra 'classic' application is being run
+      # 2. The app is being run by executing the main file directly, rather
+      #    than via a config.ru file.
+      # 3. newrelic_rpm is required *after* sinatra
+      #
+      # In this case, the entire application runs from an at_exit handler in
+      # Sinatra, and if we were to install ours, it would be executed before
+      # the one in Sinatra, meaning that we'd shutdown the agent too early
+      # and never collect any data.
+      def sinatra_classic_app?
+        (
+          defined?(Sinatra::Application) &&
+          Sinatra::Application.respond_to?(:run) &&
+          Sinatra::Application.run?
+        )
+      end
+
+      def should_install_exit_handler?
+        return false unless Agent.config[:send_data_on_exit]
+        !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
+      end
+
+      def install_exit_handler
+        return unless should_install_exit_handler?
+        NewRelic::Agent.logger.debug("Installing at_exit handler")
+        at_exit { shutdown }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent/start_worker_thread.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module StartWorkerThread
+      LOG_ONCE_KEYS_RESET_PERIOD = 60.0
+
+      TRANSACTION_EVENT_DATA = "transaction_event_data".freeze
+      CUSTOM_EVENT_DATA = "custom_event_data".freeze
+      ERROR_EVENT_DATA = "error_event_data".freeze
+      SPAN_EVENT_DATA = "span_event_data".freeze
+      LOG_EVENT_DATA = "log_event_data".freeze
+
+      # Try to launch the worker thread and connect to the server.
+      #
+      # See #connect for a description of connection_options.
+      def start_worker_thread(connection_options = {})
+        if disable = NewRelic::Agent.config[:disable_harvest_thread]
+          NewRelic::Agent.logger.info "Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}"
+          return
+        end
+
+        ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
+        @worker_thread = Threading::AgentThread.create('Worker Loop') do
+          deferred_work!(connection_options)
+        end
+      end
+
+      def create_event_loop
+        EventLoop.new
+      end
+
+      # If the @worker_thread encounters an error during the attempt to connect to the collector
+      # then the connect attempts enter an exponential backoff retry loop.  To avoid potential
+      # race conditions with shutting down while also attempting to reconnect, we join the
+      # @worker_thread with a timeout threshold.  This allows potentially connecting and flushing
+      # pending data to the server, but without waiting indefinitely for a reconnect to succeed.
+      # The use-case where this typically arises is in cronjob scheduled rake tasks where there's
+      # also some network stability/latency issues happening.
+      def stop_event_loop
+        @event_loop.stop if @event_loop
+        # Wait the end of the event loop thread.
+        if @worker_thread
+          unless @worker_thread.join(3)
+            ::NewRelic::Agent.logger.debug "Event loop thread did not stop within 3 seconds"
+          end
+        end
+      end
+
+      # Certain event types may sometimes need to be on the same interval as metrics,
+      # so we will check config assigned in EventHarvestConfig to determine the interval
+      # on which to report them
+      def interval_for event_type
+        interval = Agent.config[:"event_report_period.#{event_type}"]
+        :"#{interval}_second_harvest"
+      end
+
+      def create_and_run_event_loop
+        data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
+        event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
+
+        @event_loop = create_event_loop
+        @event_loop.on(data_harvest) do
+          transmit_data
+        end
+
+        @event_loop.on(interval_for TRANSACTION_EVENT_DATA) do
+          transmit_analytic_event_data
+        end
+        @event_loop.on(interval_for CUSTOM_EVENT_DATA) do
+          transmit_custom_event_data
+        end
+        @event_loop.on(interval_for ERROR_EVENT_DATA) do
+          transmit_error_event_data
+        end
+        @event_loop.on(interval_for SPAN_EVENT_DATA) do
+          transmit_span_event_data
+        end
+        @event_loop.on(interval_for LOG_EVENT_DATA) do
+          transmit_log_event_data
+        end
+
+        @event_loop.on(:reset_log_once_keys) do
+          ::NewRelic::Agent.logger.clear_already_logged
+        end
+        @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
+        @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
+        @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
+
+        @event_loop.run
+      end
+
+      # Handles the case where the server tells us to restart -
+      # this clears the data, clears connection attempts, and
+      # waits a while to reconnect.
+      def handle_force_restart(error)
+        ::NewRelic::Agent.logger.debug error.message
+        drop_buffered_data
+        @service.force_restart if @service
+        @connect_state = :pending
+        sleep 30
+      end
+
+      # when a disconnect is requested, stop the current thread, which
+      # is the worker thread that gathers data and talks to the
+      # server.
+      def handle_force_disconnect(error)
+        ::NewRelic::Agent.logger.warn "Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})"
+        disconnect
+      end
+
+      # Handles an unknown error in the worker thread by logging
+      # it and disconnecting the agent, since we are now in an
+      # unknown state.
+      def handle_other_error(error)
+        ::NewRelic::Agent.logger.error "Unhandled error in worker thread, disconnecting."
+        # These errors are fatal (that is, they will prevent the agent from
+        # reporting entirely), so we really want backtraces when they happen
+        ::NewRelic::Agent.logger.log_exception(:error, error)
+        disconnect
+      end
+
+      # a wrapper method to handle all the errors that can happen
+      # in the connection and worker thread system. This
+      # guarantees a no-throw from the background thread.
+      def catch_errors
+        yield
+      rescue NewRelic::Agent::ForceRestartException => e
+        handle_force_restart(e)
+        retry
+      rescue NewRelic::Agent::ForceDisconnectException => e
+        handle_force_disconnect(e)
+      rescue => e
+        handle_other_error(e)
+      end
+
+      # This is the method that is run in a new thread in order to
+      # background the harvesting and sending of data during the
+      # normal operation of the agent.
+      #
+      # Takes connection options that determine how we should
+      # connect to the server, and loops endlessly - typically we
+      # never return from this method unless we're shutting down
+      # the agent
+      def deferred_work!(connection_options)
+        catch_errors do
+          NewRelic::Agent.disable_all_tracing do
+            connect(connection_options)
+            if connected?
+              create_and_run_event_loop
+              # never reaches here unless there is a problem or
+              # the agent is exiting
+            else
+              ::NewRelic::Agent.logger.debug "No connection.  Worker thread ending."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent/startup.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Startup
+      # True if we have initialized and completed 'start'
+      def started?
+        @started
+      end
+
+      # Check whether we have already started, which is an error condition
+      def already_started?
+        if started?
+          ::NewRelic::Agent.logger.error("Agent Started Already!")
+          true
+        end
+      end
+
+      # Logs a bunch of data and starts the agent, if needed
+      def start
+        return unless agent_should_start?
+
+        log_startup
+        check_config_and_start_agent
+        log_version_and_pid
+
+        events.subscribe(:initial_configuration_complete) do
+          log_ignore_url_regexes
+        end
+      end
+
+      # Sanity-check the agent configuration and start the agent,
+      # setting up the worker thread and the exit handler to shut
+      # down the agent
+      def check_config_and_start_agent
+        return unless monitoring? && has_correct_license_key?
+        return if using_forking_dispatcher?
+        setup_and_start_agent
+      end
+
+      # This is the shared method between the main agent startup and the
+      # after_fork call restarting the thread in deferred dispatchers.
+      #
+      # Treatment of @started and env report is important to get right.
+      def setup_and_start_agent(options = {})
+        @started = true
+        @harvester.mark_started
+
+        unless in_resque_child_process?
+          install_exit_handler
+          environment_for_connect
+          @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
+        end
+
+        connect_in_foreground if Agent.config[:sync_startup]
+        start_worker_thread(options)
+      end
+
+      # Log startup information that we almost always want to know
+      def log_startup
+        log_environment
+        log_dispatcher
+        log_app_name
+      end
+
+      # Log the environment the app thinks it's running in.
+      # Useful in debugging, as this is the key for config YAML lookups.
+      def log_environment
+        ::NewRelic::Agent.logger.info "Environment: #{NewRelic::Control.instance.env}"
+      end
+
+      # Logs the dispatcher to the log file to assist with
+      # debugging. When no debugger is present, logs this fact to
+      # assist with proper dispatcher detection
+      def log_dispatcher
+        dispatcher_name = Agent.config[:dispatcher].to_s
+
+        if dispatcher_name.empty?
+          ::NewRelic::Agent.logger.info 'No known dispatcher detected.'
+        else
+          ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
+        end
+      end
+
+      def log_app_name
+        ::NewRelic::Agent.logger.info "Application: #{Agent.config[:app_name].join(", ")}"
+      end
+
+      def log_ignore_url_regexes
+        regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
+
+        unless regexes.empty?
+          ::NewRelic::Agent.logger.info "Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}."
+        end
+      end
+
+      # Classy logging of the agent version and the current pid,
+      # so we can disambiguate processes in the log file and make
+      # sure they're running a reasonable version
+      def log_version_and_pid
+        ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
+      end
+
+      # Logs the configured application names
+      def app_name_configured?
+        names = Agent.config[:app_name]
+        return names.respond_to?(:any?) && names.any?
+      end
+
+      # Connecting in the foreground blocks further startup of the
+      # agent until we have a connection - useful in cases where
+      # you're trying to log a very-short-running process and want
+      # to get statistics from before a server connection
+      # (typically 20 seconds) exists
+      def connect_in_foreground
+        NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
+      end
+
+      # Warn the user if they have configured their agent not to
+      # send data, that way we can see this clearly in the log file
+      def monitoring?
+        if Agent.config[:monitor_mode]
+          true
+        else
+          ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
+          false
+        end
+      end
+
+      # Tell the user when the license key is missing so they can
+      # fix it by adding it to the file
+      def has_license_key?
+        if Agent.config[:license_key] && Agent.config[:license_key].length > 0
+          true
+        else
+          ::NewRelic::Agent.logger.warn("No license key found. " +
+            "This often means your newrelic.yml file was not found, or it lacks a section for the running environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml to ensure it is valid YML.")
+          false
+        end
+      end
+
+      # A correct license key exists and is of the proper length
+      def has_correct_license_key?
+        has_license_key? && correct_license_length
+      end
+
+      # A license key is an arbitrary 40 character string,
+      # usually looks something like a SHA1 hash
+      def correct_license_length
+        key = Agent.config[:license_key]
+
+        if key.length == 40
+          true
+        else
+          ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
+          false
+        end
+      end
+
+      # Check to see if the agent should start, returning +true+ if it should.
+      def agent_should_start?
+        return false if already_started? || disabled?
+
+        if defer_for_delayed_job?
+          ::NewRelic::Agent.logger.debug "Deferring startup for DelayedJob"
+          return false
+        end
+
+        if defer_for_resque?
+          ::NewRelic::Agent.logger.debug "Deferring startup for Resque in case it daemonizes"
+          return false
+        end
+
+        unless app_name_configured?
+          NewRelic::Agent.logger.error "No application name configured.",
+            "The Agent cannot start without at least one. Please check your ",
+            "newrelic.yml and ensure that it is valid and has at least one ",
+            "value set for app_name in the #{NewRelic::Control.instance.env} ",
+            "environment."
+          return false
+        end
+
+        return true
+      end
+
+      # The agent is disabled when it is not force enabled by the
+      # 'agent_enabled' option (e.g. in a manual start), or
+      # enabled normally through the configuration file
+      def disabled?
+        !Agent.config[:agent_enabled]
+      end
+    end
+  end
+end