appsignal 3.10.0-java → 3.11.0-java

data/lib/appsignal/rack/abstract_middleware.rb

@@ -9,6 +9,7 @@ module Appsignal
     # Do not use this middleware directly. Instead use
     # {InstrumentationMiddleware}.
     #
+    # @abstract
     # @api private
     class AbstractMiddleware
       DEFAULT_ERROR_REPORTING = :default
@@ -33,11 +34,7 @@ module Appsignal
             if wrapped_instrumentation
               env[Appsignal::Rack::APPSIGNAL_TRANSACTION]
             else
-              Appsignal::Transaction.create(
-                SecureRandom.uuid,
-                Appsignal::Transaction::HTTP_REQUEST,
-                request
-              )
+              Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
             end
 
           unless wrapped_instrumentation
@@ -80,7 +77,7 @@ module Appsignal
       # Either another {AbstractMiddleware} or {EventHandler} is higher in the
       # stack and will report the exception and complete the transaction.
       #
-      # @see {#instrument_app_call_with_exception_handling}
+      # @see #instrument_app_call_with_exception_handling
       def instrument_app_call(env, transaction)
         if @instrument_event_name
           Appsignal.instrument(@instrument_event_name) do
@@ -108,7 +105,7 @@ module Appsignal
       # {#instrument_app_call} this will report any exceptions being
       # raised.
       #
-      # @see {#instrument_app_call}
+      # @see #instrument_app_call
       def instrument_app_call_with_exception_handling(env, transaction, wrapped_instrumentation)
         instrument_app_call(env, transaction)
       rescue Exception => error # rubocop:disable Lint/RescueException
@@ -147,7 +144,14 @@ module Appsignal
         transaction.set_metadata("method", request_method) if request_method
 
         transaction.set_params_if_nil { params_for(request) }
-        transaction.set_http_or_background_queue_start
+        transaction.set_session_data_if_nil do
+          request.session if request.respond_to?(:session)
+        end
+        transaction.set_headers_if_nil do
+          request.env if request.respond_to?(:env)
+        end
+        queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
+        transaction.set_queue_start(queue_start) if queue_start
       end
 
       def params_for(request)
@@ -155,9 +159,9 @@ module Appsignal
 
         request.send(@params_method)
       rescue => error
-        # Getting params from the request has been know to fail.
-        Appsignal.internal_logger.debug(
-          "Exception while getting params in #{self.class} from '#{@params_method}': #{error}"
+        Appsignal.internal_logger.error(
+          "Exception while fetching params from '#{@request_class}##{@params_method}': " \
+            "#{error.class} #{error}"
         )
         nil
       end
@@ -165,7 +169,9 @@ module Appsignal
       def request_method_for(request)
         request.request_method
       rescue => error
-        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
+        )
         nil
       end
 

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

@@ -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,35 @@
 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)

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