newrelic_rpm 6.15.0 → 9.7.1

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

@@ -1,24 +1,22 @@
-# 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 Agent
     class RulesEngine
       class SegmentTermsRule
-        PREFIX_KEY                        = 'prefix'.freeze
-        TERMS_KEY                         = 'terms'.freeze
-        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
-        VALID_PREFIX_SEGMENT_COUNT        = 2
 
         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])
+            rule_spec[TERMS_KEY].kind_of?(Array) &&
+            valid_prefix_segment_count?(rule_spec[PREFIX_KEY])
         end
 
         def self.valid_prefix_segment_count?(prefix)
@@ -26,13 +24,13 @@ module NewRelic
           rindex = prefix.rindex(SEGMENT_SEPARATOR)
 
           (count == 2 && prefix[rindex + 1].nil?) ||
-          (count == 1 && !prefix[rindex + 1].nil?)
+            (count == 1 && !prefix[rindex + 1].nil?)
         end
 
         def initialize(options)
-          @prefix          = options[PREFIX_KEY]
-          @terms           = options[TERMS_KEY]
-          @trim_range      = (@prefix.size..-1)
+          @prefix = options[PREFIX_KEY]
+          @terms = options[TERMS_KEY]
+          @trim_range = (@prefix.size..-1)
         end
 
         def terminal?
@@ -50,10 +48,10 @@ module NewRelic
         end
 
         def apply(string)
-          rest          = string[@trim_range]
+          rest = string[@trim_range]
           leading_slash = rest.slice!(LEADING_SLASH_REGEX)
           segments = rest.split(SEGMENT_SEPARATOR, -1)
-          segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }
+          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,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/rules_engine/replacement_rule'
 require 'new_relic/agent/rules_engine/segment_terms_rule'
@@ -9,7 +9,7 @@ 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
@@ -24,7 +24,7 @@ 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) }
@@ -36,7 +36,7 @@ module NewRelic
             # 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)
+            segment_rules.unshift(SegmentTermsRule.new(spec))
           end
         end
 
@@ -54,7 +54,7 @@ module NewRelic
         rules.uniq! { |rule| rule.prefix }
       end
 
-      def initialize(rules=[], segment_term_rules=[])
+      def initialize(rules = [], segment_term_rules = [])
         @rules = rules.sort
         @segment_term_rules = segment_term_rules
       end
@@ -72,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/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,9 +13,8 @@
 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 = []
@@ -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)
+      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/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/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/sampler'
 
@@ -16,26 +16,26 @@ module NewRelic
           @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?
@@ -44,11 +44,12 @@ 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 && t.utime != 0.0 && t.stime != 0.0

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/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
@@ -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,13 +1,13 @@
-# 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/sampler'
+require 'new_relic/helper'
 
 module NewRelic
   module Agent
     module Samplers
-
       class MemorySampler < NewRelic::Agent::Sampler
         named :memory
 
@@ -19,22 +19,22 @@ module NewRelic
           # 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 =~ /darwin(1|2)\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?
@@ -46,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
@@ -59,7 +64,7 @@ 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
 
@@ -70,21 +75,23 @@ module NewRelic
 
           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
@@ -94,11 +101,12 @@ module NewRelic
         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
 
@@ -116,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
@@ -130,10 +140,11 @@ module NewRelic
         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/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

data/lib/new_relic/agent/samplers/vm_sampler.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/sampler'
 require 'new_relic/agent/vm'
@@ -9,15 +9,16 @@ module NewRelic
   module Agent
     module Samplers
       class VMSampler < Sampler
-        GC_RUNS_METRIC                = 'RubyVM/GC/runs'.freeze
-        HEAP_LIVE_METRIC              = 'RubyVM/GC/heap_live'.freeze
-        HEAP_FREE_METRIC              = 'RubyVM/GC/heap_free'.freeze
-        THREAD_COUNT_METRIC           = 'RubyVM/Threads/all'.freeze
-        OBJECT_ALLOCATIONS_METRIC     = 'RubyVM/GC/total_allocated_object'.freeze
-        MAJOR_GC_METRIC               = 'RubyVM/GC/major_gc_count'.freeze
-        MINOR_GC_METRIC               = 'RubyVM/GC/minor_gc_count'.freeze
-        METHOD_INVALIDATIONS_METRIC   = 'RubyVM/CacheInvalidations/method'.freeze
+        GC_RUNS_METRIC = 'RubyVM/GC/runs'.freeze
+        HEAP_LIVE_METRIC = 'RubyVM/GC/heap_live'.freeze
+        HEAP_FREE_METRIC = 'RubyVM/GC/heap_free'.freeze
+        THREAD_COUNT_METRIC = 'RubyVM/Threads/all'.freeze
+        OBJECT_ALLOCATIONS_METRIC = 'RubyVM/GC/total_allocated_object'.freeze
+        MAJOR_GC_METRIC = 'RubyVM/GC/major_gc_count'.freeze
+        MINOR_GC_METRIC = 'RubyVM/GC/minor_gc_count'.freeze
+        METHOD_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/method'.freeze
         CONSTANT_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/constant'.freeze
+        CONSTANT_MISSES_METRIC = 'RubyVM/CacheMisses/constant'.freeze
 
         attr_reader :transaction_count
 
@@ -49,7 +50,7 @@ module NewRelic
           end
         end
 
-        def record_gc_runs_metric(snapshot, txn_count) #THREAD_LOCAL_ACCESS
+        def record_gc_runs_metric(snapshot, txn_count) # THREAD_LOCAL_ACCESS
           if snapshot.gc_total_time || snapshot.gc_runs
             if snapshot.gc_total_time
               gc_time = snapshot.gc_total_time - @last_snapshot.gc_total_time.to_f
@@ -59,30 +60,30 @@ module NewRelic
             end
             wall_clock_time = snapshot.taken_at - @last_snapshot.taken_at
             NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(GC_RUNS_METRIC) do |stats|
-              stats.call_count           += txn_count
-              stats.total_call_time      += gc_runs if gc_runs
+              stats.call_count += txn_count
+              stats.total_call_time += gc_runs if gc_runs
               stats.total_exclusive_time += gc_time if gc_time
-              stats.max_call_time         = (gc_time.nil? ? 0 : 1)
-              stats.sum_of_squares       += wall_clock_time
+              stats.max_call_time = (gc_time.nil? ? 0 : 1)
+              stats.sum_of_squares += wall_clock_time
             end
           end
         end
 
-        def record_delta(snapshot, key, metric, txn_count) #THREAD_LOCAL_ACCESS
+        def record_delta(snapshot, key, metric, txn_count) # THREAD_LOCAL_ACCESS
           value = snapshot.send(key)
           if value
             delta = value - @last_snapshot.send(key)
             NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric) do |stats|
-              stats.call_count      += txn_count
+              stats.call_count += txn_count
               stats.total_call_time += delta
             end
           end
         end
 
-        def record_gauge_metric(metric_name, value) #THREAD_LOCAL_ACCESS
+        def record_gauge_metric(metric_name, value) # THREAD_LOCAL_ACCESS
           NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
-            stats.call_count      = value
-            stats.sum_of_squares  = 1
+            stats.call_count = value
+            stats.sum_of_squares = 1
           end
         end
 
@@ -114,6 +115,7 @@ module NewRelic
           record_delta(snap, :minor_gc_count, MINOR_GC_METRIC, tcount)
           record_delta(snap, :method_cache_invalidations, METHOD_INVALIDATIONS_METRIC, tcount)
           record_delta(snap, :constant_cache_invalidations, CONSTANT_INVALIDATIONS_METRIC, tcount)
+          record_delta(snap, :constant_cache_misses, CONSTANT_MISSES_METRIC, tcount)
           record_heap_live_metric(snap)
           record_heap_free_metric(snap)
           record_thread_count_metric(snap)

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -1,9 +1,9 @@
-# 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 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent' unless defined?( NewRelic::Agent )
+require 'newrelic_rpm' unless defined?(NewRelic)
+require 'new_relic/agent' unless defined?(NewRelic::Agent)
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/priority_sampled_buffer'
 
@@ -14,33 +14,33 @@ module NewRelic
       capacity_key :'span_events.max_samples_stored'
 
       enabled_keys :'span_events.enabled',
-                   :'distributed_tracing.enabled'
+        :'distributed_tracing.enabled'
 
-      def record priority: nil, event:nil, &blk
-        unless(event || priority && blk)
-          raise ArgumentError, "Expected priority and block, or event"
+      def record(priority: nil, event: nil, &blk)
+        unless event || priority && blk
+          raise ArgumentError, 'Expected priority and block, or event'
         end
 
         return unless enabled?
 
         @lock.synchronize do
-          @buffer.append priority: priority, event: event, &blk
+          @buffer.append(priority: priority, event: event, &blk)
           notify_if_full
         end
       end
 
-      SUPPORTABILITY_TOTAL_SEEN = "Supportability/SpanEvent/TotalEventsSeen".freeze
-      SUPPORTABILITY_TOTAL_SENT = "Supportability/SpanEvent/TotalEventsSent".freeze
-      SUPPORTABILITY_DISCARDED  = "Supportability/SpanEvent/Discarded".freeze
+      SUPPORTABILITY_TOTAL_SEEN = 'Supportability/SpanEvent/TotalEventsSeen'.freeze
+      SUPPORTABILITY_TOTAL_SENT = 'Supportability/SpanEvent/TotalEventsSent'.freeze
+      SUPPORTABILITY_DISCARDED = 'Supportability/SpanEvent/Discarded'.freeze
 
-      def after_harvest metadata
-        seen      = metadata[:seen]
-        sent      = metadata[:captured]
+      def after_harvest(metadata)
+        seen = metadata[:seen]
+        sent = metadata[:captured]
         discarded = seen - sent
 
         ::NewRelic::Agent.record_metric(SUPPORTABILITY_TOTAL_SEEN, count: seen)
         ::NewRelic::Agent.record_metric(SUPPORTABILITY_TOTAL_SENT, count: sent)
-        ::NewRelic::Agent.record_metric(SUPPORTABILITY_DISCARDED,  count: discarded)
+        ::NewRelic::Agent.record_metric(SUPPORTABILITY_DISCARDED, count: discarded)
 
         super
       end