newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -1,21 +1,36 @@
-# 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 Agent
     class RulesEngine
       class SegmentTermsRule
-        SEGMENT_PLACEHOLDER               = '*'.freeze
-        ADJACENT_PLACEHOLDERS_REGEX       = %r{((?:^|/)\*)(?:/\*)*}.freeze
+        PREFIX_KEY = 'prefix'.freeze
+        TERMS_KEY = 'terms'.freeze
+        ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
 
         attr_reader :prefix, :terms
 
+        def self.valid?(rule_spec)
+          rule_spec[PREFIX_KEY].kind_of?(String) &&
+            rule_spec[TERMS_KEY].kind_of?(Array) &&
+            valid_prefix_segment_count?(rule_spec[PREFIX_KEY])
+        end
+
+        def self.valid_prefix_segment_count?(prefix)
+          count = prefix.count(SEGMENT_SEPARATOR)
+          rindex = prefix.rindex(SEGMENT_SEPARATOR)
+
+          (count == 2 && prefix[rindex + 1].nil?) ||
+            (count == 1 && !prefix[rindex + 1].nil?)
+        end
+
         def initialize(options)
-          @prefix          = options['prefix']
-          @terms           = options['terms']
-          @trim_range      = (@prefix.size..-1)
+          @prefix = options[PREFIX_KEY]
+          @terms = options[TERMS_KEY]
+          @trim_range = (@prefix.size..-1)
         end
 
         def terminal?
@@ -23,15 +38,20 @@ module NewRelic
         end
 
         def matches?(string)
-          string.start_with?(@prefix)
+          string.start_with?(@prefix) &&
+            (prefix_matches_on_segment_boundary?(string) || string.size == @prefix.size)
+        end
+
+        def prefix_matches_on_segment_boundary?(string)
+          string.size > @prefix.size &&
+            string[@prefix.chomp(SEGMENT_SEPARATOR).size].chr == SEGMENT_SEPARATOR
         end
 
         def apply(string)
-          rest          = string[@trim_range]
+          rest = string[@trim_range]
           leading_slash = rest.slice!(LEADING_SLASH_REGEX)
-
-          segments = rest.split(SEGMENT_SEPARATOR)
-          segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }
+          segments = rest.split(SEGMENT_SEPARATOR, -1)
+          segments.map! { |s| @terms.include?(s) ? s : ASTERISK }
           transformed_suffix = collapse_adjacent_placeholder_segments(segments)
 
           "#{@prefix}#{leading_slash}#{transformed_suffix}"

data/lib/new_relic/agent/rules_engine.rb

@@ -1,14 +1,15 @@
-# 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 'new_relic/agent/rules_engine/replacement_rule'
 require 'new_relic/agent/rules_engine/segment_terms_rule'
+require 'new_relic/language_support'
 
 module NewRelic
   module Agent
     class RulesEngine
-      SEGMENT_SEPARATOR = '/'.freeze
+      SEGMENT_SEPARATOR = NewRelic::SLASH
       LEADING_SLASH_REGEX = %r{^/}.freeze
 
       include Enumerable
@@ -23,16 +24,37 @@ module NewRelic
       end
 
       def self.create_transaction_rules(connect_response)
-        txn_name_specs     = connect_response['transaction_name_rules']    || []
+        txn_name_specs = connect_response['transaction_name_rules'] || []
         segment_rule_specs = connect_response['transaction_segment_terms'] || []
 
-        txn_name_rules = txn_name_specs.map     { |s| ReplacementRule.new(s) }
-        segment_rules  = segment_rule_specs.map { |s| SegmentTermsRule.new(s) }
+        txn_name_rules = txn_name_specs.map { |s| ReplacementRule.new(s) }
+
+        segment_rules = []
+
+        segment_rule_specs.each do |spec|
+          if spec[SegmentTermsRule::PREFIX_KEY] && SegmentTermsRule.valid?(spec)
+            # Build segment_rules in reverse order from which they're provided,
+            # so that when we eliminate duplicates with #uniq!, we retain the last
+            # instances of repeated rules.
+            segment_rules.unshift(SegmentTermsRule.new(spec))
+          end
+        end
+
+        reject_rules_with_duplicate_prefixes!(segment_rules)
+
+        segment_rules.reverse! # Reset the rules to their original order.
 
         self.new(txn_name_rules, segment_rules)
       end
 
-      def initialize(rules=[], segment_term_rules=[])
+      # When multiple rules share the same prefix,
+      # only apply the rule with the last instance of the prefix.
+      # Note that the incoming rules are in reverse order to facilitate this.
+      def self.reject_rules_with_duplicate_prefixes!(rules)
+        rules.uniq! { |rule| rule.prefix }
+      end
+
+      def initialize(rules = [], segment_term_rules = [])
         @rules = rules.sort
         @segment_term_rules = segment_term_rules
       end
@@ -50,6 +72,7 @@ module NewRelic
       def rename(original_string)
         renamed = apply_rules(@rules, original_string)
         return nil unless renamed
+
         renamed = apply_rules(@segment_term_rules, renamed)
         renamed
       end

data/lib/new_relic/agent/sampler.rb

@@ -1,6 +1,7 @@
-# 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
+
 #
 # A Sampler is used to capture meaningful metrics in a background thread
 # periodically.  They will be invoked about once a minute, each time the agent
@@ -12,19 +13,18 @@
 module NewRelic
   module Agent
     class Sampler
-
       # Exception denotes a sampler is not available and it will not be registered.
-      class Unsupported < StandardError;  end
+      class Unsupported < StandardError; end
 
       attr_reader :id
       @sampler_classes = []
 
-      def self.named(new_name)
-        @name = new_name
+      class << self
+        attr_reader :shorthand_name
       end
 
-      def self.name
-        @name
+      def self.named(new_name)
+        @shorthand_name = new_name
       end
 
       def self.inherited(subclass)
@@ -37,8 +37,8 @@ module NewRelic
       end
 
       def self.enabled?
-        if @name
-          config_key = "disable_#{@name}_sampler"
+        if shorthand_name
+          config_key = "disable_#{shorthand_name}_sampler"
           !(Agent.config[config_key])
         else
           true
@@ -52,12 +52,12 @@ module NewRelic
       # The ID passed in here is unused by our code, but is preserved in case
       # we have clients who are defining their own subclasses of this class, and
       # expecting to be able to call super with an ID.
-      def initialize(id=nil)
-        @id = id || self.class.name
+      def initialize(id = nil)
+        @id = id || self.class.shorthand_name
       end
 
       def poll
-        raise "Implement in the subclass"
+        raise 'Implement in the subclass'
       end
     end
   end

data/lib/new_relic/agent/sampler_collection.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
 
 module NewRelic
   module Agent
@@ -17,7 +17,7 @@ module NewRelic
         @samplers.each(&blk)
       end
 
-      def clear()
+      def clear
         @samplers.clear
       end
 
@@ -34,7 +34,6 @@ module NewRelic
         end
       end
 
-
       def poll_samplers
         @samplers.delete_if do |sampler|
           begin
@@ -49,7 +48,7 @@ module NewRelic
 
       def add_sampler(sampler_class)
         supported = sampler_class.supported_on_this_platform?
-        enabled   = sampler_class.enabled?
+        enabled = sampler_class.enabled?
         if supported && enabled
           if !sampler_class_registered?(sampler_class)
             sampler = sampler_class.new
@@ -65,7 +64,7 @@ module NewRelic
       rescue NewRelic::Agent::Sampler::Unsupported => e
         ::NewRelic::Agent.logger.info("#{sampler_class.name} not available: #{e}")
       rescue => e
-        ::NewRelic::Agent.logger.error("Error registering sampler:", e)
+        ::NewRelic::Agent.logger.error('Error registering sampler:', e)
       end
     end
   end

data/lib/new_relic/agent/samplers/cpu_sampler.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
 
 require 'new_relic/agent/sampler'
 
@@ -13,28 +13,29 @@ module NewRelic
         named :cpu
 
         def initialize
+          @last_time = nil
           @processor_count = NewRelic::Agent::SystemInfo.num_logical_processors
           if @processor_count.nil?
-            NewRelic::Agent.logger.warn("Failed to determine processor count, assuming 1")
+            NewRelic::Agent.logger.warn('Failed to determine processor count, assuming 1')
             @processor_count = 1
           end
           poll
         end
 
         def record_user_util(value)
-          NewRelic::Agent.record_metric("CPU/User/Utilization", value)
+          NewRelic::Agent.record_metric('CPU/User/Utilization', value)
         end
 
         def record_system_util(value)
-          NewRelic::Agent.record_metric("CPU/System/Utilization", value)
+          NewRelic::Agent.record_metric('CPU/System/Utilization', value)
         end
 
         def record_usertime(value)
-          NewRelic::Agent.record_metric("CPU/User Time", value)
+          NewRelic::Agent.record_metric('CPU/User Time', value)
         end
 
         def record_systemtime(value)
-          NewRelic::Agent.record_metric("CPU/System Time", value)
+          NewRelic::Agent.record_metric('CPU/System Time', value)
         end
 
         def self.supported_on_this_platform?
@@ -43,13 +44,15 @@ module NewRelic
           if defined?(JRuby)
             return JRUBY_VERSION >= '1.7.0'
           end
+
           true
         end
 
         def poll
-          now = Time.now
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           t = Process.times
-          if @last_time
+
+          if @last_time && t.utime != 0.0 && t.stime != 0.0
             elapsed = now - @last_time
             return if elapsed < 1 # Causing some kind of math underflow
 
@@ -61,10 +64,10 @@ module NewRelic
 
             # Calculate the true utilization by taking cpu times and dividing by
             # elapsed time X processor_count.
-
             record_user_util(usertime / (elapsed * @processor_count))
             record_system_util(systemtime / (elapsed * @processor_count))
           end
+
           @last_utime = t.utime
           @last_stime = t.stime
           @last_time = now

data/lib/new_relic/agent/samplers/delayed_job_sampler.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
 
 require 'new_relic/agent/sampler'
 require 'new_relic/delayed_job_injection'
@@ -21,21 +21,21 @@ module NewRelic
         # DelayedJob supports multiple backends, only some of which we can
         # handle. Check whether we think we've got what we need here.
         def self.supported_backend?
-          ::Delayed::Worker.backend.to_s == "Delayed::Backend::ActiveRecord::Job"
+          ::Delayed::Worker.backend.to_s == 'Delayed::Backend::ActiveRecord::Job'
         end
 
         def initialize
-          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:disable_dj]
+          raise Unsupported, 'DJ queue sampler disabled' if Agent.config[:'instrumentation.delayed_job'] == 'disabled'
           raise Unsupported, "DJ queue sampling unsupported with backend '#{::Delayed::Worker.backend}'" unless self.class.supported_backend?
-          raise Unsupported, "No DJ worker present. Skipping DJ queue sampler" unless NewRelic::DelayedJobInjection.worker_name
+          raise Unsupported, 'No DJ worker present. Skipping DJ queue sampler' unless NewRelic::DelayedJobInjection.worker_name
         end
 
         def record_failed_jobs(value)
-          NewRelic::Agent.record_metric("Workers/DelayedJob/failed_jobs", value)
+          NewRelic::Agent.record_metric('Workers/DelayedJob/failed_jobs', value)
         end
 
         def record_locked_jobs(value)
-          NewRelic::Agent.record_metric("Workers/DelayedJob/locked_jobs", value)
+          NewRelic::Agent.record_metric('Workers/DelayedJob/locked_jobs', value)
         end
 
         FAILED_QUERY = 'failed_at is not NULL'.freeze
@@ -51,7 +51,7 @@ module NewRelic
 
         def count(query)
           if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-            ::Delayed::Job.count(query)
+            ::Delayed::Job.count(:conditions => query)
           else
             ::Delayed::Job.where(query).count
           end
@@ -62,19 +62,22 @@ module NewRelic
         end
 
         def poll
-          record_failed_jobs(failed_jobs)
-          record_locked_jobs(locked_jobs)
-          record_queue_length_metrics
+          # Wrapping these queries within the same connection avoids deadlocks
+          ActiveRecord::Base.connection_pool.with_connection do
+            record_failed_jobs(failed_jobs)
+            record_locked_jobs(locked_jobs)
+            record_queue_length_metrics
+          end
         end
 
         private
 
         def record_queue_length_metrics
           counts = []
-          counts << record_counts_by("queue", "name") if ::Delayed::Job.instance_methods.include?(:queue)
-          counts << record_counts_by("priority")
+          counts << record_counts_by('queue', 'name') if ::Delayed::Job.instance_methods.include?(:queue)
+          counts << record_counts_by('priority')
 
-          all_metric = "Workers/DelayedJob/queue_length/all"
+          all_metric = 'Workers/DelayedJob/queue_length/all'
           NewRelic::Agent.record_metric(all_metric, counts.max)
         end
 
@@ -84,7 +87,7 @@ module NewRelic
           all_count = 0
           queue_counts(column_name).each do |column_val, count|
             all_count += count
-            column_val = "default" if column_val.nil? || column_val == ""
+            column_val = 'default' if column_val.nil? || column_val == NewRelic::EMPTY_STR
             metric = "Workers/DelayedJob/queue_length/#{metric_node}/#{column_val}"
             NewRelic::Agent.record_metric(metric, count)
           end
@@ -97,11 +100,11 @@ module NewRelic
           # here that's valid on 2.x through 4.1, so split it up.
           result = if ::ActiveRecord::VERSION::MAJOR.to_i < 4
             ::Delayed::Job.count(:group => column_name,
-                                 :conditions => [QUEUE_QUERY_CONDITION, now])
+              :conditions => [QUEUE_QUERY_CONDITION, now])
           else
-            ::Delayed::Job.where(QUEUE_QUERY_CONDITION, now).
-                           group(column_name).
-                           count
+            ::Delayed::Job.where(QUEUE_QUERY_CONDITION, now)
+              .group(column_name)
+              .count
           end
           result.to_a
         end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -1,38 +1,40 @@
-# 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 'new_relic/agent/sampler'
+require 'new_relic/helper'
 
 module NewRelic
   module Agent
     module Samplers
-
       class MemorySampler < NewRelic::Agent::Sampler
         named :memory
 
         attr_accessor :sampler
 
         def initialize
+          @sampler = nil
+
           # macos, linux, solaris
           if defined? JRuby
             @sampler = JavaHeapSampler.new
-          elsif platform =~ /linux/
+          elsif platform.include?('linux')
             @sampler = ProcStatus.new
             if !@sampler.can_run?
-              ::NewRelic::Agent.logger.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
-              @sampler = ShellPS.new("ps -o rsz")
+              ::NewRelic::Agent.logger.debug("Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead.")
+              @sampler = ShellPS.new('ps -o rsz')
             else
-              ::NewRelic::Agent.logger.debug "Using /proc/#{$$}/status for reading process memory."
+              ::NewRelic::Agent.logger.debug("Using /proc/#{$$}/status for reading process memory.")
             end
-          elsif platform =~ /darwin9/ # 10.5
-            @sampler = ShellPS.new("ps -o rsz")
-          elsif platform =~ /darwin1\d+/ # >= 10.6
-            @sampler = ShellPS.new("ps -o rss")
-          elsif platform =~ /freebsd/
-            @sampler = ShellPS.new("ps -o rss")
-          elsif platform =~ /solaris/
-            @sampler = ShellPS.new("/usr/bin/ps -o rss -p")
+          elsif platform.include?('darwin9') # 10.5
+            @sampler = ShellPS.new('ps -o rsz')
+          elsif /darwin(1|2)\d+/.match?(platform) # >= 10.6
+            @sampler = ShellPS.new('ps -o rss')
+          elsif platform.include?('freebsd')
+            @sampler = ShellPS.new('ps -o rss')
+          elsif platform.include?('solaris')
+            @sampler = ShellPS.new('/usr/bin/ps -o rss -p')
           end
 
           raise Unsupported, "Unsupported platform for getting memory: #{platform}" if @sampler.nil?
@@ -44,12 +46,17 @@ module NewRelic
         end
 
         def self.platform
-          if RUBY_PLATFORM =~ /java/
-            %x[uname -s].downcase
+          if RUBY_PLATFORM.include?('java')
+            begin
+              NewRelic::Helper.run_command('uname -s').downcase
+            rescue NewRelic::CommandRunFailedError, NewRelic::CommandExecutableNotFoundError
+              'unknown'
+            end
           else
             RUBY_PLATFORM.downcase
           end
         end
+
         def platform
           NewRelic::Agent::Samplers::MemorySampler.platform
         end
@@ -57,28 +64,34 @@ module NewRelic
         def poll
           sample = @sampler.get_sample
           if sample
-            NewRelic::Agent.record_metric("Memory/Physical", sample)
+            NewRelic::Agent.record_metric('Memory/Physical', sample)
           end
         end
 
         class Base
+          def initialize
+            @broken = false
+          end
+
           def can_run?
             return false if @broken
+
             m = get_memory rescue nil
             m && m > 0
           end
 
           def get_sample
             return nil if @broken
+
             begin
               m = get_memory
               if m.nil?
-                ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+                ::NewRelic::Agent.logger.warn("Unable to get the resident memory for process #{$$}.  Disabling memory sampler.")
                 @broken = true
               end
               return m
             rescue => e
-              ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}. Disabling memory sampler.", e
+              ::NewRelic::Agent.logger.warn("Unable to get the resident memory for process #{$$}. Disabling memory sampler.", e)
               @broken = true
               return nil
             end
@@ -86,13 +99,14 @@ module NewRelic
         end
 
         class JavaHeapSampler < Base
-
           def get_memory
             raise "Can't sample Java heap unless running in JRuby" unless defined? JRuby
+
             java.lang.Runtime.getRuntime.totalMemory / (1024 * 1024).to_f rescue nil
           end
+
           def to_s
-            "JRuby Java heap sampler"
+            'JRuby Java heap sampler'
           end
         end
 
@@ -101,6 +115,7 @@ module NewRelic
             super()
             @command = command
           end
+
           # Returns the amount of resident memory this process is using in MB
           #
           def get_memory
@@ -109,8 +124,10 @@ module NewRelic
             # if for some reason the ps command doesn't work on the resident os,
             # then don't execute it any more.
             raise "Faulty command: `#{@command} #{process}`" if memory.nil? || memory <= 0
+
             memory
           end
+
           def to_s
             "shell command sampler: #{@command}"
           end
@@ -121,14 +138,13 @@ module NewRelic
         # A class that samples memory by reading the file /proc/$$/status, which is specific to linux
         #
         class ProcStatus < Base
-
           # Returns the amount of resident memory this process is using in MB
-          #
           def get_memory
-            proc_status = File.open(proc_status_file, "r") {|f| f.read_nonblock(4096).strip }
+            proc_status = File.open(proc_status_file, 'r') { |f| f.read_nonblock(4096).strip }
             if proc_status =~ /RSS:\s*(\d+) kB/i
               return $1.to_f / 1024.0
             end
+
             raise "Unable to find RSS in #{proc_status_file}"
           end
 

data/lib/new_relic/agent/samplers/object_sampler.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
 
 require 'new_relic/agent/sampler'
 
@@ -16,7 +16,7 @@ module NewRelic
 
         def poll
           live_objects = ObjectSpace.live_objects
-          NewRelic::Agent.record_metric("GC/objects", live_objects)
+          NewRelic::Agent.record_metric('GC/objects', live_objects)
         end
       end
     end