newrelic_rpm 3.12.0.288 → 9.10.2

data/bin/nrdebug

@@ -1,13 +1,13 @@
 #!/usr/bin/env ruby
 
-# 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 'tempfile'
 require 'rbconfig'
 
-def fail(msg, opts={})
+def fail(msg, opts = {})
   $stderr.puts(msg)
   usage() if opts[:usage]
   exit(-1)
@@ -84,7 +84,7 @@ class ProcessDataProvider
 
   def self.for_process(pid)
     case RbConfig::CONFIG['target_os']
-    when /linux/  then LinuxProcessDataProvider.new(pid)
+    when /linux/ then LinuxProcessDataProvider.new(pid)
     when /darwin/ then DarwinProcessDataProvider.new(pid)
     end
   end
@@ -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,45 +168,36 @@ 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
 
 class ProcessReport
   attr_reader :target, :path
 
-  def initialize(target, path=nil)
+  def initialize(target, path = nil)
     @target = target
     @path = path
   end
 
   def open
     if @path
-      File.open(@path, "w") do |f|
-        yield f
+      File.open(@path, 'w') do |f|
+        yield(f)
       end
     else
-      yield $stdout
+      yield($stdout)
     end
   end
 
-  def section(f, name=nil)
+  def section(f, name = nil)
     content = begin
       yield
     rescue StandardError => e
@@ -200,67 +212,78 @@ 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)
-          fail("Failed to attach to target process. Please try again with sudo.")
+        if /could not attach/i.match?(c_backtraces)
+          fail('Failed to attach to target process. Please try again with sudo.')
         end
-        section(f, "C Backtraces")   { c_backtraces }
-        section(f, "Ruby Backtrace(s)") { ruby_backtraces }
+
+        section(f, 'C Backtraces') { c_backtraces }
+        section(f, 'Ruby Backtrace(s)') { ruby_backtraces }
       end
 
-      section(f, "Open files") { @target.open_files }
-      section(f, "Log") do
-        commands = Logger.messages.map { |(_,msg)| msg }
+      section(f, 'Open files') { @target.open_files }
+      section(f, 'Log') do
+        commands = Logger.messages.map { |(_, msg)| msg }
         commands.join("\n")
       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':"
-
-  until ($stdin.gets.strip == 'continue') do
+  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."
   end
 end
 
 target_pid = ARGV[0]
-fail("Please provide a PID for the target process", :usage => true) unless target_pid
+fail('Please provide a PID for the target process', :usage => true) unless target_pid
 
 gdb_path = `which gdb`
-fail("Could not find gdb, please ensure it is installed and in your PATH") if gdb_path.empty?
+fail('Could not find gdb, please ensure it is installed and in your PATH') if gdb_path.empty?
 
 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}")
 end
+
 target_cmd = target.procline
 
 prompt_for_confirmation(target_pid, target_cmd)
@@ -275,5 +298,5 @@ report.generate
 
 puts "Generated '#{report_filename}'"
 puts ''
-puts "Please examine the output file for potentially sensitive information and"
-puts "remove it before sharing this file with anyone."
+puts 'Please examine the output file for potentially sensitive information and'
+puts 'remove it before sharing this file with anyone.'

data/init.rb

@@ -1,8 +1,8 @@
-# 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 initialization for the New Relic Ruby Agent when used as
+# This is the initialization for the New Relic Ruby agent when used as
 # a plugin
 require 'new_relic/control'
 
@@ -12,21 +12,19 @@ require 'new_relic/control'
 # If you can't find any log files and you don't see anything in your
 # application log files please visit support.newrelic.com.
 
-# Initializer for the NewRelic Ruby Agent
+# Initializer for the New Relic 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
-
   current_config = if defined?(config)
     config
   elsif defined?(Rails.configuration)
     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/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
 
-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/boot/strap.rb

@@ -0,0 +1,101 @@
+# 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 file is designed to bootstrap a `Bundler.require`-based Ruby app (such as
+# a Ruby on Rails app) so the app can be instrumented and observed by the
+# New Relic Ruby agent without the agent being added to the app as a dependency.
+# NOTE: introducing the agent into your application via bootstrap is in beta.
+# Use at your own risk.
+#
+# Given a production-ready Ruby app that optionally has a pre-packaged "frozen"
+# or "deployment"–gem bundle, the New Relic Ruby agent can be introduced
+# to the app without modifying the app and keeping all of the app's content
+# read-only.
+#
+# Prerequisites:
+#   - Ruby (tested v2.4+)
+#   - Bundler (included with Ruby, tested v1.17+)
+#
+# Instructions:
+#   - First, make sure the New Relic Ruby agent exists on disk. For these
+#     instructions, we'll assume the agent exists at `/newrelic`.
+#     - The agent can be downloaded as the "newrelic_rpm" gem from RubyGems.org
+#       and unpacked with "gem unpack"
+#     - The agent can be cloned from the New Relic public GitHub repo:
+#       https://github.com/newrelic/newrelic-ruby-agent
+#   - Next, use the "RUBYOPT" environment variable to require ("-r") this
+#     file (note that the ".rb" extension is dropped):
+#       ```
+#       export RUBYOPT="-r /newrelic/lib/boot/strap"
+#       ```
+#    - Add your New Relic license key as an environment variable.
+#       ```
+#       export NEW_RELIC_LICENSE_KEY=1a2b3c4d5e67f8g9h0i
+#       ```
+#   - Launch an existing Ruby app as usual. For a Ruby on Rails app, this might
+#     involve running `bin/rails server`.
+#   - In the Ruby app's directory, look for and inspect
+#     `log/newrelic_agent.log`. If this file exists and there are no "WARN" or
+#     "ERROR" entries within it, then the agent was successfully introduced to
+#     the Ruby application.
+
+module NRBundlerPatch
+  NR_AGENT_GEM = 'newrelic_rpm'
+
+  def require(*_groups)
+    super
+
+    require_newrelic
+  end
+
+  def require_newrelic
+    lib = File.expand_path('../..', __FILE__)
+    $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+    Kernel.require NR_AGENT_GEM
+  end
+end
+
+class NRBundlerPatcher
+  BUNDLER = 'bundler'
+  RUBYOPT = 'RUBYOPT'
+
+  def self.patch
+    check_for_require
+    check_for_rubyopt
+    check_for_bundler
+    Bundler::Runtime.prepend(NRBundlerPatch)
+  rescue StandardError => e
+    Kernel.warn "New Relic entrypoint at #{__FILE__} encountered an issue:\n  #{e.message}"
+  end
+
+  private
+
+  def self.check_for_require
+    raise "#{__FILE__} is meant to be required, not invoked directly" if $PROGRAM_NAME == __FILE__
+  end
+
+  def self.check_for_rubyopt
+    unless ENV[RUBYOPT].to_s.match?("-r #{__FILE__.rpartition('.').first}")
+      raise "#{__FILE__} is meant to be required via the RUBYOPT env var"
+    end
+  end
+
+  def self.check_for_bundler
+    require_bundler
+
+    raise 'Required Ruby Bundler class Bundler::Runtime not defined!' unless defined?(Bundler::Runtime)
+
+    unless Bundler::Runtime.method_defined?(:require)
+      raise "The active Ruby Bundler instance doesn't offer Bundler::Runtime#require"
+    end
+  end
+
+  def self.require_bundler
+    require BUNDLER
+  rescue LoadError => e
+    raise "Required Ruby library '#{BUNDLER}' could not be required - #{e}"
+  end
+end
+
+NRBundlerPatcher.patch

data/lib/new_relic/agent/adaptive_sampler.rb

@@ -0,0 +1,108 @@
+# 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)
+        @target = target_samples
+        @seen = 0
+        @seen_last = 0
+        @sampled_count = 0
+        @period_duration = period_duration
+        @first_period = true
+        @period_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @lock = Mutex.new
+        register_config_callbacks
+      end
+
+      # Called at the beginning of each transaction, increments seen and
+      # returns a boolean indicating if we should mark the transaction as
+      # sampled. This uses the adaptive sampling algorithm.
+      def sampled?
+        @lock.synchronize do
+          reset_if_period_expired!
+          sampled = if @first_period
+            @sampled_count < 10
+          elsif @sampled_count < @target
+            rand(@seen_last) < @target
+          else
+            # you've met the target and need to exponentially back off
+            rand(@seen) < exponential_backoff
+          end
+
+          @sampled_count += 1 if sampled
+          @seen += 1
+
+          sampled
+        end
+      end
+
+      def exponential_backoff
+        @target**(@target.to_f / @sampled_count) - @target**0.5
+      end
+
+      def stats
+        @lock.synchronize do
+          {
+            target: @target,
+            seen: @seen,
+            seen_last: @seen_last,
+            sampled_count: @sampled_count
+          }
+        end
+      end
+
+      private
+
+      def reset_if_period_expired!
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return unless @period_start + @period_duration <= now
+
+        elapsed_periods = Integer((now - @period_start) / @period_duration)
+        @period_start += elapsed_periods * @period_duration
+
+        @first_period = false
+        @seen_last = elapsed_periods > 1 ? 0 : @seen
+        @seen = 0
+        @sampled_count = 0
+      end
+
+      def register_config_callbacks
+        register_sampling_target_callback
+        register_sampling_period_callback
+      end
+
+      def register_sampling_target_callback
+        NewRelic::Agent.config.register_callback(:sampling_target) do |target|
+          target_changed = false
+          @lock.synchronize do
+            if @target != target
+              @target = target
+              target_changed = true
+            end
+          end
+          if target_changed
+            NewRelic::Agent.logger.debug("Sampling target set to: #{target}")
+          end
+        end
+      end
+
+      def register_sampling_period_callback
+        NewRelic::Agent.config.register_callback(:sampling_target_period_in_seconds) do |period_duration|
+          period_changed = false
+          @lock.synchronize do
+            if @period_duration != period_duration
+              @period_duration = period_duration
+              period_changed = true
+            end
+          end
+          if period_changed
+            NewRelic::Agent.logger.debug("Sampling period set to: #{period_duration}")
+          end
+        end
+      end
+    end
+  end
+end