appsignal 4.0.3-java → 4.0.5-java

data/spec/lib/appsignal/check_in/scheduler_spec.rb

@@ -0,0 +1,443 @@
+describe Appsignal::CheckIn::Scheduler do
+  include WaitForHelper
+  include TakeAtMostHelper
+
+  let(:log_stream) { std_stream }
+  let(:logs) { log_contents(log_stream) }
+  let(:appsignal_options) { {} }
+  let(:transmitter) { Appsignal::Transmitter.new("http://checkin-endpoint.invalid") }
+
+  before do
+    start_agent(:options => appsignal_options, :internal_logger => test_logger(log_stream))
+    allow(transmitter).to receive(:transmit).and_return(Net::HTTPSuccess.new("1.1", 200, "OK"))
+    allow(Appsignal::CheckIn).to receive(:transmitter).and_return(transmitter)
+    allow(Appsignal::CheckIn).to receive(:scheduler).and_return(subject)
+    # Shorten debounce intervals to make the tests run faster.
+    stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 0.1)
+    stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 0.1)
+  end
+
+  after do
+    subject.stop
+  end
+
+  describe "when no event is sent" do
+    it "does not start a thread" do
+      expect(subject.thread).to be_nil
+    end
+
+    it "does not schedule a debounce" do
+      expect(subject.waker).to be_nil
+    end
+
+    it "can be stopped" do
+      # Set all debounce intervals to 10 seconds, to make the assertion
+      # fail if it waits for the debounce -- this ensures that what is being
+      # tested is that no debounces are awaited when stopping the scheduler.
+      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
+      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
+
+      take_at_most(0.1) do
+        expect { subject.stop }.not_to raise_error
+      end
+    end
+
+    it "can be stopped more than once" do
+      # Set all debounce intervals to 10 seconds, to make the assertion
+      # fail if it waits for the debounce -- this ensures that what is being
+      # tested is that no debounces are awaited when stopping the scheduler.
+      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
+      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
+
+      take_at_most(0.1) do
+        expect { subject.stop }.not_to raise_error
+        expect { subject.stop }.not_to raise_error
+      end
+    end
+
+    it "closes the queue when stopped" do
+      subject.stop
+      expect(subject.queue.closed?).to be(true)
+    end
+  end
+
+  describe "when an event is sent" do
+    it "starts a thread" do
+      Appsignal::CheckIn.cron("test")
+      expect(subject.thread).to be_a(Thread)
+    end
+
+    it "schedules a debounce" do
+      Appsignal::CheckIn.cron("test")
+      expect(subject.waker).to be_a(Thread)
+    end
+
+    it "schedules the event to be transmitted" do
+      expect(transmitter).to receive(:transmit).with([hash_including(
+        :identifier => "test",
+        :check_in_type => "cron",
+        :kind => "finish"
+      )], :format => :ndjson)
+
+      expect(subject.events).to be_empty
+
+      Appsignal::CheckIn.cron("test")
+
+      expect(subject.events).not_to be_empty
+
+      wait_for("the event to be transmitted") { subject.transmitted == 1 }
+
+      expect(subject.events).to be_empty
+
+      expect(logs).to contains_log(:debug, "Scheduling cron check-in `test` finish event")
+      expect(logs).to contains_log(:debug, "Transmitted cron check-in `test` finish event")
+    end
+
+    it "waits for the event to be transmitted when stopped" do
+      # Set all debounce intervals to 10 seconds, to make the test
+      # fail if it waits for the debounce -- this ensures that what is being
+      # tested is that the events are transmitted immediately when the
+      # scheduler is stopped, without waiting for any debounce.
+      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
+      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
+
+      expect(transmitter).to receive(:transmit).with([hash_including(
+        :identifier => "test",
+        :check_in_type => "cron",
+        :kind => "finish"
+      )], :format => :ndjson)
+
+      Appsignal::CheckIn.cron("test")
+
+      expect(subject.events).not_to be_empty
+
+      take_at_most(0.1) do
+        expect { subject.stop }.not_to raise_error
+      end
+
+      # Check that the thread wasn't killed before the transmission was
+      # completed.
+      expect(subject.transmitted).to eq(1)
+
+      expect(subject.events).to be_empty
+
+      expect(logs).to contains_log(:debug, "Scheduling cron check-in `test` finish event")
+      expect(logs).to contains_log(:debug, "Transmitted cron check-in `test` finish event")
+    end
+
+    it "can be stopped more than once" do
+      # Set all debounce intervals to 10 seconds, to make the test
+      # fail if it waits for the debounce -- this ensures that what is being
+      # tested is that the events are transmitted immediately when the
+      # scheduler is stopped, without waiting for the debounce interval.
+      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
+      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
+
+      Appsignal::CheckIn.cron("test")
+      take_at_most(0.1) do
+        expect { subject.stop }.not_to raise_error
+      end
+
+      # Check that the thread wasn't killed before the transmission was
+      # completed.
+      expect(subject.transmitted).to eq(1)
+
+      take_at_most(0.1) do
+        expect { subject.stop }.not_to raise_error
+      end
+    end
+
+    it "closes the queue when stopped" do
+      Appsignal::CheckIn.cron("test")
+      subject.stop
+      expect(subject.queue.closed?).to be(true)
+    end
+
+    it "kills the thread when stopped" do
+      Appsignal::CheckIn.cron("test")
+      subject.stop
+      expect(subject.thread.alive?).to be(false)
+    end
+
+    it "unschedules the debounce when stopped" do
+      Appsignal::CheckIn.cron("test")
+      waker = subject.waker
+      subject.stop
+      expect(waker.alive?).to be(false)
+      expect(subject.waker).to be_nil
+    end
+  end
+
+  describe "when many events are sent" do
+    describe "within the short debounce interval" do
+      it "transmits all events at once" do
+        expect(transmitter).to receive(:transmit).with(
+          ["first", "second", "third"].map do |identifier|
+            hash_including(
+              :identifier => identifier,
+              :check_in_type => "cron",
+              :kind => "finish"
+            )
+          end, :format => :ndjson
+        )
+
+        Appsignal::CheckIn.cron("first")
+        Appsignal::CheckIn.cron("second")
+        Appsignal::CheckIn.cron("third")
+
+        wait_for("the events to be transmitted") { subject.transmitted == 1 }
+      end
+
+      it "transmits all events at once when stopped" do
+        # Set a short debounce interval of 10 seconds, to make the final wait
+        # fail if it waits for the debounce -- this ensures that what is being
+        # tested is that the events are transmitted when the scheduler is
+        # stopped.
+        stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
+
+        expect(transmitter).to receive(:transmit).with(
+          ["first", "second", "third"].map do |identifier|
+            hash_including(
+              :identifier => identifier,
+              :check_in_type => "cron",
+              :kind => "finish"
+            )
+          end, :format => :ndjson
+        )
+
+        Appsignal::CheckIn.cron("first")
+        Appsignal::CheckIn.cron("second")
+        Appsignal::CheckIn.cron("third")
+
+        subject.stop
+
+        wait_for("the events to be transmitted") { subject.transmitted == 1 }
+      end
+    end
+
+    describe "further apart than the short debounce interval" do
+      it "transmits the first event and enqueues future events" do
+        expect(transmitter).to receive(:transmit).with([hash_including(
+          :identifier => "first",
+          :check_in_type => "cron",
+          :kind => "finish"
+        )], :format => :ndjson)
+
+        Appsignal::CheckIn.cron("first")
+
+        wait_for("the first event to be transmitted") { subject.transmitted == 1 }
+
+        Appsignal::CheckIn.cron("second")
+        Appsignal::CheckIn.cron("third")
+
+        expect(subject.events).to match(["second", "third"].map do |identifier|
+          hash_including({
+            :identifier => identifier,
+            :check_in_type => "cron",
+            :kind => "finish"
+          })
+        end)
+      end
+
+      it "transmits the other events after the debounce interval" do
+        expect(transmitter).to receive(:transmit)
+
+        Appsignal::CheckIn.cron("first")
+
+        wait_for("the first event to be transmitted") { subject.transmitted == 1 }
+
+        expect(transmitter).to receive(:transmit).with(
+          ["second", "third"].map do |identifier|
+            hash_including(
+              :identifier => identifier,
+              :check_in_type => "cron",
+              :kind => "finish"
+            )
+          end, :format => :ndjson
+        )
+
+        Appsignal::CheckIn.cron("second")
+        Appsignal::CheckIn.cron("third")
+
+        expect(subject.events).to_not be_empty
+
+        wait_for("the other events to be transmitted") { subject.transmitted == 2 }
+
+        expect(subject.events).to be_empty
+
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `first` finish event")
+        expect(logs).to contains_log(:debug, "Transmitted cron check-in `first` finish event")
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `second` finish event")
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `third` finish event")
+        expect(logs).to contains_log(:debug, "Transmitted 2 check-in events")
+      end
+
+      it "transmits the other events when stopped" do
+        # Restore the original long debounce interval of 10 seconds, to make
+        # the final wait fail if it waits for the debounce -- this ensures
+        # that what is being tested is that the events are transmitted
+        # immediately when the scheduler is stopped.
+        stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
+
+        expect(transmitter).to receive(:transmit)
+
+        Appsignal::CheckIn.cron("first")
+
+        wait_for("the event to be transmitted") { subject.transmitted == 1 }
+
+        expect(transmitter).to receive(:transmit).with(
+          ["second", "third"].map do |identifier|
+            hash_including(
+              :identifier => identifier,
+              :check_in_type => "cron",
+              :kind => "finish"
+            )
+          end, :format => :ndjson
+        )
+
+        Appsignal::CheckIn.cron("second")
+        Appsignal::CheckIn.cron("third")
+
+        expect(subject.events).to_not be_empty
+
+        subject.stop
+
+        wait_for("the other events to be transmitted") { subject.transmitted == 2 }
+
+        expect(subject.events).to be_empty
+
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `first` finish event")
+        expect(logs).to contains_log(:debug, "Transmitted cron check-in `first` finish event")
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `second` finish event")
+        expect(logs).to contains_log(:debug, "Scheduling cron check-in `third` finish event")
+        expect(logs).to contains_log(:debug, "Transmitted 2 check-in events")
+      end
+    end
+  end
+
+  describe "when a similar event is sent more than once" do
+    it "only transmits one of the similar events" do
+      # We must instantiate `Appsignal::CheckIn::Cron` directly, as the
+      # `.cron` helper would use a different digest for each invocation.
+      cron = Appsignal::CheckIn::Cron.new(:identifier => "test")
+
+      expect(transmitter).to receive(:transmit).with([hash_including(
+        :identifier => "test",
+        :check_in_type => "cron",
+        :kind => "start"
+      )], :format => :ndjson)
+
+      cron.start
+      cron.start
+
+      wait_for("the event to be transmitted") { subject.transmitted == 1 }
+
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Replacing previously scheduled cron check-in `test` start event (digest #{cron.digest})"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `test` start event (digest #{cron.digest})"
+      )
+    end
+  end
+
+  describe "when the scheduler is stopped" do
+    it "does not schedule any events to be transmitted" do
+      expect(transmitter).not_to receive(:transmit)
+
+      subject.stop
+
+      Appsignal::CheckIn.cron("test")
+
+      expect(subject.events).to be_empty
+
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `test` finish event .+: AppSignal is stopped/
+      )
+    end
+  end
+
+  describe "when AppSignal is not active" do
+    let(:appsignal_options) { { :active => false } }
+
+    it "does not schedule any events to be transmitted" do
+      subject.stop
+
+      Appsignal::CheckIn.cron("test")
+
+      expect(subject.events).to be_empty
+
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `test` finish event .+: AppSignal is not active/
+      )
+    end
+  end
+
+  describe "when transmitting returns a non-success response code" do
+    it "logs the error and continues" do
+      expect(transmitter).to receive(:transmit).and_return(
+        Net::HTTPNotFound.new("1.1", 404, "Not Found")
+      )
+
+      Appsignal::CheckIn.cron("first")
+
+      wait_for("the first event to be transmitted") { subject.transmitted == 1 }
+
+      expect(transmitter).to receive(:transmit).and_return(
+        Net::HTTPSuccess.new("1.1", 200, "OK")
+      )
+
+      Appsignal::CheckIn.cron("second")
+
+      wait_for("the second event to be transmitted") { subject.transmitted == 2 }
+
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `first` finish event .+: 404 status code/
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `second` finish event"
+      )
+    end
+  end
+
+  describe "when transmitting throws an error" do
+    it "logs the error and continues" do
+      expect(transmitter).to receive(:transmit).and_raise("Something went wrong")
+
+      Appsignal::CheckIn.cron("first")
+
+      wait_for("the first event to be transmitted") { subject.transmitted == 1 }
+
+      expect(transmitter).to receive(:transmit).and_return(
+        Net::HTTPSuccess.new("1.1", 200, "OK")
+      )
+
+      Appsignal::CheckIn.cron("second")
+
+      wait_for("the second event to be transmitted") { subject.transmitted == 2 }
+
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `first` finish event .+: Something went wrong/
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `second` finish event"
+      )
+    end
+  end
+end

data/spec/lib/appsignal/config_spec.rb

@@ -1,5 +1,18 @@
 describe Appsignal::Config do
   describe ".add_loader_defaults" do
+    context "when the config is initialized" do
+      before { Appsignal.configure(:test) }
+
+      it "logs a warning" do
+        logs = capture_logs { described_class.add_loader_defaults(:loader1) }
+
+        expect(logs).to contains_log(
+          :warn,
+          "The config defaults from the 'loader1' loader are ignored"
+        )
+      end
+    end
+
     it "adds loader defaults to the list" do
       described_class.add_loader_defaults(:loader1)
 

data/spec/lib/appsignal/environment_spec.rb

@@ -120,7 +120,7 @@ describe Appsignal::Environment do
 
       expect(logs).to be_empty
 
-      if Bundler.rubygems.respond_to?(:all_specs)
+      unless Bundler.rubygems.respond_to?(:all_specs)
         skip "Using new Bundler version without `all_specs` method"
       end
       bundle_gem_specs = silence { ::Bundler.rubygems.all_specs }

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

@@ -40,6 +40,17 @@ describe Appsignal::Hooks::AtExit::AtExitCallback do
     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
@@ -80,4 +91,15 @@ describe Appsignal::Hooks::AtExit::AtExitCallback do
       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/puma_spec.rb

@@ -1,34 +1,45 @@
 describe Appsignal::Hooks::PumaHook do
   context "with puma" do
-    before(:context) do
-      class Puma
-        def self.stats
-        end
+    let(:puma_version) { "6.0.0" }
+    before do
+      stub_const("Puma", PumaMock)
+      stub_const("Puma::Const::VERSION", puma_version)
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      context "when Puma present" do
+        context "when Puma is newer than version 3.0.0" do
+          let(:puma_version) { "3.0.0" }
 
-        def self.cli_config
-          @cli_config ||= CliConfig.new
+          it { is_expected.to be_truthy }
         end
-      end
 
-      class CliConfig
-        attr_accessor :options
+        context "when Puma is older than version 3.0.0" do
+          let(:puma_version) { "2.9.9" }
 
-        def initialize
-          @options = {}
+          it { is_expected.to be_falsey }
         end
       end
-    end
-    after(:context) { Object.send(:remove_const, :Puma) }
 
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+      context "when Puma is not present" do
+        before do
+          hide_const("Puma")
+        end
 
-      it { is_expected.to be_truthy }
+        it { is_expected.to be_falsey }
+      end
     end
 
     describe "installation" do
       before { Appsignal::Probes.probes.clear }
 
+      it "adds the Puma::Server patch" do
+        Appsignal::Hooks::PumaHook.new.install
+        expect(::Puma::Server.included_modules).to include(Appsignal::Integrations::PumaServer)
+      end
+
       context "when not clustered mode" do
         it "does not add AppSignal stop behavior Puma::Cluster" do
           expect(defined?(::Puma::Cluster)).to be_falsy
@@ -39,15 +50,12 @@ describe Appsignal::Hooks::PumaHook do
 
       context "when in clustered mode" do
         before do
-          class Puma
-            class Cluster
-              def stop_workers
-                @called = true
-              end
+          stub_const("Puma::Cluster", Class.new do
+            def stop_workers
+              @called = true
             end
-          end
+          end)
         end
-        after { Puma.send(:remove_const, :Cluster) }
 
         it "adds behavior to Puma::Cluster.stop_workers" do
           Appsignal::Hooks::PumaHook.new.install