newrelic_rpm 8.8.0 → 8.9.0

data/lib/new_relic/agent/agent.rb

@@ -37,6 +37,11 @@ require 'new_relic/agent/adaptive_sampler'
 require 'new_relic/agent/connect/request_builder'
 require 'new_relic/agent/connect/response_handler'
 
+require 'new_relic/agent/agent/start_worker_thread'
+require 'new_relic/agent/agent/startup'
+require 'new_relic/agent/agent/special_startup'
+require 'new_relic/agent/agent/shutdown'
+
 module NewRelic
   module Agent
     # The Agent is a singleton that is instantiated when the plugin is
@@ -48,6 +53,11 @@ module NewRelic
         ::NewRelic::Agent.config
       end
 
+      include NewRelic::Agent::StartWorkerThread
+      include NewRelic::Agent::SpecialStartup
+      include NewRelic::Agent::Startup
+      include NewRelic::Agent::Shutdown
+
       def initialize
         @started = false
         @event_loop = nil
@@ -222,48 +232,11 @@ module NewRelic
           end
         end
 
-        # True if we have initialized and completed 'start'
-        def started?
-          @started
-        end
-
-        # Attempt a graceful shutdown of the agent, flushing any remaining
-        # data.
-        def shutdown
-          return unless started?
-          ::NewRelic::Agent.logger.info "Starting Agent shutdown"
-
-          stop_event_loop
-          trap_signals_for_litespeed
-          untraced_graceful_disconnect
-          revert_to_default_configuration
-
-          @started = nil
-          Control.reset
-        end
-
         def revert_to_default_configuration
           Agent.config.remove_config_type(:manual)
           Agent.config.remove_config_type(:server)
         end
 
-        # If the @worker_thread encounters an error during the attempt to connect to the collector
-        # then the connect attempts enter an exponential backoff retry loop.  To avoid potential
-        # race conditions with shutting down while also attempting to reconnect, we join the
-        # @worker_thread with a timeout threshold.  This allows potentially connecting and flushing
-        # pending data to the server, but without waiting indefinitely for a reconnect to succeed.
-        # The use-case where this typically arises is in cronjob scheduled rake tasks where there's
-        # also some network stability/latency issues happening.
-        def stop_event_loop
-          @event_loop.stop if @event_loop
-          # Wait the end of the event loop thread.
-          if @worker_thread
-            unless @worker_thread.join(3)
-              ::NewRelic::Agent.logger.debug "Event loop thread did not stop within 3 seconds"
-            end
-          end
-        end
-
         def trap_signals_for_litespeed
           # if litespeed, then ignore all future SIGUSR1 - it's
           # litespeed trying to shut us down
@@ -273,16 +246,6 @@ module NewRelic
           end
         end
 
-        def untraced_graceful_disconnect
-          begin
-            NewRelic::Agent.disable_all_tracing do
-              graceful_disconnect
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.error e
-          end
-        end
-
         # Sets a thread local variable as to whether we should or
         # should not record sql in the current thread. Returns the
         # previous value, if there is one
@@ -307,255 +270,6 @@ module NewRelic
           Tracer.state.pop_traced
         end
 
-        # Herein lies the corpse of the former 'start' method. May
-        # its unmatched flog score rest in pieces.
-        module Start
-          # Check whether we have already started, which is an error condition
-          def already_started?
-            if started?
-              ::NewRelic::Agent.logger.error("Agent Started Already!")
-              true
-            end
-          end
-
-          # The agent is disabled when it is not force enabled by the
-          # 'agent_enabled' option (e.g. in a manual start), or
-          # enabled normally through the configuration file
-          def disabled?
-            !Agent.config[:agent_enabled]
-          end
-
-          # Log startup information that we almost always want to know
-          def log_startup
-            log_environment
-            log_dispatcher
-            log_app_name
-          end
-
-          # Log the environment the app thinks it's running in.
-          # Useful in debugging, as this is the key for config YAML lookups.
-          def log_environment
-            ::NewRelic::Agent.logger.info "Environment: #{NewRelic::Control.instance.env}"
-          end
-
-          # Logs the dispatcher to the log file to assist with
-          # debugging. When no debugger is present, logs this fact to
-          # assist with proper dispatcher detection
-          def log_dispatcher
-            dispatcher_name = Agent.config[:dispatcher].to_s
-
-            if dispatcher_name.empty?
-              ::NewRelic::Agent.logger.info 'No known dispatcher detected.'
-            else
-              ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
-            end
-          end
-
-          def log_app_name
-            ::NewRelic::Agent.logger.info "Application: #{Agent.config[:app_name].join(", ")}"
-          end
-
-          def log_ignore_url_regexes
-            regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
-
-            unless regexes.empty?
-              ::NewRelic::Agent.logger.info "Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}."
-            end
-          end
-
-          # Logs the configured application names
-          def app_name_configured?
-            names = Agent.config[:app_name]
-            return names.respond_to?(:any?) && names.any?
-          end
-
-          # Connecting in the foreground blocks further startup of the
-          # agent until we have a connection - useful in cases where
-          # you're trying to log a very-short-running process and want
-          # to get statistics from before a server connection
-          # (typically 20 seconds) exists
-          def connect_in_foreground
-            NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
-          end
-
-          # This matters when the following three criteria are met:
-          #
-          # 1. A Sinatra 'classic' application is being run
-          # 2. The app is being run by executing the main file directly, rather
-          #    than via a config.ru file.
-          # 3. newrelic_rpm is required *after* sinatra
-          #
-          # In this case, the entire application runs from an at_exit handler in
-          # Sinatra, and if we were to install ours, it would be executed before
-          # the one in Sinatra, meaning that we'd shutdown the agent too early
-          # and never collect any data.
-          def sinatra_classic_app?
-            (
-              defined?(Sinatra::Application) &&
-              Sinatra::Application.respond_to?(:run) &&
-              Sinatra::Application.run?
-            )
-          end
-
-          def should_install_exit_handler?
-            return false unless Agent.config[:send_data_on_exit]
-            !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
-          end
-
-          def install_exit_handler
-            return unless should_install_exit_handler?
-            NewRelic::Agent.logger.debug("Installing at_exit handler")
-            at_exit { shutdown }
-          end
-
-          # Classy logging of the agent version and the current pid,
-          # so we can disambiguate processes in the log file and make
-          # sure they're running a reasonable version
-          def log_version_and_pid
-            ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
-          end
-
-          # Warn the user if they have configured their agent not to
-          # send data, that way we can see this clearly in the log file
-          def monitoring?
-            if Agent.config[:monitor_mode]
-              true
-            else
-              ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
-              false
-            end
-          end
-
-          # Tell the user when the license key is missing so they can
-          # fix it by adding it to the file
-          def has_license_key?
-            if Agent.config[:license_key] && Agent.config[:license_key].length > 0
-              true
-            else
-              ::NewRelic::Agent.logger.warn("No license key found. " +
-                "This often means your newrelic.yml file was not found, or it lacks a section for the running environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml to ensure it is valid YML.")
-              false
-            end
-          end
-
-          # A correct license key exists and is of the proper length
-          def has_correct_license_key?
-            has_license_key? && correct_license_length
-          end
-
-          # A license key is an arbitrary 40 character string,
-          # usually looks something like a SHA1 hash
-          def correct_license_length
-            key = Agent.config[:license_key]
-
-            if key.length == 40
-              true
-            else
-              ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
-              false
-            end
-          end
-
-          # If we're using a dispatcher that forks before serving
-          # requests, we need to wait until the children are forked
-          # before connecting, otherwise the parent process sends useless data
-          def using_forking_dispatcher?
-            # TODO: MAJOR VERSION - remove :rainbows
-            if [:puma, :passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
-              ::NewRelic::Agent.logger.info "Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork."
-              true
-            else
-              false
-            end
-          end
-
-          # Return true if we're using resque and it hasn't had a chance to (potentially)
-          # daemonize itself. This avoids hanging when there's a Thread started
-          # before Resque calls Process.daemon (Jira RUBY-857)
-          def defer_for_resque?
-            NewRelic::Agent.config[:dispatcher] == :resque &&
-              NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
-              !PipeChannelManager.listener.started?
-          end
-
-          def in_resque_child_process?
-            defined?(@service) && @service.is_a?(PipeService)
-          end
-
-          # Sanity-check the agent configuration and start the agent,
-          # setting up the worker thread and the exit handler to shut
-          # down the agent
-          def check_config_and_start_agent
-            return unless monitoring? && has_correct_license_key?
-            return if using_forking_dispatcher?
-            setup_and_start_agent
-          end
-
-          # This is the shared method between the main agent startup and the
-          # after_fork call restarting the thread in deferred dispatchers.
-          #
-          # Treatment of @started and env report is important to get right.
-          def setup_and_start_agent(options = {})
-            @started = true
-            @harvester.mark_started
-
-            unless in_resque_child_process?
-              install_exit_handler
-              environment_for_connect
-              @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
-            end
-
-            connect_in_foreground if Agent.config[:sync_startup]
-            start_worker_thread(options)
-          end
-        end
-
-        include Start
-
-        def defer_for_delayed_job?
-          NewRelic::Agent.config[:dispatcher] == :delayed_job &&
-            !NewRelic::DelayedJobInjection.worker_name
-        end
-
-        # Check to see if the agent should start, returning +true+ if it should.
-        def agent_should_start?
-          return false if already_started? || disabled?
-
-          if defer_for_delayed_job?
-            ::NewRelic::Agent.logger.debug "Deferring startup for DelayedJob"
-            return false
-          end
-
-          if defer_for_resque?
-            ::NewRelic::Agent.logger.debug "Deferring startup for Resque in case it daemonizes"
-            return false
-          end
-
-          unless app_name_configured?
-            NewRelic::Agent.logger.error "No application name configured.",
-              "The Agent cannot start without at least one. Please check your ",
-              "newrelic.yml and ensure that it is valid and has at least one ",
-              "value set for app_name in the #{NewRelic::Control.instance.env} ",
-              "environment."
-            return false
-          end
-
-          return true
-        end
-
-        # Logs a bunch of data and starts the agent, if needed
-        def start
-          return unless agent_should_start?
-
-          log_startup
-          check_config_and_start_agent
-          log_version_and_pid
-
-          events.subscribe(:initial_configuration_complete) do
-            log_ignore_url_regexes
-          end
-        end
-
         # Clear out the metric data, errors, and transaction traces, etc.
         def drop_buffered_data
           @stats_engine.reset!
@@ -592,149 +306,6 @@ module NewRelic
 
         private
 
-        # All of this module used to be contained in the
-        # start_worker_thread method - this is an artifact of
-        # refactoring and can be moved, renamed, etc at will
-        module StartWorkerThread
-          def create_event_loop
-            EventLoop.new
-          end
-
-          LOG_ONCE_KEYS_RESET_PERIOD = 60.0
-
-          # Certain event types may sometimes need to be on the same interval as metrics,
-          # so we will check config assigned in EventHarvestConfig to determine the interval
-          # on which to report them
-          def interval_for event_type
-            interval = Agent.config[:"event_report_period.#{event_type}"]
-            :"#{interval}_second_harvest"
-          end
-
-          TRANSACTION_EVENT_DATA = "transaction_event_data".freeze
-          CUSTOM_EVENT_DATA = "custom_event_data".freeze
-          ERROR_EVENT_DATA = "error_event_data".freeze
-          SPAN_EVENT_DATA = "span_event_data".freeze
-          LOG_EVENT_DATA = "log_event_data".freeze
-
-          def create_and_run_event_loop
-            data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
-            event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
-
-            @event_loop = create_event_loop
-            @event_loop.on(data_harvest) do
-              transmit_data
-            end
-
-            @event_loop.on(interval_for TRANSACTION_EVENT_DATA) do
-              transmit_analytic_event_data
-            end
-            @event_loop.on(interval_for CUSTOM_EVENT_DATA) do
-              transmit_custom_event_data
-            end
-            @event_loop.on(interval_for ERROR_EVENT_DATA) do
-              transmit_error_event_data
-            end
-            @event_loop.on(interval_for SPAN_EVENT_DATA) do
-              transmit_span_event_data
-            end
-            @event_loop.on(interval_for LOG_EVENT_DATA) do
-              transmit_log_event_data
-            end
-
-            @event_loop.on(:reset_log_once_keys) do
-              ::NewRelic::Agent.logger.clear_already_logged
-            end
-            @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
-            @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
-            @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
-
-            @event_loop.run
-          end
-
-          # Handles the case where the server tells us to restart -
-          # this clears the data, clears connection attempts, and
-          # waits a while to reconnect.
-          def handle_force_restart(error)
-            ::NewRelic::Agent.logger.debug error.message
-            drop_buffered_data
-            @service.force_restart if @service
-            @connect_state = :pending
-            sleep 30
-          end
-
-          # when a disconnect is requested, stop the current thread, which
-          # is the worker thread that gathers data and talks to the
-          # server.
-          def handle_force_disconnect(error)
-            ::NewRelic::Agent.logger.warn "Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})"
-            disconnect
-          end
-
-          # Handles an unknown error in the worker thread by logging
-          # it and disconnecting the agent, since we are now in an
-          # unknown state.
-          def handle_other_error(error)
-            ::NewRelic::Agent.logger.error "Unhandled error in worker thread, disconnecting."
-            # These errors are fatal (that is, they will prevent the agent from
-            # reporting entirely), so we really want backtraces when they happen
-            ::NewRelic::Agent.logger.log_exception(:error, error)
-            disconnect
-          end
-
-          # a wrapper method to handle all the errors that can happen
-          # in the connection and worker thread system. This
-          # guarantees a no-throw from the background thread.
-          def catch_errors
-            yield
-          rescue NewRelic::Agent::ForceRestartException => e
-            handle_force_restart(e)
-            retry
-          rescue NewRelic::Agent::ForceDisconnectException => e
-            handle_force_disconnect(e)
-          rescue => e
-            handle_other_error(e)
-          end
-
-          # This is the method that is run in a new thread in order to
-          # background the harvesting and sending of data during the
-          # normal operation of the agent.
-          #
-          # Takes connection options that determine how we should
-          # connect to the server, and loops endlessly - typically we
-          # never return from this method unless we're shutting down
-          # the agent
-          def deferred_work!(connection_options)
-            catch_errors do
-              NewRelic::Agent.disable_all_tracing do
-                connect(connection_options)
-                if connected?
-                  create_and_run_event_loop
-                  # never reaches here unless there is a problem or
-                  # the agent is exiting
-                else
-                  ::NewRelic::Agent.logger.debug "No connection.  Worker thread ending."
-                end
-              end
-            end
-          end
-        end
-        include StartWorkerThread
-
-        # Try to launch the worker thread and connect to the server.
-        #
-        # See #connect for a description of connection_options.
-        def start_worker_thread(connection_options = {})
-          if disable = NewRelic::Agent.config[:disable_harvest_thread]
-            NewRelic::Agent.logger.info "Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}"
-            return
-          end
-
-          ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
-          @worker_thread = Threading::AgentThread.create('Worker Loop') do
-            deferred_work!(connection_options)
-          end
-        end
-
         # A shorthand for NewRelic::Control.instance
         def control
           NewRelic::Control.instance

data/lib/new_relic/agent/agent_logger.rb

@@ -83,11 +83,9 @@ module NewRelic
       # Allows for passing exceptions in explicitly, which format with backtrace
       def format_and_send(level, *msgs, &block)
         if block
-          if @log.send("#{level}?")
-            msgs = Array(block.call)
-          else
-            msgs = []
-          end
+          return unless @log.send("#{level}?")
+
+          msgs = Array(block.call)
         end
 
         msgs.flatten.each do |item|

data/lib/new_relic/agent/autostart.rb

@@ -62,7 +62,7 @@ module NewRelic
           ::Rake.application.top_level_tasks
         rescue => e
           ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping denylisted_rake_tasks check: #{e}")
-          []
+          NewRelic::EMPTY_ARRAY
         end
         !(tasks & ::NewRelic::Agent.config[:'autostart.denylisted_rake_tasks'].split(/\s*,\s*/)).empty?
       end

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

@@ -113,7 +113,7 @@ module NewRelic
           end
         end
 
-        SUCCESS_RESULT = {}.freeze
+        SUCCESS_RESULT = NewRelic::EMPTY_HASH
         ERROR_KEY = "error"
 
         def success

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

@@ -96,11 +96,11 @@ module NewRelic
               paths << File.join(NewRelic::Control.instance.root, "newrelic.yml.erb")
             end
 
-            if ENV["HOME"]
-              paths << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
-              paths << File.join(ENV["HOME"], "newrelic.yml")
-              paths << File.join(ENV["HOME"], ".newrelic", "newrelic.yml.erb")
-              paths << File.join(ENV["HOME"], "newrelic.yml.erb")
+            if ENV['HOME']
+              paths << File.join(ENV['HOME'], ".newrelic", "newrelic.yml")
+              paths << File.join(ENV['HOME'], "newrelic.yml")
+              paths << File.join(ENV['HOME'], ".newrelic", "newrelic.yml.erb")
+              paths << File.join(ENV['HOME'], "newrelic.yml.erb")
             end
 
             # If we're packaged for warbler, we can tell from GEM_HOME
@@ -119,7 +119,7 @@ module NewRelic
             found_path = NewRelic::Agent.config[:config_search_paths].detect do |file|
               File.expand_path(file) if File.exist? file
             end
-            found_path || ""
+            found_path || NewRelic::EMPTY_STR
           }
         end
 
@@ -242,7 +242,7 @@ module NewRelic
           case value
           when Array then value
           when String then value.split(SEMICOLON)
-          else []
+          else NewRelic::EMPTY_ARRAY
           end
         end
 
@@ -517,9 +517,9 @@ When `true`, the agent captures HTTP request parameters and attaches them to tra
           :allowed_from_server => false,
           :transform => DefaultSource.method(:convert_to_regexp_list),
           :description => 'Specify an Array of Rake tasks to automatically instrument. ' \
-          'This configuration option converts the Array to a RegEx list. If you\'d like '\
-          'to allow all tasks by default, use `rake.tasks: [.+]`. No rake tasks will be '\
-          'instrumented unless they\'re added to this list. For more information, '\
+          'This configuration option converts the Array to a RegEx list. If you\'d like ' \
+          'to allow all tasks by default, use `rake.tasks: [.+]`. No rake tasks will be ' \
+          'instrumented unless they\'re added to this list. For more information, ' \
           'visit the (New Relic Rake Instrumentation docs)[/docs/apm/agents/ruby-agent/background-jobs/rake-instrumentation].'
         },
         :'rake.connect_timeout' => {

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

@@ -253,7 +253,7 @@ module NewRelic
           end
         rescue => e
           NewRelic::Agent.logger.error(PARSING_LABELS_FAILURE, e)
-          []
+          NewRelic::EMPTY_ARRAY
         end
 
         def parse_labels_from_string
@@ -293,7 +293,7 @@ module NewRelic
 
           unless valid_label_pairs?(pairs)
             NewRelic::Agent.logger.warn("#{MALFORMED_LABELS_WARNING}: #{labels || pairs}")
-            return []
+            return NewRelic::EMPTY_ARRAY
           end
 
           pairs = limit_number_of_labels(pairs)

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

@@ -41,7 +41,7 @@ module NewRelic
         # particular) that can't seralize 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
 

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

@@ -115,7 +115,7 @@ module NewRelic
         end
 
         SPACE = ' '.freeze
-        EMPTY = [].freeze
+        EMPTY = NewRelic::EMPTY_ARRAY
 
         def split_name(name)
           if name && name.respond_to?(:split)

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

@@ -48,7 +48,7 @@ module NewRelic
         NR_DO_NOT_TRACE_KEY = :'@do_not_trace'
         NR_IGNORE_APDEX_KEY = :'@ignore_apdex'
         NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser'
-        NR_DEFAULT_OPTIONS = {}.freeze
+        NR_DEFAULT_OPTIONS = NewRelic::EMPTY_HASH
 
         # @api public
         module ClassMethods

data/lib/new_relic/agent/instrumentation/memcache/dalli.rb

@@ -58,10 +58,18 @@ module NewRelic
               ::Dalli::Server
             end.class_eval do
               include NewRelic::Agent::Instrumentation::Memcache::Tracer
-              alias_method :send_multiget_without_newrelic_trace, :send_multiget
 
-              def send_multiget keys
-                send_multiget_with_newrelic_tracing(keys) { send_multiget_without_newrelic_trace keys }
+              # TODO: Dalli - 3.1.0 renamed send_multiget to piplined_get, but the method is otherwise the same
+              if Gem::Version.new(::Dalli::VERSION) >= Gem::Version.new('3.1.0')
+                alias_method :pipelined_get_without_newrelic_trace, :pipelined_get
+                def pipelined_get keys
+                  send_multiget_with_newrelic_tracing(keys) { pipelined_get_without_newrelic_trace keys }
+                end
+              else
+                alias_method :send_multiget_without_newrelic_trace, :send_multiget
+                def send_multiget keys
+                  send_multiget_with_newrelic_tracing(keys) { send_multiget_without_newrelic_trace keys }
+                end
               end
             end
           end

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

@@ -85,8 +85,15 @@ module NewRelic::Agent::Instrumentation
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
 
-          def send_multiget keys
-            send_multiget_with_newrelic_tracing(keys) { super }
+          # TODO: Dalli - 3.1.0 renamed send_multiget to piplined_get, but the method is otherwise the same
+          if Gem::Version.new(::Dalli::VERSION) >= Gem::Version.new('3.1.0')
+            def pipelined_get keys
+              send_multiget_with_newrelic_tracing(keys) { super }
+            end
+          else
+            def send_multiget keys
+              send_multiget_with_newrelic_tracing(keys) { super }
+            end
           end
         end
       end

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

@@ -11,8 +11,8 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails Sunspot instrumentation'
-    deprecation_msg = 'The instrumentation for Sunspot is deprecated.' \
-      ' It will be removed in version 9.0.0.' \
+    deprecation_msg = 'The instrumentation for Sunspot is deprecated. ' \
+      'It will be removed in version 9.0.0.'
 
     ::NewRelic::Agent.logger.log_once(
       :warn,