Add tracing support to ActionCable integration (#1640)

st0012 · web-flow · commit 1f59f0b2304f · 2021-12-25T22:10:01.000+08:00
* Avoid using :all callback to setup Rails apps

* Adding tracing support to ActionCable integration

* Use context instead of extra to pass ActionCable data

* Improve ActionCable tests

* Update changelog
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,9 @@
 ## Unreleased
 
+### Features
+
 - Add Action Cable exception capturing (Rails 6+) [#1638](https://github.com/getsentry/sentry-ruby/pull/1638)
+- Add tracing support to `ActionCable` integration [#1640](https://github.com/getsentry/sentry-ruby/pull/1640)
 
 ### Bug Fixes
 
diff --git a/sentry-rails/lib/sentry/rails/action_cable.rb b/sentry-rails/lib/sentry/rails/action_cable.rb
@@ -2,20 +2,40 @@ module Sentry
   module Rails
     module ActionCableExtensions
       class ErrorHandler
-        def self.capture(env, transaction_name:, extra_context: nil, &block)
-          Sentry.with_scope do |scope|
-            scope.set_rack_env(env)
-            scope.set_extras(action_cable: extra_context) if extra_context
-            scope.set_transaction_name(transaction_name)
+        class << self
+          def capture(env, transaction_name:, extra_context: nil, &block)
+            Sentry.with_scope do |scope|
+              scope.set_rack_env(env)
+              scope.set_context("action_cable", extra_context) if extra_context
+              scope.set_transaction_name(transaction_name)
+              transaction = start_transaction(env, scope.transaction_name)
+              scope.set_span(transaction) if transaction
 
-            begin
-              block.call
-            rescue Exception => e # rubocop:disable Lint/RescueException
-              Sentry::Rails.capture_exception(e)
+              begin
+                block.call
+                finish_transaction(transaction, 200)
+              rescue Exception => e # rubocop:disable Lint/RescueException
+                Sentry::Rails.capture_exception(e)
+                finish_transaction(transaction, 500)
 
-              raise
+                raise
+              end
             end
           end
+
+          def start_transaction(env, transaction_name)
+            sentry_trace = env["HTTP_SENTRY_TRACE"]
+            options = { name: transaction_name, op: "rails.action_cable".freeze }
+            transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+            Sentry.start_transaction(transaction: transaction, **options)
+          end
+
+          def finish_transaction(transaction, status_code)
+            return unless transaction
+
+            transaction.set_http_status(status_code)
+            transaction.finish
+          end
         end
       end
 
diff --git a/sentry-rails/spec/sentry/rails/action_cable_spec.rb b/sentry-rails/spec/sentry/rails/action_cable_spec.rb
@@ -2,6 +2,8 @@
   require "spec_helper"
   require "action_cable/engine"
 
+  ::ActionCable.server.config.cable = { "adapter" => "test" }
+
   # ensure we can access `connection.env` in tests like we can in production
   ActiveSupport.on_load :action_cable_channel_test_case do
     class ::ActionCable::Channel::ConnectionStub
@@ -30,73 +32,191 @@ def unsubscribed
   RSpec.describe "Sentry::Rails::ActionCableExtensions", type: :channel do
     let(:transport) { Sentry.get_current_client.transport }
 
-    before(:all) do
-      make_basic_app
-      ::ActionCable.server.config.cable = { "adapter" => "test" }
-    end
-
     after do
       transport.events = []
     end
 
-    describe ChatChannel do
-      it "captures errors during the subscribe" do
-        expect { subscribe room_id: 42 }.to raise_error('foo')
-        expect(transport.events.count).to eq(1)
+    context "without tracing" do
+      before do
+        make_basic_app
+      end
+
+      describe ChatChannel do
+        it "captures errors during the subscribe" do
+          expect { subscribe room_id: 42 }.to raise_error('foo')
+          expect(transport.events.count).to eq(1)
 
-        event = transport.events.last.to_json_compatible
+          event = transport.events.last.to_json_compatible
+          expect(event["transaction"]).to eq("ChatChannel#subscribed")
+          expect(event["contexts"]).to include("action_cable" => { "params" => { "room_id" => 42 } })
+        end
+      end
 
-        expect(event).to include(
-          "transaction" => "ChatChannel#subscribed",
-          "extra" => {
+      describe AppearanceChannel do
+        before { subscribe room_id: 42 }
+
+        it "captures errors during the action" do
+          expect { perform :appear, foo: 'bar' }.to raise_error('foo')
+          expect(transport.events.count).to eq(1)
+
+          event = transport.events.last.to_json_compatible
+
+          expect(event["transaction"]).to eq("AppearanceChannel#appear")
+          expect(event["contexts"]).to include(
             "action_cable" => {
-              "params" => { "room_id" => 42 }
+              "params" => { "room_id" => 42 },
+              "data" => { "action" => "appear", "foo" => "bar" }
             }
-          }
-        )
+          )
+        end
+
+        it "captures errors during unsubscribe" do
+          expect { unsubscribe }.to raise_error('foo')
+          expect(transport.events.count).to eq(1)
+
+          event = transport.events.last.to_json_compatible
 
-        expect(Sentry.get_current_scope.extra).to eq({})
+          expect(event["transaction"]).to eq("AppearanceChannel#unsubscribed")
+          expect(event["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 }
+            }
+          )
+        end
       end
     end
 
-    describe AppearanceChannel do
-      before { subscribe room_id: 42 }
+    context "with tracing enabled" do
+      before do
+        make_basic_app do |config|
+          config.traces_sample_rate = 1.0
+        end
+      end
+
+      describe ChatChannel do
+        it "captures errors and transactions during the subscribe" do
+          expect { subscribe room_id: 42 }.to raise_error('foo')
+          expect(transport.events.count).to eq(2)
+
+          event = transport.events.first.to_json_compatible
 
-      it "captures errors during the action" do
-        expect { perform :appear, foo: 'bar' }.to raise_error('foo')
-        expect(transport.events.count).to eq(1)
+          expect(event["transaction"]).to eq("ChatChannel#subscribed")
+          expect(event["contexts"]).to include("action_cable" => { "params" => { "room_id" => 42 } })
 
-        event = transport.events.last.to_json_compatible
+          transaction = transport.events.last.to_json_compatible
 
-        expect(event).to include(
-          "transaction" => "AppearanceChannel#appear",
-          "extra" => {
+          expect(transaction["type"]).to eq("transaction")
+          expect(transaction["transaction"]).to eq("ChatChannel#subscribed")
+          expect(transaction["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 }
+            }
+          )
+          expect(transaction["contexts"]).to include(
+            "trace" => hash_including(
+              "op" => "rails.action_cable",
+              "status" => "internal_error"
+            )
+          )
+        end
+      end
+
+      describe AppearanceChannel do
+        before { subscribe room_id: 42 }
+
+        it "captures errors and transactions during the action" do
+          expect { perform :appear, foo: 'bar' }.to raise_error('foo')
+          expect(transport.events.count).to eq(3)
+
+          subscription_transaction = transport.events[0].to_json_compatible
+
+          expect(subscription_transaction["type"]).to eq("transaction")
+          expect(subscription_transaction["transaction"]).to eq("AppearanceChannel#subscribed")
+          expect(subscription_transaction["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 }
+            }
+          )
+          expect(subscription_transaction["contexts"]).to include(
+            "trace" => hash_including(
+              "op" => "rails.action_cable",
+              "status" => "ok"
+            )
+          )
+
+          event = transport.events[1].to_json_compatible
+
+          expect(event["transaction"]).to eq("AppearanceChannel#appear")
+          expect(event["contexts"]).to include(
             "action_cable" => {
               "params" => { "room_id" => 42 },
               "data" => { "action" => "appear", "foo" => "bar" }
             }
-          }
-        )
+          )
 
-        expect(Sentry.get_current_scope.extra).to eq({})
-      end
+          action_transaction = transport.events[2].to_json_compatible
 
-      it "captures errors during unsubscribe" do
-        expect { unsubscribe }.to raise_error('foo')
-        expect(transport.events.count).to eq(1)
+          expect(action_transaction["type"]).to eq("transaction")
+          expect(action_transaction["transaction"]).to eq("AppearanceChannel#appear")
+          expect(action_transaction["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 },
+              "data" => { "action" => "appear", "foo" => "bar" }
+            }
+          )
+          expect(action_transaction["contexts"]).to include(
+            "trace" => hash_including(
+              "op" => "rails.action_cable",
+              "status" => "internal_error"
+            )
+          )
+        end
+
+        it "captures errors during unsubscribe" do
+          expect { unsubscribe }.to raise_error('foo')
+          expect(transport.events.count).to eq(3)
+
+          subscription_transaction = transport.events[0].to_json_compatible
+
+          expect(subscription_transaction["type"]).to eq("transaction")
+          expect(subscription_transaction["transaction"]).to eq("AppearanceChannel#subscribed")
+          expect(subscription_transaction["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 }
+            }
+          )
+          expect(subscription_transaction["contexts"]).to include(
+            "trace" => hash_including(
+              "op" => "rails.action_cable",
+              "status" => "ok"
+            )
+          )
+
+          event = transport.events[1].to_json_compatible
+
+          expect(event["transaction"]).to eq("AppearanceChannel#unsubscribed")
+          expect(event["contexts"]).to include(
+            "action_cable" => {
+              "params" => { "room_id" => 42 }
+            }
+          )
 
-        event = transport.events.last.to_json_compatible
+          transaction = transport.events[2].to_json_compatible
 
-        expect(event).to include(
-          "transaction" => "AppearanceChannel#unsubscribed",
-          "extra" => {
+          expect(transaction["type"]).to eq("transaction")
+          expect(transaction["transaction"]).to eq("AppearanceChannel#unsubscribed")
+          expect(transaction["contexts"]).to include(
             "action_cable" => {
               "params" => { "room_id" => 42 }
             }
-          }
-        )
-
-        expect(Sentry.get_current_scope.extra).to eq({})
+          )
+          expect(transaction["contexts"]).to include(
+            "trace" => hash_including(
+              "op" => "rails.action_cable",
+              "status" => "internal_error"
+            )
+          )
+        end
       end
     end
   end
