newrelic_rpm 8.5.0 → 8.8.0

data/lib/new_relic/agent/new_relic_service.rb

@@ -15,23 +15,23 @@ module NewRelic
     class NewRelicService
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
-
       PROTOCOL_VERSION = 17
 
-      # 1f147a42: v10 (tag 3.5.3.17)
-      # cf0d1ff1: v9 (tag 3.5.0)
-      # 14105: v8 (tag 2.10.3)
-      # (no v7)
-      # 10379: v6 (not tagged)
-      # 4078:  v5 (tag 2.5.4)
-      # 2292:  v4 (tag 2.3.6)
-      # 1754:  v3 (tag 2.3.0)
-      # 534:   v2 (shows up in 2.1.0, our first tag)
-
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
       CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
 
+      # Don't perform compression on the payload unless its uncompressed size is
+      # greater than or equal to this number of bytes. In testing with
+      # Ruby 2.2 - 3.1, we determined an absolute minimum value for ASCII to be
+      # 535 bytes to obtain at least a 10% savings in size. It is recommended
+      # that this value be kept above that 535 number. It is also important to
+      # consider the CPU cost involved with performing compression and to find
+      # a balance between CPU cycles spent and bandwidth saved. A good
+      # reasonable default here is 2048 bytes, which is a tried and true Apache
+      # Tomcat default (as of v8.5.78)
+      MIN_BYTE_SIZE_TO_COMPRESS = 2048
+
       attr_accessor :request_timeout
       attr_reader :collector, :marshaller, :agent_id
 
@@ -177,26 +177,30 @@ module NewRelic
           :item_count => items.size)
       end
 
+      def log_event_data(data)
+        payload, size = LogEventAggregator.payload_to_melt_format(data)
+        invoke_remote(:log_event_data, payload, :item_count => size)
+      end
+
       def error_event_data(data)
         metadata, items = data
-        invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
+        response = invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Sent", :count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Seen", :count => metadata[:events_seen])
+        response
       end
 
       def span_event_data(data)
         metadata, items = data
-        invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
+        response = invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Sent", :count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Seen", :count => metadata[:events_seen])
+        response
       end
 
-      # We do not compress if content is smaller than 64kb.  There are
-      # problems with bugs in Ruby in some versions that expose us
-      # to a risk of segfaults if we compress aggressively.
       def compress_request_if_needed(data, endpoint)
         encoding = 'identity'
-        if data.size > 64 * 1024
+        if data.size >= MIN_BYTE_SIZE_TO_COMPRESS
           encoding = Agent.config[:compressed_content_encoding]
           data = if encoding == 'deflate'
             Encoders::Compressed::Deflate.encode(data)
@@ -422,8 +426,8 @@ module NewRelic
         end
         serialize_finish_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+        size = data.size # only the uncompressed size is reported
         data, encoding = compress_request_if_needed(data, method)
-        size = data.size
 
         # Preconnect needs to always use the configured collector host, not the redirect host
         # We reset it here so we are always using the configured collector during our creation of the new connection
@@ -454,7 +458,7 @@ module NewRelic
       def handle_serialization_error(method, e)
         NewRelic::Agent.increment_metric("Supportability/serialization_failure")
         NewRelic::Agent.increment_metric("Supportability/serialization_failure/#{method}")
-        msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
+        msg = "Failed to serialize #{method} data using #{@marshaller.class}: #{e.inspect}"
         error = SerializationError.new(msg)
         error.set_backtrace(e.backtrace)
         raise error
@@ -464,11 +468,11 @@ module NewRelic
         serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
         request_duration = response_check_ts && (response_check_ts - request_send_ts)
         if request_duration
-          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method.to_s}/Duration", request_duration)
+          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method}/Duration", request_duration)
         end
         if serialize_time
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method}", serialize_time)
         end
       end
 
@@ -482,8 +486,8 @@ module NewRelic
       # of items as arguments.
       def record_size_supportability_metrics(method, size_bytes, item_count)
         metrics = [
-          "Supportability/invoke_remote_size",
-          "Supportability/invoke_remote_size/#{method.to_s}"
+          "Supportability/Ruby/Collector/Output/Bytes",
+          "Supportability/Ruby/Collector/#{method}/Output/Bytes"
         ]
         # we may not have an item count, in which case, just record 0 for the exclusive time
         item_count ||= 0

data/lib/new_relic/agent/pipe_service.rb

@@ -10,8 +10,7 @@ module NewRelic
 
       def initialize(channel_id)
         @channel_id = channel_id
-        @collector = NewRelic::Control::Server.new(:name => 'parent',
-          :port => 0)
+        @collector = NewRelic::Control::Server.new({name: 'parent', port: 0})
         @pipe = NewRelic::Agent::PipeChannelManager.channels[@channel_id]
         if @pipe && @pipe.parent_pid != $$
           @pipe.after_fork_in_child
@@ -61,6 +60,10 @@ module NewRelic
         write_to_pipe(:sql_trace_data, sql) if sql
       end
 
+      def log_event_data(logs)
+        write_to_pipe(:log_event_data, logs) if logs
+      end
+
       def shutdown
         @pipe.close if @pipe
       end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/agent/sampler'
+require 'new_relic/helper'
 
 module NewRelic
   module Agent
@@ -46,7 +47,11 @@ module NewRelic
 
         def self.platform
           if RUBY_PLATFORM =~ /java/
-            %x(uname -s).downcase
+            begin
+              NewRelic::Helper.run_command('uname -s').downcase
+            rescue NewRelic::CommandRunFailedError, NewRelic::CommandExecutableNotFoundError
+              'unknown'
+            end
           else
             RUBY_PLATFORM.downcase
           end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -165,18 +165,21 @@ module NewRelic
         end
       end
 
-      def merge_and_freeze_attributes agent_attributes, error_attributes
-        return agent_attributes.freeze unless error_attributes
-        return error_attributes.freeze if agent_attributes.equal?(NewRelic::EMPTY_HASH)
-        agent_attributes.merge!(error_attributes).freeze
+      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)
-        return NewRelic::EMPTY_HASH unless agent_attributes || error_attributes
-        merge_and_freeze_attributes(agent_attributes, error_attributes)
+        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

data/lib/new_relic/agent/stats.rb

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

data/lib/new_relic/agent/tracer.rb

@@ -405,6 +405,19 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def thread_block_with_current_transaction(*args, &block)
+          current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state]
+          Proc.new do
+            begin
+              NewRelic::Agent::Tracer.state.current_transaction = current_txn
+              segment = NewRelic::Agent::Tracer.start_segment(name: "Ruby/Thread/#{::Thread.current.object_id}")
+              block.call(*args) if block.respond_to?(:call)
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
         private
 
         def start_and_add_segment segment, parent = nil
@@ -445,7 +458,7 @@ module NewRelic
         end
 
         # Current transaction stack
-        attr_reader :current_transaction
+        attr_accessor :current_transaction
 
         # Execution tracing on current thread
         attr_accessor :untraced

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -20,13 +20,14 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_thread_id
         attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
         def initialize name = nil, start_time = nil
           @name = name
+          @starting_thread_id = ::Thread.current.object_id
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid
@@ -45,6 +46,10 @@ module NewRelic
           @record_scoped_metric = true
           @record_on_finish = false
           @noticed_error = nil
+          @code_filepath = nil
+          @code_function = nil
+          @code_lineno = nil
+          @code_namespace = nil
         end
 
         def start
@@ -56,6 +61,7 @@ module NewRelic
         def finish
           @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           @duration = end_time - start_time
+
           return unless transaction
           run_complete_callbacks
           finalize if record_on_finish?
@@ -109,6 +115,28 @@ module NewRelic
           @concurrent_children
         end
 
+        def code_information=(info = {})
+          return unless info[:filepath]
+
+          @code_filepath = info[:filepath]
+          @code_function = info[:function]
+          @code_lineno = info[:lineno]
+          @code_namespace = info[:namespace]
+        end
+
+        def all_code_information_present?
+          @code_filepath && @code_function && @code_lineno && @code_namespace
+        end
+
+        def code_attributes
+          return ::NewRelic::EMPTY_HASH unless all_code_information_present?
+
+          @code_attributes ||= {'code.filepath' => @code_filepath,
+                                'code.function' => @code_function,
+                                'code.lineno' => @code_lineno,
+                                'code.namespace' => @code_namespace}
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect

data/lib/new_relic/agent/transaction/tracing.rb

@@ -6,7 +6,7 @@ module NewRelic
   module Agent
     class Transaction
       module Tracing
-        attr_reader :current_segment
+        attr_reader :current_segment_by_thread
 
         def async?
           @async ||= false
@@ -23,7 +23,7 @@ module NewRelic
         def add_segment segment, parent = nil
           segment.transaction = self
           segment.parent = parent || current_segment
-          @current_segment = segment
+          set_current_segment segment
           if @segments.length < segment_limit
             @segments << segment
           else
@@ -34,7 +34,12 @@ module NewRelic
         end
 
         def segment_complete segment
-          @current_segment = segment.parent
+          # if parent was in another thread, remove the current_segment entry for this thread
+          if segment.parent && segment.parent.starting_thread_id != ::Thread.current.object_id
+            remove_current_segment_by_thread_id(::Thread.current.object_id)
+          else
+            set_current_segment segment.parent
+          end
         end
 
         def segment_limit

data/lib/new_relic/agent/transaction.rb

@@ -77,6 +77,7 @@ module NewRelic
 
       attr_reader :guid,
         :metrics,
+        :logs,
         :gc_start_snapshot,
         :category,
         :attributes,
@@ -123,7 +124,7 @@ module NewRelic
         txn = Transaction.new(category, options)
         state.reset(txn)
         txn.state = state
-        txn.start
+        txn.start(options)
         txn
       end
 
@@ -216,7 +217,8 @@ module NewRelic
 
       def initialize(category, options)
         @nesting_max_depth = 0
-        @current_segment = nil
+        @current_segment_by_thread = {}
+        @current_segment_lock = Mutex.new
         @segments = []
 
         self.default_name = options[:transaction_name]
@@ -236,6 +238,7 @@ module NewRelic
 
         @exceptions = {}
         @metrics = TransactionMetrics.new
+        @logs = PrioritySampledBuffer.new(NewRelic::Agent.instance.log_event_aggregator.capacity)
         @guid = NewRelic::Agent::GuidGenerator.generate_guid
 
         @ignore_this_transaction = false
@@ -259,6 +262,25 @@ module NewRelic
         end
       end
 
+      def parent_thread_id
+        ::Thread.current.nr_parent_thread_id if ::Thread.current.respond_to?(:nr_parent_thread_id)
+      end
+
+      def current_segment
+        current_thread_id = ::Thread.current.object_id
+        return current_segment_by_thread[current_thread_id] if current_segment_by_thread[current_thread_id]
+        return current_segment_by_thread[parent_thread_id] if current_segment_by_thread[parent_thread_id]
+        current_segment_by_thread[@starting_thread_id]
+      end
+
+      def set_current_segment(new_segment)
+        @current_segment_lock.synchronize { current_segment_by_thread[::Thread.current.object_id] = new_segment }
+      end
+
+      def remove_current_segment_by_thread_id(id)
+        @current_segment_lock.synchronize { current_segment_by_thread.delete(id) }
+      end
+
       def distributed_tracer
         @distributed_tracer ||= DistributedTracer.new(self)
       end
@@ -392,7 +414,7 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      def start
+      def start(options = {})
         return if !state.is_execution_traced?
 
         sql_sampler.on_start_transaction(state, request_path)
@@ -401,7 +423,7 @@ module NewRelic
 
         ignore! if user_defined_rules_ignore?
 
-        create_initial_segment
+        create_initial_segment(options)
         Segment.merge_untrusted_agent_attributes \
           @filtered_params,
           :'request.parameters',
@@ -412,12 +434,12 @@ module NewRelic
         segments.first
       end
 
-      def create_initial_segment
-        segment = create_segment @default_name
+      def create_initial_segment(options = {})
+        segment = create_segment @default_name, options
         segment.record_scoped_metric = false
       end
 
-      def create_segment(name)
+      def create_segment(name, options = {})
         summary_metrics = nil
 
         if name.start_with?(MIDDLEWARE_PREFIX)
@@ -431,6 +453,10 @@ module NewRelic
           unscoped_metrics: summary_metrics
         )
 
+        # #code_information will glean the code info out of the options hash
+        # if it exists or noop otherwise
+        segment.code_information = options
+
         segment
       end
 
@@ -445,7 +471,8 @@ module NewRelic
 
         nest_initial_segment if segments.length == 1
         nested_name = self.class.nested_transaction_name options[:transaction_name]
-        segment = create_segment nested_name
+
+        segment = create_segment nested_name, options
         set_default_transaction_name(options[:transaction_name], category)
         segment
       end
@@ -533,6 +560,7 @@ module NewRelic
 
         record_exceptions
         record_transaction_event
+        record_log_events
         merge_metrics
         send_transaction_finished_event
       end
@@ -716,9 +744,9 @@ module NewRelic
       # Do not call this.  Invoke the class method instead.
       def notice_error(error, options = {}) # :nodoc:
         # Only the last error is kept
-        if @current_segment
-          @current_segment.notice_error error, expected: options[:expected]
-          options[:span_id] = @current_segment.guid
+        if current_segment
+          current_segment.notice_error(error, expected: options[:expected])
+          options[:span_id] = current_segment.guid
         end
 
         if @exceptions[error]
@@ -732,6 +760,10 @@ module NewRelic
         agent.transaction_event_recorder.record payload
       end
 
+      def record_log_events
+        agent.log_event_aggregator.record_batch self, @logs.to_a
+      end
+
       def queue_time
         @apdex_start ? @start_time - @apdex_start : 0
       end
@@ -826,6 +858,10 @@ module NewRelic
         attributes.merge_custom_attributes(p)
       end
 
+      def add_log_event(event)
+        logs.append(event: event)
+      end
+
       def recording_web_transaction?
         web_category?(@category)
       end

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -63,6 +63,8 @@ module NewRelic
           append_cat payload, attrs
           DistributedTraceAttributes.copy_to_hash payload, attrs
           PayloadMetricMapping.append_mapped_metrics payload[:metrics], attrs
+        else
+          attrs[PRIORITY_KEY] = rand.round(NewRelic::PRIORITY_PRECISION)
         end
 
         attrs

data/lib/new_relic/agent/transaction_metrics.rb

@@ -13,6 +13,7 @@ module NewRelic
       DEFAULT_PROC = Proc.new { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
 
       def initialize
+        @lock = Mutex.new
         @unscoped = Hash.new(&DEFAULT_PROC)
         @scoped = Hash.new(&DEFAULT_PROC)
       end
@@ -42,11 +43,11 @@ module NewRelic
       end
 
       def each_unscoped
-        @unscoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @unscoped.each { |name, stats| yield name, stats } }
       end
 
       def each_scoped
-        @scoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @scoped.each { |name, stats| yield name, stats } }
       end
 
       def _record_metrics(names, value, aux, target, &blk)
@@ -54,10 +55,10 @@ module NewRelic
         case names
         when Array
           names.each do |name|
-            target[name].record(value, aux, &blk)
+            @lock.synchronize { target[name].record(value, aux, &blk) }
           end
         else
-          target[names].record(value, aux, &blk)
+          @lock.synchronize { target[names].record(value, aux, &blk) }
         end
       end
     end

data/lib/new_relic/agent/vm/mri_vm.rb

@@ -49,7 +49,19 @@ module NewRelic
           end
 
           if supports?(:constant_cache_invalidations)
-            snap.constant_cache_invalidations = RubyVM.stat[:global_constant_state]
+            snap.constant_cache_invalidations = gather_constant_cache_invalidations
+          end
+        end
+
+        def gather_constant_cache_invalidations
+          # Ruby >= 3.2 uses :constant_cache
+          # see: https://github.com/ruby/ruby/pull/5433 and https://bugs.ruby-lang.org/issues/18589
+          # TODO: now that 3.2+ provides more granual cache invalidation data, should we report it instead of summing?
+          if RUBY_VERSION >= '3.2.0'
+            RubyVM.stat[:constant_cache].values.sum
+          # Ruby < 3.2 uses :global_constant_state
+          else
+            RubyVM.stat[:global_constant_state]
           end
         end