newrelic_rpm 6.15.0 → 8.13.1

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

@@ -1,6 +1,6 @@
-# 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
   module Agent
@@ -12,7 +12,7 @@ module NewRelic
           SINATRA_ROUTE = 'sinatra.route'
 
           def transaction_name_for_route(env, request)
-            if env.key? SINATRA_ROUTE
+            if env.key?(SINATRA_ROUTE)
               env[SINATRA_ROUTE]
             else
               name = route_for_sinatra(env)

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

@@ -1,187 +1,58 @@
-# 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
 
-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'
+    ::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
-    if Sinatra::Base.respond_to?(:build)
-      # These requires are inside an executes block because they require rack, and
-      # 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
-      end
+    # These requires are inside an executes block because they require rack, and
+    # 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'
+    if use_prepend?
+      prepend_instrument ::Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
     else
-      ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
     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
 
-          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
-
-          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
-        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
-
-        # 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_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
-
-        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
+  executes do
+    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
 
-        # Overrides ControllerInstrumentation implementation
-        def ignore_apdex?
-          Ignorer.should_ignore?(self, :apdex)
-        end
+    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
+      'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
 
-        # Overrides ControllerInstrumentation implementation
-        def ignore_enduser?
-          Ignorer.should_ignore?(self, :enduser)
-        end
-      end
-    end
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sinatra_version,
+      deprecation_msg
+    )
   end
 end

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

@@ -1,6 +1,6 @@
-# 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
 
 DependencyDetection.defer do
   @name = :sunspot
@@ -10,13 +10,21 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails Sunspot instrumentation'
+    ::NewRelic::Agent.logger.info('Installing Rails Sunspot instrumentation')
+    deprecation_msg = 'The instrumentation for Sunspot is deprecated. ' \
+      'It will be removed in version 9.0.0.'
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sunspot,
+      deprecation_msg
+    )
   end
 
   executes do
     ::Sunspot.module_eval do
       class << self
-        %w(index index!).each do |method|
+        %w[index index!].each do |method|
           add_method_tracer method, 'SolrClient/Sunspot/index'
         end
         add_method_tracer :commit, 'SolrClient/Sunspot/commit'

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

@@ -0,0 +1,24 @@
+# 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
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module MonitoredThread
+    module Chain
+      def self.instrument!
+        ::Thread.class_eval do
+          include NewRelic::Agent::Instrumentation::MonitoredThread
+
+          alias_method(:initialize_without_new_relic, :initialize)
+
+          def initialize(*args, &block)
+            traced_block = add_thread_tracing(*args, &block)
+            initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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
+  module Agent
+    module Instrumentation
+      module MonitoredThread
+        attr_reader :nr_parent_thread_id
+
+        def initialize_with_newrelic_tracing
+          @nr_parent_thread_id = ::Thread.current.object_id
+          yield
+        end
+
+        def add_thread_tracing(*args, &block)
+          return block if skip_tracing?
+
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(*args, &block)
+        end
+
+        def skip_tracing?
+          !NewRelic::Agent.config[:'instrumentation.thread.tracing']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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
+
+require_relative 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module MonitoredThread
+        module Prepend
+          include NewRelic::Agent::Instrumentation::MonitoredThread
+
+          def initialize(*args, &block)
+            traced_block = add_thread_tracing(*args, &block)
+            initialize_with_newrelic_tracing { super(*args, &traced_block) }
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,24 @@
+# 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 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 @@
+# 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
+  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 @@
+# 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 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 @@
+# 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
+
+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/instrumentation/typhoeus/chain.rb

@@ -0,0 +1,22 @@
+# 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 Typhoeus
+    module Chain
+      def self.instrument!
+        ::Typhoeus::Hydra.class_eval do
+          include NewRelic::Agent::Instrumentation::Typhoeus
+
+          def run_with_newrelic(*args)
+            with_tracing { run_without_newrelic(*args) }
+          end
+
+          alias run_without_newrelic run
+          alias run run_with_newrelic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# 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
+  module Agent
+    module Instrumentation
+      module Typhoeus
+        HYDRA_SEGMENT_NAME = "External/Multiple/Typhoeus::Hydra/run"
+        NOTICEABLE_ERROR_CLASS = "Typhoeus::Errors::TyphoeusError"
+
+        EARLIEST_VERSION = Gem::Version.new("0.5.3")
+
+        def self.is_supported_version?
+          Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
+        end
+
+        def self.request_is_hydra_enabled?(request)
+          request.respond_to?(:hydra) && request.hydra
+        end
+
+        def self.response_message(response)
+          if response.respond_to?(:response_message)
+            response.response_message
+          elsif response.respond_to?(:return_message)
+            response.return_message
+          else
+            # 0.5.4 seems to have lost xxxx_message methods altogether.
+            "timeout"
+          end
+        end
+
+        def with_tracing
+          segment = NewRelic::Agent::Tracer.start_segment(name: HYDRA_SEGMENT_NAME)
+          instance_variable_set(:@__newrelic_hydra_segment, segment)
+          begin
+            yield
+          ensure
+            segment.finish if segment
+          end
+        end
+
+        def self.trace(request)
+          state = NewRelic::Agent::Tracer.state
+          return unless state.is_execution_traced?
+
+          wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
+
+          parent = if request_is_hydra_enabled?(request)
+            request.hydra.instance_variable_get(:@__newrelic_hydra_segment)
+          end
+
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method,
+            parent: parent
+          )
+
+          segment.add_request_headers(wrapped_request)
+
+          callback = proc do
+            wrapped_response = HTTPClients::TyphoeusHTTPResponse.new(request.response)
+
+            segment.process_response_headers(wrapped_response)
+
+            if request.response.code == 0
+              segment.notice_error(NoticeableError.new(NOTICEABLE_ERROR_CLASS, response_message(request.response)))
+            end
+
+            segment.finish if segment
+          end
+          request.on_complete.unshift(callback)
+        rescue => e
+          NewRelic::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# 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 Typhoeus
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Typhoeus
+      def run(*args)
+        with_tracing { super }
+      end
+    end
+  end
+end