appsignal 4.0.4 → 4.0.5

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

@@ -1,86 +1,69 @@
 describe Appsignal::CheckIn::Cron do
+  let(:log_stream) { std_stream }
+  let(:logs) { log_contents(log_stream) }
+  let(:appsignal_options) { {} }
   let(:config) { project_fixture_config }
   let(:cron_checkin) { described_class.new(:identifier => "cron-checkin-name") }
   let(:transmitter) { Appsignal::Transmitter.new("https://checkin-endpoint.invalid") }
   let(:scheduler) { Appsignal::CheckIn::Scheduler.new }
 
   before do
-    allow(Appsignal).to receive(:active?).and_return(true)
-    config.logger = Logger.new(StringIO.new)
+    start_agent(
+      :options => appsignal_options,
+      :internal_logger => test_logger(log_stream)
+    )
     allow(Appsignal::CheckIn).to receive(:scheduler).and_return(scheduler)
     allow(Appsignal::CheckIn).to receive(:transmitter).and_return(transmitter)
   end
+  after { stop_scheduler }
 
-  after do
+  def stop_scheduler
     scheduler.stop
   end
 
   describe "when Appsignal is not active" do
-    it "should not transmit any events" do
-      allow(Appsignal).to receive(:active?).and_return(false)
+    let(:appsignal_options) { { :active => false } }
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` start event") &&
-        message.include?("AppSignal is not active")
-      end)
+    it "does not transmit any events" do
+      expect(Appsignal).to_not be_started
 
       cron_checkin.start
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` finish event") &&
-        message.include?("AppSignal is not active")
-      end)
-
       cron_checkin.finish
-
-      expect(transmitter).not_to receive(:transmit)
-
-      scheduler.stop
+      stop_scheduler
+
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `cron-checkin-name` start event .+: AppSignal is not active/
+      )
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `cron-checkin-name` finish event .+: AppSignal is not active/
+      )
     end
   end
 
   describe "when AppSignal is stopped" do
-    it "should not transmit any events" do
-      expect(transmitter).not_to receive(:transmit)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
-
+    it "does not transmit any events" do
       Appsignal.stop
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` start event") &&
-        message.include?("AppSignal is stopped")
-      end)
-
       cron_checkin.start
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` finish event") &&
-        message.include?("AppSignal is stopped")
-      end)
-
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
-
-      Appsignal.stop
+      expect(logs).to contains_log(
+        :debug,
+        "Cannot transmit cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Cannot transmit cron check-in `cron-checkin-name` finish event"
+      )
     end
   end
 
   describe "#start" do
-    it "should send a cron check-in start" do
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` start event")
-      end)
-
+    it "sends a cron check-in start" do
       cron_checkin.start
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `cron-checkin-name` start event")
-      end)
-
       expect(transmitter).to receive(:transmit).with([hash_including(
         :identifier => "cron-checkin-name",
         :kind => "start",
@@ -88,20 +71,21 @@ describe Appsignal::CheckIn::Cron do
       )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
 
       scheduler.stop
-    end
 
-    it "should log an error if it fails" do
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` start event")
-      end)
+      expect(logs).to_not contains_log(:error)
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `cron-checkin-name` start event"
+      )
+    end
 
+    it "logs an error if it fails" do
       cron_checkin.start
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `cron-checkin-name` start event") &&
-          message.include?("499 status code")
-      end)
-
       expect(transmitter).to receive(:transmit).with([hash_including(
         :identifier => "cron-checkin-name",
         :kind => "start",
@@ -109,23 +93,22 @@ describe Appsignal::CheckIn::Cron do
       )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
 
       scheduler.stop
+
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `cron-checkin-name` start event .+: 499 status code/
+      )
     end
   end
 
   describe "#finish" do
-    it "should send a cron check-in finish" do
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` finish event")
-      end)
-
+    it "sends a cron check-in finish" do
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `cron-checkin-name` finish event")
-      end)
-
       expect(transmitter).to receive(:transmit).with([hash_including(
         :identifier => "cron-checkin-name",
         :kind => "finish",
@@ -133,20 +116,20 @@ describe Appsignal::CheckIn::Cron do
       )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
 
       scheduler.stop
+      expect(logs).to_not contains_log(:error)
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` finish event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `cron-checkin-name` finish event"
+      )
     end
 
-    it "should log an error if it fails" do
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` finish event")
-      end)
-
+    it "logs an error if it fails" do
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `cron-checkin-name` finish event") &&
-          message.include?("499 status code")
-      end)
-
       expect(transmitter).to receive(:transmit).with([hash_including(
         :identifier => "cron-checkin-name",
         :kind => "finish",
@@ -154,12 +137,21 @@ describe Appsignal::CheckIn::Cron do
       )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
 
       scheduler.stop
+
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` finish event"
+      )
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `cron-checkin-name` finish event .+: 499 status code/
+      )
     end
   end
 
   describe ".cron" do
     describe "when a block is given" do
-      it "should send a cron check-in start and finish and return the block output" do
+      it "sends a cron check-in start and finish and return the block output" do
         expect(scheduler).to receive(:schedule).with(hash_including(
           :kind => "start",
           :identifier => "cron-checkin-with-block",
@@ -176,7 +168,7 @@ describe Appsignal::CheckIn::Cron do
         expect(output).to eq("output")
       end
 
-      it "should not send a cron check-in finish event when an error is raised" do
+      it "does not send a cron check-in finish event when an error is raised" do
         expect(scheduler).to receive(:schedule).with(hash_including(
           :kind => "start",
           :identifier => "cron-checkin-with-block",
@@ -196,7 +188,7 @@ describe Appsignal::CheckIn::Cron do
     end
 
     describe "when no block is given" do
-      it "should only send a cron check-in finish event" do
+      it "only sends a cron check-in finish event" do
         expect(scheduler).to receive(:schedule).with(hash_including(
           :kind => "finish",
           :identifier => "cron-checkin-without-block",

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

@@ -2,10 +2,13 @@ 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
-    allow(Appsignal).to receive(:active?).and_return(true)
+    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)
@@ -76,23 +79,18 @@ describe Appsignal::CheckIn::Scheduler do
         :kind => "finish"
       )], :format => :ndjson)
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `test` finish event")
-      end)
-
       expect(subject.events).to be_empty
 
       Appsignal::CheckIn.cron("test")
 
       expect(subject.events).not_to be_empty
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `test` finish event")
-      end)
-
       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
@@ -109,16 +107,8 @@ describe Appsignal::CheckIn::Scheduler do
         :kind => "finish"
       )], :format => :ndjson)
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `test` finish event")
-      end)
-
       Appsignal::CheckIn.cron("test")
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `test` finish event")
-      end)
-
       expect(subject.events).not_to be_empty
 
       take_at_most(0.1) do
@@ -130,6 +120,9 @@ describe Appsignal::CheckIn::Scheduler do
       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
@@ -249,16 +242,8 @@ describe Appsignal::CheckIn::Scheduler do
       it "transmits the other events after the debounce interval" do
         expect(transmitter).to receive(:transmit)
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `first` finish event")
-        end)
-
         Appsignal::CheckIn.cron("first")
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Transmitted cron check-in `first` finish event")
-        end)
-
         wait_for("the first event to be transmitted") { subject.transmitted == 1 }
 
         expect(transmitter).to receive(:transmit).with(
@@ -271,27 +256,20 @@ describe Appsignal::CheckIn::Scheduler do
           end, :format => :ndjson
         )
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `second` finish event")
-        end)
-
         Appsignal::CheckIn.cron("second")
-
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `third` finish event")
-        end)
-
         Appsignal::CheckIn.cron("third")
 
         expect(subject.events).to_not be_empty
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(
-          "Transmitted 2 check-in events"
-        )
-
         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
@@ -303,16 +281,8 @@ describe Appsignal::CheckIn::Scheduler do
 
         expect(transmitter).to receive(:transmit)
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `first` finish event")
-        end)
-
         Appsignal::CheckIn.cron("first")
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Transmitted cron check-in `first` finish event")
-        end)
-
         wait_for("the event to be transmitted") { subject.transmitted == 1 }
 
         expect(transmitter).to receive(:transmit).with(
@@ -325,29 +295,22 @@ describe Appsignal::CheckIn::Scheduler do
           end, :format => :ndjson
         )
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `second` finish event")
-        end)
-
         Appsignal::CheckIn.cron("second")
-
-        expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-          message.include?("Scheduling cron check-in `third` finish event")
-        end)
-
         Appsignal::CheckIn.cron("third")
 
         expect(subject.events).to_not be_empty
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(
-          "Transmitted 2 check-in events"
-        )
-
         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
@@ -364,27 +327,27 @@ describe Appsignal::CheckIn::Scheduler do
         :kind => "start"
       )], :format => :ndjson)
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
-      )
-
       cron.start
+      cron.start
+
+      wait_for("the event to be transmitted") { subject.transmitted == 1 }
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(
+      expect(logs).to contains_log(
+        :debug,
         "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
       )
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
+      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})"
       )
-
-      cron.start
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
+      expect(logs).to contains_log(
+        :debug,
         "Transmitted cron check-in `test` start event (digest #{cron.digest})"
       )
-
-      wait_for("the event to be transmitted") { subject.transmitted == 1 }
     end
   end
 
@@ -394,31 +357,31 @@ describe Appsignal::CheckIn::Scheduler do
 
       subject.stop
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `test` finish event") &&
-          message.include?("AppSignal is stopped")
-      end)
-
       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
-    it "does not schedule any events to be transmitted" do
-      allow(Appsignal).to receive(:active?).and_return(false)
+    let(:appsignal_options) { { :active => false } }
 
+    it "does not schedule any events to be transmitted" do
       subject.stop
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `test` finish event") &&
-          message.include?("AppSignal is not active")
-      end)
-
       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
 
@@ -430,11 +393,6 @@ describe Appsignal::CheckIn::Scheduler do
 
       Appsignal::CheckIn.cron("first")
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `first` finish event") &&
-          message.include?("404 status code")
-      end)
-
       wait_for("the first event to be transmitted") { subject.transmitted == 1 }
 
       expect(transmitter).to receive(:transmit).and_return(
@@ -443,13 +401,16 @@ describe Appsignal::CheckIn::Scheduler do
 
       Appsignal::CheckIn.cron("second")
 
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `second` finish event")
-      end)
-
       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
 
@@ -459,11 +420,6 @@ describe Appsignal::CheckIn::Scheduler do
 
       Appsignal::CheckIn.cron("first")
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `first` finish event") &&
-          message.include?("Something went wrong")
-      end)
-
       wait_for("the first event to be transmitted") { subject.transmitted == 1 }
 
       expect(transmitter).to receive(:transmit).and_return(
@@ -472,13 +428,16 @@ describe Appsignal::CheckIn::Scheduler do
 
       Appsignal::CheckIn.cron("second")
 
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `second` finish event")
-      end)
-
       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/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