newrelic_rpm 8.2.0 → 9.0.0

data/lib/new_relic/helper.rb

@@ -1,10 +1,14 @@
-# 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 'new_relic/language_support'
+require 'open3'
 
 module NewRelic
+  class CommandExecutableNotFoundError < StandardError; end
+  class CommandRunFailedError < StandardError; end
+
   # A singleton for shared generic helper methods
   module Helper
     extend self
@@ -12,16 +16,17 @@ module NewRelic
     # Confirm a string is correctly encoded,
     # If not force the encoding to ASCII-8BIT (binary)
     def correctly_encoded(string)
-      return string unless string.is_a? String
+      return string unless string.is_a?(String)
+
       # The .dup here is intentional, since force_encoding mutates the target,
       # and we don't know who is going to use this string downstream of us.
       string.valid_encoding? ? string : string.dup.force_encoding(Encoding::ASCII_8BIT)
     end
 
     def instance_method_visibility(klass, method_name)
-      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      if klass.private_instance_methods.map { |s| s.to_sym }.include?(method_name.to_sym)
         :private
-      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      elsif klass.protected_instance_methods.map { |s| s.to_sym }.include?(method_name.to_sym)
         :protected
       else
         :public
@@ -31,14 +36,50 @@ module NewRelic
     def instance_methods_include?(klass, method_name)
       method_name_sym = method_name.to_sym
       (
-        klass.instance_methods.map{ |s| s.to_sym }.include?(method_name_sym)          ||
-        klass.protected_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym) ||
-        klass.private_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym)
+        klass.instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.protected_instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.private_instance_methods.map { |s| s.to_sym }.include?(method_name_sym)
       )
     end
 
     def time_to_millis(time)
       (time.to_f * 1000).round
     end
+
+    def run_command(command)
+      executable = command.split(' ').first
+      unless executable_in_path?(executable)
+        raise NewRelic::CommandExecutableNotFoundError.new("Executable not found: '#{executable}'")
+      end
+
+      exception = nil
+      begin
+        output, status = Open3.capture2e(command)
+      rescue => exception
+      end
+
+      if exception || !status.success?
+        message = exception ? "#{exception.class} - #{exception.message}" : output
+        raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
+      end
+
+      output.chomp if output
+    end
+
+    # TODO: Open3 defers the actual execution of a binary to Process.spawn,
+    #       which will raise an Errno::ENOENT exception for a file that
+    #       cannot be found. We might want to take the time to evaluate
+    #       relying on that Process.spawn behavior instead of checking for
+    #       existence ourselves. We'd need to see what it does, how efficient
+    #       it is, if it differs in functionality between Ruby versions and
+    #       operating systems, etc.
+    def executable_in_path?(executable)
+      return false unless ENV['PATH']
+
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |bin_path|
+        executable_path = File.join(bin_path, executable)
+        File.exist?(executable_path) && File.file?(executable_path) && File.executable?(executable_path)
+      end
+    end
   end
 end

data/lib/new_relic/language_support.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
 
 module NewRelic
   module LanguageSupport
@@ -9,7 +9,8 @@ module NewRelic
     @@forkable = nil
     def can_fork?
       # this is expensive to check, so we should only check once
-      return @@forkable if @@forkable != nil
+      return @@forkable if !@@forkable.nil?
+
       @@forkable = Process.respond_to?(:fork)
     end
 
@@ -22,7 +23,8 @@ module NewRelic
     end
 
     def object_space_usable?
-      if defined?(::JRuby) && JRuby.respond_to?(:runtime)
+      if jruby?
+        require 'jruby'
         JRuby.runtime.is_object_space_enabled
       else
         defined?(::ObjectSpace)
@@ -33,12 +35,29 @@ module NewRelic
       RUBY_ENGINE == 'jruby'
     end
 
+    # TODO: OLD RUBIES - RUBY_VERSION < 2.6
+    #
+    # Ruby 2.6 introduced an improved version of `Object.const_get` that
+    # respects the full namespace of the input and doesn't just grab the first
+    # constant matching the string to the right of the last '::'.
+    # Once we drop support for Ruby 2.5 and below, the only value this custom
+    # method will provide beyond `Object.const_get` itself is to automatically
+    # catch NameError.
+    #
+    # see: https://github.com/rails/rails/commit/7057ccf6565c1cb5354c1906880119276a9d15c0
+    #
+    # With Ruby 2.6+, this method can be defined like so:
+    # def constantize(constant_as_string_or_symbol)
+    #   Object.const_get(constant_as_string_or_symbol)
+    # rescue NameError
+    # end
+    #
     def constantize(const_name)
-      const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+      const_name.to_s.sub(/\A::/, '').split('::').inject(Object) do |namespace, name|
         begin
           result = namespace.const_get(name)
 
-          # const_get looks up the inheritence chain, so if it's a class
+          # const_get looks up the inheritance chain, so if it's a class
           # in the constant make sure we found the one in our namespace.
           #
           # Can't help if the constant isn't a class...
@@ -54,6 +73,11 @@ module NewRelic
       end
     end
 
+    def camelize(string)
+      camelized = string.downcase
+      camelized.split(/\-|\_/).map(&:capitalize).join
+    end
+
     def bundled_gem?(gem_name)
       defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
     rescue => e

data/lib/new_relic/latest_changes.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
 
 module NewRelic
   module LatestChanges
@@ -13,7 +13,7 @@ module NewRelic
     changes.
 EOS
 
-    def self.read(changelog=default_changelog)
+    def self.read(changelog = default_changelog)
       changes = extract_latest_changes(File.read(changelog))
       changes << FOOTER
 
@@ -24,14 +24,14 @@ EOS
     # precise version number included in the line in parens. For example:
     #
     # * This is a patch item (3.7.1.188)
-    def self.read_patch(patch_level, changelog=default_changelog)
+    def self.read_patch(patch_level, changelog = default_changelog)
       latest = extract_latest_changes(File.read(changelog))
       changes = ["## v#{patch_level}", ""]
 
       current_item = nil
       latest.each do |line|
-        if line.match(/^\s*\*.*/)
-          if line.match(/\(#{patch_level}\)/)
+        if line =~ /^\s*\*.*/
+          if line =~ /\(#{patch_level}\)/
             # Found a patch level item, so start tracking the lines!
             current_item = line
           else
@@ -52,10 +52,11 @@ EOS
       changes = []
       version_count = 0
       contents.each_line do |line|
-        if line.match(/##\s+v[\d.]+/)
+        if line =~ /##\s+v[\d.]+/
           version_count += 1
         end
         break if version_count >= 2
+
         changes << line.sub(/^  \* /, "* ").chomp
       end
       changes

data/lib/new_relic/local_environment.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
 
 require 'set'
 require 'new_relic/version'
@@ -26,7 +26,7 @@ module NewRelic
   #
   # If the environment can't be determined, it will be set to nil.
   #
-  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
+  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#local_env (via the NewRelic::Control singleton).
   class LocalEnvironment
     def discovered_dispatcher
       discover_dispatcher unless @discovered_dispatcher
@@ -34,11 +34,11 @@ module NewRelic
     end
 
     def initialize
-      # Extend self with any any submodules of LocalEnvironment.  These can override
-      # the discover methods to discover new framworks and dispatchers.
-      NewRelic::LocalEnvironment.constants.each do | const |
-        mod = NewRelic::LocalEnvironment.const_get const
-        self.extend mod if mod.instance_of? Module
+      # Extend self with any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new frameworks and dispatchers.
+      NewRelic::LocalEnvironment.constants.each do |const|
+        mod = NewRelic::LocalEnvironment.const_get(const)
+        self.extend(mod) if mod.instance_of?(Module)
       end
 
       @discovered_dispatcher = nil
@@ -71,19 +71,19 @@ module NewRelic
         thin
         mongrel
         litespeed
+        unicorn
         webrick
         fastcgi
-        rainbows
-        unicorn
       ]
       while dispatchers.any? && @discovered_dispatcher.nil?
-        send 'check_for_'+(dispatchers.shift)
+        send('check_for_' + (dispatchers.shift))
       end
     end
 
     def check_for_torquebox
       return unless defined?(::JRuby) &&
-         ( org.torquebox::TorqueBox rescue nil)
+        (org.torquebox::TorqueBox rescue nil)
+
       @discovered_dispatcher = :torquebox
     end
 
@@ -92,11 +92,13 @@ module NewRelic
         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
           defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
          (jruby_rack? && defined?(::GlassFish::Server)))
+
       @discovered_dispatcher = :glassfish
     end
 
     def check_for_trinidad
       return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+
       @discovered_dispatcher = :trinidad
     end
 
@@ -106,17 +108,20 @@ module NewRelic
 
     def check_for_webrick
       return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+
       @discovered_dispatcher = :webrick
     end
 
     def check_for_fastcgi
       return unless defined?(::FCGI)
+
       @discovered_dispatcher = :fastcgi
     end
 
     # this case covers starting by mongrel_rails
     def check_for_mongrel
       return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+
       @discovered_dispatcher = :mongrel
     end
 
@@ -127,13 +132,6 @@ module NewRelic
       end
     end
 
-    def check_for_rainbows
-      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
-        v = find_class_in_object_space(::Rainbows::HttpServer)
-        @discovered_dispatcher = :rainbows if v
-      end
-    end
-
     def check_for_puma
       if defined?(::Puma) && File.basename($0) == 'puma'
         @discovered_dispatcher = :puma
@@ -147,9 +145,9 @@ module NewRelic
     end
 
     def check_for_resque
-      has_queue              = ENV['QUEUE'] || ENV['QUEUES']
-      resque_rake            = executable == 'rake' && ARGV.include?('resque:work')
-      resque_pool_rake       = executable == 'rake' && ARGV.include?('resque:pool')
+      has_queue = ENV['QUEUE'] || ENV['QUEUES']
+      resque_rake = executable == 'rake' && ARGV.include?('resque:work')
+      resque_pool_rake = executable == 'rake' && ARGV.include?('resque:pool')
       resque_pool_executable = executable == 'resque-pool' && defined?(::Resque::Pool)
 
       using_resque = defined?(::Resque) &&
@@ -180,7 +178,7 @@ module NewRelic
     end
 
     def check_for_litespeed
-      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+      if caller.pop.include?('fcgi-bin/RailsRunner.rb')
         @discovered_dispatcher = :litespeed
       end
     end
@@ -192,16 +190,14 @@ module NewRelic
     end
 
     public
+
     # outputs a human-readable description
     def to_s
-      s = "LocalEnvironment["
-      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
-      s << "]"
+      %Q(LocalEnvironment[#{";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher}])
     end
 
     def executable
       File.basename($0)
     end
-
   end
 end

data/lib/new_relic/metric_data.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
 
 require 'new_relic/coerce'
 
@@ -8,9 +8,11 @@ module NewRelic
   class MetricData
     # a NewRelic::MetricSpec object
     attr_reader :metric_spec
-    # the actual statistics object
+    # a NewRelic::Agent::Stats object
     attr_accessor :stats
 
+    include NewRelic::Coerce
+
     def initialize(metric_spec, stats)
       @original_spec = nil
       @metric_spec = metric_spec
@@ -18,50 +20,53 @@ module NewRelic
     end
 
     def eql?(o)
-     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+      (metric_spec.eql?(o.metric_spec)) && (stats.eql?(o.stats))
     end
 
-    def original_spec
-      @original_spec || @metric_spec
+    def hash
+      [metric_spec, stats].hash
+    end
+
+    def inspect
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}>"
     end
 
     # assigns a new metric spec, and retains the old metric spec as
     # @original_spec if it exists currently
-    def metric_spec= new_spec
+    def metric_spec=(new_spec)
       @original_spec = @metric_spec if @metric_spec
       @metric_spec = new_spec
     end
 
-    def hash
-      metric_spec.hash ^ stats.hash
+    def original_spec
+      @original_spec || @metric_spec
+    end
+
+    def to_collector_array(encoder = nil)
+      stat_key = {'name' => metric_spec.name, 'scope' => metric_spec.scope}
+      [stat_key, stats_collector_array(stat_key)]
     end
 
     def to_json(*a)
-       %Q[{"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}}]
+      %Q({"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}})
     end
 
     def to_s
       "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
     end
 
-    def inspect
-      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}>"
-    end
-
-    include NewRelic::Coerce
+    private
 
-    def to_collector_array(encoder=nil)
-      stat_key = { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
-      [ stat_key,
-        [
-          int(stats.call_count, stat_key),
-          float(stats.total_call_time, stat_key),
-          float(stats.total_exclusive_time, stat_key),
-          float(stats.min_call_time, stat_key),
-          float(stats.max_call_time, stat_key),
-          float(stats.sum_of_squares, stat_key)
-        ]
-      ]
+    def stats_collector_array(stat_key)
+      [[:call_count, Integer], [:total_call_time, Float],
+        [:total_exclusive_time, Float], [:min_call_time, Float],
+        [:max_call_time, Float], [:sum_of_squares, Float]].map do |attr_types|
+        if attr_types[1].eql?(Integer)
+          int(stats.send(attr_types[0]), stat_key)
+        elsif attr_types[1].eql?(Float)
+          float(stats.send(attr_types[0]), stat_key)
+        end
+      end
     end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -1,18 +1,18 @@
-# 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 struct uniquely defines a metric, optionally inside
 # the call scope of another metric
 class NewRelic::MetricSpec
-  attr_reader   :name, :scope
+  attr_reader :name, :scope
 
   # the maximum length of a metric name or metric scope
   MAX_LENGTH = 255
   LENGTH_RANGE = (0...MAX_LENGTH)
   EMPTY_SCOPE = ''.freeze
 
-  def initialize(metric_name='', metric_scope=nil)
+  def initialize(metric_name = '', metric_scope = nil)
     if metric_name.to_s.length > MAX_LENGTH
       @name = metric_name.to_s[LENGTH_RANGE]
     else
@@ -34,16 +34,17 @@ class NewRelic::MetricSpec
     self.eql?(o)
   end
 
-  def eql? o
+  def eql?(o)
     @name == o.name && @scope == o.scope
   end
 
   def hash
-    @name.hash ^ @scope.hash
+    [@name, @scope].hash
   end
 
   def to_s
     return name if scope.empty?
+
     "#{name}:#{scope}"
   end
 
@@ -53,12 +54,13 @@ class NewRelic::MetricSpec
 
   def to_json(*a)
     {'name' => name,
-    'scope' => scope}.to_json(*a)
+     'scope' => scope}.to_json(*a)
   end
 
   def <=>(o)
     namecmp = self.name <=> o.name
     return namecmp if namecmp != 0
+
     return (self.scope || '') <=> (o.scope || '')
   end
 end

data/lib/new_relic/noticed_error.rb

@@ -1,4 +1,3 @@
-# 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
@@ -12,11 +11,11 @@ class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
 
   attr_accessor :path, :timestamp, :message, :exception_class_name,
-                :request_uri, :request_port, :file_name, :line_number,
-                :stack_trace, :attributes_from_notice_error, :attributes,
-                :expected
+    :request_uri, :request_port, :file_name, :line_number,
+    :stack_trace, :attributes_from_notice_error, :attributes,
+    :expected
 
-  attr_reader   :exception_id, :is_internal
+  attr_reader :exception_id, :is_internal
 
   STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by New Relic 'strip_exception_messages' setting"
   UNKNOWN_ERROR_CLASS_NAME = 'Error'
@@ -28,9 +27,9 @@ class NewRelic::NoticedError
 
   DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
 
-  ERROR_PREFIX_KEY   = 'error'
-  ERROR_MESSAGE_KEY  = "#{ERROR_PREFIX_KEY}.message"
-  ERROR_CLASS_KEY    = "#{ERROR_PREFIX_KEY}.class"
+  ERROR_PREFIX_KEY = 'error'
+  ERROR_MESSAGE_KEY = "#{ERROR_PREFIX_KEY}.message"
+  ERROR_CLASS_KEY = "#{ERROR_PREFIX_KEY}.class"
   ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
 
   def initialize(path, exception, timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), expected = false)
@@ -51,7 +50,7 @@ class NewRelic::NoticedError
 
     # replace error message if enabled
     if NewRelic::Agent.config[:'strip_exception_messages.enabled'] &&
-       !self.class.passes_message_allowlist(exception.class)
+        !self.class.passes_message_allowlist(exception.class)
       @message = STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE
     end
 
@@ -77,12 +76,12 @@ class NewRelic::NoticedError
 
   include NewRelic::Coerce
 
-  def to_collector_array(encoder=nil)
-    [ NewRelic::Helper.time_to_millis(timestamp),
+  def to_collector_array(encoder = nil)
+    [NewRelic::Helper.time_to_millis(timestamp),
       string(path),
       string(message),
       string(exception_class_name),
-      processed_attributes ]
+      processed_attributes]
   end
 
   # Note that we process attributes lazily and store the result. This is because
@@ -101,9 +100,9 @@ class NewRelic::NoticedError
 
   def base_parameters
     params = {}
-    params[:file_name]        = file_name   if file_name
-    params[:line_number]      = line_number if line_number
-    params[:stack_trace]      = stack_trace if stack_trace
+    params[:file_name] = file_name if file_name
+    params[:line_number] = line_number if line_number
+    params[:stack_trace] = stack_trace if stack_trace
     params[ERROR_EXPECTED_KEY.to_sym] = expected
     params
   end
@@ -135,10 +134,8 @@ class NewRelic::NoticedError
 
   def build_error_attributes
     @attributes_from_notice_error ||= {}
-    @attributes_from_notice_error.merge!({
-      ERROR_MESSAGE_KEY => string(message),
-      ERROR_CLASS_KEY => string(exception_class_name)
-    })
+    @attributes_from_notice_error[ERROR_MESSAGE_KEY] = string(message)
+    @attributes_from_notice_error[ERROR_CLASS_KEY] = string(exception_class_name)
 
     @attributes_from_notice_error[ERROR_EXPECTED_KEY] = true if expected
   end
@@ -189,7 +186,7 @@ class NewRelic::NoticedError
     if exception.nil?
       @exception_class_name = UNKNOWN_ERROR_CLASS_NAME
       @message = NIL_ERROR_MESSAGE
-    elsif exception.is_a? NewRelic::Agent::NoticibleError
+    elsif exception.is_a?(NewRelic::Agent::NoticeableError)
       @exception_class_name = exception.class_name
       @message = exception.message
     else
@@ -200,5 +197,4 @@ class NewRelic::NoticedError
       @message = exception.to_s
     end
   end
-
 end

data/lib/new_relic/rack/agent_hooks.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
 
 require 'new_relic/agent/event_listener'
 require 'new_relic/rack/agent_middleware'

data/lib/new_relic/rack/agent_middleware.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
 
 require 'new_relic/agent/tracer'
 require 'new_relic/agent/instrumentation/controller_instrumentation'
@@ -13,10 +13,10 @@ module NewRelic
 
       attr_reader :transaction_options, :category, :target
 
-      def initialize(app, options={})
+      def initialize(app, options = {})
         @app = app
         @category = :middleware
-        @target   = self
+        @target = self
         @transaction_options = {
           :transaction_name => build_transaction_name
         }
@@ -33,11 +33,13 @@ module NewRelic
       # response code before it goes back to the client.
       def capture_http_response_code(state, result)
         return if NewRelic::Agent.config[:disable_middleware_instrumentation]
+
         super
       end
 
       def capture_response_content_type(state, result)
         return if NewRelic::Agent.config[:disable_middleware_instrumentation]
+
         super
       end
     end