newrelic_rpm 7.2.0 → 8.0.0

data/lib/new_relic/agent/distributed_tracing/distributed_trace_payload.rb

@@ -50,7 +50,7 @@ module NewRelic
 
           payload.id = current_segment_id(transaction)
           payload.transaction_id = transaction.guid
-          payload.timestamp = (Time.now.to_f * 1000).round
+          payload.timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
           payload.trace_id = transaction.trace_id
           payload.sampled = transaction.sampled?
           payload.priority = transaction.priority

data/lib/new_relic/agent/distributed_tracing/trace_context_payload.rb

@@ -57,7 +57,7 @@ module NewRelic
         private
 
         def now_ms
-          (Time.now.to_f * 1000).round
+          Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
         end
 
         def handle_invalid_payload error: nil, message: nil

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/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/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

@@ -277,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/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/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/queue_time.rb

@@ -15,7 +15,7 @@ module NewRelic
         ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
         # any timestamps before this are thrown out and the parser
         # will try again with a larger unit (2000/1/1 UTC)
-        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
+        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800).to_f
 
         CANDIDATE_HEADERS = [
           REQUEST_START_HEADER,
@@ -27,7 +27,7 @@ module NewRelic
 
         module_function
 
-        def parse_frontend_timestamp(headers, now=Time.now)
+        def parse_frontend_timestamp(headers, now=Process.clock_gettime(Process::CLOCK_REALTIME))
           earliest = nil
 
           CANDIDATE_HEADERS.each do |header|
@@ -40,7 +40,7 @@ module NewRelic
           end
 
           if earliest && earliest > now
-            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now}")
             earliest = now
           end
 
@@ -59,7 +59,7 @@ module NewRelic
         def parse_timestamp(string)
           DIVISORS.each do |divisor|
             begin
-              t = Time.at(string.to_f / divisor)
+              t = (string.to_f / divisor)
               return t if t > EARLIEST_ACCEPTABLE_TIME
             rescue RangeError
               # On Ruby versions built with a 32-bit time_t, attempting to

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

@@ -20,13 +20,13 @@ DependencyDetection.defer do
   executes do
     ActionView::PartialTemplate.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial'
+      add_method_tracer :render, -> (*) { "View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial" }
     end
 
     # this is for template rendering, as opposed to partial rendering.
     ActionView::Template.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering" }
     end
   end
 end
@@ -47,7 +47,7 @@ DependencyDetection.defer do
   executes do
     ActionController::Base.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{newrelic_metric_path}/Rendering" }
     end
   end
 end
@@ -68,12 +68,12 @@ DependencyDetection.defer do
   executes do
     ActionView::RenderablePartial.module_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+      add_method_tracer :render_partial, -> (*) { "View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial" }
     end
 
     ActionView::Template.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering" }
     end
   end
 end

data/lib/new_relic/agent/instrumentation/rails/action_web_service.rb

@@ -38,7 +38,7 @@ DependencyDetection.defer do
     if defined?(ActionController) && defined?(ActionController::Base)
       ActionController::Base.class_eval do
         if method_defined? :perform_invocation
-          add_method_tracer :perform_invocation, 'WebService/#{controller_name}/#{args.first}'
+          add_method_tracer :perform_invocation, -> (*args) { "WebService/#{controller_name}/#{args.first}" }
         end
       end
     end

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

@@ -84,52 +84,16 @@ DependencyDetection.defer do
     end
   end
 end
-DependencyDetection.defer do
-  @name = :rails30_view
-
-  depends_on do
-    defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 0
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_view_instrumentation]
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
-  end
-
-  executes do
-    ActionView::Template.class_eval do
-      include NewRelic::Agent::MethodTracer
-      def render_with_newrelic(*args, &block)
-        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
-          {:file => true }
-        else
-          {}
-        end
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(@identifier, options)}/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.render_type(@identifier)}"
-        trace_execution_scoped str do
-          render_without_newrelic(*args, &block)
-        end
-      end
-
-      alias_method :render_without_newrelic, :render
-      alias_method :render, :render_with_newrelic
-
-    end
-  end
-end
 
+# Though this uses the name :rails31_view, it is used only for rails 3.2 now
+# Rails 3.1 is no longer supported by the agent.
 DependencyDetection.defer do
   @name = :rails31_view
 
-  # We can't be sure that this will work with future versions of Rails 3.
-  # Currently enabled for Rails 3.1 and 3.2
+  # Enabled for Rails 3.2
   depends_on do
     defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
+      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 2
   end
 
   depends_on do
@@ -137,7 +101,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3.2 view instrumentation'
   end
 
   executes do

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

@@ -60,7 +60,12 @@ DependencyDetection.defer do
 
     class Sidekiq::Extensions::DelayedClass
       def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = YAML.load(msg['args'][0])
+        (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
+                                         YAML.unsafe_load(msg['args'][0])
+                                       else 
+                                         YAML.load(msg['args'][0])
+                                       end
+
         {
           :name => method_name,
           :class_name => target.name,

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -136,9 +136,9 @@ module NewRelic
 
       # NOTE: Internal prototyping may override this, so leave name stable!
       def data_for_js_agent(transaction)
-        queue_time_in_seconds = [transaction.queue_time.to_f, 0.0].max
-        start_time_in_seconds = [transaction.start_time.to_f, 0.0].max
-        app_time_in_seconds   = Time.now.to_f - start_time_in_seconds
+        queue_time_in_seconds = [transaction.queue_time, 0.0].max
+        start_time_in_seconds = [transaction.start_time, 0.0].max
+        app_time_in_seconds   = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
         queue_time_in_millis = (1000.0 * queue_time_in_seconds).round
         app_time_in_millis   = (1000.0 * app_time_in_seconds).round

data/lib/new_relic/agent/messaging.rb

@@ -110,20 +110,15 @@ module NewRelic
       #
       # @api public
       #
-      def wrap_message_broker_consume_transaction library: nil,
-                                                  destination_type: nil,
-                                                  destination_name: nil,
+      def wrap_message_broker_consume_transaction(library:,
+                                                  destination_type:,
+                                                  destination_name:,
                                                   headers: nil,
                                                   routing_key: nil,
                                                   queue_name: nil,
                                                   exchange_type: nil,
                                                   reply_to: nil,
-                                                  correlation_id: nil
-
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+                                                  correlation_id: nil)
 
         state = Tracer.state
         return yield if state.current_transaction
@@ -185,17 +180,14 @@ module NewRelic
       #
       # @api public
       #
-      def start_amqp_publish_segment(library: nil,
-                                     destination_name: nil,
+      def start_amqp_publish_segment(library:,
+                                     destination_name:,
                                      headers: nil,
                                      routing_key: nil,
                                      reply_to: nil,
                                      correlation_id: nil,
                                      exchange_type: nil)
 
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
         raise ArgumentError, 'missing required argument: headers' if headers.nil? && CrossAppTracing.cross_app_enabled?
 
         original_headers = headers.nil? ? nil : headers.dup
@@ -247,20 +239,14 @@ module NewRelic
       #
       # @api public
       #
-      def start_amqp_consume_segment(library: nil,
-                                     destination_name: nil,
-                                     delivery_info: nil,
-                                     message_properties: nil,
+      def start_amqp_consume_segment(library:,
+                                     destination_name:,
+                                     delivery_info:,
+                                     message_properties:,
                                      exchange_type: nil,
                                      queue_name: nil,
                                      start_time: nil)
 
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
-        raise ArgumentError, 'missing required argument: delivery_info' if delivery_info.nil?
-        raise ArgumentError, 'missing required argument: message_properties' if message_properties.nil?
-
         segment = Tracer.start_message_broker_segment(
           action: :consume,
           library: library,