newrelic_rpm 8.2.0 → 9.0.0

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/configuration/dotted_hash'
 
@@ -26,9 +26,10 @@ module NewRelic
           def change_setting(policies, option, new_value)
             current_value = Agent.config[option]
             unless current_value == new_value
-              NewRelic::Agent.logger.info \
+              NewRelic::Agent.logger.info( \
                 "Setting changed: {#{option}: from #{current_value} " \
                 "to #{new_value}}. Source: SecurityPolicySource"
+              )
             end
             policies[option] = new_value
           end
@@ -52,150 +53,143 @@ module NewRelic
         SECURITY_SETTINGS_MAP = {
           "record_sql" => [
             {
-              option:         :'transaction_tracer.record_sql',
-              supported:      true,
-              enabled_fn:     method(:record_sql_enabled?),
+              option: :'transaction_tracer.record_sql',
+              supported: true,
+              enabled_fn: method(:record_sql_enabled?),
               disabled_value: 'off',
-              permitted_fn:   proc { |policies|
+              permitted_fn: proc { |policies|
                 change_setting(policies, :'transaction_tracer.record_sql', 'obfuscated')
               }
             },
             {
-              option:         :'slow_sql.record_sql',
-              supported:      true,
-              enabled_fn:     method(:record_sql_enabled?),
+              option: :'slow_sql.record_sql',
+              supported: true,
+              enabled_fn: method(:record_sql_enabled?),
               disabled_value: 'off',
-              permitted_fn:   proc { |policies|
+              permitted_fn: proc { |policies|
                 change_setting(policies, :'slow_sql.record_sql', 'obfuscated')
               }
             },
             {
-              option:         :'mongo.capture_queries',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'mongo.capture_queries',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   proc{ |policies|
+              permitted_fn: proc { |policies|
                 change_setting(policies, :'mongo.obfuscate_queries', true)
               }
             },
             {
-              option:         :'transaction_tracer.record_redis_arguments',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'elasticsearch.capture_queries',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   nil
+              permitted_fn: proc { |policies|
+                change_setting(policies, :'elasticsearch.obfuscate_queries', true)
+              }
+            },
+            {
+              option: :'transaction_tracer.record_redis_arguments',
+              supported: true,
+              enabled_fn: method(:enabled?),
+              disabled_value: false,
+              permitted_fn: nil
             }
           ],
           "attributes_include" => [
             {
-              option:         :'attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'transaction_tracer.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'transaction_tracer.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'transaction_events.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'transaction_events.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'error_collector.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'error_collector.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'browser_monitoring.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'browser_monitoring.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'span_events.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'span_events.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             },
             {
-              option:         :'transaction_segments.attributes.include',
-              supported:      true,
-              enabled_fn:     method(:not_empty?),
+              option: :'transaction_segments.attributes.include',
+              supported: true,
+              enabled_fn: method(:not_empty?),
               disabled_value: [],
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ],
           "allow_raw_exception_messages" => [
             {
-              option:         :'strip_exception_messages.enabled',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'strip_exception_messages.enabled',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ],
           "custom_events" => [
             {
-              option:         :'custom_insights_events.enabled',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'custom_insights_events.enabled',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ],
           "custom_parameters" => [
             {
-              option:         :'custom_attributes.enabled',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'custom_attributes.enabled',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ],
           "custom_instrumentation_editor" => [
             {
-              option:         nil,
-              supported:      false,
-              enabled_fn:     nil,
+              option: nil,
+              supported: false,
+              enabled_fn: nil,
               disabled_value: nil,
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ],
           "message_parameters" => [
             {
-              option:         :'message_tracer.segment_parameters.enabled',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
-              disabled_value: false,
-              permitted_fn:   nil
-            }
-          ],
-          "job_arguments" => [
-            {
-              option:         :'resque.capture_params',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
-              disabled_value: false,
-              permitted_fn:   nil
-            },
-            {
-              option:         :'sidekiq.capture_params',
-              supported:      true,
-              enabled_fn:     method(:enabled?),
+              option: :'message_tracer.segment_parameters.enabled',
+              supported: true,
+              enabled_fn: method(:enabled?),
               disabled_value: false,
-              permitted_fn:   nil
+              permitted_fn: nil
             }
           ]
         }
@@ -211,6 +205,7 @@ module NewRelic
           security_policies.inject({}) do |settings, (policy_name, policy_settings)|
             SECURITY_SETTINGS_MAP[policy_name].each do |policy|
               next unless policy[:supported]
+
               if policy_settings[ENABLED]
                 if policy[:enabled_fn].call(policy[:option])
                   if permitted_fn = policy[:permitted_fn]
@@ -218,15 +213,17 @@ module NewRelic
                   end
                 else
                   config_source = Agent.config.source(policy[:option]).class.name.split(COLON_COLON).last
-                  NewRelic::Agent.logger.info \
+                  NewRelic::Agent.logger.info( \
                     "Setting applied: {#{policy[:option]}: #{policy[:disabled_value]}}. " \
                     "Source: #{config_source}"
+                  )
                 end
               else
-                settings[policy[:option]] =  policy[:disabled_value]
-                NewRelic::Agent.logger.info \
+                settings[policy[:option]] = policy[:disabled_value]
+                NewRelic::Agent.logger.info( \
                   "Setting applied: {#{policy[:option]}: #{policy[:disabled_value]}}. " \
                   "Source: SecurityPolicySource"
+                )
               end
             end
             settings

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
@@ -33,7 +33,7 @@ module NewRelic
           "trusted_account_key"
         ]
 
-        def initialize(connect_reply, existing_config={})
+        def initialize(connect_reply, existing_config = {})
           merged_settings = {}
 
           merge_top_level_keys(merged_settings, connect_reply)
@@ -76,33 +76,34 @@ module NewRelic
         end
 
         EVENT_HARVEST_CONFIG_SUPPORTABILITY_METRIC_NAMES = {
-          :'analytics_events.max_samples_stored' => 'Supportability/EventHarvest/AnalyticEventData/HarvestLimit',
+          :'transaction_events.max_samples_stored' => 'Supportability/EventHarvest/AnalyticEventData/HarvestLimit',
           :'custom_insights_events.max_samples_stored' => 'Supportability/EventHarvest/CustomEventData/HarvestLimit',
-          :'error_collector.max_event_samples_stored'=> 'Supportability/EventHarvest/ErrorEventData/HarvestLimit',
+          :'error_collector.max_event_samples_stored' => 'Supportability/EventHarvest/ErrorEventData/HarvestLimit',
+          :'application_logging.forwarding.max_samples_stored' => 'Supportability/EventHarvest/LogEventData/HarvestLimit',
           :'span_events.max_samples_stored' => 'Supportability/SpanEvent/Limit',
           :event_report_period => 'Supportability/EventHarvest/ReportPeriod',
-          :'event_report_period.span_event_data' => 'Supportability/SpanEvent/ReportPeriod',
+          :'event_report_period.span_event_data' => 'Supportability/SpanEvent/ReportPeriod'
         }
 
         def add_event_harvest_config(merged_settings, connect_reply)
-          return unless event_harvest_config_is_valid connect_reply
+          return unless event_harvest_config_is_valid(connect_reply)
 
           event_harvest_config = EventHarvestConfig.to_config_hash(connect_reply)
           EVENT_HARVEST_CONFIG_SUPPORTABILITY_METRIC_NAMES.each do |config_key, metric_name|
-            NewRelic::Agent.record_metric metric_name, event_harvest_config[config_key]
+            NewRelic::Agent.record_metric(metric_name, event_harvest_config[config_key])
           end
 
-          merged_settings.merge! event_harvest_config
+          merged_settings.merge!(event_harvest_config)
         end
 
-        def event_harvest_config_is_valid connect_reply
+        def event_harvest_config_is_valid(connect_reply)
           event_harvest_config = connect_reply['event_harvest_config']
 
           if event_harvest_config.nil? \
               || event_harvest_config['harvest_limits'].values.min < 0 \
               || (event_harvest_config['report_period_ms'] / 1000) <= 0
-            NewRelic::Agent.logger.warn "Invalid event harvest config found " \
-                "in connect response; using default event report period."
+            NewRelic::Agent.logger.warn("Invalid event harvest config found " \
+                "in connect response; using default event report period.")
             false
           else
             true
@@ -133,19 +134,19 @@ module NewRelic
         # do the real enforcement there.
         def apply_feature_gates(merged_settings, connect_reply, existing_config)
           gated_features = {
-            'transaction_tracer.enabled'     => 'collect_traces',
-            'slow_sql.enabled'               => 'collect_traces',
-            'error_collector.enabled'        => 'collect_errors',
-            'analytics_events.enabled'       => 'collect_analytics_events',
+            'transaction_tracer.enabled' => 'collect_traces',
+            'slow_sql.enabled' => 'collect_traces',
+            'error_collector.enabled' => 'collect_errors',
+            'transaction_events.enabled' => 'collect_analytics_events',
             'custom_insights_events.enabled' => 'collect_custom_events',
             'error_collector.capture_events' => 'collect_error_events',
-            'span_events.enabled'            => 'collect_span_events'
+            'span_events.enabled' => 'collect_span_events'
           }
           gated_features.each do |config_key, gate_key|
             if connect_reply.has_key?(gate_key)
               allowed_by_server = connect_reply[gate_key]
-              requested_value   = ungated_value(config_key, merged_settings, existing_config)
-              effective_value   = (allowed_by_server && requested_value)
+              requested_value = ungated_value(config_key, merged_settings, existing_config)
+              effective_value = (allowed_by_server && requested_value)
               merged_settings[config_key] = effective_value
             end
           end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/configuration/dotted_hash'
 
@@ -13,11 +13,11 @@ module NewRelic
 
         # These are configuration options that have a value of a Hash
         # This is used in YamlSource#dot_flattened prevent flattening these values
-        CONFIG_WITH_HASH_VALUE = ['expected_messages', 'ignore_messages']
+        CONFIG_WITH_HASH_VALUE = %w[expected_messages ignore_messages]
 
         def initialize(path, env)
           @path = path
-          config    = {}
+          config = {}
           @failures = []
 
           # These are needed in process_erb for populating the newrelic.yml via
@@ -34,7 +34,7 @@ module NewRelic
             ::NewRelic::Agent.logger.info("Reading configuration from #{path} (#{Dir.pwd})")
             raw_file = File.read(@file_path)
             erb_file = process_erb(raw_file)
-            config   = process_yaml(erb_file, env, config, @file_path)
+            config = process_yaml(erb_file, env, config, @file_path)
           rescue ScriptError, StandardError => e
             log_failure("Failed to read or parse configuration file at #{path}", e)
           end
@@ -63,8 +63,8 @@ module NewRelic
         end
 
         def warn_missing_config_file(path)
-          based_on        = 'unknown'
-          source          = ::NewRelic::Agent.config.source(:config_path)
+          based_on = 'unknown'
+          source = ::NewRelic::Agent.config.source(:config_path)
           candidate_paths = [path]
 
           case source
@@ -104,10 +104,10 @@ module NewRelic
         def process_yaml(file, env, config, path)
           if file
             confighash = if YAML.respond_to?(:unsafe_load)
-                           YAML.unsafe_load(file)
-                         else 
-                           YAML.load(file)
-                         end
+              YAML.unsafe_load(file)
+            else
+              YAML.load(file)
+            end
 
             unless confighash.key?(env)
               log_failure("Config file at #{path} doesn't include a '#{env}' section!")
@@ -124,6 +124,8 @@ module NewRelic
               config['transaction_tracer']['transaction_threshold'].to_s =~ /apdex_f/i
             # when value is "apdex_f" remove the config and defer to default
             config['transaction_tracer'].delete('transaction_threshold')
+          elsif config['transaction_tracer.transaction_threshold'].to_s =~ /apdex_f/i
+            config.delete('transaction_tracer.transaction_threshold')
           end
         end
 
@@ -135,7 +137,7 @@ module NewRelic
             elsif !config[option].nil? && !is_boolean?(config[option])
               coerced_value = !!(config[option].to_s =~ /yes|on|true/i)
               if !coerced_value
-                log_failure "Unexpected value (#{config[option]}) for '#{option}' in #{@path}"
+                log_failure("Unexpected value (#{config[option]}) for '#{option}' in #{@path}")
               end
               config[option] = coerced_value
             end
@@ -151,9 +153,10 @@ module NewRelic
           messages.each { |message| @failures << message }
         end
 
-        def dot_flattened(nested_hash, names=[], result={})
+        def dot_flattened(nested_hash, names = [], result = {})
           nested_hash.each do |key, val|
-            next if val == nil
+            next if val.nil?
+
             if val.respond_to?(:has_key?) && !CONFIG_WITH_HASH_VALUE.include?(key)
               dot_flattened(val, names + [key], result)
             else

data/lib/new_relic/agent/configuration.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/configuration/dotted_hash'

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/environment_report'
 require 'new_relic/agent/configuration/event_harvest_config'
@@ -8,9 +8,7 @@ require 'new_relic/agent/configuration/event_harvest_config'
 module NewRelic
   module Agent
     module Connect
-
       class RequestBuilder
-
         def initialize(new_relic_service, config, event_harvest_config, environment_report)
           @service = new_relic_service
           @config = config
@@ -18,39 +16,39 @@ module NewRelic
           @environment_report = sanitize_environment_report(environment_report)
         end
 
-
         # Initializes the hash of settings that we send to the
         # server. Returns a literal hash containing the options
         def connect_payload
           {
-            :pid           => $$,
-            :host          => local_host,
-            :display_host  => Agent.config[:'process_host.display_name'],
-            :app_name      => Agent.config[:app_name],
-            :language      => 'ruby',
-            :labels        => Agent.config.parsed_labels,
+            :pid => $$,
+            :host => local_host,
+            :display_host => Agent.config[:'process_host.display_name'],
+            :app_name => Agent.config[:app_name],
+            :language => 'ruby',
+            :labels => Agent.config.parsed_labels,
             :agent_version => NewRelic::VERSION::STRING,
-            :environment   => @environment_report,
-            :metadata      => environment_metadata,
-            :settings      => Agent.config.to_collector_hash,
+            :environment => @environment_report,
+            :metadata => environment_metadata,
+            :settings => Agent.config.to_collector_hash,
             :high_security => Agent.config[:high_security],
-            :utilization   => UtilizationData.new.to_collector_hash,
-            :identifier    => "ruby:#{local_host}:#{Agent.config[:app_name].sort.join(',')}",
+            :utilization => UtilizationData.new.to_collector_hash,
+            :identifier => "ruby:#{local_host}:#{Agent.config[:app_name].sort.join(',')}",
             :event_harvest_config => @event_harvest_config
           }
         end
 
         # We've seen objects in the environment report (Rails.env in
-        # particular) that can't seralize to JSON. Cope with that here and
+        # particular) that can't serialize to JSON. Cope with that here and
         # clear out so downstream code doesn't have to check again.
         def sanitize_environment_report(environment_report)
-          return [] unless @service.valid_to_marshal?(environment_report)
+          return NewRelic::EMPTY_ARRAY unless @service.valid_to_marshal?(environment_report)
+
           environment_report
         end
 
-        def environment_metadata 
+        def environment_metadata
           env_copy = {}
-          ENV.keys.each {|k| env_copy[k] = ENV[k] if k =~ /^NEW_RELIC_METADATA_/}
+          ENV.keys.each { |k| env_copy[k] = ENV[k] if k =~ /^NEW_RELIC_METADATA_/ }
           env_copy
         end
 

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

@@ -1,14 +1,11 @@
-# encoding: utf-8
 # 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 Connect
-
       class ResponseHandler
-
         def initialize(agent, config)
           @agent = agent
           @config = config
@@ -22,7 +19,7 @@ module NewRelic
         # Can accommodate most arbitrary data - anything extra is
         # ignored unless we say to do something with it here.
         def configure_agent(config_data)
-          return if config_data == nil
+          return if config_data.nil?
 
           @agent.agent_id = config_data['agent_run_id']
 
@@ -40,16 +37,16 @@ module NewRelic
 
         def add_server_side_config(config_data)
           if config_data['agent_config']
-            ::NewRelic::Agent.logger.debug "Using config from server"
+            ::NewRelic::Agent.logger.debug("Using config from server")
           end
 
-          ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
+          ::NewRelic::Agent.logger.debug("Server provided config: #{config_data.inspect}")
           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'
+          ::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

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/attribute_processing'
@@ -10,9 +10,9 @@ module NewRelic
     class CustomEventAggregator < EventAggregator
       include NewRelic::Coerce
 
-      TYPE             = 'type'.freeze
-      TIMESTAMP        = 'timestamp'.freeze
-      PRIORITY         = 'priority'.freeze
+      TYPE = 'type'.freeze
+      TIMESTAMP = 'timestamp'.freeze
+      PRIORITY = 'priority'.freeze
       EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
 
       named :CustomEventAggregator
@@ -20,7 +20,7 @@ module NewRelic
       enabled_key :'custom_insights_events.enabled'
 
       def record(type, attributes)
-        unless attributes.is_a? Hash
+        unless attributes.is_a?(Hash)
           raise ArgumentError, "Expected Hash but got #{attributes.class}"
         end
 
@@ -46,10 +46,9 @@ module NewRelic
 
       def create_event(type, priority, attributes)
         [
-          { TYPE => type,
-            TIMESTAMP => Process.clock_gettime(Process::CLOCK_REALTIME).to_i,
-            PRIORITY => priority
-          },
+          {TYPE => type,
+           TIMESTAMP => Process.clock_gettime(Process::CLOCK_REALTIME).to_i,
+           PRIORITY => priority},
           AttributeProcessing.flatten_and_coerce(attributes)
         ]
       end
@@ -58,23 +57,23 @@ module NewRelic
         @type_strings = Hash.new { |hash, key| hash[key] = key.to_s.freeze }
       end
 
-      def after_harvest metadata
+      def after_harvest(metadata)
         dropped_count = metadata[:seen] - metadata[:captured]
         note_dropped_events(metadata[:seen], dropped_count)
         record_supportability_metrics(metadata[:seen], metadata[:captured], dropped_count)
       end
 
-      def note_dropped_events total_count, dropped_count
+      def note_dropped_events(total_count, dropped_count)
         if dropped_count > 0
           NewRelic::Agent.logger.warn("Dropped #{dropped_count} custom events out of #{total_count}.")
         end
       end
 
-      def record_supportability_metrics total_count, captured_count, dropped_count
+      def record_supportability_metrics(total_count, captured_count, dropped_count)
         engine = NewRelic::Agent.instance.stats_engine
-        engine.tl_record_supportability_metric_count("Events/Customer/Seen"   ,    total_count)
-        engine.tl_record_supportability_metric_count("Events/Customer/Sent"   , captured_count)
-        engine.tl_record_supportability_metric_count("Events/Customer/Dropped",  dropped_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Seen", total_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Sent", captured_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Dropped", dropped_count)
       end
 
       def note_dropped_event(type)