newrelic_rpm 7.0.0 → 8.2.0

data/lib/new_relic/agent/event_loop.rb

@@ -14,7 +14,7 @@ module NewRelic
           @interval      = interval
           @event         = event
           @repeat        = repeat
-          @started_at    = Time.now
+          @started_at    = Process.clock_gettime(Process::CLOCK_REALTIME)
           @last_fired_at = nil
           reschedule
         end
@@ -32,7 +32,7 @@ module NewRelic
         end
 
         def calculate_next_fire_time
-          now = Time.now
+          now = Process.clock_gettime(Process::CLOCK_REALTIME)
           return now if @interval == 0
           fire_time = @last_fired_at || now
           while fire_time <= now
@@ -42,10 +42,10 @@ module NewRelic
         end
 
         def set_fired_time
-          @last_fired_at = Time.now
+          @last_fired_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
-        def due?(now=Time.now)
+        def due?(now=Process.clock_gettime(Process::CLOCK_REALTIME))
           now >= @next_fire_time
         end
 
@@ -69,7 +69,7 @@ module NewRelic
         existing_timer = @timers[timer.event]
 
         if existing_timer
-          elapsed_interval = Time.now - existing_timer.last_interval_start
+          elapsed_interval = Process.clock_gettime(Process::CLOCK_REALTIME) - existing_timer.last_interval_start
           timer.advance(elapsed_interval)
         end
 
@@ -80,7 +80,7 @@ module NewRelic
 
       def next_timeout
         return nil if @timers.empty?
-        timeout = @timers.values.map(&:next_fire_time).min - Time.now
+        timeout = @timers.values.map(&:next_fire_time).min - Process.clock_gettime(Process::CLOCK_REALTIME)
         timeout < 0 ? 0 : timeout
       end
 

data/lib/new_relic/agent/external.rb

@@ -18,38 +18,6 @@ module NewRelic
     module External
       extend self
 
-      # This method creates and starts an external request segment using the
-      # given library, URI, and procedure. This is used to time external calls
-      # made over HTTP.
-      #
-      # @param [String] library a string of the class name of the library used to
-      # make the external call, for example, 'Net::HTTP'.
-      #
-      # @param [String, URI] uri indicates the URI to which the
-      # external request is being made. The URI should begin with the protocol,
-      # for example, 'https://github.com'.
-      #
-      # @param [String] procedure the HTTP method being used for the external
-      # request as a string, for example, 'GET'.
-      #
-      # @api public
-      def start_segment(library: nil, uri: nil, procedure: nil)
-        Deprecator.deprecate 'External.start_segment',
-                             'Tracer#start_external_request_segment'
-
-        raise ArgumentError, 'Argument `library` is required' if library.nil?
-        raise ArgumentError, 'Argument `uri` is required' if uri.nil?
-        raise ArgumentError, 'Argument `procedure` is required' if procedure.nil?
-
-        ::NewRelic::Agent.record_api_supportability_metric(:start_segment)
-
-        ::NewRelic::Agent::Tracer.start_external_request_segment(
-          library: library,
-          uri: uri,
-          procedure: procedure
-        )
-      end
-
       NON_HTTP_CAT_ID_HEADER  = 'NewRelicID'.freeze
       NON_HTTP_CAT_TXN_HEADER = 'NewRelicTransaction'.freeze
       NON_HTTP_CAT_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze

data/lib/new_relic/agent/http_clients/abstract.rb

@@ -46,7 +46,7 @@ module NewRelic
       # NOTE: response_object should be non-nil!
       class AbstractResponse # :nodoc:
 
-        def initialize wrapped_response
+        def initialize(wrapped_response)
           if wrapped_response.nil? 
             raise ArgumentError, WHINY_NIL_ERROR % self.class
           end
@@ -65,7 +65,7 @@ module NewRelic
 
         private 
 
-        def get_status_code_using method_name
+        def get_status_code_using(method_name)
           return unless @wrapped_response.respond_to?(method_name)
           code = @wrapped_response.send(method_name).to_i
           code == 0 ? nil : code

data/lib/new_relic/agent/http_clients/net_http_wrappers.rb

@@ -4,6 +4,7 @@
 # frozen_string_literal: true
 
 require_relative 'abstract'
+require 'resolv'
 
 module NewRelic
   module Agent
@@ -61,9 +62,14 @@ module NewRelic
           when /^https?:\/\//
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@request.path)
           else
+            connection_address = @connection.address
+            if (connection_address =~ Resolv::IPv6::Regex)
+              connection_address = "[#{connection_address}]"
+            end
+
             scheme = @connection.use_ssl? ? 'https' : 'http'
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
-              "#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}"
+              "#{scheme}://#{connection_address}:#{@connection.port}#{@request.path}"
               )
           end
         end

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

@@ -91,7 +91,7 @@ module NewRelic
 
         def queue_start(request)
           if request && request.respond_to?(:env)
-            QueueTime.parse_frontend_timestamp(request.env, Time.now)
+            QueueTime.parse_frontend_timestamp(request.env, Process.clock_gettime(Process::CLOCK_REALTIME))
           end
         end
       end

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

@@ -26,9 +26,9 @@ DependencyDetection.defer do
         gateway_name = self.name.split('::').last
         [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
           if implemented_methods.include?(operation)
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
-            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+            add_method_tracer operation, [-> (*) { "ActiveMerchant/gateway/#{gateway_name}/#{operation}" },
+                                          -> (*) { "ActiveMerchant/gateway/#{gateway_name}" },
+                                          -> (*) { "ActiveMerchant/operation/#{operation}" }]
           end
         end
       end

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

@@ -84,8 +84,6 @@ module NewRelic
         end
 
         def active_record_config(payload)
-          return unless payload[:connection_id]
-
           # handle if the notification payload provides the AR connection
           # available in Rails 6+ & our ActiveRecordNotifications#log extension
           if payload[:connection]
@@ -93,8 +91,8 @@ module NewRelic
             return connection_config if connection_config
           end
 
+          return unless connection_id = payload[:connection_id]
           connection = nil
-          connection_id = payload[:connection_id]
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
             connection = handler.connections.detect do |conn|

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

@@ -65,7 +65,7 @@ module NewRelic
           def pop_with_tracing
             bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
             begin
-              t0 = Time.now
+              t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
               msg = yield
               delivery_info, message_properties, _payload = msg
             rescue StandardError => error

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

@@ -179,6 +179,7 @@ module NewRelic
                   #{without_method_name}(*args, &block)
                  end
               end
+              ruby2_keywords(:#{with_method_name}) if respond_to?(:ruby2_keywords, true)
             EOC
 
             visibility = NewRelic::Helper.instance_method_visibility self, method
@@ -276,7 +277,7 @@ module NewRelic
         end
 
         # Yield to the given block with NewRelic tracing.  Used by
-        # default instrumentation on controller actions in Rails and Merb.
+        # default instrumentation on controller actions in Rails.
         # But it can also be used in custom instrumentation of controller
         # methods and background tasks.
         #

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

@@ -16,10 +16,11 @@ module NewRelic
                         when self.class.respond_to?(:default_name) then self.class.default_name
                         end
           NewRelic::DelayedJobInjection.worker_name = worker_name
-  
+
+          # TODO: Refactor the last line of this condition so that it can be evaluated in both prepend and chain instrumentation
           if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
-            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
-  
+            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic))
+
             ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
             install_newrelic_job_tracer
             NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
@@ -27,7 +28,6 @@ module NewRelic
             NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
           end
         end
-
       end
 
       module DelayedJobTracer

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

@@ -5,17 +5,9 @@
 DependencyDetection.defer do
   named :excon
 
-  # We have two ways of instrumenting Excon:
-  # - For newer versions, use the middleware mechanism Excon exposes
-  # - For older versions, monkey-patch Excon::Connection#request
+  # We instrument Excon 0.19.0 and above using the middleware mechanism
   #
   # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
-  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
-  #   instrumentation for.
-  #
-  # Note that middlewares were added to Excon prior to 0.19, but we don't
-  # use middleware-based instrumentation prior to that version because it didn't
-  # expose a way for middlewares to know about request failures.
   #
   # Why don't we use Excon.defaults[:instrumentor]?
   # While this might seem a perfect fit, it unfortunately isn't suitable in
@@ -25,8 +17,7 @@ DependencyDetection.defer do
   # so we could safely subscribe and not be clobbered by future subscribers,
   # but alas, it does not yet.
 
-  EXCON_MIN_VERSION = Gem::Version.new("0.10.1")
-  EXCON_MIDDLEWARE_MIN_VERSION = Gem::Version.new("0.19.0")
+  EXCON_MIN_VERSION = Gem::Version.new("0.19.0")
 
   depends_on do
     defined?(::Excon) && defined?(::Excon::VERSION)
@@ -45,11 +36,7 @@ DependencyDetection.defer do
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'
 
-    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
-      install_middleware_excon_instrumentation
-    else
-      install_legacy_excon_instrumentation
-    end
+    install_middleware_excon_instrumentation
   end
 
   def install_middleware_excon_instrumentation
@@ -63,11 +50,5 @@ DependencyDetection.defer do
       ::NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
     end
   end
-
-  def install_legacy_excon_instrumentation
-    ::NewRelic::Agent::Deprecator.deprecate :install_legacy_excon_instrumentation, :install_middleware_excon_instrumentation, "8.0.0"
-    ::NewRelic::Agent.logger.warn 'Installing deprecated legacy Excon instrumentation. This instrumentation will be removed in a future release. Update Excon version to > 0.19.0 for updated instrumentation'
-    require 'new_relic/agent/instrumentation/excon/connection'
-    ::Excon::Connection.install_newrelic_instrumentation
-  end
 end
+

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

@@ -0,0 +1,21 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Logger
+    def self.instrument!
+      ::Logger.class_eval do
+        include NewRelic::Agent::Instrumentation::Logger
+
+        alias_method :format_message_without_new_relic, :format_message
+
+        def format_message(severity, datetime, progname, msg)
+          format_message_with_tracing(severity, datetime, progname, msg) do
+            format_message_without_new_relic(severity, datetime, progname, msg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Logger
+        def skip_instrumenting?
+          defined?(@skip_instrumenting) && @skip_instrumenting
+        end
+
+        def mark_skip_instrumenting
+          @skip_instrumenting = true
+        end
+
+        def clear_skip_instrumenting
+          @skip_instrumenting = false
+        end
+
+        LINES = "Logging/lines".freeze
+        SIZE = "Logging/size".freeze
+
+        def line_metric_name_by_severity(severity)
+          @line_metrics ||= {}
+          @line_metrics[severity] ||= "Logging/lines/#{severity}".freeze
+        end
+
+        def size_metric_name_by_severity(severity)
+          @size_metrics ||= {}
+          @size_metrics[severity] ||= "Logging/size/#{severity}".freeze
+        end
+
+
+        def format_message_with_tracing(severity, datetime, progname, msg)
+          formatted_message = yield
+          return formatted_message if skip_instrumenting?
+
+          begin
+            # It's critical we don't instrument logging from metric recording
+            # methods within NewRelic::Agent, or we'll stack overflow!!
+            mark_skip_instrumenting
+
+            NewRelic::Agent.increment_metric(LINES)
+            NewRelic::Agent.increment_metric(line_metric_name_by_severity(severity))
+
+            size = formatted_message.nil? ? 0 : formatted_message.bytesize
+            NewRelic::Agent.record_metric(SIZE, size)
+            NewRelic::Agent.record_metric(size_metric_name_by_severity(severity), size)
+
+            return formatted_message
+          ensure
+            clear_skip_instrumenting
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Logger::Prepend
+    include NewRelic::Agent::Instrumentation::Logger
+
+    def format_message(severity, datetime, progname, msg)
+      format_message_with_tracing(severity, datetime, progname, msg) { super }
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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.
+
+require_relative 'logger/instrumentation'
+require_relative 'logger/chain'
+require_relative 'logger/prepend'
+
+DependencyDetection.defer do
+  named :logger
+
+  depends_on { defined?(::Logger) }
+
+  executes do
+    ::NewRelic::Agent.logger.info  "Installing Logger instrumentation"
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument ::Logger, NewRelic::Agent::Instrumentation::Logger::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Logger
+    end
+  end
+end

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

@@ -51,7 +51,11 @@ module NewRelic
           end
 
           def instrument_send_multiget
-            ::Dalli::Server.class_eval do
+            if supports_binary_protocol?
+              ::Dalli::Protocol::Binary
+            else
+              ::Dalli::Server
+            end.class_eval do
               include NewRelic::Agent::Instrumentation::Memcache::Tracer
               alias_method :send_multiget_without_newrelic_trace, :send_multiget
 

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

@@ -7,11 +7,16 @@ module NewRelic::Agent::Instrumentation
   module Memcache
     module Helper
       DATASTORE_INSTANCES_SUPPORTED_VERSION = Gem::Version.new '2.6.4'
+      BINARY_PROTOCOL_SUPPORTED_VERSION = Gem::Version.new '3.0.2'
 
       def supports_datastore_instances?
         DATASTORE_INSTANCES_SUPPORTED_VERSION <= Gem::Version.new(::Dalli::VERSION)
       end
 
+      def supports_binary_protocol?
+        BINARY_PROTOCOL_SUPPORTED_VERSION <= Gem::Version.new(::Dalli::VERSION)
+      end
+
       def client_methods
         [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
           :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]

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

@@ -31,7 +31,13 @@ module NewRelic::Agent::Instrumentation
         if supports_datastore_instances?
           yield ::Dalli::Client, dalli_client_prepender(dalli_methods)
           yield ::Dalli::Client, dalli_get_multi_prepender(:get_multi)
-          yield ::Dalli::Server, dalli_server_prepender
+
+          if supports_binary_protocol?
+            yield ::Dalli::Protocol::Binary, dalli_server_prepender
+          else
+            yield ::Dalli::Server, dalli_server_prepender
+          end
+
           yield ::Dalli::Ring, dalli_ring_prepender
         else
           yield ::Dalli::Client, dalli_client_prepender(client_methods)
@@ -85,4 +91,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -11,19 +11,15 @@ DependencyDetection.defer do
 
   depends_on do
     require 'new_relic/agent/datastores/mongo'
-    if NewRelic::Agent::Datastores::Mongo.is_unsupported_2x?
-      NewRelic::Agent.logger.log_once(:info, :mongo2, 'Detected unsupported Mongo 2, upgrade your Mongo Driver to 2.1 or newer for instrumentation')
+    unless NewRelic::Agent::Datastores::Mongo.is_supported_version?
+      NewRelic::Agent.logger.log_once(:warn, :mongo2, 'Detected unsupported Mongo 2, upgrade your Mongo Driver to 2.1 or newer for instrumentation')
     end
     NewRelic::Agent::Datastores::Mongo.is_supported_version?
   end
 
   executes do
     NewRelic::Agent.logger.info 'Installing Mongo instrumentation'
-    if NewRelic::Agent::Datastores::Mongo.is_monitoring_enabled?
-      install_mongo_command_subscriber
-    else
-      install_mongo_instrumentation
-    end
+    install_mongo_command_subscriber
   end
 
   def install_mongo_command_subscriber
@@ -33,138 +29,4 @@ DependencyDetection.defer do
       NewRelic::Agent::Instrumentation::MongodbCommandSubscriber.new
     )
   end
-
-  # TODO: Remove in 8.0.0 release
-  def install_mongo_instrumentation
-    ::NewRelic::Agent::Deprecator.deprecate "install_mongo_instrumentation", "install_mongo_command_subscriber", "8.0.0"
-    ::NewRelic::Agent.logger.warn("Installing deprecated Mongo instrumentation. " \
-        "This instrumentation will be removed in a future release. " \
-        "Update Mongo version to >= 2.1.0 for updated instrumentation"
-    )
-
-    require 'new_relic/agent/datastores/mongo/metric_translator'
-    require 'new_relic/agent/datastores/mongo/statement_formatter'
-
-    hook_instrument_methods
-    instrument_save
-    instrument_ensure_index
-  end
-
-  def hook_instrument_methods
-    hook_instrument_method(::Mongo::Collection)
-    hook_instrument_method(::Mongo::Connection)
-    hook_instrument_method(::Mongo::Cursor)
-    hook_instrument_method(::Mongo::CollectionWriter) if defined?(::Mongo::CollectionWriter)
-  end
-
-  def hook_instrument_method(target_class)
-    target_class.class_eval do
-      include NewRelic::Agent::MethodTracer
-
-      # It's key that this method eats all exceptions, as it rests between the
-      # Mongo operation the user called and us returning them the data. Be safe!
-      def new_relic_notice_statement(segment, payload, name)
-        statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(payload, name)
-        if statement
-          segment.notice_nosql_statement statement
-        end
-      rescue => e
-        NewRelic::Agent.logger.debug("Exception during Mongo statement gathering", e)
-      end
-
-      def new_relic_default_payload
-        { :collection => self.name, :database => self.db.name }
-      end
-
-      def new_relic_start_segment name, payload
-        product = NewRelic::Agent::Datastores::Mongo::MetricTranslator::MONGO_PRODUCT_NAME
-        op_and_col = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for name, payload
-        if op_and_col
-          operation, collection = op_and_col
-          NewRelic::Agent::Tracer.start_datastore_segment(
-            product: product,
-            operation: operation,
-            collection: collection
-          )
-        end
-      end
-
-      def instrument_with_new_relic_trace(name, payload = {}, &block)
-        segment = new_relic_start_segment name, payload
-
-        begin
-          result = NewRelic::Agent.disable_all_tracing do
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              instrument_without_new_relic_trace(name, payload, &block)
-            end
-          end
-
-          new_relic_notice_statement(segment, payload, name) if segment
-          result
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias_method :instrument_without_new_relic_trace, :instrument
-      alias_method :instrument, :instrument_with_new_relic_trace
-    end
-  end
-
-  def instrument_save
-    ::Mongo::Collection.class_eval do
-      def save_with_new_relic_trace(doc, opts = {}, &block)
-        segment = new_relic_start_segment :save, new_relic_default_payload
-
-        begin
-          result = NewRelic::Agent.disable_all_tracing do
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              save_without_new_relic_trace(doc, opts, &block)
-            end
-          end
-
-          new_relic_notice_statement(segment, doc, :save) if segment
-          result
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias_method :save_without_new_relic_trace, :save
-      alias_method :save, :save_with_new_relic_trace
-    end
-  end
-
-  def instrument_ensure_index
-    ::Mongo::Collection.class_eval do
-      def ensure_index_with_new_relic_trace(spec, opts = {}, &block)
-        segment = new_relic_start_segment :ensureIndex, new_relic_default_payload
-
-        begin
-          result = NewRelic::Agent.disable_all_tracing do
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              ensure_index_without_new_relic_trace(spec, opts, &block)
-            end
-          end
-
-          spec = case spec
-                 when Array
-                   Hash[spec]
-                 when String, Symbol
-                   { spec => 1 }
-                 else
-                   spec.dup
-                 end
-
-          new_relic_notice_statement(segment, spec, :ensureIndex) if segment
-          result
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias_method :ensure_index_without_new_relic_trace, :ensure_index
-      alias_method :ensure_index, :ensure_index_with_new_relic_trace
-    end
-  end
 end

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

@@ -17,8 +17,13 @@ DependencyDetection.defer do
     require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
+  # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
   conflicts_with_prepend do
-    defined?(::Airbrake)
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('10.0.2')
+  end
+
+  conflicts_with_prepend do
+    defined?(::ScoutApm)
   end
 
   conflicts_with_prepend do