appsignal 3.9.3 → 3.11.0

data/lib/appsignal/rack/event_handler.rb

@@ -7,10 +7,32 @@ module Appsignal
     APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
     RACK_AFTER_REPLY = "rack.after_reply"
 
-    # @api private
+    # Instrumentation middleware using Rack's Events module.
+    #
+    # We recommend using this in combination with the
+    # {InstrumentationMiddleware}.
+    #
+    # This middleware will report the response status code as the
+    # `response_status` tag on the sample. It will also report the response
+    # status as the `response_status` metric.
+    #
+    # This middleware will ensure the AppSignal transaction is always completed
+    # for every request.
+    #
+    # @example Add EventHandler to a Rack app
+    #   # Add this middleware as the first middleware of an app
+    #   use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+    #
+    #   # Then add the InstrumentationMiddleware
+    #   use Appsignal::Rack::InstrumentationMiddleware
+    #
+    # @see https://docs.appsignal.com/ruby/integrations/rack.html
+    #   Rack integration documentation.
+    # @api public
     class EventHandler
       include ::Rack::Events::Abstract
 
+      # @api private
       def self.safe_execution(name)
         yield
       rescue => e
@@ -19,27 +41,27 @@ module Appsignal
         )
       end
 
+      # @api private
       attr_reader :id
 
+      # @api private
       def initialize
         @id = SecureRandom.uuid
       end
 
+      # @api private
       def request_handler?(given_id)
         id == given_id
       end
 
+      # @api private
       def on_start(request, _response)
         event_handler = self
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_start") do
           request.env[APPSIGNAL_EVENT_HANDLER_ID] ||= id
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
-          transaction = Appsignal::Transaction.create(
-            SecureRandom.uuid,
-            Appsignal::Transaction::HTTP_REQUEST,
-            request
-          )
+          transaction = Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
           request.env[APPSIGNAL_TRANSACTION] = transaction
 
           request.env[RACK_AFTER_REPLY] ||= []
@@ -49,7 +71,8 @@ module Appsignal
             Appsignal::Rack::EventHandler
               .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
               transaction.finish_event("process_request.rack", "", "")
-              transaction.set_http_or_background_queue_start
+              queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
+              transaction.set_queue_start(queue_start) if queue_start
             end
 
             # Make sure the current transaction is always closed when the request
@@ -65,6 +88,7 @@ module Appsignal
         end
       end
 
+      # @api private
       def on_error(request, _response, error)
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
@@ -77,6 +101,7 @@ module Appsignal
         end
       end
 
+      # @api private
       def on_finish(request, response)
         return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
@@ -85,7 +110,13 @@ module Appsignal
 
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "", "")
-          transaction.set_http_or_background_queue_start
+          transaction.set_params_if_nil { request.params }
+          transaction.set_headers_if_nil { request.env }
+          transaction.set_session_data_if_nil do
+            request.session if request.respond_to?(:session)
+          end
+          queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
+          transaction.set_queue_start(queue_start) if queue_start
           response_status =
             if response
               response.status

data/lib/appsignal/rack/generic_instrumentation.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require "rack"
-
 module Appsignal
-  # @api private
   module Rack
+    # @deprecated Use {InstrumentationMiddleware} instead.
+    # @api private
     class GenericInstrumentation < AbstractMiddleware
       def initialize(app, options = {})
-        options[:instrument_span_name] ||= "process_action.generic"
+        options[:instrument_event_name] ||= "process_action.generic"
         super
       end
 
@@ -16,5 +15,8 @@ module Appsignal
         transaction.set_action_if_nil("unknown")
       end
     end
+
+    # @api private
+    class GenericInstrumentationAlias < GenericInstrumentation; end
   end
 end

data/lib/appsignal/rack/grape_middleware.rb

@@ -2,10 +2,11 @@
 
 module Appsignal
   module Rack
-    # @api private
+    # @api public
     class GrapeMiddleware < Appsignal::Rack::AbstractMiddleware
+      # @api private
       def initialize(app, options = {})
-        options[:instrument_span_name] = "process_request.grape"
+        options[:instrument_event_name] = "process_request.grape"
         options[:report_errors] = lambda { |env| !env["grape.skip_appsignal_error"] }
         super
       end

data/lib/appsignal/rack/hanami_middleware.rb

@@ -6,7 +6,7 @@ module Appsignal
     class HanamiMiddleware < AbstractMiddleware
       def initialize(app, options = {})
         options[:params_method] ||= :params
-        options[:instrument_span_name] ||= "process_action.hanami"
+        options[:instrument_event_name] ||= "process_action.hanami"
         super
       end
 

data/lib/appsignal/rack/instrumentation_middleware.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    # Rack instrumentation middleware.
+    #
+    # This Ruby gem automatically instruments several Rack based libraries,
+    # like Rails and Sinatra. This middleware does not need to be added
+    # manually to these frameworks.
+    #
+    # This instrumentation middleware will wrap an app and report how long the
+    # request and response took, report errors that occurred in the app, and
+    # report metadata about the request method and path.
+    #
+    # The action name for the endpoint is not set by default, which is required
+    # for performance monitoring. Set the action name in each endpoint using
+    # the {Appsignal::Helpers::Instrumentation#set_action} helper.
+    #
+    # If multiple of these middlewares, or
+    # {AbstractMiddleware} subclasses are present in an app, only the top
+    # middleware will report errors from apps and other middleware.
+    #
+    # This middleware is best used in combination with the {EventHandler}.
+    #
+    # @example
+    #   # config.ru
+    #   require "appsignal"
+    #   # Configure and start AppSignal
+    #
+    #   # Add the EventHandler first
+    #   use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+    #   # Add the instrumentation middleware second
+    #   use Appsignal::Rack::InstrumentationMiddleware
+    #
+    #   # Other middleware
+    #
+    #   # Start app
+    #
+    # @example Customize instrumentation event category
+    #   use Appsignal::Rack::InstrumentationMiddleware,
+    #     :instrument_event_name => "custom.goup"
+    #
+    # @example Disable error reporting for this middleware
+    #   use Appsignal::Rack::InstrumentationMiddleware, :report_errors => false
+    #
+    # @example Always report errors, even when wrapped by other instrumentation middleware
+    #   use Appsignal::Rack::InstrumentationMiddleware, :report_errors => true
+    #
+    # @example Disable error reporting for this middleware based on the request env
+    #   use Appsignal::Rack::InstrumentationMiddleware,
+    #     :report_errors => lambda { |env| env["some_key"] == "some value" }
+    #
+    # @see https://docs.appsignal.com/ruby/integrations/rack.html
+    # @api public
+    class InstrumentationMiddleware < AbstractMiddleware
+      def initialize(app, options = {})
+        options[:instrument_event_name] ||= "process_request_middleware.rack"
+        super
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "rack"
-
 module Appsignal
   module Rack
     # @api private
@@ -9,7 +7,7 @@ module Appsignal
       def initialize(app, options = {})
         options[:request_class] ||= ActionDispatch::Request
         options[:params_method] ||= :filtered_parameters
-        options[:instrument_span_name] = nil
+        options[:instrument_event_name] = nil
         options[:report_errors] = true
         super
       end

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "rack"
-
 module Appsignal
   module Rack
     # Stub old middleware. Prevents Sinatra middleware being loaded twice.
@@ -34,7 +32,7 @@ module Appsignal
       def initialize(app, options = {})
         options[:request_class] ||= Sinatra::Request
         options[:params_method] ||= :params
-        options[:instrument_span_name] ||= "process_action.sinatra"
+        options[:instrument_event_name] ||= "process_action.sinatra"
         super
         @raise_errors_on = raise_errors?(app)
       end

data/lib/appsignal/rack/streaming_listener.rb

@@ -1,73 +1,28 @@
 # frozen_string_literal: true
 
+Appsignal::Utils::StdoutAndLoggerMessage.warning \
+  "The constant Appsignal::Rack::StreamingListener has been deprecated. " \
+    "Please update the constant name to " \
+    "Appsignal::Rack::InstrumentationMiddleware."
+
 module Appsignal
   module Rack
-    # Appsignal module that tracks exceptions in Streaming rack responses.
+    # Instrumentation middleware that tracks exceptions in streaming Rack
+    # responses.
     #
+    # @deprecated Use {InstrumentationMiddleware} instead.
     # @api private
-    class StreamingListener
+    class StreamingListener < AbstractMiddleware
       def initialize(app, options = {})
-        Appsignal.internal_logger.debug "Initializing Appsignal::Rack::StreamingListener"
-        @app = app
-        @options = options
-      end
-
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
+        options[:instrument_event_name] ||= "process_streaming_request.rack"
+        super
       end
 
-      def call_with_appsignal_monitoring(env)
-        request = ::Rack::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request
-        )
+      def add_transaction_metadata_after(transaction, request)
+        transaction.set_action_if_nil(request.env["appsignal.action"])
 
-        # Instrument a `process_action`, to set params/action name
-        status, headers, body =
-          Appsignal.instrument("process_action.rack") do
-            @app.call(env)
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            transaction.set_error(e)
-            raise e
-          ensure
-            transaction.set_action_if_nil(env["appsignal.action"])
-            transaction.set_metadata("path", request.path)
-            transaction.set_metadata("method", request.request_method)
-            transaction.set_http_or_background_queue_start
-          end
-
-        # Wrap the result body with our StreamWrapper
-        [status, headers, StreamWrapper.new(body, transaction)]
+        super
       end
     end
   end
-
-  class StreamWrapper
-    def initialize(stream, transaction)
-      @stream = stream
-      @transaction = transaction
-    end
-
-    def each(&block)
-      @stream.each(&block)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      @transaction.set_error(e)
-      raise e
-    end
-
-    def close
-      @stream.close if @stream.respond_to?(:close)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      @transaction.set_error(e)
-      raise e
-    ensure
-      Appsignal::Transaction.complete_current!
-    end
-  end
 end

data/lib/appsignal/rack.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # @api private
+  module Rack
+    class Utils
+      # Fetch the queue start time from the request environment.
+      #
+      # @since 3.11.0
+      # @param env [Hash] Request environment hash.
+      # @return [Integer, NilClass]
+      def self.queue_start_from(env)
+        return unless env
+
+        env_var = env["HTTP_X_QUEUE_START"] || env["HTTP_X_REQUEST_START"]
+        return unless env_var
+
+        cleaned_value = env_var.tr("^0-9", "")
+        return if cleaned_value.empty?
+
+        value = cleaned_value.to_i
+        if value > 4_102_441_200_000
+          # Value is in microseconds. Transform to milliseconds.
+          value / 1_000
+        elsif value < 946_681_200_000
+          # Value is too low to be plausible
+          nil
+        else
+          # Value is in milliseconds
+          value
+        end
+      end
+    end
+
+    # Alias constants that have moved with a warning message that points to the
+    # place to update the reference.
+    def self.const_missing(name)
+      case name
+      when :GenericInstrumentation
+        require "appsignal/rack/generic_instrumentation"
+
+        callers = caller
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The constant Appsignal::Rack::GenericInstrumentation has been deprecated. " \
+            "Please use the new Appsignal::Rack::InstrumentationMiddleware middleware. " \
+            "This new middleware does not default the action name to 'unknown'. " \
+            "Set the action name for the endpoint using the Appsignal.set_action helper. " \
+            "Read our Rack docs for more information " \
+            "https://docs.appsignal.com/ruby/integrations/rack.html " \
+            "Update the constant name to " \
+            "Appsignal::Rack::InstrumentationMiddleware in the following file to " \
+            "remove this message.\n#{callers.first}"
+        # Return the alias so it can't ever get stuck in a recursive loop
+        Appsignal::Rack::GenericInstrumentationAlias
+      else
+        super
+      end
+    end
+  end
+end

data/lib/appsignal/span.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
+  # @api private
   class Span
     def initialize(namespace = nil, ext = nil)
       @ext = ext || Appsignal::Extension::Span.root(namespace || "")