newrelic_rpm 5.5.0.348 → 7.2.0

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

@@ -0,0 +1,55 @@
+# 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 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,45 @@
 # 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.
 
-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,124 @@
+# 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.
+
+# 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 @@
+# 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 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

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/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent

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/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   @name = :sunspot

data/lib/new_relic/agent/instrumentation/typhoeus.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.
+
+require_relative 'typhoeus/instrumentation'
+require_relative 'typhoeus/chain'
+require_relative 'typhoeus/prepend'
 
 DependencyDetection.defer do
   named :typhoeus
@@ -10,19 +14,19 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
+    NewRelic::Agent::Instrumentation::Typhoeus.is_supported_version?
   end
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Typhoeus instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/typhoeus_wrappers'
   end
 
   # Basic request tracing
   executes do
     Typhoeus.before do |request|
-      NewRelic::Agent::Instrumentation::TyphoeusTracing.trace(request)
+      NewRelic::Agent::Instrumentation::Typhoeus.trace(request)
 
       # Ensure that we always return a truthy value from the before block,
       # otherwise Typhoeus will bail out of the instrumentation.
@@ -32,76 +36,10 @@ DependencyDetection.defer do
 
   # Apply single TT node for Hydra requests until async support
   executes do
-    class Typhoeus::Hydra
-
-      def run_with_newrelic(*args)
-        segment = NewRelic::Agent::Transaction.start_segment(
-          name: NewRelic::Agent::Instrumentation::TyphoeusTracing::HYDRA_SEGMENT_NAME
-        )
-
-        instance_variable_set :@__newrelic_hydra_segment, segment
-
-        begin
-          run_without_newrelic(*args)
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias run_without_newrelic run
-      alias run run_with_newrelic
-    end
-  end
-end
-
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module TyphoeusTracing
-
-        HYDRA_SEGMENT_NAME = "External/Multiple/Typhoeus::Hydra/run"
-
-        EARLIEST_VERSION = Gem::Version.new("0.5.3")
-
-        def self.is_supported_version?
-          Gem::Version.new(Typhoeus::VERSION) >= NewRelic::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
-        end
-
-        def self.request_is_hydra_enabled?(request)
-          request.respond_to?(:hydra) && request.hydra
-        end
-
-        def self.trace(request)
-          state = NewRelic::Agent::TransactionState.tl_get
-          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::Transaction.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.new do
-            wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-            segment.read_response_headers wrapped_response
-            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
+    if use_prepend?
+      prepend_instrument Typhoeus::Hydra, NewRelic::Agent::Instrumentation::Typhoeus::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Typhoeus::Chain
     end
   end
 end

data/lib/new_relic/agent/instrumentation/typhoeus/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 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