newrelic_rpm 6.15.0 → 9.7.1

data/lib/new_relic/agent/stats_engine/stats_hash.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
 
 # A Hash-like class for storing metric data.
 #
@@ -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
@@ -77,11 +76,11 @@ module NewRelic
 
       def each
         @scoped.each do |k, v|
-          yield k, v
+          yield(k, v)
         end
         @unscoped.each do |k, v|
           spec = NewRelic::MetricSpec.new(k)
-          yield spec, v
+          yield(spec, v)
         end
       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,13 +121,13 @@ 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
         if hash.respond_to?(:default_proc=)
-          hash.default_proc = Proc.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+          hash.default_proc = proc { |h, k| h[k] = NewRelic::Agent::Stats.new }
         end
         stats
       end

data/lib/new_relic/agent/stats_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/stats_engine/gc_profiler'
 require 'new_relic/agent/stats_engine/stats_hash'
@@ -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

@@ -1,7 +1,7 @@
 # -*- ruby -*-
-# 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/event_aggregator'
 require 'new_relic/agent/timestamp_sampled_buffer'
@@ -13,33 +13,32 @@ 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
+      def record(event)
         return unless enabled?
 
         @lock.synchronize do
-          @buffer.append event: event, priority: -event[0][TIMESTAMP]
+          @buffer.append(event: event, priority: -event[0][TIMESTAMP])
         end
       end
 
       private
 
-      def after_harvest metadata
-        record_dropped_synthetics metadata
+      def after_harvest(metadata)
+        record_dropped_synthetics(metadata)
       end
 
-      def record_dropped_synthetics metadata
+      def record_dropped_synthetics(metadata)
         num_dropped = metadata[:seen] - metadata[:captured]
         return unless num_dropped > 0
 
         NewRelic::Agent.logger.debug("Synthetics transaction event limit (#{metadata[:capacity]}) reached. Further synthetics events this harvest period dropped.")
 
         engine = NewRelic::Agent.instance.stats_engine
-        engine.tl_record_supportability_metric_count("SyntheticsEventAggregator/synthetics_events_dropped", num_dropped)
+        engine.tl_record_supportability_metric_count('SyntheticsEventAggregator/synthetics_events_dropped', num_dropped)
       end
     end
   end
 end
-

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 -
@@ -13,6 +13,8 @@ require 'socket'
 module NewRelic
   module Agent
     module SystemInfo
+      DOCKER_CGROUPS_V2_PATTERN = %r{.*/docker/containers/([0-9a-f]{64})/.*}.freeze
+
       def self.ruby_os_identifier
         RbConfig::CONFIG['target_os']
       end
@@ -39,54 +41,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 +128,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.sum
 
         if num_physical_cores == 0
           num_logical_processors = total_processors
@@ -127,25 +144,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']
@@ -155,8 +174,25 @@ module NewRelic
         proc_try_read('/proc/version')
       end
 
+      # When operating within a Docker container, attempt to obtain the
+      # container id.
+      #
+      # First look for `/proc/self/mountinfo` to exist on disk to signify
+      # cgroups v2. If that file exists, read it and expect it to contain one
+      # or more "/docker/containers/<container_id>/" lines from which the
+      # container id can be gleaned.
+      #
+      # Next look for `/proc/self/cgroup` to exist on disk to signify cgroup v1.
+      # If that file exists, read it and parse the "cpu" group info in the hope
+      # of finding a 64 character container id value.
+      #
+      # For non-cgroups based containers, use a `nil` value for the container
+      # id without generating any warnings or errors.
       def self.docker_container_id
-        return unless ruby_os_identifier =~ /linux/
+        return unless ruby_os_identifier.include?('linux')
+
+        cgroupsv2_based_id = docker_container_id_for_cgroupsv2
+        return cgroupsv2_based_id if cgroupsv2_based_id
 
         cgroup_info = proc_try_read('/proc/self/cgroup')
         return unless cgroup_info
@@ -164,6 +200,13 @@ module NewRelic
         parse_docker_container_id(cgroup_info)
       end
 
+      def self.docker_container_id_for_cgroupsv2
+        mountinfo = proc_try_read('/proc/self/mountinfo')
+        return unless mountinfo
+
+        Regexp.last_match(1) if mountinfo =~ DOCKER_CGROUPS_V2_PATTERN
+      end
+
       def self.parse_docker_container_id(cgroup_info)
         cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
         return unless cpu_cgroup
@@ -178,14 +221,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 +237,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 +250,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 +267,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 = +''
         File.open(path) do |f|
           loop do
             begin
@@ -241,12 +286,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 +299,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 +309,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.logger.debug('boot_id not found in /proc/sys/kernel/random/boot_id')
+              ::NewRelic::Agent.increment_metric('Supportability/utilization/boot_id/error')
               nil
 
             elsif bid.bytesize == 36
@@ -278,19 +324,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.logger.debug('boot_id not found in /proc/sys/kernel/random/boot_id')
+          ::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&.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 = +"#<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 = +"#{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