newrelic_rpm 9.23.0 → 10.0.0

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

@@ -13,17 +13,15 @@ module NewRelic
           /^NEW_RELIC_METADATA_/ # read by NewRelic::Agent::Connect::RequestBuilder
         ]
 
-        attr_accessor :alias_map, :type_map
+        attr_accessor :alias_map
 
         def initialize
           set_log_file
           set_config_file
 
           @alias_map = {}
-          @type_map = {}
 
           DEFAULTS.each do |config_setting, value|
-            self.type_map[config_setting] = value[:type]
             set_aliases(config_setting, value)
           end
 
@@ -70,43 +68,14 @@ module NewRelic
           nr_env_var_keys.each do |key|
             next if SPECIAL_CASE_KEYS.any? { |pattern| pattern === key.upcase }
 
-            set_value_from_environment_variable(key)
-          end
-        end
-
-        def set_value_from_environment_variable(key)
-          config_key = convert_environment_key_to_config_key(key)
-          set_key_by_type(config_key, key)
-        end
+            config_key = convert_environment_key_to_config_key(key)
 
-        def set_key_by_type(config_key, environment_key)
-          value = ENV[environment_key]
-          type = self.type_map[config_key]
-
-          if type == String
-            self[config_key] = value
-          elsif type == Integer
-            self[config_key] = value.to_i
-          elsif type == Float
-            self[config_key] = value.to_f
-          elsif type == Symbol
-            self[config_key] = value.to_sym
-          elsif type == Array
-            self[config_key] = if DEFAULTS[config_key].key?(:transform)
-              DEFAULTS[config_key][:transform].call(value)
-            else
-              value.split(/\s*,\s*/)
-            end
-          elsif type == NewRelic::Agent::Configuration::Boolean
-            if /false|off|no/i.match?(value)
-              self[config_key] = false
-            elsif !value.nil?
-              self[config_key] = true
+            unless DEFAULTS.key?(config_key) || serverless?
+              ::NewRelic::Agent.logger.info("#{key} does not have a corresponding configuration setting (#{config_key} does not exist).")
+              ::NewRelic::Agent.logger.info('Run `rake newrelic:config:docs` or visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/configuration/ruby-agent-configuration to see a list of available configuration settings.')
             end
-          elsif !serverless?
-            ::NewRelic::Agent.logger.info("#{environment_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
-            ::NewRelic::Agent.logger.info('Run `rake newrelic:config:docs` or visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/configuration/ruby-agent-configuration to see a list of available configuration settings.')
-            self[config_key] = value
+
+            self[config_key] = ENV[key]
           end
         end
 

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

@@ -9,7 +9,6 @@ require 'new_relic/agent/configuration/default_source'
 require 'new_relic/agent/configuration/server_source'
 require 'new_relic/agent/configuration/environment_source'
 require 'new_relic/agent/configuration/high_security_source'
-require 'new_relic/agent/configuration/security_policy_source'
 
 module NewRelic
   module Agent
@@ -17,6 +16,28 @@ module NewRelic
       class Manager
         DEPENDENCY_DETECTION_VALUES = %i[prepend chain unsatisfied].freeze
 
+        BOOLEAN_MAP = {
+          'true' => true,
+          'yes' => true,
+          'on' => true,
+          'false' => false,
+          'no' => false,
+          'off' => false
+        }.freeze
+
+        INSTRUMENTATION_VALUES = %w[chain prepend unsatisfied]
+        NUMERIC_TYPES = [Integer, Float]
+        STRINGLIKE_TYPES = [String, Symbol]
+
+        TYPE_COERCIONS = {Integer => {pattern: /^\d+$/, proc: proc { |s| s.to_i }},
+                          Float => {pattern: /^\d+\.\d+$/, proc: proc { |s| s.to_f }},
+                          Array => {proc: proc { |s| s.split(/\s*,\s*/) }},
+                          Hash => {proc: proc { |s| s.split(/\s*,\s*/).each_with_object({}) { |i, h| k, v = i.split(/\s*=\s*/); h[k] = v } }},
+                          NewRelic::Agent::Configuration::Boolean => {pattern: /^(?:#{BOOLEAN_MAP.keys.join('|')})$/,
+                                                                      proc: proc { |s| BOOLEAN_MAP[s] }}}.freeze
+
+        USER_CONFIG_CLASSES = [NewRelic::Agent::Configuration::EnvironmentSource, NewRelic::Agent::Configuration::YamlSource]
+
         # Defining these explicitly saves object allocations that we incur
         # if we use Forwardable and def_delegators.
         def [](key)
@@ -48,7 +69,6 @@ module NewRelic
 
         def remove_config_type(sym)
           source = case sym
-          when :security_policy then @security_policy_source
           when :high_security then @high_security_source
           when :environment then @environment_source
           when :server then @server_source
@@ -62,7 +82,6 @@ module NewRelic
 
         def remove_config(source)
           case source
-          when SecurityPolicySource then @security_policy_source = nil
           when HighSecuritySource then @high_security_source = nil
           when EnvironmentSource then @environment_source = nil
           when ServerSource then @server_source = nil
@@ -85,7 +104,6 @@ module NewRelic
           invoke_callbacks(:add, source)
 
           case source
-          when SecurityPolicySource then @security_policy_source = source
           when HighSecuritySource then @high_security_source = source
           when EnvironmentSource then @environment_source = source
           when ServerSource then @server_source = source
@@ -116,74 +134,139 @@ module NewRelic
             next unless config
 
             accessor = key.to_sym
+            next unless config.has_key?(accessor)
 
-            if config.has_key?(accessor)
-              begin
-                return evaluate_and_apply_transformations(accessor, config[accessor])
-              rescue
-                next
-              end
+            begin
+              return evaluate_and_apply_transformations(accessor, config[accessor], config_category(config.class))
+            rescue
+              next
             end
           end
 
           nil
         end
 
-        def evaluate_procs(value)
-          if value.respond_to?(:call)
-            instance_eval(&value)
-          else
-            value
-          end
-        end
+        def config_category(klass)
+          return :user if USER_CONFIG_CLASSES.include?(klass)
+          return :test if [DottedHash, Hash].include?(klass)
+          return :manual if klass == ManualSource
 
-        def evaluate_and_apply_transformations(key, value)
-          evaluated = evaluate_procs(value)
-          default = enforce_allowlist(key, evaluated)
-          return default if default
+          return :nr
+        end
 
-          boolean = enforce_boolean(key, value)
-          evaluated = boolean if [true, false].include?(boolean)
+        def evaluate_and_apply_transformations(key, value, category)
+          evaluated = value.respond_to?(:call) ? instance_eval(&value) : value
+          evaluated = type_coerce(key, evaluated, category)
+          evaluated = enforce_allowlist(key, evaluated)
 
           apply_transformations(key, evaluated)
         end
 
-        def apply_transformations(key, value)
-          if transform = transform_from_default(key)
-            begin
-              transform.call(value)
-            rescue => e
-              NewRelic::Agent.logger.error("Error applying transformation for #{key}, pre-transform value was: #{value}.", e)
-              raise e
-            end
-          else
-            value
+        def boolean?(type, value)
+          return false unless type == NewRelic::Agent::Configuration::Boolean
+
+          value.class == TrueClass || value.class == FalseClass
+        end
+
+        # auto-instrumentation configuration params can be symbols or strings
+        # and unless we want to refactor the configuration hash to support both
+        # types, we handle the special case here
+        def instrumentation?(type, value)
+          return false unless type == String || type == Symbol
+          return true if INSTRUMENTATION_VALUES.include?(value.to_s)
+
+          false
+        end
+
+        def handle_nil_type(key, value, category)
+          return value if %i[manual test].include?(category)
+
+          # TODO: identify all config params such as :web_transactions_apdex
+          #       that can exist in the @config hash without having an entry
+          #       in the DEFAULTS hash. then warn here when a key is in play
+          #       that is not on that allowlist. for now, just permit any key
+          #       and return the value.
+          #       https://github.com/newrelic/newrelic-ruby-agent/issues/3340
+          default_without_warning(key) || value
+        end
+
+        # permit an int to be supplied for a float based param and vice versa
+        def numeric_conversion(value)
+          value.is_a?(Integer) ? value.to_f : value.round
+        end
+
+        # permit a symbol to be supplied for a string based param and vice versa
+        def string_conversion(value)
+          value.is_a?(Symbol) ? value.to_s : value.to_sym
+        end
+
+        def type_coerce(key, value, category)
+          return validate_nil(key, category) if value.nil?
+
+          type = DEFAULTS.dig(key, :type)
+          return handle_nil_type(key, value, category) unless type
+          return value if value.is_a?(type) || boolean?(type, value) || instrumentation?(type, value)
+          return numeric_conversion(value) if NUMERIC_TYPES.include?(type) && NUMERIC_TYPES.include?(value.class)
+          return string_conversion(value) if STRINGLIKE_TYPES.include?(type) && STRINGLIKE_TYPES.include?(value.class)
+
+          # convert bool to string for regex usage and bool hash lookup
+          value = value.to_s if type == Boolean
+          if value.class != String
+            return value if category == :test || likely_transformed_already?(key, value)
+
+            return default_with_warning(key, value, "Expected to receive a value of type #{type} but " \
+                                        "received #{value.class}.")
+          end
+
+          pattern = TYPE_COERCIONS.dig(type, :pattern)
+          if pattern && value !~ pattern
+            return default_with_warning(key, value, "Expected to receive a value of type #{type} matching " \
+              "pattern '#{pattern}'.")
           end
+
+          procedure = TYPE_COERCIONS.dig(type, :proc)
+          return value unless procedure
+
+          procedure.call(value)
         end
 
-        def enforce_allowlist(key, value)
-          return unless allowlist = default_source.allowlist_for(key)
-          return if allowlist.include?(value)
+        def likely_transformed_already?(key, value)
+          DEFAULTS.dig(key, :transformed_type) == value.class
+        end
 
-          default = default_source.default_for(key)
-          NewRelic::Agent.logger.warn "Invalid value '#{value}' for #{key}, applying default value of '#{default}'"
+        def default_with_warning(key, value, msg)
+          default = default_without_warning(key)
+          NewRelic::Agent.logger.warn "Received an invalid '#{value}' value for the '#{key}' configuration " \
+            "parameter! #{msg} Using the default value of '#{default}'."
           default
         end
 
-        def enforce_boolean(key, value)
-          type = default_source.value_from_defaults(key, :type)
-          return unless type == Boolean
+        def default_without_warning(key)
+          default = DEFAULTS.dig(key, :default)
+          default.respond_to?(:call) ? default.call : default
+        end
 
-          bool_value = default_source.boolean_for(key, value)
-          return bool_value unless bool_value.nil?
+        def validate_nil(key, category)
+          return if DEFAULTS.dig(key, :allow_nil) || category == :test # tests are free to specify nil
+          return default_without_warning(key) unless category == :user # only user supplied config raises a warning
 
-          default = default_source.default_for(key)
-          NewRelic::Agent.logger.warn "Invalid value '#{value}' for #{key}, applying default value of '#{default}'"
-          default
+          default_with_warning(key, nil, 'Nil values are not permitted for the parameter.')
         end
 
-        def transform_from_default(key)
-          default_source.transform_for(key)
+        def apply_transformations(key, value)
+          return value unless transform = default_source.transform_for(key)
+
+          transform.call(value)
+        rescue => e
+          default_with_warning(key, value, "Error encountered while applying transformation: >>#{e}<<")
+        end
+
+        def enforce_allowlist(key, value)
+          return value unless allowlist = default_source.allowlist_for(key)
+          return value if allowlist.include?(value)
+
+          default_with_warning(key, value, 'Expected to receive a value found on the following list: ' \
+                               ">>#{allowlist}<<, but received '#{value}'.")
         end
 
         def default_source
@@ -197,17 +280,19 @@ module NewRelic
 
         def invoke_callbacks(direction, source)
           return unless source
+          return if source.respond_to?(:empty?) && source.empty?
 
           source.keys.each do |key|
+            next unless @callbacks.key?(key)
+
             begin
-              # we need to evaluate and apply transformations for the value to deal with procs as values
-              # this is usually done by the fetch method when accessing config, however the callbacks bypass that
-              evaluated_cache = evaluate_and_apply_transformations(key, @cache[key])
-              evaluated_source = evaluate_and_apply_transformations(key, source[key])
-            rescue
+              evaluated_source = evaluate_and_apply_transformations(key, source[key], config_category(source.class))
+            rescue => e
+              NewRelic::Agent.logger.warn("Error evaluating callback for direction '#{direction}' with key '#{key}': #{e}")
               next
             end
 
+            evaluated_cache = @cache[key]
             if evaluated_cache != evaluated_source
               @callbacks[key].each do |proc|
                 if direction == :add
@@ -256,8 +341,8 @@ module NewRelic
         end
 
         def apply_mask(hash)
-          MASK_DEFAULTS \
-            .select { |_, proc| proc.call } \
+          MASK_DEFAULTS
+            .select { |_, proc| proc.call }
             .each { |key, _| hash.delete(key) }
           hash
         end
@@ -379,7 +464,6 @@ module NewRelic
 
         # Generally only useful during initial construction and tests
         def reset_to_defaults
-          @security_policy_source = nil
           @high_security_source = nil
           @environment_source = EnvironmentSource.new
           log_config(:add, @environment_source) # this is the only place the EnvironmentSource is ever created, so we should log it
@@ -433,7 +517,6 @@ module NewRelic
         end
 
         def delete_all_configs_for_testing
-          @security_policy_source = nil
           @high_security_source = nil
           @environment_source = nil
           @server_source = nil
@@ -454,8 +537,7 @@ module NewRelic
         private
 
         def config_stack
-          stack = [@security_policy_source,
-            @high_security_source,
+          stack = [@high_security_source,
             @environment_source,
             @server_source,
             @manual_source,

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

@@ -0,0 +1,54 @@
+# 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 Configuration
+      # Handles validation for the `distributed_tracing.sampler.*` configs
+      # Focuses on validating the trace id ratio based ratios
+      module SamplerConfigValidator
+        @sampler_strategy_warnings = {}
+
+        class << self
+          def validate_sampling_ratio(ratio)
+            return nil if ratio.nil?
+            return nil unless valid_ratio?(ratio)
+
+            ratio
+          end
+
+          def validate_sampler_strategy_with_ratio(strategy_key, ratio_key)
+            proc do |strategy|
+              next strategy unless strategy == 'trace_id_ratio_based'
+
+              ratio = NewRelic::Agent.config[ratio_key]
+
+              next strategy if valid_ratio?(ratio)
+
+              unless @sampler_strategy_warnings[strategy_key]
+                NewRelic::Agent.logger.warn(
+                  "Invalid or missing ratio for #{ratio_key} (value: #{ratio.inspect}). " \
+                  "Falling back to 'adaptive' for #{strategy_key}."
+                )
+
+                @sampler_strategy_warnings[strategy_key] = true
+              end
+
+              'adaptive'
+            end
+          end
+
+          def valid_ratio?(ratio)
+            ratio.is_a?(Float) && (0.0..1.0).cover?(ratio)
+          end
+
+          # used for testing
+          def reset_warnings!
+            @sampler_strategy_warnings = {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,6 @@ module NewRelic
           'browser_monitoring.debug',
           'browser_monitoring.loader',
           'browser_monitoring.loader_version',
-          'cross_process_id',
           'data_report_period',
           'encoding_key',
           'entity_guid',

data/lib/new_relic/agent/connect/response_handler.rb

@@ -23,10 +23,7 @@ module NewRelic
 
           @agent.agent_id = config_data['agent_run_id']
 
-          security_policies = config_data.delete('security_policies')
-
           add_server_side_config(config_data)
-          add_security_policy_config(security_policies) if security_policies
 
           @agent.transaction_rules = RulesEngine.create_transaction_rules(config_data)
           @agent.stats_engine.metric_rules = RulesEngine.create_metric_rules(config_data)
@@ -44,14 +41,6 @@ module NewRelic
           server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data, @config)
           @config.replace_or_add_config(server_config)
         end
-
-        def add_security_policy_config(security_policies)
-          ::NewRelic::Agent.logger.info('Installing security policies')
-          security_policy_source = NewRelic::Agent::Configuration::SecurityPolicySource.new(security_policies)
-          @config.replace_or_add_config(security_policy_source)
-          # drop data collected before applying security policies
-          @agent.drop_buffered_data
-        end
       end
     end
   end

data/lib/new_relic/agent/datastores.rb

@@ -85,13 +85,12 @@ module NewRelic
       #   statement-level metrics (i.e. table or model name)
       #
       # @param [Proc,#call] callback proc or other callable to invoke after
-      #   running the datastore block. Receives three arguments: result of the
-      #   yield, the most specific (scoped) metric name, and elapsed time of the
-      #   call. An example use is attaching SQL to Transaction Traces at the end
+      #   running the datastore block. Receives one argument: result of the
+      #   yield. An example use is attaching SQL to Transaction Traces at the end
       #   of a wrapped datastore call.
       #
-      #     callback = Proc.new do |result, metrics, elapsed|
-      #       NewRelic::Agent::Datastores.notice_sql(query, metrics, elapsed)
+      #     callback = Proc.new do |result|
+      #       NewRelic::Agent::Datastores.notice_sql(query)
       #     end
       #
       #     NewRelic::Agent::Datastores.wrap("FauxDB", "find", "items", callback) do
@@ -107,6 +106,11 @@ module NewRelic
       # @api public
       #
       def self.wrap(product, operation, collection = nil, callback = nil)
+        NewRelic::Agent.logger.warn('The NewRelic::Agent::Datastores.wrap method is changing. ' \
+          'In a future major version, proc will only accept a single argument, the result of the yield. ' \
+          'The scoped metric name and elapsed arguments will be removed, as they are being removed from the ' \
+          'Datastores.notice_sql method. The scoped metric name and elapsed values are derived from the ' \
+          'current segment when the wrap yields.')
         NewRelic::Agent.record_api_supportability_metric(:wrap)
 
         return yield unless operation
@@ -138,19 +142,13 @@ module NewRelic
       # If you are recording non-SQL data, please use {notice_statement}
       # instead.
       #
-      #   NewRelic::Agent::Datastores.notice_sql(query, metrics, elapsed)
+      #   NewRelic::Agent::Datastores.notice_sql(query)
       #
       # @param [String] query the SQL text to be captured. Note that depending
       #   on user settings, this string will be run through obfuscation, but
       #   some dialects of SQL (or non-SQL queries) are not guaranteed to be
       #   properly obfuscated by these routines!
       #
-      # @param [String] scoped_metric The most specific metric relating to this
-      #   query. Typically the result of
-      #   NewRelic::Agent::Datastores::MetricHelper#metrics_for
-      #
-      # @param [Float] elapsed the elapsed time during query execution
-      #
       # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING QUERY TEXT!
       #   New Relic's Transaction Tracing and Slow SQL features will
       #   attempt to apply obfuscation to the passed queries, but it is possible
@@ -159,7 +157,7 @@ module NewRelic
       #
       # @api public
       #
-      def self.notice_sql(query, scoped_metric, elapsed)
+      def self.notice_sql(query)
         NewRelic::Agent.record_api_supportability_metric(:notice_sql)
 
         if (txn = Tracer.current_transaction) && (segment = txn.current_segment) && segment.respond_to?(:notice_sql)
@@ -176,12 +174,10 @@ module NewRelic
       # ensure that user information is obfuscated if the agent setting
       # `transaction_tracer.record_sql` is set to `obfuscated`
       #
-      #   NewRelic::Agent::Datastores.notice_statement("key", elapsed)
+      #   NewRelic::Agent::Datastores.notice_statement("key")
       #
       # @param [String] statement text of the statement to capture.
       #
-      # @param [Float] elapsed the elapsed time during query execution
-      #
       # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING STATEMENTS!
       #   This method will properly ignore statements when the user has turned
       #   off capturing queries, but it is not able to obfuscate arbitrary data!
@@ -191,7 +187,7 @@ module NewRelic
       #
       # @api public
       #
-      def self.notice_statement(statement, elapsed)
+      def self.notice_statement(statement)
         NewRelic::Agent.record_api_supportability_metric(:notice_statement)
 
         # Settings may change eventually, but for now we follow the same

data/lib/new_relic/agent/distributed_tracing.rb

@@ -2,9 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require_relative 'distributed_tracing/cross_app_payload'
-require_relative 'distributed_tracing/cross_app_tracing'
-
 require_relative 'distributed_tracing/distributed_trace_transport_type'
 require_relative 'distributed_tracing/distributed_trace_payload'
 

data/lib/new_relic/agent/health_check.rb

@@ -93,6 +93,7 @@ module NewRelic
 
       def contents
         <<~CONTENTS
+          entity_guid: #{NewRelic::Agent.config[:entity_guid]}
           healthy: #{@status[:healthy]}
           status: #{@status[:message]}#{last_error}
           start_time_unix_nano: #{@start_time}

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

@@ -71,7 +71,7 @@ module NewRelic
         end
 
         def self.run_in_trace(job, block, event)
-          trace_execution_scoped("ActiveJob/#{adapter.sub(/^ActiveJob::/, '')}/Queue/#{event}/Named/#{job.queue_name}",
+          trace_execution_scoped("ActiveJob/#{adapter.sub(/^ActiveJob::/, '')}/Queue/#{event}/Named/#{job.queue_name}/#{job.class}",
             code_information: code_information_for_job(job)) do
             block.call
           end

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

@@ -22,8 +22,9 @@ module NewRelic
           job = payload[:job] || payload[:jobs].first
 
           queue = job.queue_name
+          job_class = job.class.name.include?('::') ? job.class.name[job.class.name.rindex('::') + 2..-1] : job.class.name
           method = method_from_name(name)
-          "Ruby/ActiveJob/#{queue}/#{method}"
+          "Ruby/ActiveJob/#{queue}/#{job_class}/#{method}"
         end
 
         PATTERN = /\A([^\.]+)\.active_job\z/

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

@@ -99,10 +99,7 @@ module NewRelic
         # convert vendor (makara, etc.) wrapper names to their bare names
         # ex: postgresql_makara -> postgresql
         def bare_adapter_name(adapter_name)
-          # TODO: OLD RUBIES - RUBY_VERSION < 2.5
-          # With Ruby 2.5+ we could use #delete_suffix instead of #chomp for a
-          # potential speed boost
-          return adapter_name.chomp(MAKARA_SUFFIX) if adapter_name&.end_with?(MAKARA_SUFFIX)
+          return adapter_name.delete_suffix(MAKARA_SUFFIX) if adapter_name&.end_with?(MAKARA_SUFFIX)
 
           adapter_name
         end

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

@@ -7,6 +7,8 @@ require 'new_relic/agent/instrumentation/active_support_subscriber'
 DependencyDetection.defer do
   named :active_support
 
+  EVENT_NAMES_PARAMETER = :'instrumentation.active_support_notifications.active_support_events'
+
   depends_on do
     !NewRelic::Agent.config[:disable_active_support]
   end
@@ -16,12 +18,17 @@ DependencyDetection.defer do
       !NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.subscribed?
   end
 
+  depends_on do
+    !NewRelic::Agent.config[EVENT_NAMES_PARAMETER].empty?
+  end
+
   executes do
     NewRelic::Agent.logger.info('Installing ActiveSupport instrumentation')
   end
 
   executes do
-    ActiveSupport::Notifications.subscribe(/\.active_support$/,
+    event_names = NewRelic::Agent.config[EVENT_NAMES_PARAMETER].map { |n| Regexp.escape(n) }.join('|')
+    ActiveSupport::Notifications.subscribe(/\A(?:#{event_names})\z/,
       NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.new)
   end
 end