newrelic_rpm 7.0.0 → 9.0.0

data/lib/new_relic/agent/system_info.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
 
 # This module is intended to provide access to information about the host OS and
 # [virtual] machine. It intentionally does no caching and maintains no state -
@@ -39,54 +39,69 @@ module NewRelic
         @processor_info = nil
       end
 
-      def self.get_processor_info
-        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_logical_processors => sysctl_value('hw.logicalcpu_max').to_i
-            }
-            # in case those don't work, try backup values
-            if @processor_info[:num_physical_cores] <= 0
-              @processor_info[:num_physical_cores] = sysctl_value('hw.physicalcpu').to_i
-            end
-            if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = sysctl_value('hw.logicalcpu').to_i
-            end
-            if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu').to_i
-            end
-
-          elsif linux?
-            cpuinfo = proc_try_read('/proc/cpuinfo')
-            @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
+      def self.processor_info
+        return @processor_info if @processor_info
 
-          elsif bsd?
-            @processor_info = {
-              :num_physical_packages  => nil,
-              :num_physical_cores     => nil,
-              :num_logical_processors => sysctl_value('hw.ncpu').to_i
-            }
-          end
-
-          # give nils for obviously wrong values
-          @processor_info.keys.each do |key|
-            value = @processor_info[key]
-            if value.is_a?(Numeric) && value <= 0
-              @processor_info[key] = nil
-            end
-          end
+        if darwin?
+          processor_info_darwin
+        elsif linux?
+          processor_info_linux
+        elsif bsd?
+          processor_info_bsd
+        else
+          raise "Couldn't determine OS"
         end
+        remove_bad_values
 
         @processor_info
       rescue
-        {}
+        @processor_info = NewRelic::EMPTY_HASH
+      end
+
+      def self.processor_info_darwin
+        @processor_info = {
+          num_physical_packages: sysctl_value('hw.packages'),
+          num_physical_cores: sysctl_value('hw.physicalcpu_max'),
+          num_logical_processors: sysctl_value('hw.logicalcpu_max')
+        }
+        # in case those don't work, try backup values
+        if @processor_info[:num_physical_cores] <= 0
+          @processor_info[:num_physical_cores] = sysctl_value('hw.physicalcpu')
+        end
+        if @processor_info[:num_logical_processors] <= 0
+          @processor_info[:num_logical_processors] = sysctl_value('hw.logicalcpu')
+        end
+        if @processor_info[:num_logical_processors] <= 0
+          @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu')
+        end
+      end
+
+      def self.processor_info_linux
+        cpuinfo = proc_try_read('/proc/cpuinfo')
+        @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : NewRelic::EMPTY_HASH
+      end
+
+      def self.processor_info_bsd
+        @processor_info = {
+          num_physical_packages: nil,
+          num_physical_cores: nil,
+          num_logical_processors: sysctl_value('hw.ncpu')
+        }
+      end
+
+      def self.remove_bad_values
+        # give nils for obviously wrong values
+        @processor_info.keys.each do |key|
+          value = @processor_info[key]
+          if value.is_a?(Numeric) && value <= 0
+            @processor_info[key] = nil
+          end
+        end
       end
 
       def self.sysctl_value(name)
         # make sure to redirect stderr so we don't spew if the name is unknown
-        `sysctl -n #{name} 2>/dev/null`
+        `sysctl -n #{name} 2>/dev/null`.to_i
       end
 
       def self.parse_cpuinfo(cpuinfo)
@@ -111,9 +126,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,25 +142,27 @@ 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_logical_processors; get_processor_info[:num_logical_processors] end
+      def self.num_physical_packages; processor_info[:num_physical_packages] end
+
+      def self.num_physical_cores; processor_info[:num_physical_cores] end
+
+      def self.num_logical_processors; processor_info[:num_logical_processors] end
 
       def self.processor_arch
         RbConfig::CONFIG['target_cpu']
@@ -156,7 +173,7 @@ module NewRelic
       end
 
       def self.docker_container_id
-        return unless ruby_os_identifier =~ /linux/
+        return unless ruby_os_identifier.include?('linux')
 
         cgroup_info = proc_try_read('/proc/self/cgroup')
         return unless cgroup_info
@@ -178,14 +195,14 @@ 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"
+          ::NewRelic::Agent.increment_metric("Supportability/utilization/docker/error")
           return
         else
           ::NewRelic::Agent.logger.debug("Ignoring unrecognized cgroup ID format: '#{cpu_cgroup}'")
@@ -194,7 +211,7 @@ module NewRelic
 
         if container_id && container_id.size != 64
           ::NewRelic::Agent.logger.debug("Found docker container_id with invalid length: #{container_id}")
-          ::NewRelic::Agent.increment_metric "Supportability/utilization/docker/error"
+          ::NewRelic::Agent.increment_metric("Supportability/utilization/docker/error")
           nil
         else
           container_id
@@ -207,6 +224,7 @@ module NewRelic
         cgroup_info.split("\n").each do |line|
           parts = line.split(':')
           next unless parts.size == 3
+
           _, subsystems, cgroup_id = parts
           subsystems = subsystems.split(',')
           subsystems.each do |subsystem|
@@ -223,7 +241,8 @@ module NewRelic
       # for details on why we do it this way.
       def self.proc_try_read(path)
         return nil unless File.exist?(path)
-        content = ''
+
+        content = String.new('')
         File.open(path) do |f|
           loop do
             begin
@@ -241,12 +260,12 @@ module NewRelic
 
       def self.ram_in_mib
         if darwin?
-          (sysctl_value('hw.memsize').to_i / (1024 ** 2)).to_i
+          (sysctl_value('hw.memsize') / (1024**2))
         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') / (1024**2))
         else
           ::NewRelic::Agent.logger.debug("Unable to determine ram_in_mib for host os: #{ruby_os_identifier}")
           nil
@@ -254,7 +273,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}")
@@ -264,13 +283,14 @@ module NewRelic
 
       def self.boot_id
         return nil unless linux?
+
         if bid = proc_try_read('/proc/sys/kernel/random/boot_id')
           bid.chomp!
 
           if bid.ascii_only?
             if bid.empty?
               ::NewRelic::Agent.logger.debug("boot_id not found in /proc/sys/kernel/random/boot_id")
-              ::NewRelic::Agent.increment_metric "Supportability/utilization/boot_id/error"
+              ::NewRelic::Agent.increment_metric("Supportability/utilization/boot_id/error")
               nil
 
             elsif bid.bytesize == 36
@@ -278,19 +298,19 @@ 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]
+              ::NewRelic::Agent.increment_metric("Supportability/utilization/boot_id/error")
+              bid[0, 128]
 
             end
           else
             ::NewRelic::Agent.logger.debug("Found boot_id with non-ASCII characters: #{bid}")
-            ::NewRelic::Agent.increment_metric "Supportability/utilization/boot_id/error"
+            ::NewRelic::Agent.increment_metric("Supportability/utilization/boot_id/error")
             nil
 
           end
         else
           ::NewRelic::Agent.logger.debug("boot_id not found in /proc/sys/kernel/random/boot_id")
-          ::NewRelic::Agent.increment_metric "Supportability/utilization/boot_id/error"
+          ::NewRelic::Agent.increment_metric("Supportability/utilization/boot_id/error")
           nil
 
         end

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

@@ -1,28 +1,31 @@
-# 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
     module Threading
       class AgentThread
-
         def self.create(label, &blk)
-          ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
-          wrapped_blk = Proc.new do
+          ::NewRelic::Agent.logger.debug("Creating AgentThread: #{label}")
+          wrapped_blk = proc do
+            if ::Thread.current[:newrelic_tracer_state] && Thread.current[:newrelic_tracer_state].current_transaction
+              txn = ::Thread.current[:newrelic_tracer_state].current_transaction
+              ::NewRelic::Agent.logger.warn("AgentThread created with current transaction #{txn.best_name}")
+            end
             begin
-              blk.call
+              yield
             rescue => e
-              ::NewRelic::Agent.logger.error("Thread #{label} exited with error", e)
+              ::NewRelic::Agent.logger.error("AgentThread #{label} exited with error", e)
             rescue Exception => e
-              ::NewRelic::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interrupt.", e)
+              ::NewRelic::Agent.logger.error("AgentThread #{label} exited with exception. Re-raising in case of interrupt.", e)
               raise
             ensure
-              ::NewRelic::Agent.logger.debug("Exiting New Relic thread: #{label}")
+              ::NewRelic::Agent.logger.debug("Exiting AgentThread: #{label}")
             end
           end
-
-          thread = backing_thread_class.new(&wrapped_blk)
+          thread = nil
+          NewRelic::Agent.disable_all_tracing { thread = backing_thread_class.new(&wrapped_blk) }
           thread[:newrelic_label] = label
           thread
         end
@@ -33,16 +36,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
@@ -57,6 +60,7 @@ module NewRelic
             ::NewRelic::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
           end
           return nil unless bt
+
           bt.reject! { |t| t.include?('/newrelic_rpm-') } unless profile_agent_code
           bt
         end

data/lib/new_relic/agent/threading/backtrace_node.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
@@ -13,12 +13,12 @@ module NewRelic
 
         def initialize
           @children = []
-          @depth    = 0
+          @depth = 0
         end
 
         def add_child_unless_present(child)
           child.depth = @depth + 1
-          @children << child unless @children.include? child
+          @children << child unless @children.include?(child)
         end
 
         def add_child(child)
@@ -31,7 +31,6 @@ module NewRelic
         end
       end
 
-
       class BacktraceRoot < BacktraceBase
         attr_reader :flattened
 
@@ -71,16 +70,15 @@ module NewRelic
         end
 
         def dump_string
-          result = "#<BacktraceRoot:#{object_id}>"
+          result = String.new("#<BacktraceRoot:#{object_id}>")
           child_results = @children.map { |c| c.dump_string(2) }.join("\n")
           result << "\n" unless child_results.empty?
           result << child_results
         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,12 @@ 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")
+          indentation = ' ' * indent
+          result = String.new("#{indentation}#<BacktraceNode:#{object_id} ) + \
+                              [#{@runnable_count}] #{@file}:#{@line_no} in #{@method}>")
+          child_results = @children.map { |c| c.dump_string(indent + 2) }.join("\n")
           result << "\n" unless child_results.empty?
           result << child_results
         end
@@ -129,7 +129,6 @@ module NewRelic
           [$1, $4, $3] # sic
         end
       end
-
     end
   end
 end

data/lib/new_relic/agent/threading/backtrace_service.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
@@ -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)
@@ -151,6 +151,7 @@ module NewRelic
         # This method is expected to be called with @lock held
         def stop
           return unless @running
+
           @running = false
           self.worker_loop.stop
 
@@ -163,7 +164,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 +174,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 +198,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 +231,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 +278,6 @@ module NewRelic
           end
           @last_poll = poll_start
         end
-
       end
     end
   end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'set'
 require 'new_relic/agent/worker_loop'
@@ -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
@@ -39,7 +37,7 @@ module NewRelic
           @failure_count = 0
           @unique_threads = []
 
-          @created_at = Time.now
+          @created_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
         def requested_period
@@ -56,6 +54,7 @@ module NewRelic
 
         def unique_thread_count
           return 0 if @unique_threads.nil?
+
           @unique_threads.length
         end
 
@@ -69,27 +68,29 @@ 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
-            # it is thus impossible for any child to preceed their parent
+            comparison = a.depth <=> b.depth if comparison == 0
+            # it is thus impossible for any child to precede their parent
             comparison
           end
 
           all_nodes.each_with_index do |n, i|
             break if i >= count_to_keep
+
             n.mark_for_array_conversion
           end
           all_nodes.each_with_index do |n, i|
             break if i >= count_to_keep
+
             n.complete_array_conversion
           end
         end
@@ -102,9 +103,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
@@ -124,11 +125,10 @@ module NewRelic
         end
 
         def to_log_description
-          "#<ThreadProfile:#{object_id} "\
-            "@profile_id: #{profile_id} "\
+          "#<ThreadProfile:#{object_id} " \
+            "@profile_id: #{profile_id} " \
             "@command_arguments=#{@command_arguments.inspect}>"
         end
-
       end
     end
   end

data/lib/new_relic/agent/timestamp_sampled_buffer.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/heap'