appsignal 2.2.1 → 2.3.0.beta.1

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require "yaml"
 
 module Appsignal
-  VERSION = "2.2.1".freeze
+  VERSION = "2.3.0.beta.1".freeze
 end

data/spec/lib/appsignal/config_spec.rb

@@ -84,8 +84,9 @@ describe Appsignal::Config do
       expect(config.config_hash).to eq(
         :debug                          => false,
         :log                            => "file",
-        :ignore_errors                  => [],
         :ignore_actions                 => [],
+        :ignore_errors                  => [],
+        :ignore_namespaces              => [],
         :filter_parameters              => [],
         :instrument_net_http            => true,
         :instrument_redis               => true,
@@ -279,6 +280,8 @@ describe Appsignal::Config do
       ENV["APPSIGNAL_APP_NAME"]             = "App name"
       ENV["APPSIGNAL_DEBUG"]                = "true"
       ENV["APPSIGNAL_IGNORE_ACTIONS"]       = "action1,action2"
+      ENV["APPSIGNAL_IGNORE_ERRORS"]        = "VerySpecificError,AnotherError"
+      ENV["APPSIGNAL_IGNORE_NAMESPACES"]    = "admin,private_namespace"
       ENV["APPSIGNAL_INSTRUMENT_NET_HTTP"]  = "false"
       ENV["APPSIGNAL_INSTRUMENT_REDIS"]     = "false"
       ENV["APPSIGNAL_INSTRUMENT_SEQUEL"]    = "false"
@@ -294,6 +297,8 @@ describe Appsignal::Config do
       expect(config[:name]).to eq "App name"
       expect(config[:debug]).to be_truthy
       expect(config[:ignore_actions]).to eq %w(action1 action2)
+      expect(config[:ignore_errors]).to eq %w(VerySpecificError AnotherError)
+      expect(config[:ignore_namespaces]).to eq %w(admin private_namespace)
       expect(config[:instrument_net_http]).to be_falsey
       expect(config[:instrument_redis]).to be_falsey
       expect(config[:instrument_sequel]).to be_falsey
@@ -366,6 +371,7 @@ describe Appsignal::Config do
       config[:http_proxy] = "http://localhost"
       config[:ignore_actions] = %w(action1 action2)
       config[:ignore_errors] = %w(VerySpecificError AnotherError)
+      config[:ignore_namespaces] = %w(admin private_namespace)
       config[:log] = "stdout"
       config[:log_path] = "/tmp"
       config[:hostname] = "app1.local"
@@ -391,6 +397,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_HTTP_PROXY"]).to                   eq "http://localhost"
       expect(ENV["_APPSIGNAL_IGNORE_ACTIONS"]).to               eq "action1,action2"
       expect(ENV["_APPSIGNAL_IGNORE_ERRORS"]).to                eq "VerySpecificError,AnotherError"
+      expect(ENV["_APPSIGNAL_IGNORE_NAMESPACES"]).to            eq "admin,private_namespace"
       expect(ENV["_APPSIGNAL_FILTER_PARAMETERS"]).to            eq "password,confirm_password"
       expect(ENV["_APPSIGNAL_SEND_PARAMS"]).to                  eq "true"
       expect(ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]).to         eq "false"

data/spec/lib/appsignal/hooks/action_cable_spec.rb

@@ -0,0 +1,370 @@
+describe Appsignal::Hooks::ActionCableHook do
+  if DependencyHelper.action_cable_present?
+    context "with ActionCable" do
+      require "action_cable/engine"
+
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns true" do
+          is_expected.to be_truthy
+        end
+      end
+
+      describe ActionCable::Channel::Base do
+        let(:transaction) do
+          Appsignal::Transaction.new(
+            transaction_id,
+            Appsignal::Transaction::ACTION_CABLE,
+            ActionDispatch::Request.new(env)
+          )
+        end
+        let(:channel) do
+          Class.new(ActionCable::Channel::Base) do
+            def speak(_data)
+            end
+
+            def self.to_s
+              "MyChannel"
+            end
+          end
+        end
+        let(:log) { StringIO.new }
+        let(:server) do
+          ActionCable::Server::Base.new.tap do |s|
+            s.config.logger = ActiveSupport::Logger.new(log)
+          end
+        end
+        let(:connection) { ActionCable::Connection::Base.new(server, env) }
+        let(:identifier) { { :channel => "MyChannel" }.to_json }
+        let(:params) { {} }
+        let(:request_id) { SecureRandom.uuid }
+        let(:transaction_id) { request_id }
+        let(:env) do
+          http_request_env_with_data("action_dispatch.request_id" => request_id, :params => params)
+        end
+        let(:instance) { channel.new(connection, identifier, params) }
+        subject { transaction.to_h }
+        before do
+          start_agent
+          expect(Appsignal.active?).to be_truthy
+          transaction
+
+          expect(Appsignal::Transaction).to receive(:create)
+            .with(transaction_id, Appsignal::Transaction::ACTION_CABLE, kind_of(ActionDispatch::Request))
+            .and_return(transaction)
+          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
+          # Make sure sample data is added
+          expect(transaction.ext).to receive(:finish).and_return(true)
+          # Stub complete call, stops it from being cleared in the extension
+          # And allows us to call `#to_h` on it after it's been completed.
+          expect(transaction.ext).to receive(:complete)
+
+          # Stub transmit call for subscribe/unsubscribe tests
+          allow(connection).to receive(:websocket)
+            .and_return(instance_double("ActionCable::Connection::WebSocket", :transmit => nil))
+        end
+
+        describe "#perform_action" do
+          it "creates a transaction for an action" do
+            instance.perform_action("message" => "foo", "action" => "speak")
+
+            expect(subject).to include(
+              "action" => "MyChannel#speak",
+              "error" => nil,
+              "id" => transaction_id,
+              "namespace" => Appsignal::Transaction::ACTION_CABLE,
+              "metadata" => {
+                "method" => "websocket",
+                "path" => "/blog"
+              }
+            )
+            expect(subject["events"].first).to include(
+              "allocation_count" => kind_of(Integer),
+              "body" => "",
+              "body_format" => Appsignal::EventFormatter::DEFAULT,
+              "child_allocation_count" => kind_of(Integer),
+              "child_duration" => kind_of(Float),
+              "child_gc_duration" => kind_of(Float),
+              "count" => 1,
+              "gc_duration" => kind_of(Float),
+              "start" => kind_of(Float),
+              "duration" => kind_of(Float),
+              "name" => "perform_action.action_cable",
+              "title" => ""
+            )
+            expect(subject["sample_data"]).to include(
+              "params" => {
+                "action" => "speak",
+                "message" => "foo"
+              }
+            )
+          end
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            let(:action_transaction) do
+              Appsignal::Transaction.new(
+                transaction_id,
+                Appsignal::Transaction::ACTION_CABLE,
+                ActionDispatch::Request.new(env)
+              )
+            end
+            before do
+              # Stub future (private AppSignal) transaction id generated by the hook.
+              expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+            end
+
+            it "uses its own internal request_id set by the subscribed callback" do
+              # Subscribe action, sets the request_id
+              instance.subscribe_to_channel
+              expect(transaction.to_h["id"]).to eq(transaction_id)
+
+              # Expect another transaction for the action.
+              # This transaction will use the same request_id as the
+              # transaction id used to subscribe to the channel.
+              expect(Appsignal::Transaction).to receive(:create).with(
+                transaction_id,
+                Appsignal::Transaction::ACTION_CABLE,
+                kind_of(ActionDispatch::Request)
+              ).and_return(action_transaction)
+              allow(Appsignal::Transaction).to receive(:current).and_return(action_transaction)
+              # Stub complete call, stops it from being cleared in the extension
+              # And allows us to call `#to_h` on it after it's been completed.
+              expect(action_transaction.ext).to receive(:complete)
+
+              instance.perform_action("message" => "foo", "action" => "speak")
+              expect(action_transaction.to_h["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the action" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def speak(_data)
+                  raise VerySpecificError, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.perform_action("message" => "foo", "action" => "speak")
+              end.to raise_error(VerySpecificError)
+
+              expect(subject).to include(
+                "action" => "MyChannel#speak",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "VerySpecificError",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => {
+                  "action" => "speak",
+                  "message" => "foo"
+                }
+              )
+            end
+          end
+        end
+
+        describe "subscribe callback" do
+          let(:params) { { "internal" => true } }
+
+          it "creates a transaction for a subscription" do
+            instance.subscribe_to_channel
+
+            expect(subject).to include(
+              "action" => "MyChannel#subscribed",
+              "error" => nil,
+              "id" => transaction_id,
+              "namespace" => Appsignal::Transaction::ACTION_CABLE,
+              "metadata" => {
+                "method" => "websocket",
+                "path" => "/blog"
+              }
+            )
+            expect(subject["events"].first).to include(
+              "allocation_count" => kind_of(Integer),
+              "body" => "",
+              "body_format" => Appsignal::EventFormatter::DEFAULT,
+              "child_allocation_count" => kind_of(Integer),
+              "child_duration" => kind_of(Float),
+              "child_gc_duration" => kind_of(Float),
+              "count" => 1,
+              "gc_duration" => kind_of(Float),
+              "start" => kind_of(Float),
+              "duration" => kind_of(Float),
+              "name" => "subscribed.action_cable",
+              "title" => ""
+            )
+            expect(subject["sample_data"]).to include(
+              "params" => { "internal" => "true" }
+            )
+          end
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            before do
+              allow(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              instance.subscribe_to_channel
+            end
+
+            it "uses its own internal request_id" do
+              expect(subject["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the callback" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def subscribed
+                  raise VerySpecificError, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.subscribe_to_channel
+              end.to raise_error(VerySpecificError)
+
+              expect(subject).to include(
+                "action" => "MyChannel#subscribed",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "VerySpecificError",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => { "internal" => "true" }
+              )
+            end
+          end
+        end
+
+        describe "unsubscribe callback" do
+          let(:params) { { "internal" => true } }
+
+          it "creates a transaction for a subscription" do
+            instance.unsubscribe_from_channel
+
+            expect(subject).to include(
+              "action" => "MyChannel#unsubscribed",
+              "error" => nil,
+              "id" => transaction_id,
+              "namespace" => Appsignal::Transaction::ACTION_CABLE,
+              "metadata" => {
+                "method" => "websocket",
+                "path" => "/blog"
+              }
+            )
+            expect(subject["events"].first).to include(
+              "allocation_count" => kind_of(Integer),
+              "body" => "",
+              "body_format" => Appsignal::EventFormatter::DEFAULT,
+              "child_allocation_count" => kind_of(Integer),
+              "child_duration" => kind_of(Float),
+              "child_gc_duration" => kind_of(Float),
+              "count" => 1,
+              "gc_duration" => kind_of(Float),
+              "start" => kind_of(Float),
+              "duration" => kind_of(Float),
+              "name" => "unsubscribed.action_cable",
+              "title" => ""
+            )
+            expect(subject["sample_data"]).to include(
+              "params" => { "internal" => "true" }
+            )
+          end
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            before do
+              allow(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              instance.unsubscribe_from_channel
+            end
+
+            it "uses its own internal request_id" do
+              expect(subject["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the callback" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def unsubscribed
+                  raise VerySpecificError, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.unsubscribe_from_channel
+              end.to raise_error(VerySpecificError)
+
+              expect(subject).to include(
+                "action" => "MyChannel#unsubscribed",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "VerySpecificError",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => { "internal" => "true" }
+              )
+            end
+          end
+        end
+      end
+    end
+  else
+    context "without ActionCable" do
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns false" do
+          is_expected.to be_falsy
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications_spec.rb

@@ -1,45 +1,77 @@
 describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
+    let(:notifier) { ActiveSupport::Notifications::Fanout.new }
+    let(:as) { ActiveSupport::Notifications }
     before :context do
       start_agent
     end
     before do
+      as.notifier = notifier
       Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
     end
 
-    let(:notifier) { ActiveSupport::Notifications::Fanout.new }
-    let(:instrumenter) { ActiveSupport::Notifications::Instrumenter.new(notifier) }
-
     describe "#dependencies_present?" do
       subject { described_class.new.dependencies_present? }
 
       it { is_expected.to be_truthy }
     end
 
-    it "should instrument an AS notifications instrument call with a block" do
+    it "instruments an ActiveSupport::Notifications.instrument event" do
       expect(Appsignal::Transaction.current).to receive(:start_event)
         .at_least(:once)
       expect(Appsignal::Transaction.current).to receive(:finish_event)
         .at_least(:once)
         .with("sql.active_record", nil, "SQL", 1)
 
-      return_value = instrumenter.instrument("sql.active_record", :sql => "SQL") do
+      return_value = as.instrument("sql.active_record", :sql => "SQL") do
         "value"
       end
 
       expect(return_value).to eq "value"
     end
 
-    it "should not instrument events whose name starts with a bang" do
+    it "does not instrument events whose name starts with a bang" do
       expect(Appsignal::Transaction.current).not_to receive(:start_event)
       expect(Appsignal::Transaction.current).not_to receive(:finish_event)
 
-      return_value = instrumenter.instrument("!sql.active_record", :sql => "SQL") do
+      return_value = as.instrument("!sql.active_record", :sql => "SQL") do
         "value"
       end
 
       expect(return_value).to eq "value"
     end
+
+    context "when an error is raised in an instrumented block" do
+      it "instruments an ActiveSupport::Notifications.instrument event" do
+        expect(Appsignal::Transaction.current).to receive(:start_event)
+          .at_least(:once)
+        expect(Appsignal::Transaction.current).to receive(:finish_event)
+          .at_least(:once)
+          .with("sql.active_record", nil, "SQL", 1)
+
+        expect do
+          as.instrument("sql.active_record", :sql => "SQL") do
+            raise VerySpecificError, "foo"
+          end
+        end.to raise_error(VerySpecificError, "foo")
+      end
+    end
+
+    context "when a message is thrown in an instrumented block" do
+      it "instruments an ActiveSupport::Notifications.instrument event" do
+        expect(Appsignal::Transaction.current).to receive(:start_event)
+          .at_least(:once)
+        expect(Appsignal::Transaction.current).to receive(:finish_event)
+          .at_least(:once)
+          .with("sql.active_record", nil, "SQL", 1)
+
+        expect do
+          as.instrument("sql.active_record", :sql => "SQL") do
+            throw :foo
+          end
+        end.to throw_symbol(:foo)
+      end
+    end
   else
     describe "#dependencies_present?" do
       subject { described_class.new.dependencies_present? }