appsignal 4.0.6-java → 4.0.7-java

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

@@ -1,345 +0,0 @@
-describe Appsignal::Hooks::ActionCableHook do
-  if DependencyHelper.action_cable_present?
-    context "with ActionCable" do
-      require "action_cable/engine"
-      # Require test helper to test with ConnectionStub
-      require "action_cable/channel/test_case" if DependencyHelper.rails6_present?
-
-      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(: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(:env) do
-          http_request_env_with_data(
-            "action_dispatch.request_id" => request_id,
-            :params => params,
-            :with_queue_start => true
-          )
-        end
-        let(:connection) { ActionCable::Connection::Base.new(server, env) }
-        let(:identifier) { { :channel => "MyChannel" }.to_json }
-        let(:params) { {} }
-        let(:request_id) { SecureRandom.uuid }
-        let(:instance) { channel.new(connection, identifier, params) }
-        before do
-          start_agent
-
-          # Stub transmit call for subscribe/unsubscribe tests
-          allow(connection).to receive(:websocket)
-            .and_return(instance_double("ActionCable::Connection::WebSocket", :transmit => nil))
-        end
-        around { |example| keep_transactions { example.run } }
-
-        describe "#perform_action" do
-          it "creates a transaction for an action" do
-            instance.perform_action("message" => "foo", "action" => "speak")
-
-            transaction = last_transaction
-            expect(transaction).to have_id
-            expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-            expect(transaction).to have_action("MyChannel#speak")
-            expect(transaction).to_not have_error
-            expect(transaction).to include_metadata(
-              "method" => "websocket",
-              "path" => "/blog"
-            )
-            expect(transaction).to include_event(
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT,
-              "count" => 1,
-              "name" => "perform_action.action_cable",
-              "title" => ""
-            )
-            expect(transaction).to include_params(
-              "action" => "speak",
-              "message" => "foo"
-            )
-            expect(transaction).to include_tags("request_id" => request_id)
-            expect(transaction).to_not have_queue_start
-            expect(transaction).to be_completed
-          end
-
-          context "without request_id (standalone server)" do
-            let(:request_id) { nil }
-
-            it "sets a generated request ID" do
-              # Subscribe action, sets the request_id
-              instance.subscribe_to_channel
-
-              instance.perform_action("message" => "foo", "action" => "speak")
-              expect(last_transaction).to include_tags("request_id" => kind_of(String))
-            end
-          end
-
-          context "with an error in the action" do
-            let(:channel) do
-              Class.new(ActionCable::Channel::Base) do
-                def speak(_data)
-                  raise ExampleException, "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(ExampleException)
-
-              transaction = last_transaction
-              expect(transaction).to have_id
-              expect(transaction).to have_action("MyChannel#speak")
-              expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-              expect(transaction).to have_error("ExampleException", "oh no!")
-              expect(transaction).to include_metadata(
-                "method" => "websocket",
-                "path" => "/blog"
-              )
-              expect(transaction).to include_params(
-                "action" => "speak",
-                "message" => "foo"
-              )
-              expect(transaction).to_not have_queue_start
-              expect(transaction).to be_completed
-            end
-          end
-        end
-
-        describe "subscribe callback" do
-          let(:params) { { "internal" => true } }
-
-          it "creates a transaction for a subscription" do
-            instance.subscribe_to_channel
-
-            transaction = last_transaction
-            expect(transaction).to have_id
-            expect(transaction).to have_action("MyChannel#subscribed")
-            expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-            expect(transaction).to_not have_error
-            expect(transaction).to include_metadata(
-              "method" => "websocket",
-              "path" => "/blog"
-            )
-            expect(transaction).to include_params("internal" => "true")
-            expect(transaction).to include_event(
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT,
-              "count" => 1,
-              "name" => "subscribed.action_cable",
-              "title" => ""
-            )
-            expect(transaction).to include_tags("request_id" => request_id)
-            expect(transaction).to_not have_queue_start
-            expect(transaction).to be_completed
-          end
-
-          context "without request_id (standalone server)" do
-            let(:request_id) { nil }
-            before { instance.subscribe_to_channel }
-
-            it "sets a generated request ID" do
-              expect(last_transaction).to include_tags("request_id" => kind_of(String))
-            end
-          end
-
-          context "with an error in the callback" do
-            let(:channel) do
-              Class.new(ActionCable::Channel::Base) do
-                def subscribed
-                  raise ExampleException, "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(ExampleException)
-
-              transaction = last_transaction
-              expect(transaction).to have_id
-              expect(transaction).to have_action("MyChannel#subscribed")
-              expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-              expect(transaction).to have_error("ExampleException", "oh no!")
-              expect(transaction).to include_metadata(
-                "method" => "websocket",
-                "path" => "/blog"
-              )
-              expect(transaction).to include_params("internal" => "true")
-              expect(transaction).to_not have_queue_start
-              expect(transaction).to be_completed
-            end
-          end
-
-          if DependencyHelper.rails6_present?
-            context "with ConnectionStub" do
-              let(:connection) { ActionCable::Channel::ConnectionStub.new }
-
-              it "does not fail on missing `#env` method on `ConnectionStub`" do
-                instance.subscribe_to_channel
-
-                transaction = last_transaction
-                expect(transaction).to have_id
-                expect(transaction).to have_action("MyChannel#subscribed")
-                expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-                expect(transaction).to_not have_error
-                expect(transaction).to include_metadata(
-                  "method" => "websocket",
-                  "path" => "" # No path as the ConnectionStub doesn't have the real request env
-                )
-                expect(transaction).to_not include_params
-                expect(transaction).to include_event(
-                  "body" => "",
-                  "body_format" => Appsignal::EventFormatter::DEFAULT,
-                  "count" => 1,
-                  "name" => "subscribed.action_cable",
-                  "title" => ""
-                )
-                expect(transaction).to_not have_queue_start
-                expect(transaction).to be_completed
-              end
-            end
-          end
-        end
-
-        describe "unsubscribe callback" do
-          let(:params) { { "internal" => true } }
-
-          it "creates a transaction for a subscription" do
-            instance.unsubscribe_from_channel
-
-            transaction = last_transaction
-            expect(transaction).to have_id
-            expect(transaction).to have_action("MyChannel#unsubscribed")
-            expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-            expect(transaction).to_not have_error
-            expect(transaction).to include_metadata(
-              "method" => "websocket",
-              "path" => "/blog"
-            )
-            expect(transaction).to include_params("internal" => "true")
-            expect(transaction).to include_event(
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT,
-              "count" => 1,
-              "name" => "unsubscribed.action_cable",
-              "title" => ""
-            )
-            expect(transaction).to_not have_queue_start
-            expect(transaction).to be_completed
-          end
-
-          context "without request_id (standalone server)" do
-            let(:request_id) { nil }
-            before { instance.unsubscribe_from_channel }
-
-            it "sets a generated request ID" do
-              expect(last_transaction).to include_tags("request_id" => kind_of(String))
-            end
-          end
-
-          context "with an error in the callback" do
-            let(:channel) do
-              Class.new(ActionCable::Channel::Base) do
-                def unsubscribed
-                  raise ExampleException, "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(ExampleException)
-
-              transaction = last_transaction
-              expect(transaction).to have_id
-              expect(transaction).to have_action("MyChannel#unsubscribed")
-              expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-              expect(transaction).to have_error("ExampleException", "oh no!")
-              expect(transaction).to include_metadata(
-                "method" => "websocket",
-                "path" => "/blog"
-              )
-              expect(transaction).to include_params("internal" => "true")
-              expect(transaction).to_not have_queue_start
-              expect(transaction).to be_completed
-            end
-          end
-
-          if DependencyHelper.rails6_present?
-            context "with ConnectionStub" do
-              let(:connection) { ActionCable::Channel::ConnectionStub.new }
-
-              it "does not fail on missing `#env` method on `ConnectionStub`" do
-                instance.unsubscribe_from_channel
-
-                transaction = last_transaction
-                expect(transaction).to have_id
-                expect(transaction).to have_action("MyChannel#unsubscribed")
-                expect(transaction).to have_namespace(Appsignal::Transaction::ACTION_CABLE)
-                expect(transaction).to_not have_error
-                expect(transaction).to include_metadata(
-                  "method" => "websocket",
-                  "path" => "" # No path as the ConnectionStub doesn't have the real request env
-                )
-                expect(transaction).to_not include_params
-                expect(transaction).to include_event(
-                  "body" => "",
-                  "body_format" => Appsignal::EventFormatter::DEFAULT,
-                  "count" => 1,
-                  "name" => "unsubscribed.action_cable",
-                  "title" => ""
-                )
-                expect(transaction).to_not have_queue_start
-                expect(transaction).to be_completed
-              end
-            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/action_mailer_spec.rb

@@ -1,55 +0,0 @@
-describe Appsignal::Hooks::ActionMailerHook do
-  if DependencyHelper.action_mailer_present? &&
-      DependencyHelper.rails_version >= Gem::Version.new("4.0.0")
-    context "with ActionMailer" do
-      require "action_mailer"
-
-      class UserMailer < ActionMailer::Base
-        default :from => "test@example.com"
-
-        def welcome
-          mail(:to => "test@example.com", :subject => "ActionMailer test",
-            :content_type => "text/html") do |format|
-            format.html { render :html => "This is a test" }
-          end
-        end
-      end
-      UserMailer.delivery_method = :test
-
-      describe ".dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it "returns true" do
-          is_expected.to be_truthy
-        end
-      end
-
-      describe ".install" do
-        before do
-          start_agent
-          expect(Appsignal.active?).to be_truthy
-        end
-
-        it "is subscribed to 'process.action_mailer' and processes instrumentation" do
-          expect(Appsignal).to receive(:increment_counter).with(
-            :action_mailer_process,
-            1,
-            :mailer => "UserMailer", :action => :welcome
-          )
-
-          UserMailer.welcome.deliver_now
-        end
-      end
-    end
-  else
-    context "without ActionMailer" 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/finish_with_state_shared_examples.rb

@@ -1,23 +0,0 @@
-shared_examples "activesupport finish_with_state override" do
-  let(:instrumenter) { as.instrumenter }
-
-  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
-    listeners_state = instrumenter.start("sql.active_record", {})
-    instrumenter.finish_with_state(listeners_state, "sql.active_record", :sql => "SQL")
-
-    expect(transaction).to include_event(
-      "body" => "SQL",
-      "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-      "count" => 1,
-      "name" => "sql.active_record",
-      "title" => ""
-    )
-  end
-
-  it "does not instrument events whose name starts with a bang" do
-    listeners_state = instrumenter.start("!sql.active_record", {})
-    instrumenter.finish_with_state(listeners_state, "!sql.active_record", :sql => "SQL")
-
-    expect(transaction).to_not include_events
-  end
-end

data/spec/lib/appsignal/hooks/active_support_notifications/instrument_shared_examples.rb

@@ -1,99 +0,0 @@
-shared_examples "activesupport instrument override" do
-  it "instruments an ActiveSupport::Notifications.instrument event" do
-    return_value = as.instrument("sql.active_record", :sql => "SQL") do
-      "value"
-    end
-
-    expect(return_value).to eq "value"
-    expect(transaction).to include_event(
-      "body" => "SQL",
-      "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-      "count" => 1,
-      "name" => "sql.active_record",
-      "title" => ""
-    )
-  end
-
-  it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
-    return_value = as.instrument("no-registered.formatter", :key => "something") do
-      "value"
-    end
-
-    expect(return_value).to eq "value"
-    expect(transaction).to include_event(
-      "body" => "",
-      "body_format" => Appsignal::EventFormatter::DEFAULT,
-      "count" => 1,
-      "name" => "no-registered.formatter",
-      "title" => ""
-    )
-  end
-
-  it "converts non-string names to strings" do
-    as.instrument(:not_a_string) {} # rubocop:disable Lint/EmptyBlock
-    expect(transaction).to include_event(
-      "body" => "",
-      "body_format" => Appsignal::EventFormatter::DEFAULT,
-      "count" => 1,
-      "name" => "not_a_string",
-      "title" => ""
-    )
-  end
-
-  it "does not instrument events whose name starts with a bang" do
-    return_value = as.instrument("!sql.active_record", :sql => "SQL") do
-      "value"
-    end
-
-    expect(return_value).to eq "value"
-
-    expect(transaction).to_not include_events
-  end
-
-  context "when an error is raised in an instrumented block" do
-    it "instruments an ActiveSupport::Notifications.instrument event" do
-      expect do
-        as.instrument("sql.active_record", :sql => "SQL") do
-          raise ExampleException, "foo"
-        end
-      end.to raise_error(ExampleException, "foo")
-
-      expect(transaction).to include_event(
-        "body" => "SQL",
-        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-        "count" => 1,
-        "name" => "sql.active_record",
-        "title" => ""
-      )
-    end
-  end
-
-  context "when a message is thrown in an instrumented block" do
-    it "instruments an ActiveSupport::Notifications.instrument event" do
-      expect do
-        as.instrument("sql.active_record", :sql => "SQL") do
-          throw :foo
-        end
-      end.to throw_symbol(:foo)
-
-      expect(transaction).to include_event(
-        "body" => "SQL",
-        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-        "count" => 1,
-        "name" => "sql.active_record",
-        "title" => ""
-      )
-    end
-  end
-
-  context "when a transaction is completed in an instrumented block" do
-    it "does not complete the ActiveSupport::Notifications.instrument event" do
-      as.instrument("sql.active_record", :sql => "SQL") do
-        Appsignal::Transaction.complete_current!
-      end
-
-      expect(transaction).to_not include_events
-      expect(transaction).to be_completed
-    end
-  end
-end

data/spec/lib/appsignal/hooks/active_support_notifications/start_finish_shared_examples.rb

@@ -1,47 +0,0 @@
-shared_examples "activesupport start finish override" do
-  let(:instrumenter) { as.instrumenter }
-
-  it "instruments start/finish events with payload on start ignores payload" do
-    instrumenter.start("sql.active_record", :sql => "SQL")
-    instrumenter.finish("sql.active_record", {})
-
-    expect(transaction).to include_event(
-      "body" => "",
-      "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-      "count" => 1,
-      "name" => "sql.active_record",
-      "title" => ""
-    )
-  end
-
-  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
-    instrumenter.start("sql.active_record", {})
-    instrumenter.finish("sql.active_record", :sql => "SQL")
-
-    expect(transaction).to include_event(
-      "body" => "SQL",
-      "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-      "count" => 1,
-      "name" => "sql.active_record",
-      "title" => ""
-    )
-  end
-
-  it "does not instrument events whose name starts with a bang" do
-    instrumenter.start("!sql.active_record", {})
-    instrumenter.finish("!sql.active_record", {})
-
-    expect(transaction).to_not include_events
-  end
-
-  context "when a transaction is completed in an instrumented block" do
-    it "does not complete the ActiveSupport::Notifications.instrument event" do
-      instrumenter.start("sql.active_record", {})
-      Appsignal::Transaction.complete_current!
-      instrumenter.finish("sql.active_record", {})
-
-      expect(transaction).to_not include_events
-      expect(transaction).to be_completed
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require_relative "active_support_notifications/instrument_shared_examples"
-
-describe Appsignal::Hooks::ActiveSupportNotificationsHook do
-  if active_support_present?
-    let(:notifier) { ActiveSupport::Notifications::Fanout.new }
-    let(:as) { ActiveSupport::Notifications }
-    let(:transaction) { http_request_transaction }
-    before do
-      start_agent
-      set_current_transaction(transaction)
-      as.notifier = notifier
-    end
-    around { |example| keep_transactions { example.run } }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it_behaves_like "activesupport instrument override"
-
-    if defined?(::ActiveSupport::Notifications::Fanout::Handle)
-      require_relative "active_support_notifications/start_finish_shared_examples"
-
-      it_behaves_like "activesupport start finish override"
-    end
-
-    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:start)
-      require_relative "active_support_notifications/start_finish_shared_examples"
-
-      it_behaves_like "activesupport start finish override"
-    end
-
-    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:finish_with_state)
-      require_relative "active_support_notifications/finish_with_state_shared_examples"
-
-      it_behaves_like "activesupport finish_with_state override"
-    end
-  else
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end