appsignal 3.10.0 → 3.11.0

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")
@@ -235,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)
@@ -390,8 +561,7 @@ module Appsignal
           else
             Appsignal::Transaction.new(
               SecureRandom.uuid,
-              Appsignal::Transaction::HTTP_REQUEST,
-              Appsignal::Transaction::GenericRequest.new({})
+              Appsignal::Transaction::HTTP_REQUEST
             )
           end
 
@@ -565,8 +735,8 @@ module Appsignal
       # 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` and a block is given to this method, the
-      # `params` argument is leading and the block will _not_ be called.
+      # 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")
@@ -608,6 +778,125 @@ module Appsignal
         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.
       #
       # Breadcrumbs can be used to trace what path a user has taken
@@ -699,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.
@@ -749,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

data/lib/appsignal/hooks/active_job.rb

@@ -54,20 +54,13 @@ module Appsignal
               # we do for Sidekiq.
               #
               # Prefer job_id from provider, instead of ActiveJob's internal ID.
-              Appsignal::Transaction.create(
-                job["provider_job_id"] || job["job_id"],
-                Appsignal::Transaction::BACKGROUND_JOB,
-                Appsignal::Transaction::GenericRequest.new({})
-              )
+              Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
             end
 
           if transaction
             transaction.set_params_if_nil(job["arguments"])
 
             transaction_tags = ActiveJobHelpers.transaction_tags_for(job)
-            transaction_tags["active_job_id"] = job["job_id"]
-            provider_job_id = job["provider_job_id"]
-            transaction_tags[:provider_job_id] = provider_job_id if provider_job_id
             transaction.set_tags(transaction_tags)
 
             transaction.set_action(ActiveJobHelpers.action_name(job))
@@ -154,12 +147,25 @@ module Appsignal
 
         def self.transaction_tags_for(job)
           tags = {}
+
           queue = job["queue_name"]
           tags[:queue] = queue if queue
+
           priority = job["priority"]
           tags[:priority] = priority if priority
+
           executions = job["executions"]
           tags[:executions] = executions.to_i + 1 if executions
+
+          job_id = job["job_id"]
+          tags[:active_job_id] = job_id
+
+          provider_job_id = job["provider_job_id"]
+          tags[:provider_job_id] = provider_job_id if provider_job_id
+
+          request_id = provider_job_id || job_id
+          tags[:request_id] = request_id if request_id
+
           tags
         end
 

data/lib/appsignal/hooks/delayed_job.rb

@@ -14,7 +14,7 @@ module Appsignal
         # The DJ plugin is a subclass of Delayed::Plugin, so we can only
         # require this code if we're actually installing.
         require "appsignal/integrations/delayed_job_plugin"
-        ::Delayed::Worker.plugins << Appsignal::Hooks::DelayedJobPlugin
+        ::Delayed::Worker.plugins << Appsignal::Integrations::DelayedJobPlugin
       end
     end
   end

data/lib/appsignal/hooks/shoryuken.rb

@@ -3,68 +3,6 @@
 module Appsignal
   class Hooks
     # @api private
-    class ShoryukenMiddleware
-      def call(worker_instance, queue, sqs_msg, body, &block)
-        batch = sqs_msg.is_a?(Array)
-        attributes =
-          if batch
-            # We can't instrument batched message separately, the `yield` will
-            # perform all the batched messages.
-            # To provide somewhat useful metadata, Get first message based on
-            # SentTimestamp, and use its attributes as metadata for the
-            # transaction. We can't combine them all because then they would
-            # overwrite each other and the last message (in an sorted order)
-            # would be used as the source of the metadata.  With the
-            # oldest/first message at least some useful information is stored
-            # such as the first received time and the number of retries for the
-            # first message. The newer message should have lower values and
-            # timestamps in their metadata.
-            first_msg = sqs_msg.min do |a, b|
-              a.attributes["SentTimestamp"].to_i <=> b.attributes["SentTimestamp"].to_i
-            end
-            # Add batch => true metadata so people can recognize when a
-            # transaction is about a batch of messages.
-            first_msg.attributes.merge(:batch => true)
-          else
-            sqs_msg.attributes.merge(:message_id => sqs_msg.message_id)
-          end
-        metadata = { :queue => queue }.merge(attributes)
-        options = {
-          :class => worker_instance.class.name,
-          :method => "perform",
-          :metadata => metadata
-        }
-
-        args =
-          if batch
-            bodies = {}
-            sqs_msg.each_with_index do |msg, index|
-              # Store all separate bodies on a hash with the key being the
-              # message_id
-              bodies[msg.message_id] = body[index]
-            end
-            bodies
-          else
-            case body
-            when Hash
-              body
-            else
-              { :params => body }
-            end
-          end
-        options[:params] = Appsignal::Utils::HashSanitizer.sanitize(
-          args,
-          Appsignal.config[:filter_parameters]
-        )
-
-        if attributes.key?("SentTimestamp")
-          options[:queue_start] = Time.at(attributes["SentTimestamp"].to_i / 1000)
-        end
-
-        Appsignal.monitor_transaction("perform_job.shoryuken", options, &block)
-      end
-    end
-
     class ShoryukenHook < Appsignal::Hooks::Hook
       register :shoryuken
 
@@ -73,9 +11,11 @@ module Appsignal
       end
 
       def install
+        require "appsignal/integrations/shoryuken"
+
         ::Shoryuken.configure_server do |config|
           config.server_middleware do |chain|
-            chain.add Appsignal::Hooks::ShoryukenMiddleware
+            chain.add Appsignal::Integrations::ShoryukenMiddleware
           end
         end
       end

data/lib/appsignal/integrations/action_cable.rb

@@ -2,19 +2,16 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module ActionCableIntegration
       def perform_action(*args, &block)
         # The request is only the original websocket request
         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
           super
@@ -26,6 +23,7 @@ module Appsignal
           transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", "websocket")
+          transaction.set_tags(:request_id => request_id) if request_id
           Appsignal::Transaction.complete_current!
         end
       end