newrelic_rpm 10.8.0 → 10.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4d18bdc5c32826f29d700b466f49c1cf0995dfcfd34bcde0d9152d8d1021def
-  data.tar.gz: 8ff19da678ccce6796918d3b420bcb8d69123e04b615cffefb69d049cc25b522
+  metadata.gz: fbb51c8f4559d8bb50f88a7e3fcd47d63de49fbe5ec974e9c4ec48b277e28049
+  data.tar.gz: 129662fccdead351c98519c957172412b20a917e79350960875b53a5ff2d4dcd
 SHA512:
-  metadata.gz: 8bcb3c02bbc6e4510dcb85926f73aa394083d2a7cc43d6f7cb3989b1fbaef6605c0d4298e7f7596c77e6396f296ae2f01f812dfd73fb030e7e98317da83c0822
-  data.tar.gz: cb84c5756c4e7398cbad79d1c01e5d8097538787c1d1e193c806226022eefa12d440efe201800fc76ea0363bfe8b633a31fbe6abdb92b213d4d4ff3d2b5e0b72
+  metadata.gz: 630af5f3ffd009f852384cae072cb42d6f0b293c5ca4b13d096d442bbc2f51ab52d12af348e72bdbccfee60549a45ad4e449e45c0ee401aabc8efb58342e61ad
+  data.tar.gz: 429d5e818a9ec3ece5838b30882fc9ae56dc717916ce423c1bde6e928f4bc672f3eaeb77f26ea608206c203f0db03bec52bc8d9b406822e4646ad0f807a781f3

data/.claude/hooks/check_comments.sh

@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 # Stop hook: judges every comment line added during this session against this repo's
-# CLAUDE.md comment-discipline rule (WHY only, never WHAT, 1-2 lines). Blocks the turn from
-# ending if a fresh, context-free `claude -p` review finds anything to fix.
+# CLAUDE.md comment-discipline rule (WHY only, never WHAT, 1-2 lines), defaulting to removal
+# rather than rewording. Blocks the turn from ending if a fresh, context-free `claude -p`
+# review finds anything to fix.
 set -euo pipefail
 
 # Guard against the nested `claude -p` judge call below re-triggering this same hook.
@@ -30,17 +31,34 @@ if [ -z "$ADDED_COMMENTS" ]; then
 fi
 
 PROMPT="Review ONLY the added lines (prefixed with +) in this git diff for Ruby comments.
-Rule: a comment is only justified if it states a non-obvious WHY (a hidden constraint, a 
-subtle invariant, a workaround, surprising behavior) that a reader could not get from the 
-code itself. Never justified: restating WHAT the code does, referencing PR/issue numbers 
-or task history, or exceeding 2 lines when a shorter version would do. If a comment doesn't 
-need to be there, remove it. 
-Ignore the standard 2-line license header and frozen_string_literal comment, and any yardoc 
+
+The default verdict is REMOVE. Deletion is the preferred fix; shortening is a distant second
+and is right only for a comment that genuinely must stay but is wordy. Begin from the
+assumption that every added comment should go, and spare one only if deleting it would
+plausibly lead a competent reader of this code to make a mistake.
+
+A comment survives only if it states a non-obvious WHY the code cannot state itself: a hidden
+constraint, a cross-file or ordering dependency, a subtle invariant, a workaround for specific
+behavior, or something whose breakage would be silent. \"Useful context\", \"helps the reader
+follow along\", and \"explains the design\" are NOT survival reasons -- those are removals.
+
+Report REMOVE (never merely shortening) when the comment:
+- restates WHAT the code does, or narrates the obvious
+- explains or justifies a change, or reads as commit-message, PR, issue, or task-history content
+- repeats what a nearby existing comment, a method name, a constant name, or a test name says
+- explains why code is defensive, redundant, or belt-and-braces
+- labels or introduces the lines beneath it
+- needs more than 2 lines to make its point -- treat the length as evidence it is narrating
+  rather than constraining, and remove it instead of compressing it
+
+Ignore the standard 2-line license header, the frozen_string_literal comment, and yardoc
 comments for public documentation.
 
-For each added comment that violates the rule, report file, line (from the diff hunk
-header), the comment text, and a one-sentence reason. If every added comment is fine,
-say so explicitly.
+For each added comment that should change, report file, line (from the diff hunk header), the
+comment text, and a one-sentence reason that starts with the action: \"remove -- \" plus why it
+fails, or, for the rare must-stay-but-wordy case, \"shorten -- \" plus what constraint makes it
+load-bearing. When torn between the two, say remove. If every added comment is justified,
+return an empty violations array.
 
 Respond with ONLY a JSON object, no markdown fences, no other text, matching exactly:
 {\"violations\": [{\"file\": \"...\", \"line\": ..., \"comment\": \"...\", \"reason\": \"...\"}]}
@@ -67,5 +85,6 @@ fi
 
 REASON="$(echo "$RESULT" | jq -r '.violations[] | "- \(.file):\(.line) — \(.comment | tostring) — \(.reason)"' 2>/dev/null || true)"
 
-jq -n --arg reason "Comment-discipline check found issues to fix before finishing:
+jq -n --arg reason "Comment-discipline check found comments to fix before finishing. Prefer
+deleting a flagged comment over rewording it; only shorten one that is genuinely load-bearing:
 $REASON" '{decision: "block", reason: $reason}'

data/.claude/hooks/check_rubocop.sh

@@ -18,7 +18,9 @@ if [ "${#EXISTING_FILES[@]}" -eq 0 ]; then
 fi
 
 set +e
-RESULT="$(bundle exec rubocop --format simple "${EXISTING_FILES[@]}" 2>&1)"
+# --force-exclusion: rubocop ignores AllCops/Exclude when given explicit paths, which would
+# otherwise lint generated files (e.g. the vendored *_pb.rb protobuf classes) the project excludes.
+RESULT="$(bundle exec rubocop --format simple --force-exclusion "${EXISTING_FILES[@]}" 2>&1)"
 EXIT_CODE=$?
 set -e
 

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # New Relic Ruby Agent Release Notes
 
+## v10.9.0
+
+- **Feature: Continuous Profiling (preview)**
+
+  Continuous Profiling is a new feature which is not yet generally available for use. The agent-side component code is now present in the agent but to actually use it ahead of the General Availability release, you will need to contact your New Relic sales representative to join the preview early.
+
+  Continuous Profiling repeatedly samples the Ruby call stacks of your running application and reports them to New Relic, so you can see which methods are consuming the most CPU time (or allocating the most objects) in production, without adding code to your app.
+
+  To turn it on, add the [`stackprof`](https://rubygems.org/gems/stackprof) and [`google-protobuf`](https://rubygems.org/gems/google-protobuf) gems to your application's `Gemfile`, then set `profiling.enabled` to `true`:
+
+  ```yaml
+    profiling.enabled: true
+  ```
+
+  With only `profiling.enabled` set, the agent samples CPU time every 10 milliseconds for the life of the process. These options let you tune that behavior:
+
+  | Configuration name | Default | Behavior |
+  | ------------------ | ------- | -------- |
+  | profiling.enabled | `false` | If `true`, the agent collects and reports continuous profiling data. |
+  | profiling.include | `cpu` | What to sample: `cpu` for CPU time, or `object` for object allocations. |
+  | profiling.sample_period | `0.01` | Seconds between stack samples. Only used when `profiling.include` is `cpu`. Must be between 0.000001 and 0.999999. |
+  | profiling.object_allocation_interval | `10000` | Object allocations between stack samples. Only used when `profiling.include` is `object`. Must be between 1000 and 999999. |
+  | profiling.delay | `0` | Milliseconds to wait before profiling starts. `0` starts immediately. |
+  | profiling.duration | `0` | Milliseconds to profile before stopping automatically. `0` profiles until the process exits. |
+
+  [PR#3617](https://github.com/newrelic/newrelic-ruby-agent/pull/3617)
+
+- **Feature: Add support for Dalli 5.1.1**
+
+  Dalli 5.1.1 added arguments to some of the methods the agent instruments, which could raise an `ArgumentError` on multi-key operations or cause request options to be silently dropped. Now, the agent accepts and forwards a variable number of positional and keyword arguments for these methods. [PR#3683](https://github.com/newrelic/newrelic-ruby-agent/pull/3683)
+
 ## v10.8.0
 
 - **Feature: Report a unique hostname for Google Cloud Run Worker Pools and Jobs**

data/lib/new_relic/agent/agent.rb

@@ -28,6 +28,7 @@ require 'new_relic/agent/transaction_event_recorder'
 require 'new_relic/agent/custom_event_aggregator'
 require 'new_relic/agent/span_event_aggregator'
 require 'new_relic/agent/log_event_aggregator'
+require 'new_relic/agent/continuous_profiling/session'
 require 'new_relic/agent/sampler_collection'
 require 'new_relic/agent/javascript_instrumentor'
 require 'new_relic/agent/vm/monotonic_gc_profiler'
@@ -87,6 +88,8 @@ module NewRelic
         @wait_on_connect_mutex = Mutex.new
         @after_fork_lock = Mutex.new
         @wait_on_connect_condition = ConditionVariable.new
+        @profiles_forwarder_lock = Mutex.new
+        @profiles_forwarder_count = 0
       end
 
       def init_components
@@ -121,6 +124,7 @@ module NewRelic
         @custom_event_aggregator = CustomEventAggregator.new(@events)
         @span_event_aggregator = SpanEventAggregator.new(@events)
         @log_event_aggregator = LogEventAggregator.new(@events)
+        @continuous_profiling_session = ContinuousProfiling::Session.new(@events)
       end
 
       def setup_attribute_filter
@@ -149,6 +153,8 @@ module NewRelic
       # Holds all the methods defined on NewRelic::Agent::Agent
       # instances
       module InstanceMethods
+        MAX_CONCURRENT_PROFILES_FORWARDERS = 4
+
         # the agent control health check file generator
         attr_reader :health_check
         # the statistics engine that holds all the timeslice data
@@ -181,6 +187,7 @@ module NewRelic
         attr_reader :custom_event_aggregator
         attr_reader :span_event_aggregator
         attr_reader :log_event_aggregator
+        attr_reader :continuous_profiling_session
         attr_reader :transaction_event_recorder
         attr_reader :attribute_filter
         attr_reader :adaptive_sampler
@@ -231,6 +238,10 @@ module NewRelic
           reset_objects_with_locks
           drop_buffered_data
 
+          # Ahead of setup_and_start_agent: a connect on the worker thread it spawns applies
+          # server-side config, which can start a session this call would then tear down.
+          @continuous_profiling_session.after_fork
+
           setup_and_start_agent(options)
         end
 
@@ -319,6 +330,9 @@ module NewRelic
         # might be holding locks for background thread that aren't there anymore.
         def reset_objects_with_locks
           @stats_engine = StatsEngine.new
+          @continuous_profiling_session.reset_after_fork_from_parent_thread
+          @profiles_forwarder_lock = Mutex.new
+          @profiles_forwarder_count = 0
         end
 
         def flush_pipe_data # used only by resque
@@ -348,7 +362,41 @@ module NewRelic
           end
         end
 
+        # Forwarded off-thread so a slow export doesn't block other children's data; capped
+        # since forwarders serialize on NewRelicService's profiles request lock anyway.
+        def forward_profiles_data(data)
+          @profiles_forwarder_lock.synchronize do
+            if @profiles_forwarder_count >= MAX_CONCURRENT_PROFILES_FORWARDERS
+              NewRelic::Agent.increment_metric('Supportability/Ruby/Profiling/Forward/Dropped')
+              NewRelic::Agent.logger.debug(
+                'Dropping a forwarded continuous profiling payload: too many exports already in flight'
+              )
+              return nil
+            end
+
+            @profiles_forwarder_count += 1
+          end
+
+          begin
+            Threading::AgentThread.create('Continuous Profiling Forwarder') do
+              @service.profiles_data(data)
+            ensure
+              @profiles_forwarder_lock.synchronize { @profiles_forwarder_count -= 1 }
+            end
+          rescue => e
+            # The block's ensure never runs if the thread was never created, and a count that
+            # can't come back down drops every later payload for the life of the process.
+            @profiles_forwarder_lock.synchronize { @profiles_forwarder_count -= 1 }
+            NewRelic::Agent.logger.error('Failed to start a continuous profiling forwarder thread', e)
+            nil
+          end
+        end
+
         def merge_data_for_endpoint(endpoint, data)
+          if endpoint == :profiles_data && data && !data.empty?
+            return forward_profiles_data(data)
+          end
+
           if data && !data.empty?
             container = container_for_endpoint(endpoint)
             if container.respond_to?(:has_metadata?) && container.has_metadata?

data/lib/new_relic/agent/audit_logger.rb

@@ -39,16 +39,23 @@ module NewRelic
       end
 
       def log_request(uri, data, marshaller)
+        log_request_body(uri) do
+          if marshaller.class.human_readable?
+            marshaller.dump(data, :encoder => @encoder)
+          else
+            marshaller.prepare(data, :encoder => @encoder).inspect
+          end
+        end
+      end
+
+      # Yielded, not passed: rendering a body eagerly would cost a marshal or protobuf decode on
+      # every request even when audit logging is off or the endpoint is filtered out.
+      def log_request_body(uri)
         return unless enabled? && allowed_endpoint?(uri)
 
         setup_logger unless setup?
-        request_body = if marshaller.class.human_readable?
-          marshaller.dump(data, :encoder => @encoder)
-        else
-          marshaller.prepare(data, :encoder => @encoder).inspect
-        end
         @log.info("REQUEST: #{uri}")
-        @log.info("REQUEST BODY: #{request_body}")
+        @log.info("REQUEST BODY: #{yield}")
       rescue StandardError, SystemStackError, SystemCallError => e
         ::NewRelic::Agent.logger.warn('Failed writing to audit log', e)
       rescue Exception => e

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -15,6 +15,9 @@ module NewRelic
   module Agent
     module Commands
       class AgentCommandRouter
+        START_CONTINUOUS_PROFILING_COMMAND = 'start_continuous_profiling'
+        STOP_CONTINUOUS_PROFILING_COMMAND = 'stop_continuous_profiling'
+
         attr_reader :handlers
 
         attr_accessor :thread_profiler_session, :backtrace_service
@@ -28,6 +31,8 @@ module NewRelic
 
           @handlers['start_profiler'] = proc { |cmd| thread_profiler_session.handle_start_command(cmd) }
           @handlers['stop_profiler'] = proc { |cmd| thread_profiler_session.handle_stop_command(cmd) }
+          @handlers[START_CONTINUOUS_PROFILING_COMMAND] = proc { |cmd| continuous_profiling_session.handle_start_command(cmd) }
+          @handlers[STOP_CONTINUOUS_PROFILING_COMMAND] = proc { |cmd| continuous_profiling_session.handle_stop_command(cmd) }
 
           event_listener&.subscribe(:before_shutdown, &method(:on_before_shutdown))
         end
@@ -36,6 +41,11 @@ module NewRelic
           NewRelic::Agent.instance.service
         end
 
+        def continuous_profiling_session
+          NewRelic::Agent.agent&.continuous_profiling_session ||
+            raise(AgentCommandError, 'Continuous profiling session unavailable; agent not fully started')
+        end
+
         def check_for_and_handle_agent_commands
           commands = get_agent_commands
 

data/lib/new_relic/agent/configuration/default_source.rb

@@ -216,6 +216,58 @@ module NewRelic
           constants.compact!
           constants
         end
+
+        OBJECT_ALLOCATION_INTERVAL_MINIMUM = 1000
+
+        # StackProf's C extension rejects any interval outside 1..999_999 (stackprof_start in
+        # stackprof.c), whether it's microseconds or a raw allocation count.
+        STACKPROF_INTERVAL_MAXIMUM = 999_999
+        SAMPLE_PERIOD_MINIMUM_SECONDS = 1 / 1_000_000.0
+        SAMPLE_PERIOD_MAXIMUM_SECONDS = STACKPROF_INTERVAL_MAXIMUM / 1_000_000.0
+
+        def self.enforce_object_allocation_interval_range(value)
+          return value if value.nil?
+
+          if value < OBJECT_ALLOCATION_INTERVAL_MINIMUM
+            NewRelic::Agent.logger.debug(
+              "profiling.object_allocation_interval is set to #{value.inspect}, which is below the minimum " \
+              "of #{OBJECT_ALLOCATION_INTERVAL_MINIMUM}. Using #{OBJECT_ALLOCATION_INTERVAL_MINIMUM} instead."
+            )
+            return OBJECT_ALLOCATION_INTERVAL_MINIMUM
+          end
+
+          if value > STACKPROF_INTERVAL_MAXIMUM
+            NewRelic::Agent.logger.debug(
+              "profiling.object_allocation_interval is set to #{value.inspect}, which is above the maximum " \
+              "of #{STACKPROF_INTERVAL_MAXIMUM}. Using #{STACKPROF_INTERVAL_MAXIMUM} instead."
+            )
+            return STACKPROF_INTERVAL_MAXIMUM
+          end
+
+          value
+        end
+
+        def self.enforce_sample_period_range(value)
+          return value if value.nil?
+
+          if value < SAMPLE_PERIOD_MINIMUM_SECONDS
+            NewRelic::Agent.logger.debug(
+              "profiling.sample_period is set to #{value.inspect}, which is below the minimum of " \
+              "#{SAMPLE_PERIOD_MINIMUM_SECONDS} seconds. Using #{SAMPLE_PERIOD_MINIMUM_SECONDS} instead."
+            )
+            return SAMPLE_PERIOD_MINIMUM_SECONDS
+          end
+
+          if value > SAMPLE_PERIOD_MAXIMUM_SECONDS
+            NewRelic::Agent.logger.debug(
+              "profiling.sample_period is set to #{value.inspect}, which is above the maximum of " \
+              "#{SAMPLE_PERIOD_MAXIMUM_SECONDS} seconds. Using #{SAMPLE_PERIOD_MAXIMUM_SECONDS} instead."
+            )
+            return SAMPLE_PERIOD_MAXIMUM_SECONDS
+          end
+
+          value
+        end
       end
 
       AUTOSTART_DENYLISTED_RAKE_TASKS = [
@@ -1054,6 +1106,69 @@ module NewRelic
           :description => "If `true`, the agent will report source code level metrics for traced methods.\n\tSee: " \
                           'https://docs.newrelic.com/docs/apm/agents/ruby-agent/features/ruby-codestream-integration/'
         },
+        # Continuous profiler
+        :'profiling.enabled' => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :allowed_from_server => true,
+          :description => 'If `true`, enables continuous profiling. Requires the `stackprof` and `google-protobuf` ' \
+            'gems to be present in the application. Not supported on JRuby. Automatically disabled when high ' \
+            'security mode is enabled.'
+        },
+        :'profiling.delay' => {
+          :default => 0,
+          :public => true,
+          :type => Integer,
+          :allowed_from_server => true,
+          :description => 'The delay, in milliseconds, before continuous profiling starts after being enabled. ' \
+            'Defaults to `0`, meaning profiling starts immediately.'
+        },
+        :'profiling.duration' => {
+          :default => 0,
+          :public => true,
+          :type => Integer,
+          :allowed_from_server => true,
+          :description => 'The duration, in milliseconds, that continuous profiling runs before automatically ' \
+            'stopping. Defaults to `0`, meaning profiling runs indefinitely until explicitly stopped.'
+        },
+        :'profiling.include' => {
+          :default => 'cpu',
+          :public => true,
+          :type => String,
+          :allowed_from_server => true,
+          :allowlist => %w[cpu object],
+          :description => 'The `stackprof` sampling mode to use for continuous profiling: `cpu` or `object`.'
+        },
+        :'profiling.sample_period' => {
+          :default => 0.01,
+          :public => true,
+          :type => Float,
+          :allowed_from_server => true,
+          :transform => DefaultSource.method(:enforce_sample_period_range),
+          :description => 'The interval, in seconds, between stack samples taken by the continuous profiler. ' \
+            'Only used when `profiling.include` is `cpu`. Must be between ' \
+            "#{format('%.6f', DefaultSource::SAMPLE_PERIOD_MINIMUM_SECONDS)} and " \
+            "#{format('%.6f', DefaultSource::SAMPLE_PERIOD_MAXIMUM_SECONDS)}."
+        },
+        :'profiling.object_allocation_interval' => {
+          :default => 10000,
+          :public => true,
+          :type => Integer,
+          :allowed_from_server => true,
+          :transform => DefaultSource.method(:enforce_object_allocation_interval_range),
+          :description => 'The number of object allocations between stack samples taken by the continuous ' \
+            'profiler. Only used when `profiling.include` is `object`. Must be between ' \
+            "#{DefaultSource::OBJECT_ALLOCATION_INTERVAL_MINIMUM} and #{DefaultSource::STACKPROF_INTERVAL_MAXIMUM}."
+        },
+        :'profiling.harvest_period' => {
+          :default => 10,
+          :public => false,
+          :type => Integer,
+          :allowed_from_server => true,
+          :description => 'The interval, in seconds, at which the continuous profiler converts and reports its ' \
+            'collected samples.'
+        },
         # Custom attributes
         :'custom_attributes.enabled' => {
           :default => true,

data/lib/new_relic/agent/configuration/high_security_source.rb

@@ -20,6 +20,7 @@ module NewRelic
             :'transaction_tracer.record_redis_arguments' => false,
 
             :'ai_monitoring.enabled' => false,
+            :'profiling.enabled' => false,
             :'custom_insights_events.enabled' => false,
             :'strip_exception_messages.enabled' => true
           })