newrelic_rpm 8.15.0 → 9.6.0

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -9,9 +9,9 @@ DependencyDetection.defer do
   @name = :action_cable_notifications
 
   depends_on do
-    defined?(Rails::VERSION::MAJOR) &&
-      Rails::VERSION::MAJOR.to_i >= 5 &&
-      defined?(ActionCable)
+    defined?(ActionCable::VERSION::MAJOR) &&
+      ActionCable::VERSION::MAJOR.to_i >= 5 &&
+      defined?(ActiveSupport)
   end
 
   depends_on do
@@ -25,7 +25,7 @@ DependencyDetection.defer do
 
   executes do
     # enumerate the specific events we want so that we do not get unexpected additions in the future
-    ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
+    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit.*|broadcast)\.action_cable\z/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -3,6 +3,7 @@
 # frozen_string_literal: true
 
 require 'new_relic/agent/instrumentation/action_controller_subscriber'
+require 'new_relic/agent/instrumentation/action_controller_other_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
 DependencyDetection.defer do
@@ -13,7 +14,8 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
+    !NewRelic::Agent.config[:disable_action_controller] &&
+      defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
   end
 
   executes do
@@ -29,5 +31,16 @@ DependencyDetection.defer do
 
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)
+
+    subs = %w[send_file
+      send_data
+      send_stream
+      redirect_to
+      halted_callback
+      unpermitted_parameters]
+
+    # have to double escape period because its going from string -> regex
+    NewRelic::Agent::Instrumentation::ActionControllerOtherSubscriber \
+      .subscribe(Regexp.new("^(#{subs.join('|')})\\.action_controller$"))
   end
 end

data/lib/new_relic/agent/instrumentation/rake/instrumentation.rb

@@ -7,16 +7,20 @@ module NewRelic
     module Instrumentation
       module Rake
         module Tracer
+          INSTRUMENTATION_NAME = 'Rake'
+
           def invoke_with_newrelic_tracing(*args)
             unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               timeout = NewRelic::Agent.config[:'rake.connect_timeout']
               NewRelic::Agent.instance.wait_on_connect(timeout)
             rescue => e
-              NewRelic::Agent.logger.error("Exception in wait_on_connect", e)
+              NewRelic::Agent.logger.error('Exception in wait_on_connect', e)
               return yield
             end
 
@@ -36,9 +40,9 @@ module NewRelic
         end
 
         def safe_from_third_party_gem?
-          return true unless NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
+          return true unless NewRelic::LanguageSupport.bundled_gem?('newrelic-rake')
 
-          ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
+          ::NewRelic::Agent.logger.info('Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present')
           false
         end
 
@@ -72,11 +76,7 @@ module NewRelic
         def instrument_invoke_prerequisites_concurrently(task)
           task.instance_eval do
             def invoke_prerequisites_concurrently(*_)
-              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
-                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
-                if txn = ::NewRelic::Agent::Tracer.current_transaction
-                  txn.current_segment.params[:statement] = NewRelic::Agent::Database.truncate_query("Couldn't trace concurrent prereq tasks: #{prereqs}")
-                end
+              NewRelic::Agent::MethodTracer.trace_execution_scoped('Rake/execute/multitask') do
                 super
               end
             end
@@ -86,19 +86,16 @@ module NewRelic
         def before_invoke_transaction(task)
           ensure_at_exit
 
-          # We can't represent overlapping operations yet, so if multitask just
-          # make one node and annotate with prereq task names
+          instrument_execute_on_prereqs(task)
           if task.application.options.always_multitask
             instrument_invoke_prerequisites_concurrently(task)
-          else
-            instrument_execute_on_prereqs(task)
           end
         rescue => e
-          NewRelic::Agent.logger.error("Error during Rake task invoke", e)
+          NewRelic::Agent.logger.error('Error during Rake task invoke', e)
         end
 
         def record_attributes(args, task)
-          command_line = task.application.top_level_tasks.join(" ")
+          command_line = task.application.top_level_tasks.join(' ')
           NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({:command => command_line},
             :'job.rake',
             NewRelic::Agent::AttributeFilter::DST_NONE)
@@ -109,7 +106,7 @@ module NewRelic
               NewRelic::Agent::AttributeFilter::DST_NONE)
           end
         rescue => e
-          NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
+          NewRelic::Agent.logger.error('Error during Rake task attribute recording.', e)
         end
 
         # Expects literal args passed to the task and array of task names

data/lib/new_relic/agent/instrumentation/rake.rb

@@ -8,16 +8,16 @@ require_relative 'rake/prepend'
 
 DependencyDetection.defer do
   # Why not :rake? newrelic-rake used that name, so avoid conflicting
-  named :rake_instrumentation
+  @name = :rake_instrumentation
   configure_with :rake
 
   depends_on { defined?(Rake) && defined?(Rake::VERSION) }
-  depends_on { Gem::Version.new(Rake::VERSION) >= Gem::Version.new("10.0.0") }
+  depends_on { Gem::Version.new(Rake::VERSION) >= Gem::Version.new('10.0.0') }
   depends_on { NewRelic::Agent.config[:'rake.tasks'].any? }
   depends_on { NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
 
   executes do
-    NewRelic::Agent.logger.info("Installing Rake instrumentation")
+    NewRelic::Agent.logger.info('Installing Rake instrumentation')
     NewRelic::Agent.logger.debug("Instrumenting Rake tasks: #{NewRelic::Agent.config[:'rake.tasks']}")
   end
 

data/lib/new_relic/agent/instrumentation/redis/constants.rb

@@ -12,6 +12,6 @@ module NewRelic::Agent::Instrumentation::Redis
     PIPELINE_OPERATION = 'pipeline'
     HAS_REDIS_CLIENT = defined?(::Redis) &&
       Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0.0') &&
-      !!defined?(::RedisClient)
+      !defined?(::RedisClient).nil?
   end
 end

data/lib/new_relic/agent/instrumentation/redis/instrumentation.rb

@@ -6,6 +6,8 @@ require_relative 'constants'
 
 module NewRelic::Agent::Instrumentation
   module Redis
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def connect_with_tracing
       with_tracing(Constants::CONNECT, database: db) { yield }
     end
@@ -43,6 +45,8 @@ module NewRelic::Agent::Instrumentation
     private
 
     def with_tracing(operation, statement: nil, database: nil)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: Constants::PRODUCT_NAME,
         operation: operation,
@@ -79,7 +83,8 @@ module NewRelic::Agent::Instrumentation
           self
         # redis-client gem v0.11+ (self is a RedisClient::Middlewares)
         elsif respond_to?(:client)
-          client && client.config
+          # The following line needs else branch coverage
+          client && client.config # rubocop:disable Style/SafeNavigation
         # redis-client gem <0.11 (self is a RedisClient::Middlewares)
         elsif defined?(::RedisClient)
           ::RedisClient.config if ::RedisClient.respond_to?(:config)

data/lib/new_relic/agent/instrumentation/redis.rb

@@ -13,7 +13,7 @@ require_relative 'redis/middleware'
 
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
-  named :redis_instrumentation
+  @name = :redis_instrumentation
   configure_with :redis
 
   depends_on do

data/lib/new_relic/agent/instrumentation/resque/helper.rb

@@ -10,7 +10,7 @@ module NewRelic
           extend self
 
           def resque_fork_per_job?
-            ENV["FORK_PER_JOB"] != 'false' && NewRelic::LanguageSupport.can_fork?
+            ENV['FORK_PER_JOB'] != 'false' && NewRelic::LanguageSupport.can_fork?
           end
         end
       end

data/lib/new_relic/agent/instrumentation/resque/instrumentation.rb

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',

data/lib/new_relic/agent/instrumentation/resque.rb

@@ -10,7 +10,7 @@ DependencyDetection.defer do
   @name = :resque
 
   depends_on do
-    defined?(Resque::Job) && !NewRelic::Agent.config[:disable_resque]
+    defined?(Resque::Job)
   end
 
   # Airbrake uses method chaining on Resque::Job on versions < 11.0.3

data/lib/new_relic/agent/instrumentation/roda/chain.rb

@@ -0,0 +1,43 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Chain
+      def self.instrument!
+        ::Roda.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+          alias_method(:_roda_handle_main_route_without_tracing, :_roda_handle_main_route)
+
+          def _roda_handle_main_route(*args)
+            _roda_handle_main_route_with_tracing(*args) do
+              _roda_handle_main_route_without_tracing(*args)
+            end
+          end
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Roda.class_eval do
+            include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+            class << self
+              alias_method(:build_rack_app_without_tracing, :build_rack_app)
+
+              def build_rack_app
+                build_rack_app_with_tracing do
+                  build_rack_app_without_tracing
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/ignorer.rb

@@ -0,0 +1,45 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false unless app.opts.include?(:newrelic_ignores)
+
+        app.opts[:newrelic_ignores][type].any? do |pattern|
+          pattern === app.request.path_info
+        end
+      end
+
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
+
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
+
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
+
+      private
+
+      def set_newrelic_ignore(type, *routes)
+        # Create a newrelic_ignores hash if one doesn't exist
+        opts[:newrelic_ignores] = Hash.new([]) if !opts.include?(:newrelic_ignores)
+
+        if routes.empty?
+          opts[:newrelic_ignores][type] += [Regexp.new('.*')]
+        else
+          opts[:newrelic_ignores][type] += routes.map do |r|
+            # Roda adds leading slashes to routes, so we need to do the same
+            "#{'/' unless r.start_with?('/')}#{r}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/instrumentation.rb

@@ -0,0 +1,68 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      INSTRUMENTATION_NAME = 'Roda'
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_rack_app_with_tracing
+        unless NewRelic::Agent.config[:disable_roda_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            self.use middleware_class
+          end
+        end
+        yield
+      end
+
+      # Roda makes use of Rack, so we can get params from the request object
+      def rack_request_params
+        begin
+          @_request.params
+        rescue => e
+          NewRelic::Agent.logger.debug('Failed to get params from Rack request.', e)
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def _roda_handle_main_route_with_tracing(*args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        perform_action_with_newrelic_trace(
+          category: :roda,
+          name: ::NewRelic::Agent::Instrumentation::Roda::TransactionNamer.transaction_name(request),
+          params: ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, rack_request_params)
+        ) do
+          yield
+        end
+      end
+
+      def do_not_trace?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :routes)
+      end
+
+      def ignore_apdex?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :apdex)
+      end
+
+      def ignore_enduser?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :enduser)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/prepend.rb

@@ -0,0 +1,24 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+      def _roda_handle_main_route(*args)
+        _roda_handle_main_route_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+        def build_rack_app
+          build_rack_app_with_tracing { super }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -0,0 +1,29 @@
+# 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 Instrumentation
+      module Roda
+        module TransactionNamer
+          extend self
+
+          REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
+
+          def transaction_name(request)
+            path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
+            name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
+            name = NewRelic::ROOT if name.empty?
+            name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
+
+            name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Roda transaction name")
+            ::NewRelic::Agent::UNKNOWN_METRIC
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda.rb

@@ -0,0 +1,36 @@
+# 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_relative 'roda/instrumentation'
+require_relative 'roda/roda_transaction_namer'
+require_relative 'roda/ignorer'
+
+DependencyDetection.defer do
+  named :roda
+
+  depends_on do
+    defined?(Roda) &&
+      Gem::Version.new(Roda::RodaVersion) >= Gem::Version.new('3.19.0') &&
+      Roda::RodaPlugins::Base::ClassMethods.private_method_defined?(:build_rack_app) &&
+      Roda::RodaPlugins::Base::InstanceMethods.method_defined?(:_roda_handle_main_route)
+  end
+
+  executes do
+    require_relative '../../rack/agent_hooks'
+    require_relative '../../rack/browser_monitoring'
+
+    NewRelic::Agent.logger.info('Installing Roda instrumentation')
+
+    if use_prepend?
+      require_relative 'roda/prepend'
+      prepend_instrument Roda.singleton_class, NewRelic::Agent::Instrumentation::Roda::Build::Prepend
+      prepend_instrument Roda, NewRelic::Agent::Instrumentation::Roda::Prepend
+    else
+      require_relative 'roda/chain'
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Build::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Chain
+    end
+    Roda.class_eval { extend NewRelic::Agent::Instrumentation::Roda::Ignorer }
+  end
+end

data/lib/new_relic/agent/instrumentation/sequel.rb

@@ -11,8 +11,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-      !NewRelic::Agent.config[:disable_database_instrumentation]
+    !NewRelic::Agent.config[:disable_sequel_instrumentation]
   end
 
   def supported_sequel_version?
@@ -27,21 +26,21 @@ DependencyDetection.defer do
       NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
       if Sequel::Database.respond_to?(:extension)
-        Sequel::Database.extension(:newrelic_instrumentation)
+        Sequel::Database.extension(:new_relic_instrumentation)
       else
-        NewRelic::Agent.logger.info("Detected Sequel version %s." % [Sequel::VERSION])
-        NewRelic::Agent.logger.info("Please see additional documentation: " +
-          "https://newrelic.com/docs/ruby/sequel-instrumentation")
+        NewRelic::Agent.logger.info('Detected Sequel version %s.' % [Sequel::VERSION])
+        NewRelic::Agent.logger.info('Please see additional documentation: ' +
+          'https://docs.newrelic.com/docs/apm/agents/ruby-agent/frameworks/sequel-instrumentation/')
       end
 
       Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
-        db.extension(:newrelic_instrumentation)
+        db.extension(:new_relic_instrumentation)
       end
 
-      Sequel::Model.plugin(:newrelic_instrumentation) if defined?(Sequel::Model)
+      Sequel::Model.plugin(:new_relic_instrumentation) if defined?(Sequel::Model)
     else
 
-      NewRelic::Agent.logger.info("Sequel instrumentation requires at least version 3.37.0.")
+      NewRelic::Agent.logger.info('Sequel instrumentation requires at least version 3.37.0.')
 
     end
   end

data/lib/new_relic/agent/instrumentation/sequel_helper.rb

@@ -9,22 +9,22 @@ module NewRelic
         extend self
 
         # Fallback if the product cannot be determined
-        DEFAULT_PRODUCT_NAME = "Sequel".freeze
+        DEFAULT_PRODUCT_NAME = 'Sequel'.freeze
 
         # A Sequel adapter is called an "adapter_scheme" and can be accessed from
         # the database:
         #
         #   DB.adapter_scheme
         PRODUCT_NAMES = {
-          :ibmdb => "IBMDB2",
-          :firebird => "Firebird",
-          :informix => "Informix",
-          :jdbc => "JDBC",
-          :mysql => "MySQL",
-          :mysql2 => "MySQL",
-          :oracle => "Oracle",
-          :postgres => "Postgres",
-          :sqlite => "SQLite"
+          :ibmdb => 'IBMDB2',
+          :firebird => 'Firebird',
+          :informix => 'Informix',
+          :jdbc => 'JDBC',
+          :mysql => 'MySQL',
+          :mysql2 => 'MySQL',
+          :oracle => 'Oracle',
+          :postgres => 'Postgres',
+          :sqlite => 'SQLite'
         }.freeze
 
         def product_name_from_adapter(adapter)

data/lib/new_relic/agent/instrumentation/sidekiq/client.rb

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation::Sidekiq
   class Client
     include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
 
+    INSTRUMENTATION_NAME = 'SidekiqClient'
+
     def call(_worker_class, job, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
       yield
     end

data/lib/new_relic/agent/instrumentation/sidekiq/extensions/delayed_class.rb

@@ -23,7 +23,7 @@ if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
         :category => 'OtherTransaction/SidekiqJob'
       }
     rescue => e
-      NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+      NewRelic::Agent.logger.error('Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass', e)
       NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
     end
   end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -7,9 +7,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
 
+    ATTRIBUTE_BASE_NAMESPACE = 'sidekiq.args'
+    ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+    ATTRIBUTE_JOB_NAMESPACE = :"job.#{ATTRIBUTE_BASE_NAMESPACE}"
+    INSTRUMENTATION_NAME = 'SidekiqServer'
+
     # Client middleware has additional parameters, and our tests use the
     # middleware client-side to work inline.
     def call(worker, msg, queue, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       trace_args = if worker.respond_to?(:newrelic_trace_args)
         worker.newrelic_trace_args(msg, queue)
       else
@@ -18,10 +25,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
       trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
 
       perform_action_with_newrelic_trace(trace_args) do
-        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-          NewRelic::Agent::AttributeFilter::DST_NONE)
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+          NewRelic::Agent::AttributePreFiltering.pre_filter(msg['args'], self.class.nr_attribute_options),
+          ATTRIBUTE_JOB_NAMESPACE,
+          NewRelic::Agent::AttributeFilter::DST_NONE
+        )
+
+        if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
+          ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other')
+        end
 
-        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
         yield
       end
     end
@@ -33,5 +46,15 @@ module NewRelic::Agent::Instrumentation::Sidekiq
         :category => 'OtherTransaction/SidekiqJob'
       }
     end
+
+    def self.nr_attribute_options
+      @nr_attribute_options ||= begin
+        ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+          pattern =
+            NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_BASE_NAMESPACE}.#{type}")
+          opts[type] = pattern if pattern
+        end.merge(attribute_namespace: ATTRIBUTE_JOB_NAMESPACE)
+      end
+    end
   end
 end