newrelic_rpm 8.7.0 → 8.11.0

data/bin/nrdebug

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
-# 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.
+# frozen_string_literal: true
 
 require 'tempfile'
 require 'rbconfig'
@@ -96,11 +96,11 @@ class LinuxProcessDataProvider < ProcessDataProvider
   end
 
   def procline
-    File.read(proc_path('cmdline')).gsub("\000", " ")
+    File.read(proc_path('cmdline')).tr("\000", " ")
   end
 
   def environment
-    File.read(proc_path('environ')).gsub("\000", "\n")
+    File.read(proc_path('environ')).tr("\000", "\n")
   end
 end
 
@@ -133,8 +133,29 @@ class RubyProcess
     backtrace_file = Tempfile.new('nrdebug_ruby_bt')
     File.chmod(0666, backtrace_file.path)
 
-    backtrace_gathering_code = 'Thread.list.each { |t| bt = t.backtrace rescue nil; puts \"#{t.inspect}\n#{bt && bt.join(\"\n\")}\n\n\" }'
-    gdb_script_body = <<-END
+    body = gdb_script_body(backtrace_file)
+
+    script_file = write_script_file(body)
+
+    gdb_stderr = Tempfile.new('nrdebug_gdb_stderr')
+
+    gdb_cmd = "gdb -batch -x #{script_file.path} 2>#{gdb_stderr.path}"
+    gdb_output = ShellWrapper.execute(gdb_cmd)
+    ruby_backtrace = File.read(backtrace_file.path)
+
+    script_file.close!
+    backtrace_file.close!
+    gdb_stderr.close!
+
+    [gdb_output, ruby_backtrace]
+  end
+
+  private
+
+  def gdb_script_body(backtrace_file)
+    backtrace_gathering_code = 'Thread.list.each { |t| bt = t.backtrace rescue nil; ' \
+      'puts \"#{t.inspect}\n#{bt && bt.join(\"\n\")}\n\n\" }'
+    <<-END
       attach #{pid}
       t a a bt
       call (void)close(1)
@@ -147,23 +168,14 @@ class RubyProcess
       call (void)fflush(0)
       quit
     END
-    Logger.log("Using gdb script:\n#{gdb_script_body}")
+  end
 
+  def write_script_file(body)
+    Logger.log("Using gdb script:\n#{body}")
     script_file = Tempfile.new('nrdebug_gdb_script')
-    script_file.write(gdb_script_body)
+    script_file.write(body)
     script_file.close
-
-    gdb_stderr = Tempfile.new('nrdebug_gdb_stderr')
-
-    gdb_cmd = "gdb -batch -x #{script_file.path} 2>#{gdb_stderr.path}"
-    gdb_output = ShellWrapper.execute(gdb_cmd)
-    ruby_backtrace = File.read(backtrace_file.path)
-
-    script_file.close!
-    backtrace_file.close!
-    gdb_stderr.close!
-
-    [gdb_output, ruby_backtrace]
+    script_file
   end
 end
 
@@ -178,10 +190,10 @@ class ProcessReport
   def open
     if @path
       File.open(@path, "w") do |f|
-        yield f
+        yield(f)
       end
     else
-      yield $stdout
+      yield($stdout)
     end
   end
 
@@ -200,18 +212,11 @@ class ProcessReport
 
   def generate
     open do |f|
-      section(f, "Time") { Time.now }
-      section(f, "PID") { @target.pid }
-      section(f, "Command") { @target.procline }
-      section(f, "RSS") { @target.rss }
-      section(f, "CPU") { @target.cpu }
-      section(f, "Parent PID") { @target.ppid }
-      section(f, "OS") { ShellWrapper.execute('uname -a') }
-      section(f, "Environment") { @target.environment }
+      add_environment_sections(f)
 
       section(f) do
         c_backtraces, ruby_backtraces = @target.gather_backtraces
-        if c_backtraces.match(/could not attach/i)
+        if c_backtraces =~ /could not attach/i
           fail("Failed to attach to target process. Please try again with sudo.")
         end
         section(f, "C Backtraces") { c_backtraces }
@@ -225,23 +230,38 @@ class ProcessReport
       end
     end
   end
+
+  private
+
+  def add_environment_sections(handle)
+    section(handle, "Time") { Time.now }
+    section(handle, "PID") { @target.pid }
+    section(handle, "Command") { @target.procline }
+    section(handle, "RSS") { @target.rss }
+    section(handle, "CPU") { @target.cpu }
+    section(handle, "Parent PID") { @target.ppid }
+    section(handle, "OS") { ShellWrapper.execute('uname -a') }
+    section(handle, "Environment") { @target.environment }
+  end
 end
 
 def prompt_for_confirmation(target_pid, target_cmd)
-  puts "Are you sure you want to attach to PID #{target_pid} ('#{target_cmd}')}?"
-  puts ''
-  puts '************************** !WARNING! **************************'
-  puts "Extracting debug information from this process may cause it to CRASH OR HANG."
-  puts ''
-  puts "It is highly recommended that you only run this script against processes that"
-  puts "are already unresponsive."
-  puts ''
-  puts "Additionally, the output may contain sensitive information from the program's"
-  puts "command line arguments, environment, or open file list. Please examine the"
-  puts "output before sharing it."
-  puts '************************** !WARNING! **************************'
-  puts ''
-  puts "To continue, type 'continue':"
+  puts <<-PROMPT
+  Are you sure you want to attach to PID #{target_pid} ('#{target_cmd}')}?
+  
+  ************************** !WARNING! **************************
+  Extracting debug information from this process may cause it to CRASH OR HANG.
+  
+  It is highly recommended that you only run this script against processes that
+  are already unresponsive.
+  
+  Additionally, the output may contain sensitive information from the program's
+  command line arguments, environment, or open file list. Please examine the
+  output before sharing it.
+  ************************** !WARNING! **************************
+  
+  To continue, type 'continue':
+  PROMPT
 
   until $stdin.gets.strip == 'continue'
     puts "Please type 'continue' to continue, or ctrl-c to abort."
@@ -256,7 +276,8 @@ fail("Could not find gdb, please ensure it is installed and in your PATH") if gd
 
 target = RubyProcess.new(target_pid)
 if !target.attachable?
-  fail("You do not appear to have permissions to attach to the target process.\nPlease check the process owner and try again with sudo if necessary")
+  fail("You do not appear to have permissions to attach to the target process.\nPlease check the process owner " \
+    'and try again with sudo if necessary')
 end
 if !target.alive?
   fail("Could not find process with PID #{target_pid}")

data/config.dot

@@ -90,7 +90,7 @@ digraph AgentEnabled {
   "Agent#log_seed_token"
   "Agent#log_error"
   "Agent#monitoring?"
-  "Agent#check_trasaction_sampler_status"
+  "Agent#check_transaction_sampler_status"
   "Agent#check_sql_sampler_status"
   "Agent#config_transaction_tracer"
   "Agent#set_sql_recording!"
@@ -134,8 +134,8 @@ digraph AgentEnabled {
 
   "MetricFrame.update_apdex"
 
-  "TranactionInfo#force_persist_sample?"
-  "TranactionInfo#include_guid?"
+  "TransactionInfo#force_persist_sample?"
+  "TransactionInfo#include_guid?"
 
   "TransactionSampleBuilder#initialize"
   "TransactionSampleBuilder#set_transaction_info"
@@ -257,8 +257,8 @@ digraph AgentEnabled {
 
   "MetricFrame.update_apdex" -> "[apdex_t]"
 
-  "TranactionInfo#force_persist_sample?" -> "[apdex_t]"
-  "TranactionInfo#include_guid?" -> "[apdex_t]"
+  "TransactionInfo#force_persist_sample?" -> "[apdex_t]"
+  "TransactionInfo#include_guid?" -> "[apdex_t]"
 
   "TransactionSampleBuilder#initialize" -> "[transaction_tracer.limit_segments]"
   "TransactionSampleBuilder#set_transaction_info" -> "[capture_params]"

data/init.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 # This is the initialization for the New Relic Ruby Agent when used as
 # a plugin
@@ -14,7 +14,7 @@ require 'new_relic/control'
 
 # Initializer for the NewRelic Ruby Agent
 
-# After verison 2.0 of Rails we can access the configuration directly.
+# After version 2.0 of Rails we can access the configuration directly.
 # We need it to add dev mode routes after initialization finished.
 
 begin
@@ -24,7 +24,7 @@ begin
     Rails.configuration
   end
 
-  NewRelic::Control.instance.init_plugin :config => current_config
+  NewRelic::Control.instance.init_plugin(:config => current_config)
 rescue => e
-  ::NewRelic::Agent.logger.error "Error initializing New Relic plugin. Agent is disabled.", e
+  ::NewRelic::Agent.logger.error("Error initializing New Relic plugin. Agent is disabled.", e)
 end

data/install.rb

@@ -1,8 +1,8 @@
-# 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.
+# frozen_string_literal: true
 
-if __FILE__ == $0 || $0 =~ /script\/plugin/ || File.basename($0) == 'rake'
+if __FILE__ == $0 || $0.include?('script/plugin') || File.basename($0) == 'rake'
   $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
   require 'new_relic/cli/command'
   begin

data/lib/new_relic/agent/adaptive_sampler.rb

@@ -1,11 +1,11 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class AdaptiveSampler
-      def initialize target_samples = 10, period_duration = 60
+      def initialize(target_samples = 10, period_duration = 60)
         @target = target_samples
         @seen = 0
         @seen_last = 0
@@ -84,7 +84,7 @@ module NewRelic
             end
           end
           if target_changed
-            NewRelic::Agent.logger.debug "Sampling target set to: #{target}"
+            NewRelic::Agent.logger.debug("Sampling target set to: #{target}")
           end
         end
       end
@@ -99,7 +99,7 @@ module NewRelic
             end
           end
           if period_changed
-            NewRelic::Agent.logger.debug "Sampling period set to: #{period_duration}"
+            NewRelic::Agent.logger.debug("Sampling period set to: #{period_duration}")
           end
         end
       end

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

@@ -0,0 +1,34 @@
+# 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 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 @@
+# 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 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 @@
+# 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 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