newrelic_rpm 7.0.0 → 8.8.0

data/lib/new_relic/agent/stats.rb

@@ -4,6 +4,8 @@
 module NewRelic
   module Agent
     class Stats
+      SKIP_MARSHALLING = [:@lock]
+
       attr_accessor :call_count
       attr_accessor :min_call_time
       attr_accessor :max_call_time
@@ -12,6 +14,7 @@ module NewRelic
       attr_accessor :sum_of_squares
 
       def initialize
+        @lock = Mutex.new
         reset
       end
 
@@ -34,12 +37,14 @@ module NewRelic
       end
 
       def merge!(other)
-        @min_call_time = other.min_call_time if min_time_less?(other)
-        @max_call_time = other.max_call_time if other.max_call_time > max_call_time
-        @total_call_time      += other.total_call_time
-        @total_exclusive_time += other.total_exclusive_time
-        @sum_of_squares       += other.sum_of_squares
-        @call_count += other.call_count
+        @lock.synchronize do
+          @min_call_time = other.min_call_time if min_time_less?(other)
+          @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+          @total_call_time += other.total_call_time
+          @total_exclusive_time += other.total_exclusive_time
+          @sum_of_squares += other.sum_of_squares
+          @call_count += other.call_count
+        end
         self
       end
 
@@ -49,16 +54,16 @@ module NewRelic
 
       def to_json(*_)
         {
-          'call_count'           => call_count.to_i,
-          'min_call_time'        => min_call_time.to_f,
-          'max_call_time'        => max_call_time.to_f,
-          'total_call_time'      => total_call_time.to_f,
+          'call_count' => call_count.to_i,
+          'min_call_time' => min_call_time.to_f,
+          'max_call_time' => max_call_time.to_f,
+          'total_call_time' => total_call_time.to_f,
           'total_exclusive_time' => total_exclusive_time.to_f,
-          'sum_of_squares'       => sum_of_squares.to_f
+          'sum_of_squares' => sum_of_squares.to_f
         }.to_json(*_)
       end
 
-      def record(value=nil, aux=nil, &blk)
+      def record(value = nil, aux = nil, &blk)
         if blk
           yield self
         else
@@ -78,13 +83,15 @@ module NewRelic
       # will aggregate all data points collected over a specified period and upload
       # its data to the NewRelic server
       def record_data_point(value, exclusive_time = value)
-        @call_count += 1
-        @total_call_time += value
-        @min_call_time = value if value < @min_call_time || @call_count == 1
-        @max_call_time = value if value > @max_call_time
-        @total_exclusive_time += exclusive_time
-
-        @sum_of_squares += (value * value)
+        @lock.synchronize do
+          @call_count += 1
+          @total_call_time += value
+          @min_call_time = value if value < @min_call_time || @call_count == 1
+          @max_call_time = value if value > @max_call_time
+          @total_exclusive_time += exclusive_time
+
+          @sum_of_squares += (value * value)
+        end
         self
       end
 
@@ -92,7 +99,7 @@ module NewRelic
 
       # increments the call_count by one
       def increment_count(value = 1)
-        @call_count += value
+        @lock.synchronize { @call_count += value }
       end
 
       # Concerned about implicit usage of inspect relying on stats format, so
@@ -106,14 +113,14 @@ module NewRelic
 
       def ==(other)
         other.class == self.class &&
-        (
-          @min_call_time        == other.min_call_time &&
-          @max_call_time        == other.max_call_time &&
-          @total_call_time      == other.total_call_time &&
-          @total_exclusive_time == other.total_exclusive_time &&
-          @sum_of_squares       == other.sum_of_squares &&
-          @call_count           == other.call_count
-        )
+          (
+            @min_call_time == other.min_call_time &&
+            @max_call_time == other.max_call_time &&
+            @total_call_time == other.total_call_time &&
+            @total_exclusive_time == other.total_exclusive_time &&
+            @sum_of_squares == other.sum_of_squares &&
+            @call_count == other.call_count
+          )
       end
 
       # Apdex-related accessors
@@ -122,17 +129,35 @@ module NewRelic
       alias_method :apdex_f, :total_exclusive_time
 
       def record_apdex(bucket, apdex_t)
-        case bucket
-        when :apdex_s then @call_count += 1
-        when :apdex_t then @total_call_time += 1
-        when :apdex_f then @total_exclusive_time += 1
+        @lock.synchronize do
+          case bucket
+          when :apdex_s then @call_count += 1
+          when :apdex_t then @total_call_time += 1
+          when :apdex_f then @total_exclusive_time += 1
+          end
+          if apdex_t
+            @min_call_time = apdex_t
+            @max_call_time = apdex_t
+          else
+            ::NewRelic::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+          end
         end
-        if apdex_t
-          @min_call_time = apdex_t
-          @max_call_time = apdex_t
-        else
-          ::NewRelic::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+      end
+
+      # Override marshalling methods to exclude @lock from being included in marshalled data
+      def marshal_dump
+        instance_variables.each_with_object({}) do |name, instance_copy|
+          next if SKIP_MARSHALLING.include?(name)
+          instance_copy[name] = instance_variable_get(name)
+        end
+      end
+
+      def marshal_load(marshalled_data)
+        marshalled_data.each do |name, value|
+          instance_variable_set(name, value) unless SKIP_MARSHALLING.include?(name)
         end
+        # since the lock is excluded when marshalling, create a new lock when loading marshalled data
+        @lock = Mutex.new
       end
 
       protected

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

@@ -22,7 +22,7 @@ module NewRelic
         end
 
         def self.reset
-          @profiler    = nil
+          @profiler = nil
           @initialized = nil
         end
 
@@ -30,15 +30,13 @@ module NewRelic
           init
           if @profiler
             GCSnapshot.new(@profiler.call_time_s, @profiler.call_count)
-          else
-            nil
           end
         end
 
         def self.record_delta(start_snapshot, end_snapshot)
           if @profiler && start_snapshot && end_snapshot
             elapsed_gc_time_s = end_snapshot.gc_time_s - start_snapshot.gc_time_s
-            num_calls         = end_snapshot.gc_call_count - start_snapshot.gc_call_count
+            num_calls = end_snapshot.gc_call_count - start_snapshot.gc_call_count
             record_gc_metric(num_calls, elapsed_gc_time_s)
 
             @profiler.reset
@@ -46,17 +44,17 @@ module NewRelic
           end
         end
 
-        def self.record_gc_metric(call_count, elapsed) #THREAD_LOCAL_ACCESS
+        def self.record_gc_metric(call_count, elapsed) # THREAD_LOCAL_ACCESS
           NewRelic::Agent.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(gc_metric_name, GC_ROLLUP) do |stats|
-            stats.call_count           += call_count
-            stats.total_call_time      += elapsed
+            stats.call_count += call_count
+            stats.total_call_time += elapsed
             stats.total_exclusive_time += elapsed
           end
         end
 
         GC_ROLLUP = 'GC/Transaction/all'.freeze
-        GC_OTHER  = 'GC/Transaction/allOther'.freeze
-        GC_WEB    = 'GC/Transaction/allWeb'.freeze
+        GC_OTHER = 'GC/Transaction/allOther'.freeze
+        GC_WEB = 'GC/Transaction/allWeb'.freeze
 
         def self.gc_metric_name
           if NewRelic::Agent::Transaction.recording_web_transaction?

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=Time.now)
+      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)
@@ -150,7 +150,7 @@ module NewRelic
       end
 
       def harvest!
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         snapshot = reset!
         snapshot = apply_rules_to_metric_data(@metric_rules, snapshot)
         snapshot.harvested_at = now

data/lib/new_relic/agent/synthetics_event_aggregator.rb

@@ -13,7 +13,7 @@ module NewRelic
 
       named :SyntheticsEventAggregator
       capacity_key :'synthetics.events_limit'
-      enabled_key :'analytics_events.enabled'
+      enabled_key :'transaction_events.enabled'
       buffer_class TimestampSampledBuffer
 
       def record event
@@ -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
@@ -105,7 +105,7 @@ module NewRelic
           @lock.synchronize do
             if @profiles[transaction_name]
               profile = @profiles.delete(transaction_name)
-              profile.finished_at = Time.now
+              profile.finished_at = Process.clock_gettime(Process::CLOCK_REALTIME)
               @profiles[transaction_name] = ThreadProfile.new(profile.command_arguments)
               profile
             end
@@ -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)
@@ -163,7 +163,7 @@ module NewRelic
         end
 
         def poll
-          poll_start = Time.now
+          poll_start = Process.clock_gettime(Process::CLOCK_REALTIME)
 
           @lock.synchronize do
             AgentThread.list.each do |thread|
@@ -173,7 +173,7 @@ module NewRelic
             @buffer.delete_if { |thread, _| !thread.alive? }
           end
 
-          end_time = Time.now
+          end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           adjust_polling_time(end_time, poll_start)
           record_supportability_metrics(end_time, poll_start)
         end
@@ -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)
@@ -230,7 +230,7 @@ module NewRelic
           bucket = AgentThread.bucket_thread(thread, @profile_agent_code)
 
           if need_backtrace?(bucket)
-            timestamp = Time.now.to_f
+            timestamp = Process.clock_gettime(Process::CLOCK_REALTIME)
             backtrace = AgentThread.scrub_backtrace(thread, @profile_agent_code)
             aggregate_global_backtrace(backtrace, bucket, thread)
             buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
@@ -277,7 +277,6 @@ module NewRelic
           end
           @last_poll = poll_start
         end
-
       end
     end
   end