newrelic_rpm 6.8.0.360 → 8.13.1

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

@@ -1,6 +1,10 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'resque/instrumentation'
+require_relative 'resque/chain'
+require_relative 'resque/prepend'
 
 DependencyDetection.defer do
   @name = :resque
@@ -9,64 +13,52 @@ 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'
+    ::NewRelic::Agent.logger.info('Installing Resque instrumentation')
   end
 
   executes do
     if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
-      ::NewRelic::Agent.logger.info 'Requiring resolv-replace'
+      ::NewRelic::Agent.logger.info('Requiring resolv-replace')
       require 'resolv'
       require 'resolv-replace'
     end
   end
 
   executes do
-    module ::Resque
-      class Job
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        alias_method :perform_without_instrumentation, :perform
-
-        def perform
-          begin
-            perform_action_with_newrelic_trace(
-              :name => 'perform',
-              :class_name => self.payload_class,
-              :category => 'OtherTransaction/ResqueJob') do
-
-              NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
-                args,
-                :'job.resque.args',
-                NewRelic::Agent::AttributeFilter::DST_NONE)
-
-              perform_without_instrumentation
-            end
-          ensure
-            NewRelic::Agent.agent.flush_pipe_data
-          end
-        end
-      end
+    if use_prepend?
+      prepend_instrument ::Resque::Job, NewRelic::Agent::Instrumentation::Resque::Prepend
+    else
+      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,
-                                     :start_channel_listener => true)
+        NewRelic::Agent.manual_start(:dispatcher => :resque,
+          :sync_startup => true,
+          :start_channel_listener => true)
       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|
         # Only suppress reporting Instance/Busy for forked children
         # Traced errors UI relies on having the parent process report that metric
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
-                                   :report_instance_busy => false)
+          :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

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

@@ -1,7 +1,7 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   @name = :sequel
@@ -12,39 +12,37 @@ DependencyDetection.defer do
 
   depends_on do
     !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-    !NewRelic::Agent.config[:disable_database_instrumentation]
+      !NewRelic::Agent.config[:disable_database_instrumentation]
   end
 
   def supported_sequel_version?
-    Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
+    Sequel.const_defined?(:MAJOR) &&
+      (Sequel::MAJOR > 3 ||
+        Sequel::MAJOR == 3 && Sequel::MINOR >= 37)
   end
 
   executes do
     if supported_sequel_version?
 
-      ::NewRelic::Agent.logger.info 'Installing Sequel instrumentation'
+      ::NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
-      if Sequel::Database.respond_to?( :extension )
-        Sequel::Database.extension :newrelic_instrumentation
+      if Sequel::Database.respond_to?(:extension)
+        Sequel::Database.extension(:newrelic_instrumentation)
       else
-        NewRelic::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
-        NewRelic::Agent.logger.info "Please see additional documentation: " +
-          "https://newrelic.com/docs/ruby/sequel-instrumentation"
+        NewRelic::Agent.logger.info("Detected Sequel version %s." % [Sequel::VERSION])
+        NewRelic::Agent.logger.info("Please see additional documentation: " +
+          "https://newrelic.com/docs/ruby/sequel-instrumentation")
       end
 
-      Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
-        db.extension :newrelic_instrumentation
+      Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
+        db.extension(:newrelic_instrumentation)
       end
 
       Sequel::Model.plugin(:newrelic_instrumentation) if defined?(Sequel::Model)
     else
 
-      NewRelic::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."
+      NewRelic::Agent.logger.info("Sequel instrumentation requires at least version 3.37.0.")
 
     end
-
   end
-
 end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -33,4 +33,4 @@ module NewRelic
       end
     end
   end
-end
+end

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

@@ -0,0 +1,20 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Client
+    include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+    def call(_worker_class, job, *_)
+      job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+      yield
+    end
+
+    def distributed_tracing_headers
+      headers = {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+      headers
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# TODO: remove this class once Sidekiq v6 is no longer supported.
+#       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
+#       were removed entirely in Sidekiq 7.
+#
+#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       of the removal, which includes mentions of alternatives
+if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+  class Sidekiq::Extensions::DelayedClass
+    def newrelic_trace_args(msg, queue)
+      (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,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Server
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+    # Client middleware has additional parameters, and our tests use the
+    # middleware client-side to work inline.
+    def call(worker, msg, queue, *_)
+      trace_args = if worker.respond_to?(:newrelic_trace_args)
+        worker.newrelic_trace_args(msg, queue)
+      else
+        self.class.default_trace_args(msg)
+      end
+      trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
+
+      perform_action_with_newrelic_trace(trace_args) do
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
+          NewRelic::Agent::AttributeFilter::DST_NONE)
+
+        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+  end
+end

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

@@ -1,6 +1,9 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+require_relative 'sidekiq/client'
+require_relative 'sidekiq/server'
+require_relative 'sidekiq/extensions/delayed_class'
 
 DependencyDetection.defer do
   @name = :sidekiq
@@ -10,63 +13,43 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Sidekiq instrumentation'
+    ::NewRelic::Agent.logger.info('Installing Sidekiq instrumentation')
   end
 
   executes do
-    class NewRelic::SidekiqInstrumentation
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-      # Client middleware has additional parameters, and our tests use the
-      # middleware client-side to work inline.
-      def call(worker, msg, queue, *_)
-        trace_args = if worker.respond_to?(:newrelic_trace_args)
-          worker.newrelic_trace_args(msg, queue)
-        else
-          self.class.default_trace_args(msg)
-        end
-
-        perform_action_with_newrelic_trace(trace_args) do
-          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-            NewRelic::Agent::AttributeFilter::DST_NONE)
-
-          yield
-        end
-      end
-
-      def self.default_trace_args(msg)
-        {
-          :name => 'perform',
-          :class_name => msg['class'],
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      end
-    end
-
-    class Sidekiq::Extensions::DelayedClass
-      def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = YAML.load(msg['args'][0])
-        {
-          :name => method_name,
-          :class_name => target.name,
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      rescue => e
-        NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
-        NewRelic::SidekiqInstrumentation.default_trace_args(msg)
+    Sidekiq.configure_client do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
     end
 
     Sidekiq.configure_server do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
+      end
       config.server_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << Proc.new do |error, *_|
+        config.error_handlers << proc do |error, *_|
           NewRelic::Agent.notice_error(error)
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Sidekiq version to continue receiving full support. '
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sidekiq_version,
+      deprecation_msg
+    )
+  end
 end

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

@@ -0,0 +1,55 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Chain
+      def self.instrument!
+        ::Sinatra::Base.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+          def dispatch_with_newrelic
+            dispatch_with_tracing { dispatch_without_newrelic }
+          end
+          alias dispatch_without_newrelic dispatch!
+          alias dispatch! dispatch_with_newrelic
+
+          def process_route_with_newrelic(*args, &block)
+            process_route_with_tracing(*args) do
+              process_route_without_newrelic(*args, &block)
+            end
+          end
+          alias process_route_without_newrelic process_route
+          alias process_route process_route_with_newrelic
+
+          def route_eval_with_newrelic(*args, &block)
+            route_eval_with_tracing(*args) do
+              route_eval_without_newrelic(*args, &block)
+            end
+          end
+          alias route_eval_without_newrelic route_eval
+          alias route_eval route_eval_with_newrelic
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Sinatra::Base.class_eval do
+            class << self
+              def build_with_newrelic(*args, &block)
+                build_with_tracing(*args) do
+                  build_without_newrelic(*args, &block)
+                end
+              end
+              alias build_without_newrelic build
+              alias build build_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sinatra/ignorer.rb

@@ -1,50 +1,44 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Sinatra
-        module Ignorer
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false if !app.settings.respond_to?(:newrelic_ignores)
 
-          def self.should_ignore?(app, type)
-            return false if !app.settings.respond_to?(:newrelic_ignores)
-
-            app.settings.newrelic_ignores[type].any? do |pattern|
-              pattern.match(app.request.path_info)
-            end
-          end
-
-          def newrelic_ignore(*routes)
-            set_newrelic_ignore(:routes, *routes)
-          end
+        app.settings.newrelic_ignores[type].any? do |pattern|
+          pattern.match(app.request.path_info)
+        end
+      end
 
-          def newrelic_ignore_apdex(*routes)
-            set_newrelic_ignore(:apdex, *routes)
-          end
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
 
-          def newrelic_ignore_enduser(*routes)
-            set_newrelic_ignore(:enduser, *routes)
-          end
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
 
-          private
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
 
-          def set_newrelic_ignore(type, *routes)
-            # Important to default this in the context of the actual app
-            # If it's done at register time, ignores end up shared between apps.
-            set :newrelic_ignores, Hash.new([]) if !respond_to?(:newrelic_ignores)
+      private
 
-            # If we call an ignore without a route, it applies to the whole app
-            routes = ["*"] if routes.empty?
+      def set_newrelic_ignore(type, *routes)
+        # Important to default this in the context of the actual app
+        # If it's done at register time, ignores end up shared between apps.
+        set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
-            settings.newrelic_ignores[type] += routes.map do |r|
-              # Ugly sending to private Base#compile, but we want to mimic
-              # exactly Sinatra's mapping of route text to regex
-              Array(send(:compile, r)).first
-            end
-          end
+        # If we call an ignore without a route, it applies to the whole app
+        routes = ["*"] if routes.empty?
 
+        settings.newrelic_ignores[type] += routes.map do |r|
+          # Ugly sending to private Base#compile, but we want to mimic
+          # exactly Sinatra's mapping of route text to regex
+          Array(send(:compile, r)).first
         end
       end
     end

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

@@ -0,0 +1,125 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# NewRelic instrumentation for Sinatra applications.  Sinatra actions will
+# appear in the UI similar to controller actions, and have breakdown charts
+# and transaction traces.
+#
+# The actions in the UI will correspond to the pattern expression used
+# to match them, not directly to full URL's.
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      # Expected method for supporting ControllerInstrumentation
+      def newrelic_request_headers(_)
+        request.env
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_with_tracing(*args, &block)
+        unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            try_to_use(self, middleware_class)
+          end
+        end
+        yield
+      end
+
+      def install_lock
+        @install_lock ||= Mutex.new
+      end
+
+      def try_to_use(app, clazz)
+        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
+      def process_route_with_tracing(*args)
+        begin
+          env["newrelic.last_route"] = args[0]
+        rescue => e
+          ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
+        end
+        yield
+      end
+
+      # If a transaction name is already set, this call will tromple over it.
+      # This is intentional, as typically passing to a separate route is like
+      # an entirely separate transaction, so we pick up the new name.
+      #
+      # If we're ignored, this remains safe, since set_transaction_name
+      # care for the gating on the transaction's existence for us.
+      def route_eval_with_tracing(*args)
+        begin
+          if txn_name = TransactionNamer.transaction_name_for_route(env, request)
+            ::NewRelic::Agent::Transaction.set_default_transaction_name(
+              "#{self.class.name}/#{txn_name}", :sinatra
+            )
+          end
+        rescue => e
+          ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
+        end
+        yield
+      end
+
+      def get_request_params
+        begin
+          @request.params
+        rescue => e
+          NewRelic::Agent.logger.debug("Failed to get params from Rack request.", e)
+          nil
+        end
+      end
+
+      def dispatch_with_tracing
+        request_params = get_request_params
+        filtered_params = ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, request_params || {})
+
+        name = TransactionNamer.initial_transaction_name(request)
+        perform_action_with_newrelic_trace(:category => :sinatra,
+          :name => name,
+          :params => filtered_params) do
+          begin
+            yield
+          ensure
+            # Will only see an error raised if :show_exceptions is true, but
+            # will always see them in the env hash if they occur
+            had_error = env.has_key?('sinatra.error')
+            ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
+          end
+        end
+      end
+
+      def do_not_trace?
+        Ignorer.should_ignore?(self, :routes)
+      end
+
+      # Overrides ControllerInstrumentation implementation
+      def ignore_apdex?
+        Ignorer.should_ignore?(self, :apdex)
+      end
+
+      # Overrides ControllerInstrumentation implementation
+      def ignore_enduser?
+        Ignorer.should_ignore?(self, :enduser)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+      def dispatch!
+        dispatch_with_tracing { super }
+      end
+
+      def process_route(*args, &block)
+        process_route_with_tracing(*args) { super }
+      end
+
+      def route_eval(*args, &block)
+        route_eval_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+        def build(*args, &block)
+          build_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end