appsignal 3.10.0-java → 3.12.0-java

data/lib/appsignal/rack/event_handler.rb

@@ -2,15 +2,32 @@
 
 module Appsignal
   module Rack
-    APPSIGNAL_TRANSACTION = "appsignal.transaction"
-    APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
-    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 +36,29 @@ 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)
+        return unless Appsignal.active?
+
         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 +68,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,7 +85,10 @@ module Appsignal
         end
       end
 
+      # @api private
       def on_error(request, _response, error)
+        return unless Appsignal.active?
+
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
@@ -77,7 +100,9 @@ module Appsignal
         end
       end
 
+      # @api private
       def on_finish(request, response)
+        return unless Appsignal.active?
         return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
         transaction = request.env[APPSIGNAL_TRANSACTION]
@@ -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

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Rack
+    # @deprecated Use {InstrumentationMiddleware} instead.
     # @api private
     class GenericInstrumentation < AbstractMiddleware
       def initialize(app, options = {})

data/lib/appsignal/rack/grape_middleware.rb

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

data/lib/appsignal/rack/streaming_listener.rb

@@ -10,6 +10,7 @@ module Appsignal
     # Instrumentation middleware that tracks exceptions in streaming Rack
     # responses.
     #
+    # @deprecated Use {InstrumentationMiddleware} instead.
     # @api private
     class StreamingListener < AbstractMiddleware
       def initialize(app, options = {})

data/lib/appsignal/rack.rb

@@ -3,6 +3,41 @@
 module Appsignal
   # @api private
   module Rack
+    APPSIGNAL_TRANSACTION = "appsignal.transaction"
+    APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
+    APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
+    APPSIGNAL_RESPONSE_INSTRUMENTED = "appsignal.response_instrumentation_active"
+    RACK_AFTER_REPLY = "rack.after_reply"
+
+    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)

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 || "")