newrelic_rpm 8.0.0 → 8.4.0

data/lib/new_relic/agent/stats_engine/stats_hash.rb

@@ -30,13 +30,12 @@ require 'new_relic/agent/internal_agent_error'
 module NewRelic
   module Agent
     class StatsHash
-
       attr_accessor :started_at, :harvested_at
 
-      def initialize(started_at=Process.clock_gettime(Process::CLOCK_REALTIME))
+      def initialize(started_at = Process.clock_gettime(Process::CLOCK_REALTIME))
         @started_at = started_at.to_f
-        @scoped     = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
-        @unscoped   = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @scoped = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @unscoped = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
       end
 
       def marshal_dump
@@ -45,7 +44,7 @@ module NewRelic
 
       def marshal_load(data)
         @started_at = data.shift
-        @scoped   = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @scoped = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
         @unscoped = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
         @scoped.merge!(data.shift)
         @unscoped.merge!(data.shift)
@@ -57,7 +56,7 @@ module NewRelic
 
       def to_h
         hash = {}
-        @scoped.each   { |k, v| hash[k] = v }
+        @scoped.each { |k, v| hash[k] = v }
         @unscoped.each { |k, v| hash[NewRelic::MetricSpec.new(k)] = v }
         hash
       end
@@ -99,7 +98,7 @@ module NewRelic
         end
       end
 
-      def record(metric_specs, value=nil, aux=nil, &blk)
+      def record(metric_specs, value = nil, aux = nil, &blk)
         Array(metric_specs).each do |metric_spec|
           if metric_spec.scope.empty?
             key = metric_spec.name
@@ -122,8 +121,8 @@ module NewRelic
       def handle_stats_lookup_error(key, hash, error)
         # This only happen in the case of a corrupted default_proc
         # Side-step it manually, notice the issue, and carry on....
-        NewRelic::Agent.instance.error_collector. \
-          notice_agent_error(StatsHashLookupError.new(error, hash, key))
+        NewRelic::Agent.instance.error_collector \
+          .notice_agent_error(StatsHashLookupError.new(error, hash, key))
         stats = NewRelic::Agent::Stats.new
         hash[key] = stats
         # Try to restore the default_proc so we won't continually trip the error

data/lib/new_relic/agent/stats_engine.rb

@@ -13,8 +13,8 @@ module NewRelic
       attr_accessor :metric_rules
 
       def initialize
-        @stats_lock   = Mutex.new
-        @stats_hash   = StatsHash.new
+        @stats_lock = Mutex.new
+        @stats_hash = StatsHash.new
         @metric_rules = RulesEngine.new
       end
 
@@ -60,12 +60,12 @@ module NewRelic
       #
       # @api private
       #
-      def tl_record_unscoped_metrics(metric_names, value=nil, aux=nil, &blk)
+      def tl_record_unscoped_metrics(metric_names, value = nil, aux = nil, &blk)
         state = NewRelic::Agent::Tracer.state
         record_unscoped_metrics(state, metric_names, value, aux, &blk)
       end
 
-      def record_unscoped_metrics(state, metric_names, value=nil, aux=nil, &blk)
+      def record_unscoped_metrics(state, metric_names, value = nil, aux = nil, &blk)
         txn = state.current_transaction
         if txn
           txn.metrics.record_unscoped(metric_names, value, aux, &blk)
@@ -96,12 +96,12 @@ module NewRelic
       #
       # @api private
       #
-      def tl_record_scoped_and_unscoped_metrics(scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
+      def tl_record_scoped_and_unscoped_metrics(scoped_metric, summary_metrics = nil, value = nil, aux = nil, &blk)
         state = NewRelic::Agent::Tracer.state
         record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics, value, aux, &blk)
       end
 
-      def record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
+      def record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics = nil, value = nil, aux = nil, &blk)
         txn = state.current_transaction
         if txn
           txn.metrics.record_scoped_and_unscoped(scoped_metric, value, aux, &blk)

data/lib/new_relic/agent/synthetics_event_aggregator.rb

@@ -42,4 +42,3 @@ module NewRelic
     end
   end
 end
-

data/lib/new_relic/agent/system_info.rb

@@ -43,8 +43,8 @@ module NewRelic
         if @processor_info.nil?
           if darwin?
             @processor_info = {
-              :num_physical_packages  => sysctl_value('hw.packages').to_i,
-              :num_physical_cores     => sysctl_value('hw.physicalcpu_max').to_i,
+              :num_physical_packages => sysctl_value('hw.packages').to_i,
+              :num_physical_cores => sysctl_value('hw.physicalcpu_max').to_i,
               :num_logical_processors => sysctl_value('hw.logicalcpu_max').to_i
             }
             # in case those don't work, try backup values
@@ -64,8 +64,8 @@ module NewRelic
 
           elsif bsd?
             @processor_info = {
-              :num_physical_packages  => nil,
-              :num_physical_cores     => nil,
+              :num_physical_packages => nil,
+              :num_physical_cores => nil,
               :num_logical_processors => sysctl_value('hw.ncpu').to_i
             }
           end
@@ -111,9 +111,9 @@ module NewRelic
         end
         cores[[phys_id, core_id]] += 1 if phys_id && core_id
 
-        num_physical_packages  = cores.keys.map(&:first).uniq.size
-        num_physical_cores     = cores.size
-        num_logical_processors = cores.values.reduce(0,:+)
+        num_physical_packages = cores.keys.map(&:first).uniq.size
+        num_physical_cores = cores.size
+        num_logical_processors = cores.values.reduce(0, :+)
 
         if num_physical_cores == 0
           num_logical_processors = total_processors
@@ -127,24 +127,26 @@ module NewRelic
             # Some older, single-core processors might not list ids,
             # so we'll just mark them all 1.
             num_physical_packages = 1
-            num_physical_cores    = 1
+            num_physical_cores = 1
           else
             # We have no way of knowing how many packages or cores
             # we have, even though we know how many processors there are.
             num_physical_packages = nil
-            num_physical_cores    = nil
+            num_physical_cores = nil
           end
         end
 
         {
-          :num_physical_packages  => num_physical_packages,
-          :num_physical_cores     => num_physical_cores,
+          :num_physical_packages => num_physical_packages,
+          :num_physical_cores => num_physical_cores,
           :num_logical_processors => num_logical_processors
         }
       end
 
-      def self.num_physical_packages ; get_processor_info[:num_physical_packages ] end
-      def self.num_physical_cores    ; get_processor_info[:num_physical_cores    ] end
+      def self.num_physical_packages; get_processor_info[:num_physical_packages] end
+
+      def self.num_physical_cores; get_processor_info[:num_physical_cores] end
+
       def self.num_logical_processors; get_processor_info[:num_logical_processors] end
 
       def self.processor_arch
@@ -178,12 +180,12 @@ module NewRelic
             return
           end
         # docker native driver with systemd
-        when '/'              then nil
+        when '/' then nil
         # in a cgroup, but we don't recognize its format
-        when /docker\/.*[^0-9a-f]/ then
+        when /docker\/.*[^0-9a-f]/
           ::NewRelic::Agent.logger.debug("Cgroup indicates docker but container_id has invalid characters: '#{cpu_cgroup}'")
           return
-        when /docker/ then
+        when /docker/
           ::NewRelic::Agent.logger.debug("Cgroup indicates docker but container_id unrecognized: '#{cpu_cgroup}'")
           ::NewRelic::Agent.increment_metric "Supportability/utilization/docker/error"
           return
@@ -241,12 +243,12 @@ module NewRelic
 
       def self.ram_in_mib
         if darwin?
-          (sysctl_value('hw.memsize').to_i / (1024 ** 2)).to_i
+          (sysctl_value('hw.memsize').to_i / (1024**2)).to_i
         elsif linux?
           meminfo = proc_try_read('/proc/meminfo')
           parse_linux_meminfo_in_mib(meminfo)
         elsif bsd?
-          (sysctl_value('hw.realmem').to_i / (1024 ** 2)).to_i
+          (sysctl_value('hw.realmem').to_i / (1024**2)).to_i
         else
           ::NewRelic::Agent.logger.debug("Unable to determine ram_in_mib for host os: #{ruby_os_identifier}")
           nil
@@ -254,7 +256,7 @@ module NewRelic
       end
 
       def self.parse_linux_meminfo_in_mib(meminfo)
-        if meminfo && mem_total = meminfo[/MemTotal:\s*(\d*)\skB/,1]
+        if meminfo && mem_total = meminfo[/MemTotal:\s*(\d*)\skB/, 1]
           (mem_total.to_i / 1024).to_i
         else
           ::NewRelic::Agent.logger.debug("Failed to parse MemTotal from /proc/meminfo: #{meminfo}")
@@ -279,7 +281,7 @@ module NewRelic
             else
               ::NewRelic::Agent.logger.debug("Found boot_id with invalid length: #{bid}")
               ::NewRelic::Agent.increment_metric "Supportability/utilization/boot_id/error"
-              bid[0,128]
+              bid[0, 128]
 
             end
           else

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -6,7 +6,6 @@ module NewRelic
   module Agent
     module Threading
       class AgentThread
-
         def self.create(label, &blk)
           ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
           wrapped_blk = Proc.new do
@@ -33,16 +32,16 @@ module NewRelic
           backing_thread_class.list
         end
 
-        def self.bucket_thread(thread, profile_agent_code) #THREAD_LOCAL_ACCESS
+        def self.bucket_thread(thread, profile_agent_code) # THREAD_LOCAL_ACCESS
           if thread.key?(:newrelic_label)
             profile_agent_code ? :agent : :ignore
           else
             state = Tracer.state_for(thread)
-            txn   = state.current_transaction
+            txn = state.current_transaction
 
-            if    txn && !txn.recording_web_transaction?
+            if txn && !txn.recording_web_transaction?
               :background
-            elsif txn &&  txn.recording_web_transaction?
+            elsif txn && txn.recording_web_transaction?
               :request
             else
               :other

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -13,7 +13,7 @@ module NewRelic
 
         def initialize
           @children = []
-          @depth    = 0
+          @depth = 0
         end
 
         def add_child_unless_present(child)
@@ -31,7 +31,6 @@ module NewRelic
         end
       end
 
-
       class BacktraceRoot < BacktraceBase
         attr_reader :flattened
 
@@ -78,9 +77,8 @@ module NewRelic
         end
       end
 
-
       class BacktraceNode < BacktraceBase
-        attr_reader   :file, :method, :line_no, :raw_line, :as_array
+        attr_reader :file, :method, :line_no, :raw_line, :as_array
         attr_accessor :runnable_count, :depth
 
         def initialize(line)
@@ -92,8 +90,8 @@ module NewRelic
 
         def ==(other)
           (
-            @raw_line       == other.raw_line &&
-            @depth          == other.depth    &&
+            @raw_line == other.raw_line &&
+            @depth == other.depth &&
             @runnable_count == other.runnable_count
           )
         end
@@ -115,10 +113,10 @@ module NewRelic
           @as_array << child_arrays
         end
 
-        def dump_string(indent=0)
+        def dump_string(indent = 0)
           @file, @method, @line_no = parse_backtrace_frame(@raw_line)
           result = "#{" " * indent}#<BacktraceNode:#{object_id} [#{@runnable_count}] #{@file}:#{@line_no} in #{@method}>"
-          child_results = @children.map { |c| c.dump_string(indent+2) }.join("\n")
+          child_results = @children.map { |c| c.dump_string(indent + 2) }.join("\n")
           result << "\n" unless child_results.empty?
           result << child_results
         end
@@ -129,7 +127,6 @@ module NewRelic
           [$1, $4, $3] # sic
         end
       end
-
     end
   end
 end

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -20,10 +20,10 @@ module NewRelic
         end
 
         attr_reader :worker_loop, :buffer, :effective_polling_period,
-                    :overhead_percent_threshold
+          :overhead_percent_threshold
         attr_accessor :worker_thread, :profile_agent_code
 
-        def initialize(event_listener=nil)
+        def initialize(event_listener = nil)
           @profiles = {}
           @buffer = {}
           @last_poll = nil
@@ -52,7 +52,7 @@ module NewRelic
           @running
         end
 
-        def subscribe(transaction_name, command_arguments={})
+        def subscribe(transaction_name, command_arguments = {})
           if self.class.is_resque?
             NewRelic::Agent.logger.info("Backtracing threads on Resque is not supported, so not subscribing transaction '#{transaction_name}'")
             return
@@ -113,11 +113,11 @@ module NewRelic
         end
 
         def on_transaction_finished(payload)
-          name     = payload[:name]
-          start    = payload[:start_timestamp]
+          name = payload[:name]
+          start = payload[:start_timestamp]
           duration = payload[:duration]
-          thread   = payload[:thread] || Thread.current
-          bucket   = payload[:bucket]
+          thread = payload[:thread] || Thread.current
+          bucket = payload[:bucket]
           @lock.synchronize do
             backtraces = @buffer.delete(thread)
             if backtraces && @profiles.has_key?(name)
@@ -197,7 +197,7 @@ module NewRelic
         # This method is expected to be called with @lock held
         def watching_for_transaction?
           @profiles.size > 1 ||
-          (@profiles.size == 1 && @profiles[ALL_TRANSACTIONS].nil?)
+            (@profiles.size == 1 && @profiles[ALL_TRANSACTIONS].nil?)
         end
 
         def allowed_bucket?(bucket)

data/lib/new_relic/agent/threading/thread_profile.rb

@@ -11,27 +11,25 @@ require 'new_relic/agent/threading/backtrace_node'
 module NewRelic
   module Agent
     module Threading
-
       class ThreadProfile
-
         attr_reader :profile_id, :traces, :sample_period,
           :duration, :poll_count, :backtrace_count, :failure_count,
           :created_at, :command_arguments, :profile_agent_code
         attr_accessor :finished_at
 
-        def initialize(command_arguments={})
-          @command_arguments  = command_arguments
-          @profile_id         = command_arguments.fetch('profile_id', -1)
-          @duration           = command_arguments.fetch('duration', 120)
-          @sample_period      = command_arguments.fetch('sample_period', 0.1)
+        def initialize(command_arguments = {})
+          @command_arguments = command_arguments
+          @profile_id = command_arguments.fetch('profile_id', -1)
+          @duration = command_arguments.fetch('duration', 120)
+          @sample_period = command_arguments.fetch('sample_period', 0.1)
           @profile_agent_code = command_arguments.fetch('profile_agent_code', false)
           @finished = false
 
           @traces = {
-            :agent      => BacktraceRoot.new,
+            :agent => BacktraceRoot.new,
             :background => BacktraceRoot.new,
-            :other      => BacktraceRoot.new,
-            :request    => BacktraceRoot.new
+            :other => BacktraceRoot.new,
+            :request => BacktraceRoot.new
           }
 
           @poll_count = 0
@@ -69,17 +67,17 @@ module NewRelic
           end
         end
 
-        def convert_N_trace_nodes_to_arrays(count_to_keep) #THREAD_LOCAL_ACCESS
+        def convert_N_trace_nodes_to_arrays(count_to_keep) # THREAD_LOCAL_ACCESS
           all_nodes = @traces.values.map { |n| n.flattened }.flatten
 
-          NewRelic::Agent.instance.stats_engine.
-            tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
+          NewRelic::Agent.instance.stats_engine
+            .tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
 
           all_nodes.sort! do |a, b|
             # we primarily prefer higher runnable_count
             comparison = b.runnable_count <=> a.runnable_count
             # we secondarily prefer lower depth
-            comparison = a.depth          <=> b.depth if comparison == 0
+            comparison = a.depth <=> b.depth if comparison == 0
             # it is thus impossible for any child to preceed their parent
             comparison
           end
@@ -102,9 +100,9 @@ module NewRelic
           convert_N_trace_nodes_to_arrays(THREAD_PROFILER_NODES)
 
           {
-            "OTHER"      => @traces[:other     ].as_array,
-            "REQUEST"    => @traces[:request   ].as_array,
-            "AGENT"      => @traces[:agent     ].as_array,
+            "OTHER" => @traces[:other].as_array,
+            "REQUEST" => @traces[:request].as_array,
+            "AGENT" => @traces[:agent].as_array,
             "BACKGROUND" => @traces[:background].as_array
           }
         end
@@ -128,7 +126,6 @@ module NewRelic
             "@profile_id: #{profile_id} "\
             "@command_arguments=#{@command_arguments.inspect}>"
         end
-
       end
     end
   end

data/lib/new_relic/agent/tracer.rb

@@ -86,9 +86,9 @@ module NewRelic
         #
         # @api public
         def in_transaction(name: nil,
-                           partial_name: nil,
-                           category: nil,
-                           options: {})
+          partial_name: nil,
+          category: nil,
+          options: {})
 
           finishable = start_transaction_or_segment(
             name: name,
@@ -130,10 +130,10 @@ module NewRelic
         #
         # @api public
         def start_transaction_or_segment(name: nil,
-                                         partial_name: nil,
-                                         category:,
-                                         options: {})
-          
+          partial_name: nil,
+          category:,
+          options: {})
+
           raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           if name
@@ -150,7 +150,6 @@ module NewRelic
           else
             Transaction.start_new_transaction(state, category, options)
           end
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -160,10 +159,10 @@ module NewRelic
         # Takes name or partial_name and a category.
         # Returns a transaction instance or nil
         def start_transaction(category:,
-                              name: nil,
-                              partial_name: nil,
-                              **options)
-          
+          name: nil,
+          partial_name: nil,
+          **options)
+
           raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           return current_transaction if current_transaction
@@ -178,8 +177,8 @@ module NewRelic
           end
 
           Transaction.start_new_transaction(state,
-                                            category,
-                                            options)
+            category,
+            options)
         rescue ArgumentError
           raise
         rescue => exception
@@ -231,13 +230,12 @@ module NewRelic
         #
         # @api public
         def start_segment(name:,
-                          unscoped_metrics:nil,
-                          start_time: nil,
-                          parent: nil)
+          unscoped_metrics: nil,
+          start_time: nil,
+          parent: nil)
 
           segment = Transaction::Segment.new name, unscoped_metrics, start_time
           start_and_add_segment segment, parent
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -283,20 +281,19 @@ module NewRelic
         #
         # @api public
         def start_datastore_segment(product: nil,
-                                    operation: nil,
-                                    collection: nil,
-                                    host: nil,
-                                    port_path_or_id: nil,
-                                    database_name: nil,
-                                    start_time: nil,
-                                    parent: nil)
+          operation: nil,
+          collection: nil,
+          host: nil,
+          port_path_or_id: nil,
+          database_name: nil,
+          start_time: nil,
+          parent: nil)
 
           product ||= UNKNOWN
           operation ||= OTHER
 
           segment = Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
           start_and_add_segment segment, parent
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -331,14 +328,13 @@ module NewRelic
         #
         # @api public
         def start_external_request_segment(library:,
-                                           uri:,
-                                           procedure:,
-                                           start_time: nil,
-                                           parent: nil)
+          uri:,
+          procedure:,
+          start_time: nil,
+          parent: nil)
 
           segment = Transaction::ExternalRequestSegment.new library, uri, procedure, start_time
           start_and_add_segment segment, parent
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -347,7 +343,7 @@ module NewRelic
 
         # Will potentially capture and notice an error at the
         # segment that was executing when error occurred.
-        # if passed +segment+ is something that doesn't 
+        # if passed +segment+ is something that doesn't
         # respond to +notice_segment_error+ then this method
         # is effectively just a yield to the given &block
         def capture_segment_error segment
@@ -362,13 +358,13 @@ module NewRelic
 
         # For New Relic internal use only.
         def start_message_broker_segment(action:,
-                                         library:,
-                                         destination_type:,
-                                         destination_name:,
-                                         headers: nil,
-                                         parameters: nil,
-                                         start_time: nil,
-                                         parent: nil)
+          library:,
+          destination_type:,
+          destination_name:,
+          headers: nil,
+          parameters: nil,
+          start_time: nil,
+          parent: nil)
 
           segment = Transaction::MessageBrokerSegment.new(
             action: action,
@@ -380,7 +376,6 @@ module NewRelic
             start_time: start_time
           )
           start_and_add_segment segment, parent
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -415,7 +410,7 @@ module NewRelic
         def start_and_add_segment segment, parent = nil
           tracer_state = state
           if (txn = tracer_state.current_transaction) &&
-            tracer_state.tracing_enabled?
+              tracer_state.tracing_enabled?
             txn.add_segment segment, parent
           else
             segment.record_metrics = false
@@ -433,7 +428,6 @@ module NewRelic
       # This is THE location to store thread local information during a transaction
       # Need a new piece of data? Add a method here, NOT a new thread local variable.
       class State
-
         def initialize
           @untraced = []
           @current_transaction = nil
@@ -441,7 +435,7 @@ module NewRelic
         end
 
         # This starts the timer for the transaction.
-        def reset(transaction=nil)
+        def reset(transaction = nil)
           # We purposefully don't reset @untraced or @record_sql
           # since those are managed by NewRelic::Agent.disable_* calls explicitly
           # and (more importantly) outside the scope of a transaction

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -25,7 +25,7 @@ module NewRelic
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
-        def initialize name=nil, start_time=nil
+        def initialize name = nil, start_time = nil
           @name = name
           @transaction_name = nil
           @transaction = nil
@@ -94,7 +94,7 @@ module NewRelic
         end
 
         def time_range
-          @start_time.to_f .. @end_time.to_f
+          @start_time.to_f..@end_time.to_f
         end
 
         def children_time_ranges
@@ -131,7 +131,7 @@ module NewRelic
           @noticed_error = noticed_error
         end
 
-        def notice_error exception, options={}
+        def notice_error exception, options = {}
           if Agent.config[:high_security]
             NewRelic::Agent.logger.debug \
               "Segment: #{name} ignores notice_error for " \
@@ -156,7 +156,7 @@ module NewRelic
 
         def child_start segment
           @active_children += 1
-          @concurrent_children = @concurrent_children || @active_children > 1
+          @concurrent_children ||= @active_children > 1
 
           transaction.async = true if @concurrent_children
         end
@@ -180,7 +180,7 @@ module NewRelic
 
         def descendant_complete child, descendant
           RangeExtensions.merge_or_append descendant.time_range,
-                                            children_time_ranges
+            children_time_ranges
           # If this child's time was previously added to this segment's
           # aggregate children time, we need to re-record it using a time range
           # for proper exclusive time calculation
@@ -227,7 +227,7 @@ module NewRelic
 
         def record_child_time_as_range child
           RangeExtensions.merge_or_append child.time_range,
-                                          children_time_ranges
+            children_time_ranges
           child.range_recorded = true
         end