newrelic_rpm 7.0.0 → 8.1.0

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/rack/chain.rb

@@ -31,7 +31,8 @@ module NewRelic::Agent::Instrumentation
             def use_with_newrelic(middleware_class, *args, &block)
               use_with_tracing(middleware_class) { |wrapped_class| use_without_newrelic(wrapped_class, *args, &block) }
             end
-    
+            ruby2_keywords(:use_with_newrelic) if respond_to?(:ruby2_keywords, true)
+
             alias_method :use_without_newrelic, :use
             alias_method :use, :use_with_newrelic
           end
@@ -54,4 +55,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -31,6 +31,7 @@ module NewRelic::Agent::Instrumentation
       def use(middleware_class, *args, &blk)
         use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
       end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
     end
   end
-end
+end

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/redis.rb

@@ -18,6 +18,10 @@ DependencyDetection.defer do
     defined?(::Redis) && defined?(::Redis::VERSION)
   end
 
+  conflicts_with_prepend do
+    defined?(::PrometheusExporter)
+  end
+
   depends_on do
     NewRelic::Agent::Datastores::Redis.is_supported_version? &&
       NewRelic::Agent::Datastores::Redis.safe_from_third_party_gem?

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

@@ -0,0 +1,19 @@
+# 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 Resque
+        module Helper
+          extend self
+
+          def resque_fork_per_job?
+            ENV["FORK_PER_JOB"] != 'false' && NewRelic::LanguageSupport.can_fork?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@
 module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    
+
     def with_tracing
       begin
         perform_action_with_newrelic_trace(
@@ -24,8 +24,10 @@ module NewRelic::Agent::Instrumentation
       ensure
         # Stopping the event loop before flushing the pipe.
         # The goal is to avoid conflict during write.
-        NewRelic::Agent.agent.stop_event_loop
-        NewRelic::Agent.agent.flush_pipe_data
+        if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
+          NewRelic::Agent.agent.stop_event_loop
+          NewRelic::Agent.agent.flush_pipe_data
+        end
       end
     end
 

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

@@ -13,6 +13,11 @@ DependencyDetection.defer do
     defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
   end
 
+  # Airbrake uses method chaining on Resque::Job on versions < 11.0.3
+  conflicts_with_prepend do
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('11.0.3')
+  end
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
   end
@@ -32,7 +37,7 @@ DependencyDetection.defer do
       chain_instrument NewRelic::Agent::Instrumentation::Resque::Chain
     end
 
-    if NewRelic::LanguageSupport.can_fork?
+    if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,
                                      :sync_startup => true,
@@ -40,9 +45,7 @@ DependencyDetection.defer do
       end
 
       ::Resque.before_fork do |job|
-        if ENV['FORK_PER_JOB'] != 'false'
-          NewRelic::Agent.register_report_channel(job.object_id)
-        end
+        NewRelic::Agent.register_report_channel(job.object_id)
       end
 
       ::Resque.after_fork do |job|
@@ -51,6 +54,12 @@ DependencyDetection.defer do
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
                                    :report_instance_busy => false)
       end
+    else
+      ::Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher   => :resque,
+                                     :sync_startup => true,
+                                     :start_channel_listener => false)
+      end
     end
   end
 end

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/instrumentation/sinatra/instrumentation.rb

@@ -39,9 +39,15 @@ module NewRelic::Agent::Instrumentation
         yield
       end
 
+      def install_lock
+        @install_lock ||= Mutex.new
+      end
+
       def try_to_use(app, clazz)
-        has_middleware = app.middleware.any? { |info| info[0] == clazz }
-        app.use(clazz) unless has_middleware
+        install_lock.synchronize do
+          has_middleware = app.middleware && app.middleware.any? { |info| info && info[0] == clazz }
+          app.use(clazz) unless has_middleware
+        end
       end
 
       # Capture last route we've seen. Will set for transaction on route_eval

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -83,39 +83,44 @@ module NewRelic
         value.nil? || value.empty?
       end
 
-      def browser_timing_header #THREAD_LOCAL_ACCESS
+      def browser_timing_header(nonce=nil) #THREAD_LOCAL_ACCESS
         return '' unless js_enabled_and_ready? # fast exit
 
         state = NewRelic::Agent::Tracer.state
 
         return '' unless insert_js?(state) # slower exit
 
-        bt_config = browser_timing_config(state)
+        bt_config = browser_timing_config(state, nonce)
         return '' if bt_config.empty?
 
-        bt_config + browser_timing_loader
+        bt_config + browser_timing_loader(nonce)
       rescue => e
         ::NewRelic::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
         ''
       end
 
-      def browser_timing_loader
-        html_safe_if_needed("\n<script>#{Agent.config[:js_agent_loader]}</script>")
+      def browser_timing_loader(nonce=nil)
+        html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>#{Agent.config[:js_agent_loader]}</script>")
       end
 
-      def browser_timing_config(state)
+      def browser_timing_config(state, nonce=nil)
         txn = state.current_transaction
         return '' if txn.nil?
 
         txn.freeze_name_and_execute_if_not_ignored do
           data = data_for_js_agent(txn)
           json = ::JSON.dump(data)
-          return html_safe_if_needed("\n<script>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+          return html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
         end
 
         ''
       end
 
+      def create_nonce(nonce=nil)
+        return '' unless nonce
+        " nonce=\"#{nonce.to_s}\""
+      end
+
       BEACON_KEY           = "beacon".freeze
       ERROR_BEACON_KEY     = "errorBeacon".freeze
       LICENSE_KEY_KEY      = "licenseKey".freeze
@@ -131,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,