newrelic_rpm 7.2.0 → 8.0.0

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -105,7 +105,7 @@ module NewRelic
           @lock.synchronize do
             if @profiles[transaction_name]
               profile = @profiles.delete(transaction_name)
-              profile.finished_at = Time.now
+              profile.finished_at = Process.clock_gettime(Process::CLOCK_REALTIME)
               @profiles[transaction_name] = ThreadProfile.new(profile.command_arguments)
               profile
             end
@@ -163,7 +163,7 @@ module NewRelic
         end
 
         def poll
-          poll_start = Time.now
+          poll_start = Process.clock_gettime(Process::CLOCK_REALTIME)
 
           @lock.synchronize do
             AgentThread.list.each do |thread|
@@ -173,7 +173,7 @@ module NewRelic
             @buffer.delete_if { |thread, _| !thread.alive? }
           end
 
-          end_time = Time.now
+          end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           adjust_polling_time(end_time, poll_start)
           record_supportability_metrics(end_time, poll_start)
         end
@@ -230,7 +230,7 @@ module NewRelic
           bucket = AgentThread.bucket_thread(thread, @profile_agent_code)
 
           if need_backtrace?(bucket)
-            timestamp = Time.now.to_f
+            timestamp = Process.clock_gettime(Process::CLOCK_REALTIME)
             backtrace = AgentThread.scrub_backtrace(thread, @profile_agent_code)
             aggregate_global_backtrace(backtrace, bucket, thread)
             buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
@@ -277,7 +277,6 @@ module NewRelic
           end
           @last_poll = poll_start
         end
-
       end
     end
   end

data/lib/new_relic/agent/threading/thread_profile.rb

@@ -39,7 +39,7 @@ module NewRelic
           @failure_count = 0
           @unique_threads = []
 
-          @created_at = Time.now
+          @created_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
         def requested_period

data/lib/new_relic/agent/tracer.rb

@@ -131,14 +131,10 @@ module NewRelic
         # @api public
         def start_transaction_or_segment(name: nil,
                                          partial_name: nil,
-                                         category: nil,
+                                         category:,
                                          options: {})
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+          
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           if name
             options[:transaction_name] = name
@@ -163,16 +159,12 @@ module NewRelic
 
         # Takes name or partial_name and a category.
         # Returns a transaction instance or nil
-        def start_transaction(name: nil,
+        def start_transaction(category:,
+                              name: nil,
                               partial_name: nil,
-                              category: nil,
                               **options)
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+          
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           return current_transaction if current_transaction
 
@@ -238,14 +230,11 @@ module NewRelic
         #   +finish+ on it at the end of the code you're tracing
         #
         # @api public
-        def start_segment(name:nil,
+        def start_segment(name:,
                           unscoped_metrics:nil,
                           start_time: nil,
                           parent: nil)
 
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: name' if name.nil?
-
           segment = Transaction::Segment.new name, unscoped_metrics, start_time
           start_and_add_segment segment, parent
 
@@ -341,17 +330,12 @@ module NewRelic
         #   you're tracing
         #
         # @api public
-        def start_external_request_segment(library: nil,
-                                           uri: nil,
-                                           procedure: nil,
+        def start_external_request_segment(library:,
+                                           uri:,
+                                           procedure:,
                                            start_time: nil,
                                            parent: nil)
 
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: library' if library.nil?
-          raise ArgumentError, 'missing required argument: uri' if uri.nil?
-          raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
-
           segment = Transaction::ExternalRequestSegment.new library, uri, procedure, start_time
           start_and_add_segment segment, parent
 
@@ -377,21 +361,15 @@ module NewRelic
         end
 
         # For New Relic internal use only.
-        def start_message_broker_segment(action: nil,
-                                         library: nil,
-                                         destination_type: nil,
-                                         destination_name: nil,
+        def start_message_broker_segment(action:,
+                                         library:,
+                                         destination_type:,
+                                         destination_name:,
                                          headers: nil,
                                          parameters: nil,
                                          start_time: nil,
                                          parent: nil)
 
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: action' if action.nil?
-          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?
-
           segment = Transaction::MessageBrokerSegment.new(
             action: action,
             library: library,

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -48,14 +48,14 @@ module NewRelic
         end
 
         def start
-          @start_time ||= Time.now
+          @start_time ||= Process.clock_gettime(Process::CLOCK_REALTIME)
           return unless transaction
           parent.child_start self if parent
         end
 
         def finish
-          @end_time = Time.now
-          @duration = end_time.to_f - start_time.to_f
+          @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+          @duration = end_time - start_time
           return unless transaction
           run_complete_callbacks
           finalize if record_on_finish?

data/lib/new_relic/agent/transaction/message_broker_segment.rb

@@ -52,19 +52,13 @@ module NewRelic
                     :library,
                     :headers
 
-        def initialize action: nil,
-                       library: nil,
-                       destination_type: nil,
-                       destination_name: nil,
+        def initialize(action:,
+                       library:,
+                       destination_type:,
+                       destination_name:,
                        headers: nil,
                        parameters: nil,
-                       start_time: nil
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: action' if action.nil?
-          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?
+                       start_time: nil)
 
           @action = action
           @library = library

data/lib/new_relic/agent/transaction.rb

@@ -119,28 +119,6 @@ module NewRelic
         "#{namer.prefix_for_category(self, category)}#{partial_name}"
       end
 
-      def self.wrap(state, name, category, options = {})
-        Deprecator.deprecate 'Transaction.wrap',
-                             'Tracer#in_transaction'
-
-        finishable = Tracer.start_transaction_or_segment(
-              name: name,
-              category: category,
-              options: options
-            )
-
-        begin
-          # We shouldn't raise from Transaction.start, but only wrap the yield
-          # to be absolutely sure we don't report agent problems as app errors
-          yield
-        rescue => e
-          Transaction.notice_error(e)
-          raise e
-        ensure
-          finishable.finish if finishable
-        end
-      end
-
       def self.start_new_transaction(state, category, options)
         txn = Transaction.new(category, options)
         state.reset(txn)
@@ -246,9 +224,10 @@ module NewRelic
         @frozen_name      = nil
 
         @category = category
-        @start_time = Time.now
+        @start_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @end_time = nil
         @duration = nil
+
         @apdex_start = options[:apdex_start_time] || @start_time
         @jruby_cpu_start = jruby_cpu_time
         @process_cpu_start = process_cpu
@@ -416,7 +395,7 @@ module NewRelic
       def start
         return if !state.is_execution_traced?
 
-        sql_sampler.on_start_transaction(state, start_time, request_path)
+        sql_sampler.on_start_transaction(state, request_path)
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::TransactionTimeAggregator.transaction_start(start_time)
 
@@ -505,8 +484,8 @@ module NewRelic
 
       def finish
         return unless state.is_execution_traced?
-        @end_time = Time.now
-        @duration = @end_time.to_f - @start_time.to_f
+        @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+        @duration = @end_time - @start_time
         freeze_name_and_execute_if_not_ignored
 
         if nesting_max_depth == 1
@@ -623,7 +602,7 @@ module NewRelic
       def calculate_transport_duration distributed_trace_payload
         return unless distributed_trace_payload
 
-        duration = (start_time.to_f * 1000 - distributed_trace_payload.timestamp) / 1000
+        duration = start_time - (distributed_trace_payload.timestamp / 1000.0)
         duration < 0 ? 0 : duration
       end
 
@@ -645,7 +624,7 @@ module NewRelic
         @payload = {
           :name                 => @frozen_name,
           :bucket               => recording_web_transaction? ? :request : :background,
-          :start_timestamp      => start_time.to_f,
+          :start_timestamp      => start_time,
           :duration             => duration,
           :metrics              => @metrics,
           :attributes           => @attributes,

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -15,24 +15,24 @@ module NewRelic
       TransactionStats = Struct.new :transaction_started_at, :elapsed_transaction_time
 
       @lock                     = Mutex.new
-      @harvest_cycle_started_at = Time.now
+      @harvest_cycle_started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
 
       @stats = Hash.new do |h, k|
         h[k] = TransactionStats.new nil, 0.0
       end
 
-      def reset!(timestamp = Time.now)
+      def reset!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(timestamp = Time.now)
+      def transaction_start(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @lock.synchronize do
           set_transaction_start_time timestamp
         end
       end
 
-      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
+      def transaction_stop(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), starting_thread_id = current_thread)
         @lock.synchronize do
           record_elapsed_transaction_time_until timestamp, starting_thread_id
           set_transaction_start_time nil, starting_thread_id
@@ -41,7 +41,7 @@ module NewRelic
 
       INSTANCE_BUSY_METRIC = 'Instance/Busy'.freeze
 
-      def harvest!(timestamp = Time.now)
+      def harvest!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread

data/lib/new_relic/agent/vm/snapshot.rb

@@ -12,7 +12,7 @@ module NewRelic
                       :thread_count, :taken_at
 
         def initialize
-          @taken_at = Time.now.to_f
+          @taken_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
       end
     end

data/lib/new_relic/agent/worker_loop.rb

@@ -18,7 +18,7 @@ module NewRelic
       # or :limit (integer) for max number of iterations
       def initialize(opts={})
         @should_run = true
-        @next_invocation_time = Time.now
+        @next_invocation_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @period = 60.0
         @duration = opts[:duration]
         @limit = opts[:limit]
@@ -34,7 +34,7 @@ module NewRelic
         @should_run = true
         @iterations = 0
 
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         @deadline = now + @duration if @duration
         @next_invocation_time = (now + @period)
       end
@@ -53,11 +53,11 @@ module NewRelic
       end
 
       def schedule_next_invocation
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         while @next_invocation_time <= now && @period > 0
           @next_invocation_time += @period
         end
-        @next_invocation_time - Time.now
+        @next_invocation_time - Process.clock_gettime(Process::CLOCK_REALTIME)
       end
 
       # a simple accessor for @should_run
@@ -66,7 +66,7 @@ module NewRelic
       end
 
       def under_duration?
-        !@deadline || Time.now < @deadline
+        !@deadline || Process.clock_gettime(Process::CLOCK_REALTIME) < @deadline
       end
 
       def under_limit?

data/lib/new_relic/agent.rb

@@ -139,20 +139,20 @@ module NewRelic
     # is initialized; these methods enable us to defer these calls
     # until we have started up and can process them.
     #
-    def add_or_defer_method_tracer(receiver, method_name, metric_name_code, options)
+    def add_or_defer_method_tracer(receiver, method_name, metric_name, options)
       @tracer_lock.synchronize do
         if @agent
-          receiver.send(:_add_method_tracer_now, method_name, metric_name_code, options)
+          receiver.send(:_nr_add_method_tracer_now, method_name, metric_name, options)
         else
-          @tracer_queue << [receiver, method_name, metric_name_code, options]
+          @tracer_queue << [receiver, method_name, metric_name, options]
         end
       end
     end
 
     def add_deferred_method_tracers_now
       @tracer_lock.synchronize do
-        @tracer_queue.each do |receiver, method_name, metric_name_code, options|
-          receiver.send(:_add_method_tracer_now, method_name, metric_name_code, options)
+        @tracer_queue.each do |receiver, method_name, metric_name, options|
+          receiver.send(:_nr_add_method_tracer_now, method_name, metric_name, options)
         end
 
         @tracer_queue = []

data/lib/new_relic/cli/commands/deployments.rb

@@ -10,7 +10,7 @@ require 'net/http'
 require 'new_relic/agent/hostname'
 
 # We need to use the Control object but we don't want to load
-# the rails/merb environment.  The defined? clause is so that
+# the rails environment.  The defined? clause is so that
 # it won't load it twice, something it does when run inside a test
 require 'new_relic/control' unless defined? NewRelic::Control
 
@@ -117,7 +117,7 @@ class NewRelic::Cli::Deployments < NewRelic::Cli::Command
              "Set the application name.",
              "Default is app_name setting in newrelic.yml") { | e | @appname = e }
       o.on("-e", "--environment=name", String,
-               "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
+               "Override the (RAILS|RUBY|RACK)_ENV setting",
                "currently: #{control.env}") { | e | @environment = e }
       o.on("-u", "--user=USER", String,
              "Specify the user deploying, for information only",

data/lib/new_relic/constants.rb

@@ -28,10 +28,6 @@ module NewRelic
   TRACEPARENT_KEY = "traceparent"
   TRACESTATE_KEY = "tracestate"
 
-  # Right now, old and new Rubies are the same.  Intention is to use "(...)" for
-  # Ruby 2.7+ for argument delegation, but doing so is a breaking API change.
-  ARGS_FOR_RUBY_VERSION = RUBY_VERSION < "2.7.0" ? "*args, &block" : "*args, &block"
-
   HTTP_TRACEPARENT_KEY = "HTTP_#{TRACEPARENT_KEY.upcase}"
   HTTP_TRACESTATE_KEY = "HTTP_#{TRACESTATE_KEY.upcase}"
   HTTP_NEWRELIC_KEY = "HTTP_#{NEWRELIC_KEY.upcase}"

data/lib/new_relic/noticed_error.rb

@@ -33,7 +33,7 @@ class NewRelic::NoticedError
   ERROR_CLASS_KEY    = "#{ERROR_PREFIX_KEY}.class"
   ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
 
-  def initialize(path, exception, timestamp = Time.now, expected = false)
+  def initialize(path, exception, timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), expected = false)
     @exception_id = exception.object_id
     @path = path
 
@@ -139,7 +139,7 @@ class NewRelic::NoticedError
       ERROR_MESSAGE_KEY => string(message),
       ERROR_CLASS_KEY => string(exception_class_name)
     })
-    
+
     @attributes_from_notice_error[ERROR_EXPECTED_KEY] = true if expected
   end
 

data/lib/new_relic/version.rb

@@ -10,8 +10,8 @@ module NewRelic
       parts.compact.join('.')
     end
 
-    MAJOR = 7
-    MINOR = 2
+    MAJOR = 8
+    MINOR = 0
     TINY  = 0
 
     begin

data/lib/newrelic_rpm.rb

@@ -6,48 +6,24 @@
 #
 # When installed as a gem, you can activate the New Relic agent one of the following ways:
 #
-# For Rails, add:
-#    config.gem 'newrelic_rpm'
-# to your initialization sequence.
+# For applications using Bundler, add this to the Gemfile:
+#    gem 'newrelic_rpm'
 #
-# For merb, do
-#    dependency 'newrelic_rpm'
-# in the Merb config/init.rb
+# You will also need to install the newrelic.yml configuration file
 #
-# For Sinatra, do
-#    require 'newrelic_rpm'
-# after requiring 'sinatra'.
-#
-# For other frameworks, or to manage the agent manually, invoke NewRelic::Agent#manual_start
-# directly.
+# For applications not using Bundler, and for other installation information, visit:
+# https://docs.newrelic.com/docs/agents/ruby-agent/installation/install-new-relic-ruby-agent/
 #
 
 require 'new_relic/control'
-if defined?(Merb) && defined?(Merb::BootLoader)
-  module NewRelic
-    class MerbBootLoader < Merb::BootLoader
-      after Merb::BootLoader::ChooseAdapter
-      def self.run
-        NewRelic::Control.instance.init_plugin
-      end
-    end
-  end
-elsif defined?(Rails::VERSION)
-  if Rails::VERSION::MAJOR.to_i >= 3
-    module NewRelic
-      class Railtie < Rails::Railtie
 
-        initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
-          NewRelic::Control.instance.init_plugin(:config => app.config)
-        end
+if defined?(Rails::VERSION)
+  module NewRelic
+    class Railtie < Rails::Railtie
+      initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
+        NewRelic::Control.instance.init_plugin(config: app.config)
       end
     end
-  else
-    # After version 2.0 of Rails we can access the configuration directly.
-    # We need it to add dev mode routes after initialization finished.
-    config = nil
-    config = Rails.configuration if Rails.respond_to?(:configuration)
-    NewRelic::Control.instance.init_plugin :config => config
   end
 else
   NewRelic::Control.instance.init_plugin

data/lib/tasks/all.rb

@@ -2,7 +2,7 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
-# This is required to load in task definitions from merb
+# This is required to load in task definitions
 Dir.glob(File.join(File.dirname(__FILE__),'*.rake')) do |file|
   load file
 end