newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/span_event_primitive.rb

@@ -1,12 +1,12 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This module builds the data structures necessary to create a Span
 # event for a segment.
 
 require 'new_relic/agent/payload_metric_mapping'
-require 'new_relic/agent/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
 
 module NewRelic
   module Agent
@@ -15,60 +15,75 @@ module NewRelic
       extend self
 
       # Strings for static keys of the event structure
-      TYPE_KEY             = 'type'.freeze
-      TRACE_ID_KEY         = 'traceId'.freeze
-      GUID_KEY             = 'guid'.freeze
-      PARENT_ID_KEY        = 'parentId'.freeze
-      GRANDPARENT_ID_KEY   = 'grandparentId'.freeze
-      TRANSACTION_ID_KEY   = 'transactionId'.freeze
-      SAMPLED_KEY          = 'sampled'.freeze
-      PRIORITY_KEY         = 'priority'.freeze
-      TIMESTAMP_KEY        = 'timestamp'.freeze
-      DURATION_KEY         = 'duration'.freeze
-      NAME_KEY             = 'name'.freeze
-      CATEGORY_KEY         = 'category'.freeze
-      HTTP_URL_KEY         = 'http.url'.freeze
-      HTTP_METHOD_KEY      = 'http.method'.freeze
-      COMPONENT_KEY        = 'component'.freeze
-      DB_INSTANCE_KEY      = 'db.instance'.freeze
-      DB_STATEMENT_KEY     = 'db.statement'.freeze
-      PEER_ADDRESS_KEY     = 'peer.address'.freeze
-      PEER_HOSTNAME_KEY    = 'peer.hostname'.freeze
-      SPAN_KIND_KEY        = 'span.kind'.freeze
-      ENTRY_POINT_KEY      = 'nr.entryPoint'.freeze
+      ELLIPSIS = '...'
+      TYPE_KEY = 'type'
+      TRACE_ID_KEY = 'traceId'
+      GUID_KEY = 'guid'
+      PARENT_ID_KEY = 'parentId'
+      TRANSACTION_ID_KEY = 'transactionId'
+      SAMPLED_KEY = 'sampled'
+      PRIORITY_KEY = 'priority'
+      TIMESTAMP_KEY = 'timestamp'
+      DURATION_KEY = 'duration'
+      NAME_KEY = 'name'
+      CATEGORY_KEY = 'category'
+      HTTP_URL_KEY = 'http.url'
+      HTTP_METHOD_KEY = 'http.method'
+      HTTP_STATUS_CODE_KEY = 'http.statusCode'
+      COMPONENT_KEY = 'component'
+      DB_INSTANCE_KEY = 'db.instance'
+      DB_STATEMENT_KEY = 'db.statement'
+      PEER_ADDRESS_KEY = 'peer.address'
+      PEER_HOSTNAME_KEY = 'peer.hostname'
+      SPAN_KIND_KEY = 'span.kind'
+      ENTRY_POINT_KEY = 'nr.entryPoint'
+      TRUSTED_PARENT_KEY = "trustedParentId"
+      TRACING_VENDORS_KEY = "tracingVendors"
+      TRANSACTION_NAME_KEY = 'transaction.name'
 
       # Strings for static values of the event structure
-      EVENT_TYPE         = 'Span'.freeze
-      GENERIC_CATEGORY   = 'generic'.freeze
-      HTTP_CATEGORY      = 'http'.freeze
-      DATASTORE_CATEGORY = 'datastore'.freeze
-      CLIENT             = 'client'.freeze
-
-      # To avoid allocations when we have empty custom or agent attributes
-      EMPTY_HASH = {}.freeze
+      EVENT_TYPE = 'Span'
+      GENERIC_CATEGORY = 'generic'
+      HTTP_CATEGORY = 'http'
+      DATASTORE_CATEGORY = 'datastore'
+      CLIENT = 'client'
+
+      # Builds a Hash of error attributes as well as the Span ID when
+      # an error is present.  Otherwise, returns nil when no error present.
+      def error_attributes(segment)
+        return if Agent.config[:high_security] || !segment.noticed_error
+
+        segment.noticed_error.build_error_attributes
+        segment.noticed_error_attributes
+      end
 
       def for_segment(segment)
         intrinsics = intrinsics_for(segment)
         intrinsics[CATEGORY_KEY] = GENERIC_CATEGORY
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        [intrinsics, custom_attributes(segment), agent_attributes(segment)]
       end
 
       def for_external_request_segment(segment)
         intrinsics = intrinsics_for(segment)
 
-        intrinsics[COMPONENT_KEY]   = segment.library
+        intrinsics[COMPONENT_KEY] = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
-        intrinsics[CATEGORY_KEY]    = HTTP_CATEGORY
-        intrinsics[SPAN_KIND_KEY]   = CLIENT
+        intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
+        intrinsics[CATEGORY_KEY] = HTTP_CATEGORY
+        intrinsics[SPAN_KIND_KEY] = CLIENT
 
-        agent_attributes = {}
+        agent_attributes = error_attributes(segment) || {}
 
         if allowed?(HTTP_URL_KEY)
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        if segment.respond_to?(:record_agent_attributes?) && segment.record_agent_attributes?
+          agent_attributes.merge!(agent_attributes(segment))
+        end
+
+        [intrinsics, custom_attributes(segment), agent_attributes]
       end
 
       def for_datastore_segment(segment)
@@ -78,7 +93,7 @@ module NewRelic
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
 
-        agent_attributes = {}
+        agent_attributes = error_attributes(segment) || {}
 
         if segment.database_name && allowed?(DB_INSTANCE_KEY)
           agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
@@ -96,38 +111,85 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes]
       end
 
       private
 
       def intrinsics_for(segment)
-        intrinsics =
-        {
-          TYPE_KEY           => EVENT_TYPE,
-          TRACE_ID_KEY       => segment.transaction.trace_id,
-          GUID_KEY           => segment.guid,
+        intrinsics = {
+          TYPE_KEY => EVENT_TYPE,
+          TRACE_ID_KEY => segment.transaction.trace_id,
+          GUID_KEY => segment.guid,
           TRANSACTION_ID_KEY => segment.transaction.guid,
-          SAMPLED_KEY        => segment.transaction.sampled?,
-          PRIORITY_KEY       => segment.transaction.priority,
-          TIMESTAMP_KEY      => milliseconds_since_epoch(segment),
-          DURATION_KEY       => segment.duration,
-          NAME_KEY           => segment.name
+          PRIORITY_KEY => segment.transaction.priority,
+          TIMESTAMP_KEY => milliseconds_since_epoch(segment),
+          DURATION_KEY => segment.duration,
+          NAME_KEY => segment.name
         }
 
-        parent_id = parent_guid(segment)
-        intrinsics[PARENT_ID_KEY] = parent_id if parent_id
+        # with infinite-tracing, transactions may or may not be sampled!
+        if segment.transaction.sampled?
+          intrinsics[SAMPLED_KEY] = true
+        end
 
-        intrinsics[ENTRY_POINT_KEY] = true unless segment.parent
+        if segment.parent.nil?
+          intrinsics[ENTRY_POINT_KEY] = true
+          if txn = segment.transaction
+            if header_data = txn.distributed_tracer.trace_context_header_data
+              if trace_state_vendors = header_data.trace_state_vendors
+                intrinsics[TRACING_VENDORS_KEY] = trace_state_vendors unless trace_state_vendors == NewRelic::EMPTY_STR
+              end
+            end
+            if trace_state_payload = txn.distributed_tracer.trace_state_payload
+              intrinsics[TRUSTED_PARENT_KEY] = trace_state_payload.id if trace_state_payload.id
+            end
+          end
+        end
+
+        if parent_id = parent_guid(segment)
+          intrinsics[PARENT_ID_KEY] = parent_id
+        end
+
+        if segment.transaction_name
+          intrinsics[TRANSACTION_NAME_KEY] = segment.transaction_name
+        end
 
         intrinsics
       end
 
+      def custom_attributes(segment)
+        attributes = segment.attributes
+        if attributes
+          result = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+          result.freeze
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def merge_hashes(hash1, hash2)
+        return hash1 if hash2.nil? || hash2.empty?
+        return hash2 if hash1.nil? || hash1.empty?
+
+        hash1.merge!(hash2)
+      end
+
+      def agent_attributes(segment)
+        agent_attributes = segment.attributes
+          .agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+        error_attributes = error_attributes(segment)
+        code_attributes = segment.code_attributes
+        agent_attributes = merge_hashes(agent_attributes, error_attributes)
+        agent_attributes = merge_hashes(agent_attributes, code_attributes)
+        agent_attributes.freeze
+      end
+
       def parent_guid(segment)
         if segment.parent
           segment.parent.guid
-        elsif segment.transaction && segment.transaction.distributed_trace?
-          segment.transaction.distributed_trace_payload.id
+        elsif txn = segment.transaction
+          txn.distributed_tracer.parent_guid
         end
       end
 
@@ -135,9 +197,7 @@ module NewRelic
         Integer(segment.start_time.to_f * 1000.0)
       end
 
-      ELLIPSIS = '...'.freeze
-
-      def truncate(value, max_size=255)
+      def truncate(value, max_size = 255)
         value = value.to_s
         if value.bytesize > max_size
           value.byteslice(0, max_size - 2).chop! << ELLIPSIS

data/lib/new_relic/agent/sql_sampler.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'zlib'
 require 'base64'
@@ -46,7 +46,7 @@ module NewRelic
           NewRelic::Agent::Database.should_record_sql?(:slow_sql)
       end
 
-      def on_start_transaction(state, start_time, uri=nil)
+      def on_start_transaction(state, uri = nil)
         return unless enabled?
 
         state.sql_sampler_transaction_data = TransactionSqlData.new
@@ -61,11 +61,11 @@ module NewRelic
       end
 
       def tl_transaction_data # only used for testing
-        TransactionState.tl_get.sql_sampler_transaction_data
+        Tracer.state.sql_sampler_transaction_data
       end
 
       # This is called when we are done with the transaction.
-      def on_finishing_transaction(state, name, time=Time.now)
+      def on_finishing_transaction(state, name)
         return unless enabled?
 
         data = state.sql_sampler_transaction_data
@@ -74,8 +74,8 @@ module NewRelic
         data.set_transaction_name(name)
         if data.sql_data.size > 0
           @samples_lock.synchronize do
-            ::NewRelic::Agent.logger.debug "Examining #{data.sql_data.size} slow transaction sql statement(s)"
-            save_slow_sql data
+            ::NewRelic::Agent.logger.debug("Examining #{data.sql_data.size} slow transaction sql statement(s)")
+            save_slow_sql(data)
           end
         end
       end
@@ -83,7 +83,7 @@ module NewRelic
       # this should always be called under the @samples_lock
       def save_slow_sql(transaction_sql_data)
         path = transaction_sql_data.path
-        uri  = transaction_sql_data.uri
+        uri = transaction_sql_data.uri
 
         transaction_sql_data.sql_data.each do |sql_item|
           normalized_sql = sql_item.normalize
@@ -140,8 +140,8 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil, binds=nil, name=nil) #THREAD_LOCAL_ACCESS sometimes
-        state ||= TransactionState.tl_get
+      def notice_sql(sql, metric_name, config, duration, state = nil, explainer = nil, binds = nil, name = nil) # THREAD_LOCAL_ACCESS sometimes
+        state ||= Tracer.state
         data = state.sql_sampler_transaction_data
         return unless data
 
@@ -156,27 +156,27 @@ module NewRelic
 
       PRIORITY = "priority".freeze
 
-      def distributed_trace_intrinsics(state)
+      def distributed_trace_attributes(state)
         transaction = state.current_transaction
         params = nil
-        if transaction && transaction.distributed_trace_payload
+        if transaction && transaction.distributed_tracer.distributed_trace_payload
           params = {}
-          payload = transaction.distributed_trace_payload
-          payload.assign_intrinsics transaction, params
+          payload = transaction.distributed_tracer.distributed_trace_payload
+          DistributedTraceAttributes.copy_from_transaction(transaction, payload, params)
           params[PRIORITY] = transaction.priority
         end
         params
       end
 
       def notice_sql_statement(statement, metric_name, duration)
-        state ||= TransactionState.tl_get
+        state ||= Tracer.state
         data = state.sql_sampler_transaction_data
         return unless data
 
         if state.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            params = distributed_trace_intrinsics state
+            params = distributed_trace_attributes(state)
             data.sql_data << SlowSql.new(statement, metric_name, duration, backtrace, params)
           end
         end
@@ -196,14 +196,14 @@ module NewRelic
       end
 
       def harvest!
-        return [] unless enabled?
+        return NewRelic::EMPTY_ARRAY unless enabled?
 
         slowest = []
         @samples_lock.synchronize do
           slowest = @sql_traces.values
           @sql_traces = {}
         end
-        slowest.each {|trace| trace.prepare_to_send }
+        slowest.each { |trace| trace.prepare_to_send }
         slowest
       end
 
@@ -240,7 +240,7 @@ module NewRelic
       attr_reader :duration
       attr_reader :backtrace
 
-      def initialize(statement, metric_name, duration, backtrace=nil, params=nil)
+      def initialize(statement, metric_name, duration, backtrace = nil, params = nil)
         @statement = statement
         @metric_name = metric_name
         @duration = duration
@@ -300,7 +300,7 @@ module NewRelic
         super()
         @params = slow_sql.base_params
         @sql_id = consistent_hash(normalized_query)
-        set_primary slow_sql, path, uri
+        set_primary(slow_sql, path, uri)
         record_data_point(float(slow_sql.duration))
       end
 
@@ -315,7 +315,7 @@ module NewRelic
 
       def aggregate(slow_sql, path, uri)
         if slow_sql.duration > max_call_time
-          set_primary slow_sql, path, uri
+          set_primary(slow_sql, path, uri)
         end
 
         record_data_point(float(slow_sql.duration))
@@ -342,7 +342,7 @@ module NewRelic
       include NewRelic::Coerce
 
       def to_collector_array(encoder)
-        [ string(@path),
+        [string(@path),
           string(@url),
           int(@sql_id),
           string(@sql),
@@ -351,7 +351,7 @@ module NewRelic
           Helper.time_to_millis(@total_call_time),
           Helper.time_to_millis(@min_call_time),
           Helper.time_to_millis(@max_call_time),
-          encoder.encode(@params) ]
+          encoder.encode(@params)]
       end
 
       private
@@ -359,10 +359,10 @@ module NewRelic
       # need to hash the same way in every process, to be able to aggregate slow SQL traces
       def consistent_hash(string)
         if NewRelic::Agent.config[:'slow_sql.use_longer_sql_id']
-          Digest::MD5.hexdigest(string).hex.modulo(2**63-1)
+          Digest::SHA1.hexdigest(string).hex.modulo(2**63 - 1)
         else
           # from when sql_id needed to fit in an INT(11)
-          Digest::MD5.hexdigest(string).hex.modulo(2**31-1)
+          Digest::SHA1.hexdigest(string).hex.modulo(2**31 - 1)
         end
       end
     end

data/lib/new_relic/agent/stats.rb

@@ -1,9 +1,12 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 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 +15,7 @@ module NewRelic
       attr_accessor :sum_of_squares
 
       def initialize
+        @lock = Mutex.new
         reset
       end
 
@@ -34,33 +38,45 @@ 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
 
-      def to_s
-        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
+      def hash_merge(hash)
+        @call_count = hash[:count] if hash[:count]
+        @total_call_time = hash[:total] if hash[:total]
+        @total_exclusive_time = hash[:total] if hash[:total]
+        @min_call_time = hash[:min] if hash[:min]
+        @max_call_time = hash[:max] if hash[:max]
+        @sum_of_squares = hash[:sum_of_squares] if hash[:sum_of_squares]
+        self
       end
 
       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 to_s
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
+      end
+
+      def record(value = nil, aux = nil, &blk)
         if blk
-          yield self
+          yield(self)
         else
           case value
           when Numeric
@@ -78,13 +94,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 +110,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 +124,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 +140,36 @@ 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

@@ -1,8 +1,7 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-# -*- coding: utf-8 -*-
 module NewRelic
   module Agent
     class StatsEngine
@@ -12,6 +11,7 @@ module NewRelic
         def self.init
           @initialized ||= nil
           return @profiler if @initialized
+
           @profiler = if RailsBenchProfiler.enabled?
             RailsBenchProfiler.new
           elsif CoreGCProfiler.enabled?
@@ -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?
@@ -99,7 +97,7 @@ module NewRelic
 
           # When using GC::Profiler, it's important to periodically call
           # GC::Profiler.clear in order to avoid unbounded growth in the number
-          # of GC recordds that are stored. However, we actually do this
+          # of GC records that are stored. However, we actually do this
           # internally within MonotonicGCProfiler on calls to #total_time_s,
           # so the reset here is a no-op.
           def reset; end