newrelic_rpm 7.0.0 → 8.2.0

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

@@ -2,30 +2,34 @@
 # 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 Padrino
-    module Chain
-      def self.instrument!
-        ::Padrino::Routing::InstanceMethods.module_eval do
-          include NewRelic::Agent::Instrumentation::Sinatra
+module NewRelic
+  module Agent
+    module Instrumentation
+      module PadrinoTracer
+        module Chain
+          def self.instrument!
+            ::Padrino::Routing::InstanceMethods.module_eval do
+              include NewRelic::Agent::Instrumentation::Sinatra
 
-          def dispatch_with_newrelic
-            dispatch_with_tracing { dispatch_without_newrelic }
-          end
+              def dispatch_with_newrelic
+                dispatch_with_tracing { dispatch_without_newrelic }
+              end
 
-          alias dispatch_without_newrelic dispatch!
-          alias dispatch! dispatch_with_newrelic
+              alias dispatch_without_newrelic dispatch!
+              alias dispatch! dispatch_with_newrelic
 
-          # Padrino 0.13 mustermann routing
-          if private_method_defined?(:invoke_route)
-            include NewRelic::Agent::Instrumentation::Padrino
+              # Padrino 0.13 mustermann routing
+              if private_method_defined?(:invoke_route)
+                include NewRelic::Agent::Instrumentation::Padrino
 
-            def invoke_route_with_newrelic(*args, &block)
-              invoke_route_with_tracing(*args) { invoke_route_without_newrelic(*args, &block) }
-            end
+                def invoke_route_with_newrelic(*args, &block)
+                  invoke_route_with_tracing(*args) { invoke_route_without_newrelic(*args, &block) }
+                end
 
-            alias invoke_route_without_newrelic invoke_route
-            alias invoke_route invoke_route_with_newrelic
+                alias invoke_route_without_newrelic invoke_route
+                alias invoke_route invoke_route_with_newrelic
+              end
+            end
           end
         end
       end

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

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic::Agent::Instrumentation
-  module Padrino
+  module PadrinoTracer
     module Prepend
       include NewRelic::Agent::Instrumentation::Sinatra
       include NewRelic::Agent::Instrumentation::Padrino

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

@@ -24,12 +24,14 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
     if use_prepend?
-      prepend_instrument ::Padrino::Routing::InstanceMethods, NewRelic::Agent::Instrumentation::Padrino::Prepend
+      prepend_instrument ::Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Padrino::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::PadrinoTracer::Chain
     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/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/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/instrumentation/tilt/chain.rb

@@ -0,0 +1,24 @@
+# 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 Tilt
+    module Chain
+      def self.instrument!
+        ::Tilt::Template.module_eval do
+          include NewRelic::Agent::Instrumentation::Tilt
+
+          def render_with_new_relic(*args, &block)
+            render_with_tracing(*args) {
+              render_without_newrelic(*args, &block)
+            }
+          end
+
+          alias render_without_newrelic render
+          alias render render_with_new_relic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# 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 Tilt
+
+        def metric_name(klass, file)
+          "View/#{klass}/#{file}/Rendering"
+        end
+
+        # Sinatra uses #caller_locations for the file name in Tilt (unlike Rails/Rack)
+        # So here we are only grabbing the file name and name of directory it is in
+        def create_filename_for_metric(file)
+          return file unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+          file.split('/')[-2..-1].join('/')
+        rescue NoMethodError
+          file
+        end
+
+        def render_with_tracing(*args, &block)
+          begin
+            finishable = Tracer.start_segment(
+              name: metric_name(self.class, create_filename_for_metric(self.file))
+            )
+            begin
+              yield
+            rescue => error
+              NewRelic::Agent.notice_error(error)
+              raise
+            end
+          ensure
+            finishable.finish if finishable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/tilt/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 Tilt::Prepend
+    include NewRelic::Agent::Instrumentation::Tilt
+
+    def render(*args, &block)
+      render_with_tracing { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/tilt.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 'tilt/instrumentation'
+require_relative 'tilt/chain'
+require_relative 'tilt/prepend'
+
+DependencyDetection.defer do
+  named :tilt
+
+  depends_on { defined?(::Tilt) }
+
+  executes do
+    ::NewRelic::Agent.logger.info('Installing Tilt instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument ::Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Tilt::Chain
+    end
+  end
+end

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

@@ -33,6 +33,7 @@ module NewRelic
         COLON = ':'.freeze
         COMMA = ','.freeze
         CLOSING_BRACE = '}'.freeze
+        REPLACEMENT_CHAR = '�'
 
         def initialize
           Agent.config.register_callback :app_name do
@@ -86,12 +87,10 @@ module NewRelic
           message << QUOTE << key << QUOTE << COLON << QUOTE << value << QUOTE
         end
 
-        def escape message
-          if String === message
-            message.to_json
-          else
-            message.inspect.to_json
-          end
+        def escape(message)
+          message = message.to_s unless message.is_a?(String)
+          message = message.scrub(REPLACEMENT_CHAR) unless message.valid_encoding?
+          message.to_json
         end
 
         def clear_tags!

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,