newrelic_rpm 6.13.1 → 7.2.0

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

@@ -0,0 +1,34 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Redis
+    module Chain 
+      def self.instrument!
+        ::Redis::Client.class_eval do
+          include NewRelic::Agent::Instrumentation::Redis
+
+          alias_method :call_without_new_relic, :call
+    
+          def call(*args, &block)
+            call_with_tracing(args[0]) { call_without_new_relic(*args, &block) }
+          end
+      
+          alias_method :call_pipeline_without_new_relic, :call_pipeline
+    
+          def call_pipeline(*args, &block)
+            call_pipeline_with_tracing(args[0]) { call_pipeline_without_new_relic(*args, &block) }
+          end
+
+          alias_method :connect_without_new_relic, :connect
+    
+          def connect(*args, &block)
+            connect_with_tracing { connect_without_new_relic(*args, &block) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Redis
+    PRODUCT_NAME = 'Redis'
+    CONNECT = 'connect'
+    UNKNOWN = "unknown"
+    LOCALHOST = "localhost"
+    MULTI_OPERATION = 'multi'
+    PIPELINE_OPERATION = 'pipeline'
+
+    def call_with_tracing command, &block
+      operation = command[0]
+      statement = ::NewRelic::Agent::Datastores::Redis.format_command(command)
+
+      with_tracing(operation, statement) { yield }
+    end
+
+    def call_pipeline_with_tracing pipeline
+      operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? MULTI_OPERATION : PIPELINE_OPERATION
+      statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
+
+      with_tracing(operation, statement) { yield }
+    end
+
+    def connect_with_tracing
+      with_tracing(CONNECT) { yield }
+    end
+
+    private
+
+    def with_tracing operation, statement=nil
+      segment = NewRelic::Agent::Tracer.start_datastore_segment(
+        product: PRODUCT_NAME,
+        operation: operation,
+        host: _nr_hostname,
+        port_path_or_id: _nr_port_path_or_id,
+        database_name: db
+      )
+      begin
+        segment.notice_nosql_statement(statement) if statement
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment.finish if segment
+      end
+    end
+
+    def _nr_hostname
+      self.path ? LOCALHOST : self.host
+    rescue => e
+      NewRelic::Agent.logger.debug "Failed to retrieve Redis host: #{e}"
+      UNKNOWN
+    end
+
+    def _nr_port_path_or_id
+      self.path || self.port
+    rescue => e
+      NewRelic::Agent.logger.debug "Failed to retrieve Redis port_path_or_id: #{e}"
+      UNKNOWN
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/redis/prepend.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.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Redis
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Redis
+
+      def call *args, &block
+        call_with_tracing(args[0]) { super }
+      end
+
+      def call_pipeline *args, &block
+        call_pipeline_with_tracing(args[0]) { super }
+      end
+
+      def connect *args, &block
+        connect_with_tracing { super }
+      end
+    end
+  end
+end

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

@@ -2,6 +2,10 @@
 # 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 'resque/instrumentation'
+require_relative 'resque/chain'
+require_relative 'resque/prepend'
+
 DependencyDetection.defer do
   @name = :resque
 
@@ -9,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
@@ -22,37 +31,13 @@ DependencyDetection.defer do
   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
-            # 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
-          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,
@@ -60,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|
@@ -71,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/resque/chain.rb

@@ -0,0 +1,22 @@
+# 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 Resque
+    module Chain 
+      def self.instrument!
+        ::Resque::Job.class_eval do
+          include NewRelic::Agent::Instrumentation::Resque
+
+          alias_method :perform_without_instrumentation, :perform
+  
+          def perform
+            with_tracing { perform_without_instrumentation }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Resque
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def with_tracing
+      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)
+
+          yield
+        end
+      ensure
+        # Stopping the event loop before flushing the pipe.
+        # The goal is to avoid conflict during write.
+        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
+
+  end
+end

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

@@ -0,0 +1,16 @@
+# 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 Resque
+    module Prepend 
+      include NewRelic::Agent::Instrumentation::Resque
+
+      def perform
+        with_tracing { super }
+      end
+    end
+  end
+end

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

@@ -46,7 +46,7 @@ DependencyDetection.defer do
       end
       class Client
         def call(_worker_class, job, *_)
-          job[NewRelic::NEWRELIC_KEY] = distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+          job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
           yield
         end
 

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

@@ -2,45 +2,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.
 
-require 'new_relic/agent/instrumentation/controller_instrumentation'
-require 'new_relic/agent/instrumentation/sinatra/transaction_namer'
-require 'new_relic/agent/instrumentation/sinatra/ignorer'
-require 'new_relic/agent/parameter_filtering'
+require_relative 'sinatra/transaction_namer'
+require_relative 'sinatra/ignorer'
+require_relative 'sinatra/instrumentation'
+require_relative 'sinatra/chain'
+require_relative 'sinatra/prepend'
 
 DependencyDetection.defer do
-  @name = :sinatra
+  named :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Sinatra) && defined?(::Sinatra::Base) &&
-      Sinatra::Base.private_method_defined?(:dispatch!) &&
-      Sinatra::Base.private_method_defined?(:process_route) &&
-      Sinatra::Base.private_method_defined?(:route_eval)
-  end
+  depends_on { defined?(::Sinatra) && defined?(::Sinatra::Base) }
+  depends_on { Sinatra::Base.private_method_defined?(:dispatch!) }
+  depends_on { Sinatra::Base.private_method_defined?(:process_route) }
+  depends_on { Sinatra::Base.private_method_defined?(:route_eval) }
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Sinatra instrumentation'
   end
 
   executes do
-    ::Sinatra::Base.class_eval do
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      alias dispatch_without_newrelic dispatch!
-      alias dispatch! dispatch_with_newrelic
-
-      alias process_route_without_newrelic process_route
-      alias process_route process_route_with_newrelic
-
-      alias route_eval_without_newrelic route_eval
-      alias route_eval route_eval_with_newrelic
-
-      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
+    if use_prepend?
+      prepend_instrument ::Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Chain
     end
 
-    module ::Sinatra
-      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
-    end
+    ::Sinatra::Base.class_eval { register ::NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
+    ::Sinatra.module_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
   end
 
   executes do
@@ -49,179 +37,13 @@ DependencyDetection.defer do
       # we can't be sure that rack is available when this file is first required.
       require 'new_relic/rack/agent_hooks'
       require 'new_relic/rack/browser_monitoring'
-
-      ::Sinatra::Base.class_eval do
-        class << self
-          alias build_without_newrelic build
-          alias build build_with_newrelic
-        end
+      if use_prepend?
+        prepend_instrument ::Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
+      else
+        chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
       end
     else
       ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
     end
   end
 end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      # 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 Sinatra
-        include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        # Expected method for supporting ControllerInstrumentation
-        def newrelic_request_headers(_)
-          request.env
-        end
-
-        def self.included(clazz)
-          clazz.extend(ClassMethods)
-        end
-
-        module ClassMethods
-          def newrelic_middlewares
-            middlewares = [NewRelic::Rack::BrowserMonitoring]
-            if NewRelic::Rack::AgentHooks.needed?
-              middlewares << NewRelic::Rack::AgentHooks
-            end
-            middlewares
-          end
-
-          if RUBY_VERSION < "2.7.0"
-            def build_with_newrelic(*args, &block)
-              unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
-                newrelic_middlewares.each do |middleware_class|
-                  try_to_use(self, middleware_class)
-                end
-              end
-              build_without_newrelic(*args, &block)
-            end
-          else 
-            def build_with_newrelic(*args, **kwargs, &block)
-              unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
-                newrelic_middlewares.each do |middleware_class|
-                  try_to_use(self, middleware_class)
-                end
-              end
-              build_without_newrelic(*args, **kwargs, &block)
-            end
-          end
-
-          def try_to_use(app, clazz)
-            has_middleware = app.middleware.any? { |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
-        if RUBY_VERSION < "2.7.0"
-          def process_route_with_newrelic(*args, &block)
-            begin
-              env["newrelic.last_route"] = args[0]
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
-            end
-  
-            process_route_without_newrelic(*args, &block)
-          end
-        else 
-          def process_route_with_newrelic(*args, **kwargs, &block)
-            begin
-              env["newrelic.last_route"] = args[0]
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
-            end
-  
-            process_route_without_newrelic(*args, **kwargs, &block)
-          end
-        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.
-        if RUBY_VERSION < "2.7.0"
-          def route_eval_with_newrelic(*args, &block)
-            begin
-              txn_name = TransactionNamer.transaction_name_for_route(env, request)
-              unless txn_name.nil?
-                ::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
-  
-            route_eval_without_newrelic(*args, &block)
-          end
-        else
-          def route_eval_with_newrelic(*args, **kwargs, &block)
-            begin
-              txn_name = TransactionNamer.transaction_name_for_route(env, request)
-              unless txn_name.nil?
-                ::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
-  
-            route_eval_without_newrelic(*args, **kwargs, &block)
-          end
-        end
-
-        def dispatch_with_newrelic #THREAD_LOCAL_ACCESS
-          request_params = get_request_params
-          filtered_params = 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
-            dispatch_and_notice_errors_with_newrelic
-          end
-        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_and_notice_errors_with_newrelic
-          dispatch_without_newrelic
-        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
-
-        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
-end