appsignal 3.9.3-java → 3.11.0-java

data/lib/appsignal/helpers/instrumentation.rb

@@ -5,6 +5,161 @@ module Appsignal
     module Instrumentation
       include Appsignal::Utils::StdoutAndLoggerMessage
 
+      # Monitor a block of code with AppSignal.
+      #
+      # This is a helper to create an AppSignal transaction, track any errors
+      # that may occur and complete the transaction.
+      #
+      # This helper is recommended to be used in Ruby scripts and parts of an
+      # app not already instrumented by AppSignal's automatic instrumentations.
+      #
+      # Use this helper in combination with our {.instrument} helper to track
+      # instrumentation events.
+      #
+      # If AppSignal is not active ({Appsignal.active?}) it will still execute
+      # the block, but not create a transaction for it.
+      #
+      # @example Instrument a block of code
+      #   Appsignal.monitor(
+      #     :namespace => "my_namespace",
+      #     :action => "MyClass#my_method"
+      #   ) do
+      #     # Some code
+      #   end
+      #
+      # @example Instrument a block of code using the default namespace
+      #   Appsignal.monitor(
+      #     :action => "MyClass#my_method"
+      #   ) do
+      #     # Some code
+      #   end
+      #
+      # @example Instrument a block of code with an instrumentation event
+      #   Appsignal.monitor(
+      #     :namespace => "my_namespace",
+      #     :action => "MyClass#my_method"
+      #   ) do
+      #     Appsignal.instrument("some_event.some_group") do
+      #       # Some code
+      #     end
+      #   end
+      #
+      # @example Set the action name in the monitor block
+      #   Appsignal.monitor(
+      #     :action => nil
+      #   ) do
+      #     # Some code
+      #
+      #     Appsignal.set_action("GET /resource/:id")
+      #   end
+      #
+      # @example Set the action name in the monitor block
+      #   Appsignal.monitor(
+      #     :action => :set_later # Explicit placeholder
+      #   ) do
+      #     # Some code
+      #
+      #     Appsignal.set_action("GET /resource/:id")
+      #   end
+      #
+      # @example Set custom metadata on the transaction
+      #   Appsignal.monitor(
+      #     :namespace => "my_namespace",
+      #     :action => "MyClass#my_method"
+      #   ) do
+      #     # Some code
+      #
+      #     Appsignal.set_tags(:tag1 => "value1", :tag2 => "value2")
+      #     Appsignal.set_params(:param1 => "value1", :param2 => "value2")
+      #   end
+      #
+      # @example Call monitor within monitor will do nothing
+      #   Appsignal.monitor(
+      #     :namespace => "my_namespace",
+      #     :action => "MyClass#my_method"
+      #   ) do
+      #     # This will _not_ update the namespace and action name
+      #     Appsignal.monitor(
+      #       :namespace => "my_other_namespace",
+      #       :action => "MyOtherClass#my_other_method"
+      #     ) do
+      #       # Some code
+      #
+      #       # The reported namespace will be "my_namespace"
+      #       # The reported action will be "MyClass#my_method"
+      #     end
+      #   end
+      #
+      # @param namespace [String/Symbol] The namespace to set on the new
+      #   transaction.
+      #   Defaults to the 'web' namespace.
+      #   This will not update the active transaction's namespace if
+      #   {.monitor} is called when another transaction is already active.
+      # @param action [String, Symbol, NilClass]
+      #   The action name for the transaction.
+      #   The action name is required to be set for the transaction to be
+      #   reported.
+      #   The argument can be set to `nil` or `:set_later` if the action is set
+      #   within the block with {#set_action}.
+      #   This will not update the active transaction's action if
+      #   {.monitor} is called when another transaction is already active.
+      # @yield The block to monitor.
+      # @raise [Exception] Any exception that occurs within the given block is
+      #   re-raised by this method.
+      # @return [Object] The value of the given block is returned.
+      # @since 3.11.0
+      def monitor(
+        action:, namespace: nil
+      )
+        return yield unless active?
+
+        has_parent_transaction = Appsignal::Transaction.current?
+        if has_parent_transaction
+          callers = caller
+          Appsignal::Utils::StdoutAndLoggerMessage.warning \
+            "An active transaction around this 'Appsignal.monitor' call. " \
+              "Calling `Appsignal.monitor` in another `Appsignal.monitor` block has no effect. " \
+              "The namespace and action are not updated for the active transaction." \
+              "Did you mean to use `Appsignal.instrument`? " \
+              "Update the 'Appsignal.monitor' call in: #{callers.first}"
+          return yield if block_given?
+
+          return
+        end
+
+        transaction =
+          if has_parent_transaction
+            Appsignal::Transaction.current
+          else
+            Appsignal::Transaction.create(namespace || Appsignal::Transaction::HTTP_REQUEST)
+          end
+
+        begin
+          yield if block_given?
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          transaction.set_action_if_nil(action.to_s) if action && action != :set_later
+          Appsignal::Transaction.complete_current!
+        end
+      end
+
+      # Instrument a block of code and stop AppSignal.
+      #
+      # Useful for cases such as one-off scripts where there is no long running
+      # process active and the data needs to be sent after the process exists.
+      #
+      # Acts the same way as {.monitor}. See that method for more
+      # documentation.
+      #
+      # @see monitor
+      def monitor_and_stop(action:, namespace: nil)
+        monitor(:namespace => namespace, :action => action)
+      ensure
+        Appsignal.stop("monitor_and_stop")
+      end
+
       # Creates an AppSignal transaction for the given block.
       #
       # If AppSignal is not {Appsignal.active?} it will still execute the
@@ -58,12 +213,22 @@ module Appsignal
       # @return [Object] the value of the given block is returned.
       # @since 0.10.0
       def monitor_transaction(name, env = {}, &block)
+        stdout_and_logger_warning \
+          "The `Appsignal.monitor_transaction` helper is deprecated. " \
+            "Please use `Appsignal.monitor` and `Appsignal.instrument` instead. " \
+            "Read our instrumentation documentation: " \
+            "https://docs.appsignal.com/ruby/instrumentation/instrumentation.html"
+        _monitor_transaction(name, env, &block)
+      end
+
+      # @api private
+      def _monitor_transaction(name, env = {}, &block)
         # Always verify input, even when Appsignal is not active.
         # This makes it more likely invalid arguments get flagged in test/dev
         # environments.
         if name.start_with?("perform_job")
           namespace = Appsignal::Transaction::BACKGROUND_JOB
-          request   = Appsignal::Transaction::GenericRequest.new(env)
+          request   = Appsignal::Transaction::InternalGenericRequest.new(env)
         elsif name.start_with?("process_action")
           namespace = Appsignal::Transaction::HTTP_REQUEST
           request   = ::Rack::Request.new(env)
@@ -88,7 +253,9 @@ module Appsignal
           raise error
         ensure
           transaction.set_http_or_background_action(request.env)
-          transaction.set_http_or_background_queue_start
+          queue_start = Appsignal::Rack::Utils.queue_start_from(request.env) ||
+            (env[:queue_start]&.to_i&.* 1_000)
+          transaction.set_queue_start(queue_start) if queue_start
           Appsignal::Transaction.complete_current!
         end
       end
@@ -101,6 +268,11 @@ module Appsignal
       #
       # @see monitor_transaction
       def monitor_single_transaction(name, env = {}, &block)
+        stdout_and_logger_warning \
+          "The `Appsignal.monitor_single_transaction` helper is deprecated. " \
+            "Please use `Appsignal.monitor_and_stop` and `Appsignal.instrument` instead. " \
+            "Read our instrumentation documentation: " \
+            "https://docs.appsignal.com/ruby/instrumentation/instrumentation.html"
         monitor_transaction(name, env, &block)
       ensure
         stop("monitor_single_transaction")
@@ -195,6 +367,7 @@ module Appsignal
       #   used to send the error.
       # @return [void]
       #
+      # @see Transaction#report_error
       # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
       #   Exception handling guide
       # @see https://docs.appsignal.com/ruby/instrumentation/tagging.html
@@ -234,8 +407,7 @@ module Appsignal
         end
         transaction = Appsignal::Transaction.new(
           SecureRandom.uuid,
-          namespace || Appsignal::Transaction::HTTP_REQUEST,
-          Appsignal::Transaction::GenericRequest.new({})
+          namespace || Appsignal::Transaction::HTTP_REQUEST
         )
         transaction.set_tags(tags) if tags
         transaction.set_error(error)
@@ -294,6 +466,7 @@ module Appsignal
       # @return [void]
       #
       # @see Transaction#set_error
+      # @see Transaction#report_error
       # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
       #   Exception handling guide
       # @since 0.6.6
@@ -334,6 +507,73 @@ module Appsignal
       alias :set_exception :set_error
       alias :add_exception :set_error
 
+      # Report an error.
+      #
+      # If a transaction is currently active, it will report the error on the
+      # current transaction. If no transaction is active, it will report the
+      # error on a new transaction.
+      #
+      # **Note**: If AppSignal is not active, no error is reported.
+      #
+      # **Note**: If the given exception argument is not an Exception subclass,
+      # it will not be reported.
+      #
+      # @example
+      #   class SomeController < ApplicationController
+      #     def create
+      #       # Do something that breaks
+      #     rescue => error
+      #       Appsignal.report_error(error)
+      #     end
+      #   end
+      #
+      # @example Add more metadata to transaction
+      #   Appsignal.report_error(error) do |transaction|
+      #     transaction.set_namespace("my_namespace")
+      #     transaction.set_action("my_action_name")
+      #     transaction.set_params(:search_query => params[:search_query])
+      #     transaction.set_tags(:key => "value")
+      #   end
+      #
+      # @param exception [Exception] The error to add to the current
+      #   transaction.
+      # @yield [transaction] yields block to allow modification of the
+      #   transaction.
+      # @yieldparam transaction [Transaction] yields the AppSignal transaction
+      #   used to report the error.
+      # @return [void]
+      #
+      # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
+      #   Exception handling guide
+      # @since 3.10.0
+      def report_error(exception)
+        unless exception.is_a?(Exception)
+          internal_logger.error "Appsignal.report_error: Cannot set error. " \
+            "The given value is not an exception: #{exception.inspect}"
+          return
+        end
+        return unless active?
+
+        has_parent_transaction = Appsignal::Transaction.current?
+        transaction =
+          if has_parent_transaction
+            Appsignal::Transaction.current
+          else
+            Appsignal::Transaction.new(
+              SecureRandom.uuid,
+              Appsignal::Transaction::HTTP_REQUEST
+            )
+          end
+
+        transaction.set_error(exception)
+        yield transaction if block_given?
+
+        return if has_parent_transaction
+
+        transaction.complete
+      end
+      alias :report_exception :report_error
+
       # Set a custom action name for the current transaction.
       #
       # When using an integration such as the Rails or Sinatra AppSignal will
@@ -404,13 +644,44 @@ module Appsignal
         Appsignal::Transaction.current.set_namespace(namespace)
       end
 
+      # Set custom data on the current transaction.
+      #
+      # Add extra information about the request or background that cannot be
+      # expressed in tags, like nested data structures.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # @example
+      #   Appsignal.set_custom_data(:user => { :locale => "en" })
+      #   Appsignal.set_custom_data([
+      #     "array with data",
+      #     :options => { :verbose => true }
+      #   ])
+      #
+      # @since 3.10.0
+      # @see Transaction#set_custom_data
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @param data [Hash/Array]
+      # @return [void]
+      def set_custom_data(data)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_custom_data(data)
+      end
+
       # Set tags on the current transaction.
       #
       # Tags are extra bits of information that are added to transaction and
       # appear on sample details pages on AppSignal.com.
       #
+      # When this method is called multiple times, it will merge the tags.
+      #
       # @example
-      #   Appsignal.tag_request(:locale => "en")
+      #   Appsignal.tag_request(:locale => "en", :user_id => 1)
       #   Appsignal.tag_request("locale" => "en")
       #   Appsignal.tag_request("user_id" => 1)
       #
@@ -445,6 +716,186 @@ module Appsignal
         transaction.set_tags(tags)
       end
       alias :tag_job :tag_request
+      alias :set_tags :tag_request
+
+      # Set parameters on the current transaction.
+      #
+      # Parameters are automatically set by most of our integrations. It should
+      # not be necessary to call this method unless you want to report
+      # different parameters.
+      #
+      # To filter parameters, see our parameter filtering guide.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # When no parameters are set this way, the transaction will look for
+      # parameters in its request environment.
+      #
+      # A block can be given to this method to defer the fetching and parsing
+      # of the parameters until and only when the transaction is sampled.
+      #
+      # When both the `params` argument and a block is given to this method,
+      # the `params` argument is leading and the block will _not_ be called.
+      #
+      # @example Set parameters
+      #   Appsignal.set_params("param1" => "value1")
+      #
+      # @example Calling `set_params` multiple times will only keep the last call
+      #   Appsignal.set_params("param1" => "value1")
+      #   Appsignal.set_params("param2" => "value2")
+      #   # The parameters are: { "param2" => "value2" }
+      #
+      # @example Calling `set_params` with a block
+      #   Appsignal.set_params do
+      #     # Some slow code to parse parameters
+      #     JSON.parse('{"param1": "value1"}')
+      #   end
+      #   # The parameters are: { "param1" => "value1" }
+      #
+      # @example Calling `set_params` with a parameter and a block
+      #   Appsignal.set_params("argument" => "argument value") do
+      #     # Some slow code to parse parameters
+      #     JSON.parse('{"param1": "value1"}')
+      #   end
+      #   # The parameters are: { "argument" => "argument value" }
+      #
+      # @since 3.10.0
+      # @param params [Hash] The parameters to set on the transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new parameters.
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @see https://docs.appsignal.com/guides/filter-data/filter-parameters.html
+      #   Parameter filtering guide
+      # @see Transaction#set_params
+      # @return [void]
+      def set_params(params = nil, &block)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_params(params, &block)
+      end
+
+      # Set session data on the current transaction.
+      #
+      # Session data is automatically set by most of our integrations. It
+      # should not be necessary to call this method unless you want to report
+      # different session data.
+      #
+      # To filter session data, see our session data filtering guide.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # A block can be given to this method to defer the fetching and parsing
+      # of the session data until and only when the transaction is sampled.
+      #
+      # When both the `session_data` argument and a block is given to this
+      # method, the `session_data` argument is leading and the block will _not_
+      # be called.
+      #
+      # @example Set session data
+      #   Appsignal.set_session_data("data" => "value")
+      #
+      # @example Calling `set_session_data` multiple times will only keep the last call
+      #   Appsignal.set_session_data("data1" => "value1")
+      #   Appsignal.set_session_data("data2" => "value2")
+      #   # The session data is: { "data2" => "value2" }
+      #
+      # @example Calling `set_session_data` with a block
+      #   Appsignal.set_session_data do
+      #     # Some slow code to parse session data
+      #     JSON.parse('{"data": "value"}')
+      #   end
+      #   # The session data is: { "data" => "value" }
+      #
+      # @example Calling `set_session_data` with a session_data argument and a block
+      #   Appsignal.set_session_data("argument" => "argument value") do
+      #     # Some slow code to parse session data
+      #     JSON.parse('{"data": "value"}')
+      #   end
+      #   # The session data is: { "argument" => "argument value" }
+      #
+      # @since 3.11.0
+      # @param session_data [Hash] The session data to set on the transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new session data.
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @see https://docs.appsignal.com/guides/filter-data/filter-session-data.html
+      #   Session data filtering guide
+      # @see Transaction#set_session_data
+      # @return [void]
+      def set_session_data(session_data = nil, &block)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_session_data(session_data, &block)
+      end
+
+      # Set request headers on the current transaction.
+      #
+      # Request headers are automatically set by most of our integrations. It
+      # should not be necessary to call this method unless you want to report
+      # different request headers.
+      #
+      # To filter request headers, see our session data filtering guide.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # A block can be given to this method to defer the fetching and parsing
+      # of the request headers until and only when the transaction is sampled.
+      #
+      # When both the `request_headers` argument and a block is given to this
+      # method, the `request_headers` argument is leading and the block will
+      # _not_ be called.
+      #
+      # @example Set request headers
+      #   Appsignal.set_headers(
+      #     "PATH_INFO" => "/some-path",
+      #     "HTTP_USER_AGENT" => "Firefox"
+      #   )
+      #
+      # @example Calling `set_headers` multiple times will only keep the last call
+      #   Appsignal.set_headers("PATH_INFO" => "/some-path")
+      #   Appsignal.set_headers("HTTP_USER_AGENT" => "Firefox")
+      #   # The request headers are: { "HTTP_USER_AGENT" => "Firefox" }
+      #
+      # @example Calling `set_headers` with a block
+      #   Appsignal.set_headers do
+      #     # Some slow code to parse request headers
+      #     JSON.parse('{"PATH_INFO": "/some-path"}')
+      #   end
+      #   # The session data is: { "PATH_INFO" => "/some-path" }
+      #
+      # @example Calling `set_headers` with a headers argument and a block
+      #   Appsignal.set_headers("PATH_INFO" => "/some-path") do
+      #     # Some slow code to parse session data
+      #     JSON.parse('{"PATH_INFO": "/block-path"}')
+      #   end
+      #   # The session data is: { "PATH_INFO" => "/some-path" }
+      #
+      # @since 3.11.0
+      # @param headers [Hash] The request headers to set on the transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new request headers.
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @see https://docs.appsignal.com/guides/filter-data/filter-headers.html
+      #   Request headers filtering guide
+      # @see Transaction#set_headers
+      # @return [void]
+      def set_headers(headers = nil, &block)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_headers(headers, &block)
+      end
 
       # Add breadcrumbs to the transaction.
       #
@@ -537,14 +988,11 @@ module Appsignal
         name,
         title = nil,
         body = nil,
-        body_format = Appsignal::EventFormatter::DEFAULT
+        body_format = Appsignal::EventFormatter::DEFAULT,
+        &block
       )
-        Appsignal::Transaction.current.start_event
-        yield if block_given?
-      ensure
-        Appsignal::Transaction
-          .current
-          .finish_event(name, title, body, body_format)
+        Appsignal::Transaction.current
+          .instrument(name, title, body, body_format, &block)
       end
 
       # Instrumentation helper for SQL queries.
@@ -587,22 +1035,48 @@ module Appsignal
         )
       end
 
-      # Convenience method for skipping instrumentations around a block of code.
+      # Convenience method for ignoring instrumentation events in a block of
+      # code.
+      #
+      # - This helper ignores events, like those created
+      #   `Appsignal.instrument`, within this block.
+      #   This includes custom instrumentation and events recorded by AppSignal
+      #   integrations for requests, database queries, view rendering, etc.
+      # - The time spent in the block is still reported on the transaction.
+      # - Errors and metrics are reported from within this block.
       #
       # @example
-      #   Appsignal.without_instrumentation do
+      #   Appsignal.instrument "my_event.my_group" do
       #     # Complex code here
       #   end
+      #   Appsignal.ignore_instrumentation_events do
+      #     Appsignal.instrument "my_ignored_event.my_ignored_group" do
+      #       # Complex code here
+      #     end
+      #   end
+      #
+      #   # Only the "my_event.my_group" instrumentation event is reported.
       #
       # @yield block of code that shouldn't be instrumented.
       # @return [Object] Returns the return value of the block.
-      # @since 0.8.7
-      def without_instrumentation
+      # @since 3.10.0
+      # @see https://docs.appsignal.com/ruby/instrumentation/ignore-instrumentation.html
+      #   Ignore instrumentation guide
+      def ignore_instrumentation_events
         Appsignal::Transaction.current&.pause!
         yield
       ensure
         Appsignal::Transaction.current&.resume!
       end
+
+      # @deprecated Use {.ignore_instrumentation_events} instead.
+      # @since 0.8.7
+      def without_instrumentation(&block)
+        stdout_and_logger_warning \
+          "The `Appsignal.without_instrumentation` helper is deprecated. " \
+            "Please use `Appsignal.ignore_instrumentation_events` instead."
+        ignore_instrumentation_events(&block)
+      end
     end
   end
 end

data/lib/appsignal/hooks/action_cable.rb

@@ -17,12 +17,13 @@ module Appsignal
         require "appsignal/integrations/action_cable"
         ActionCable::Channel::Base.prepend Appsignal::Integrations::ActionCableIntegration
 
-        install_callbacks
+        install_subscribe_callback
+        install_unsubscribe_callback
       end
 
       private
 
-      def install_callbacks
+      def install_subscribe_callback
         ActionCable::Channel::Base.set_callback :subscribe, :around,
           :prepend => true do |channel, inner|
           # The request is only the original websocket request
@@ -32,14 +33,11 @@ module Appsignal
           # in apps' test suites.
           env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
-          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
-            request.request_id || SecureRandom.uuid
+          request_id = request.request_id || SecureRandom.uuid
+          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
-          transaction = Appsignal::Transaction.create(
-            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
-            Appsignal::Transaction::ACTION_CABLE,
-            request
-          )
+          transaction =
+            Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
 
           begin
             Appsignal.instrument "subscribed.action_cable" do
@@ -52,10 +50,16 @@ module Appsignal
             transaction.set_action_if_nil("#{channel.class}#subscribed")
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
+            transaction.set_params_if_nil { request.params }
+            transaction.set_headers_if_nil { request.env }
+            transaction.set_session_data { request.session if request.respond_to? :session }
+            transaction.set_tags(:request_id => request_id) if request_id
             Appsignal::Transaction.complete_current!
           end
         end
+      end
 
+      def install_unsubscribe_callback
         ActionCable::Channel::Base.set_callback :unsubscribe, :around,
           :prepend => true do |channel, inner|
           # The request is only the original websocket request
@@ -65,14 +69,11 @@ module Appsignal
           # in apps' test suites.
           env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
-          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
-            request.request_id || SecureRandom.uuid
+          request_id = request.request_id || SecureRandom.uuid
+          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
-          transaction = Appsignal::Transaction.create(
-            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
-            Appsignal::Transaction::ACTION_CABLE,
-            request
-          )
+          transaction =
+            Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
 
           begin
             Appsignal.instrument "unsubscribed.action_cable" do
@@ -85,6 +86,10 @@ module Appsignal
             transaction.set_action_if_nil("#{channel.class}#unsubscribed")
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
+            transaction.set_params_if_nil { request.params }
+            transaction.set_headers_if_nil { request.env }
+            transaction.set_session_data { request.session if request.respond_to? :session }
+            transaction.set_tags(:request_id => request_id) if request_id
             Appsignal::Transaction.complete_current!
           end
         end