appsignal 4.0.6 → 4.0.8

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

@@ -1,105 +0,0 @@
-describe Appsignal::Hooks::AtExit do
-  describe ".install" do
-    before { start_agent(:options => options) }
-
-    context "with :enable_at_exit_reporter == true" do
-      let(:options) { { :enable_at_exit_reporter => true } }
-
-      it "installs the at_exit hook" do
-        expect(Appsignal::Hooks::AtExit::AtExitCallback).to receive(:call)
-
-        expect(Kernel).to receive(:at_exit).with(no_args) do |*_args, &block|
-          block.call
-        end
-
-        described_class.new.install
-      end
-    end
-
-    context "with :enable_at_exit_reporter == false" do
-      let(:options) { { :enable_at_exit_reporter => false } }
-
-      it "doesn't install the at_exit hook" do
-        expect(Kernel).to_not receive(:at_exit)
-      end
-    end
-  end
-end
-
-describe Appsignal::Hooks::AtExit::AtExitCallback do
-  around { |example| keep_transactions { example.run } }
-  before { start_agent(:options => { :enable_at_exit_reporter => true }) }
-
-  def with_error(error_class, error_message)
-    raise error_class, error_message
-  rescue error_class => error
-    yield error
-  end
-
-  def call_callback
-    Appsignal::Hooks::AtExit::AtExitCallback.call
-  end
-
-  it "reports no transaction if the process didn't exit with an error" do
-    logs =
-      capture_logs do
-        expect do
-          call_callback
-        end.to_not(change { created_transactions.count })
-      end
-
-    expect(logs).to_not contains_log(:error, "Appsignal.report_error: Cannot add error.")
-  end
-
-  it "reports an error if there's an unhandled error" do
-    expect do
-      with_error(ExampleException, "error message") do
-        call_callback
-      end
-    end.to change { created_transactions.count }.by(1)
-
-    transaction = last_transaction
-    expect(transaction).to have_namespace("unhandled")
-    expect(transaction).to have_error("ExampleException", "error message")
-  end
-
-  it "calls Appsignal.stop" do
-    expect(Appsignal).to receive(:stop).with("at_exit")
-    with_error(ExampleException, "error message") do
-      call_callback
-    end
-  end
-
-  it "doesn't report the error if it is also the last error reported" do
-    with_error(ExampleException, "error message") do |error|
-      Appsignal.report_error(error)
-      expect(created_transactions.count).to eq(1)
-
-      expect do
-        call_callback
-      end.to_not change { created_transactions.count }.from(1)
-    end
-  end
-
-  it "doesn't report the error if it is a SystemExit exception" do
-    with_error(SystemExit, "error message") do |error|
-      Appsignal.report_error(error)
-      expect(created_transactions.count).to eq(1)
-
-      expect do
-        call_callback
-      end.to_not change { created_transactions.count }.from(1)
-    end
-  end
-
-  it "doesn't report the error if it is a SignalException exception" do
-    with_error(SignalException, "TERM") do |error|
-      Appsignal.report_error(error)
-      expect(created_transactions.count).to eq(1)
-
-      expect do
-        call_callback
-      end.to_not change { created_transactions.count }.from(1)
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-describe Appsignal::Hooks::CelluloidHook do
-  context "with celluloid" do
-    before :context do
-      module Celluloid
-        def self.shutdown
-          @shut_down = true
-        end
-
-        def self.shut_down?
-          @shut_down == true
-        end
-      end
-      Appsignal::Hooks::CelluloidHook.new.install
-    end
-    after :context do
-      Object.send(:remove_const, :Celluloid)
-    end
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    specify { expect(Appsignal).to receive(:stop) }
-    specify { expect(Celluloid.shut_down?).to be true }
-
-    after do
-      Celluloid.shutdown
-    end
-  end
-
-  context "without celluloid" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-describe Appsignal::Hooks::DataMapperHook do
-  context "with datamapper" do
-    before :context do
-      module DataMapper
-      end
-
-      module DataObjects
-        class Connection
-        end
-      end
-      Appsignal::Hooks::DataMapperHook.new.install
-    end
-
-    after :context do
-      Object.send(:remove_const, :DataMapper)
-      Object.send(:remove_const, :DataObjects)
-    end
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "should install the listener" do
-      expect(::DataObjects::Connection).to receive(:include)
-        .with(Appsignal::Hooks::DataMapperLogListener)
-
-      Appsignal::Hooks::DataMapperHook.new.install
-    end
-  end
-
-  context "without datamapper" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-describe Appsignal::Hooks::DelayedJobHook do
-  context "with delayed job" do
-    before(:context) do
-      module Delayed
-        class Plugin
-          def self.callbacks
-          end
-        end
-
-        class Worker
-          def self.plugins
-            @plugins ||= []
-          end
-        end
-      end
-    end
-    after(:context) { Object.send(:remove_const, :Delayed) }
-    before { start_agent }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "adds the plugin" do
-      expect(::Delayed::Worker.plugins).to include(Appsignal::Integrations::DelayedJobPlugin)
-    end
-  end
-
-  context "without delayed job" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-if DependencyHelper.dry_monitor_present?
-  require "dry-monitor"
-
-  describe Appsignal::Hooks::DryMonitorHook do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      context "when Dry::Monitor::Notifications constant is found" do
-        before { stub_const "Dry::Monitor::Notifications", Class.new }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context "when Dry::Monitor::Notifications constant is not found" do
-        before { hide_const "Dry::Monitor::Notifications" }
-
-        it { is_expected.to be_falsy }
-      end
-    end
-  end
-
-  describe "#install" do
-    it "installs the dry-monitor hook" do
-      start_agent
-
-      expect(Dry::Monitor::Notifications.included_modules).to include(
-        Appsignal::Integrations::DryMonitorIntegration
-      )
-    end
-  end
-
-  describe "Dry Monitor Integration" do
-    let(:notifications) { Dry::Monitor::Notifications.new(:test) }
-    let(:transaction) { http_request_transaction }
-    before do
-      start_agent
-      set_current_transaction(transaction)
-    end
-
-    context "when is a dry-sql event" do
-      let(:event_id) { :sql }
-      let(:payload) do
-        {
-          :name => "postgres",
-          :query => "SELECT * FROM users"
-        }
-      end
-
-      it "creates an sql event" do
-        notifications.instrument(event_id, payload)
-        expect(transaction).to include_event(
-          "body" => "SELECT * FROM users",
-          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-          "count" => 1,
-          "name" => "query.postgres",
-          "title" => "query.postgres"
-        )
-      end
-    end
-
-    context "when is an unregistered formatter event" do
-      let(:event_id) { :foo }
-      let(:payload) do
-        {
-          :name => "foo"
-        }
-      end
-
-      it "creates a generic event" do
-        notifications.instrument(event_id, payload)
-        expect(transaction).to include_event(
-          "body" => "",
-          "body_format" => Appsignal::EventFormatter::DEFAULT,
-          "count" => 1,
-          "name" => "foo",
-          "title" => ""
-        )
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-describe Appsignal::Hooks::ExconHook do
-  before { start_agent }
-
-  context "with Excon" do
-    before(:context) do
-      class Excon
-        def self.defaults
-          @defaults ||= {}
-        end
-      end
-      Appsignal::Hooks::ExconHook.new.install
-    end
-    after(:context) { Object.send(:remove_const, :Excon) }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    describe "#install" do
-      it "adds the AppSignal instrumentor to Excon" do
-        expect(Excon.defaults[:instrumentor]).to eql(Appsignal::Integrations::ExconIntegration)
-      end
-    end
-
-    describe "instrumentation" do
-      let(:transaction) { http_request_transaction }
-      before { set_current_transaction(transaction) }
-      around { |example| keep_transactions { example.run } }
-
-      it "instruments a http request" do
-        data = {
-          :host => "www.google.com",
-          :method => :get,
-          :scheme => "http"
-        }
-        Excon.defaults[:instrumentor].instrument("excon.request", data) {} # rubocop:disable Lint/EmptyBlock
-
-        expect(transaction).to include_event(
-          "name" => "request.excon",
-          "title" => "GET http://www.google.com",
-          "body" => ""
-        )
-      end
-
-      it "instruments a http response" do
-        data = { :host => "www.google.com" }
-        Excon.defaults[:instrumentor].instrument("excon.response", data) {} # rubocop:disable Lint/EmptyBlock
-
-        expect(transaction).to include_event(
-          "name" => "response.excon",
-          "title" => "www.google.com",
-          "body" => ""
-        )
-      end
-    end
-  end
-
-  context "without Excon" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,145 +0,0 @@
-describe Appsignal::Hooks::GvlHook do
-  if DependencyHelper.running_jruby?
-    context "running JRuby" do
-      it "does not attempt to require GVLTools" do
-        expect_any_instance_of(described_class).not_to receive(:require).with("gvltools")
-        expect(described_class.new.dependencies_present?).to be_falsy
-      end
-    end
-  else
-    let(:options) { {} }
-    before do
-      start_agent(:options => options)
-    end
-
-    def expect_gvltools_require
-      expect_any_instance_of(described_class).to receive(:require).with("gvltools").and_return(true)
-    end
-
-    context "without GVLTools" do
-      describe "#dependencies_present?" do
-        context "if requiring gvltools fails" do
-          it "is false" do
-            expect(described_class.new.dependencies_present?).to be_falsy
-          end
-        end
-
-        it "is false" do
-          expect_gvltools_require
-          expect(described_class.new.dependencies_present?).to be_falsy
-        end
-      end
-    end
-
-    context "with old versions of GVLTools" do
-      before(:context) do
-        module GVLTools
-          VERSION = "0.1.0".freeze
-        end
-      end
-
-      after(:context) { Object.send(:remove_const, :GVLTools) }
-
-      before(:each) { expect_gvltools_require }
-
-      describe "#dependencies_present?" do
-        it "is false" do
-          expect(described_class.new.dependencies_present?).to be_falsy
-        end
-      end
-    end
-
-    context "with new versions of GVLTools" do
-      before(:context) do
-        module GVLTools
-          VERSION = "0.2.0".freeze
-
-          module GlobalTimer
-            def self.enable
-            end
-          end
-
-          module WaitingThreads
-            def self.enable
-            end
-          end
-        end
-      end
-
-      after(:context) { Object.send(:remove_const, :GVLTools) }
-
-      describe "#dependencies_present?" do
-        before(:each) { expect_gvltools_require }
-
-        if DependencyHelper.ruby_3_2_or_newer?
-          it "is true" do
-            expect(described_class.new.dependencies_present?).to be_truthy
-          end
-        else
-          it "is false" do
-            expect(described_class.new.dependencies_present?).to be_falsy
-          end
-        end
-      end
-
-      if DependencyHelper.ruby_3_2_or_newer?
-        describe "Appsignal::Hooks.load_hooks" do
-          before(:each) { expect_gvltools_require }
-
-          # After installing a hook once, it is marked as already installed,
-          # and subsequent calls to `load_hooks` silently do nothing.
-          # Because of this, only one of the tests for the installation uses
-          # `load_hooks`, while the rest call the `install` method directly.
-
-          it "is added to minutely probes" do
-            Appsignal::Hooks.load_hooks
-
-            expect(Appsignal::Probes.probes[:gvl]).to be Appsignal::Probes::GvlProbe
-          end
-        end
-      end
-
-      describe "#install" do
-        context "with enable_gvl_global_timer" do
-          let(:options) { { :enable_gvl_global_timer => true } }
-
-          it "enables the GVL global timer" do
-            expect(::GVLTools::GlobalTimer).to receive(:enable)
-
-            described_class.new.install
-          end
-        end
-
-        context "without enable_gvl_global_timer" do
-          let(:options) { { :enable_gvl_global_timer => false } }
-
-          it "does not enable the GVL global timer" do
-            expect(::GVLTools::GlobalTimer).not_to receive(:enable)
-
-            described_class.new.install
-          end
-        end
-
-        context "with enable_gvl_waiting_threads" do
-          let(:options) { { :enable_gvl_waiting_threads => true } }
-
-          it "enables the GVL waiting threads" do
-            expect(::GVLTools::WaitingThreads).to receive(:enable)
-
-            described_class.new.install
-          end
-        end
-
-        context "without enable_gvl_waiting_threads" do
-          let(:options) { { :enable_gvl_waiting_threads => false } }
-
-          it "does not enable the GVL waiting threads" do
-            expect(::GVLTools::WaitingThreads).not_to receive(:enable)
-
-            described_class.new.install
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-describe Appsignal::Hooks::HttpHook do
-  let(:options) { {} }
-  before { start_agent(:options => options) }
-
-  if DependencyHelper.http_present?
-    context "with instrument_http_rb set to true" do
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it { is_expected.to be_truthy }
-      end
-
-      it "installs the HTTP plugin" do
-        expect(HTTP::Client.included_modules)
-          .to include(Appsignal::Integrations::HttpIntegration)
-      end
-    end
-
-    context "with instrument_http_rb set to false" do
-      let(:options) { { :instrument_http_rb => false } }
-
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it { is_expected.to be_falsy }
-      end
-    end
-  else
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-describe Appsignal::Hooks::MongoRubyDriverHook do
-  require "appsignal/integrations/mongo_ruby_driver"
-
-  context "with mongo ruby driver" do
-    let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
-    before do
-      allow(Appsignal::Hooks::MongoMonitorSubscriber).to receive(:new).and_return(subscriber)
-    end
-
-    before(:context) do
-      module Mongo
-        module Monitoring
-          COMMAND = "command".freeze
-
-          class Global
-            def subscribe
-            end
-          end
-        end
-      end
-    end
-    after(:context) { Object.send(:remove_const, :Mongo) }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "adds a subscriber to Mongo::Monitoring" do
-      expect(Mongo::Monitoring::Global).to receive(:subscribe)
-        .with("command", subscriber)
-        .at_least(:once)
-
-      Appsignal::Hooks::MongoRubyDriverHook.new.install
-    end
-  end
-
-  context "without mongo ruby driver" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-describe Appsignal::Hooks::MriHook do
-  describe "#dependencies_present?" do
-    subject { described_class.new.dependencies_present? }
-
-    if DependencyHelper.running_jruby?
-      it { is_expected.to be_falsy }
-    else
-      it { is_expected.to be_truthy }
-    end
-  end
-
-  unless DependencyHelper.running_jruby?
-    context "install" do
-      before do
-        Appsignal::Hooks.load_hooks
-      end
-
-      it "should be added to minutely probes" do
-        expect(Appsignal::Probes.probes[:mri]).to be Appsignal::Probes::MriProbe
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-describe Appsignal::Hooks::NetHttpHook do
-  let(:options) { {} }
-  before { start_agent(:options => options) }
-
-  describe "#dependencies_present?" do
-    subject { described_class.new.dependencies_present? }
-
-    context "with Net::HTTP instrumentation enabled" do
-      it { is_expected.to be_truthy }
-    end
-
-    context "with Net::HTTP instrumentation disabled" do
-      let(:options) { { :instrument_net_http => false } }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-describe Appsignal::Hooks::PassengerHook do
-  context "with passenger" do
-    before(:context) do
-      module PhusionPassenger
-      end
-    end
-    after(:context) { Object.send(:remove_const, :PhusionPassenger) }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "adds behavior to stopping_worker_process and starting_worker_process" do
-      expect(PhusionPassenger).to receive(:on_event).with(:starting_worker_process)
-      expect(PhusionPassenger).to receive(:on_event).with(:stopping_worker_process)
-
-      Appsignal::Hooks::PassengerHook.new.install
-    end
-  end
-
-  context "without passenger" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end