appsignal 4.0.4 → 4.0.6

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

@@ -2,29 +2,29 @@ describe Appsignal::CheckIn::Scheduler do
   include WaitForHelper
   include TakeAtMostHelper
 
-  let(:transmitter) { Appsignal::Transmitter.new("http://checkin-endpoint.invalid") }
+  let(:log_stream) { std_stream }
+  let(:logs) { log_contents(log_stream) }
+  let(:appsignal_options) { {} }
+  let(:scheduler) { Appsignal::CheckIn.scheduler }
 
   before do
-    allow(Appsignal).to receive(:active?).and_return(true)
-    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)
+    start_agent(:options => appsignal_options, :internal_logger => test_logger(log_stream))
     # 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
+    scheduler.stop
   end
 
   describe "when no event is sent" do
     it "does not start a thread" do
-      expect(subject.thread).to be_nil
+      expect(scheduler.thread).to be_nil
     end
 
     it "does not schedule a debounce" do
-      expect(subject.waker).to be_nil
+      expect(scheduler.waker).to be_nil
     end
 
     it "can be stopped" do
@@ -35,7 +35,7 @@ describe Appsignal::CheckIn::Scheduler do
       stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
 
       take_at_most(0.1) do
-        expect { subject.stop }.not_to raise_error
+        expect { scheduler.stop }.not_to raise_error
       end
     end
 
@@ -47,52 +47,63 @@ describe Appsignal::CheckIn::Scheduler do
       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
+        expect { scheduler.stop }.not_to raise_error
+        expect { scheduler.stop }.not_to raise_error
       end
     end
 
     it "closes the queue when stopped" do
-      subject.stop
-      expect(subject.queue.closed?).to be(true)
+      scheduler.stop
+      expect(scheduler.queue.closed?).to be(true)
     end
   end
 
   describe "when an event is sent" do
     it "starts a thread" do
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
-      expect(subject.thread).to be_a(Thread)
+      expect(scheduler.thread).to be_a(Thread)
     end
 
     it "schedules a debounce" do
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
-      expect(subject.waker).to be_a(Thread)
+      expect(scheduler.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(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `test` finish event")
-      end)
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
 
-      expect(subject.events).to be_empty
+      expect(scheduler.events).to be_empty
 
       Appsignal::CheckIn.cron("test")
 
-      expect(subject.events).not_to be_empty
+      expect(scheduler.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") { scheduler.transmitted == 1 }
 
-      wait_for("the event to be transmitted") { subject.transmitted == 1 }
+      expect(scheduler.events).to be_empty
 
-      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
@@ -103,33 +114,30 @@ describe Appsignal::CheckIn::Scheduler do
       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)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `test` finish event")
-      end)
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
 
       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
+      expect(scheduler.events).not_to be_empty
 
       take_at_most(0.1) do
-        expect { subject.stop }.not_to raise_error
+        expect { scheduler.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(scheduler.transmitted).to eq(1)
+
+      expect(scheduler.events).to be_empty
 
-      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
@@ -140,59 +148,87 @@ describe Appsignal::CheckIn::Scheduler do
       stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
       stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
 
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
       take_at_most(0.1) do
-        expect { subject.stop }.not_to raise_error
+        expect { scheduler.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(scheduler.transmitted).to eq(1)
 
       take_at_most(0.1) do
-        expect { subject.stop }.not_to raise_error
+        expect { scheduler.stop }.not_to raise_error
       end
     end
 
     it "closes the queue when stopped" do
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
-      subject.stop
-      expect(subject.queue.closed?).to be(true)
+      scheduler.stop
+      expect(scheduler.queue.closed?).to be(true)
     end
 
     it "kills the thread when stopped" do
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
-      subject.stop
-      expect(subject.thread.alive?).to be(false)
+      scheduler.stop
+      expect(scheduler.thread.alive?).to be(false)
     end
 
     it "unschedules the debounce when stopped" do
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
       Appsignal::CheckIn.cron("test")
-      waker = subject.waker
-      subject.stop
+      waker = scheduler.waker
+      scheduler.stop
       expect(waker.alive?).to be(false)
-      expect(subject.waker).to be_nil
+      expect(scheduler.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
-        )
+        ["first", "second", "third"].map do |identifier|
+          stub_check_in_request(
+            :events => [
+              "identifier" => identifier,
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            ]
+          )
+        end
 
         Appsignal::CheckIn.cron("first")
         Appsignal::CheckIn.cron("second")
         Appsignal::CheckIn.cron("third")
 
-        wait_for("the events to be transmitted") { subject.transmitted == 1 }
+        wait_for("the events to be transmitted") { scheduler.transmitted == 1 }
       end
 
       it "transmits all events at once when stopped" do
@@ -202,42 +238,58 @@ describe Appsignal::CheckIn::Scheduler do
         # 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
-        )
+        ["first", "second", "third"].map do |identifier|
+          stub_check_in_request(
+            :events => [
+              "identifier" => identifier,
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            ]
+          )
+        end
 
         Appsignal::CheckIn.cron("first")
         Appsignal::CheckIn.cron("second")
         Appsignal::CheckIn.cron("third")
 
-        subject.stop
+        scheduler.stop
 
-        wait_for("the events to be transmitted") { subject.transmitted == 1 }
+        wait_for("the events to be transmitted") { scheduler.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)
+        stub_check_in_request(
+          :events => [
+            "identifier" => "first",
+            "kind" => "finish",
+            "check_in_type" => "cron"
+          ]
+        )
 
         Appsignal::CheckIn.cron("first")
 
-        wait_for("the first event to be transmitted") { subject.transmitted == 1 }
-
+        wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
+
+        stub_check_in_request(
+          :events => [
+            {
+              "identifier" => "second",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            },
+            {
+              "identifier" => "third",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            }
+          ]
+        )
         Appsignal::CheckIn.cron("second")
         Appsignal::CheckIn.cron("third")
 
-        expect(subject.events).to match(["second", "third"].map do |identifier|
+        expect(scheduler.events).to match(["second", "third"].map do |identifier|
           hash_including({
             :identifier => identifier,
             :check_in_type => "cron",
@@ -247,51 +299,46 @@ describe Appsignal::CheckIn::Scheduler do
       end
 
       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)
-
+        stub_check_in_request(
+          :events => [
+            "identifier" => "first",
+            "kind" => "finish",
+            "check_in_type" => "cron"
+          ]
+        )
         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(
-          ["second", "third"].map do |identifier|
-            hash_including(
-              :identifier => identifier,
-              :check_in_type => "cron",
-              :kind => "finish"
-            )
-          end, :format => :ndjson
+        wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
+
+        stub_check_in_request(
+          :events => [
+            {
+              "identifier" => "second",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            },
+            {
+              "identifier" => "third",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            }
+          ]
         )
 
-        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(scheduler.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") { scheduler.transmitted == 2 }
 
-        wait_for("the other events to be transmitted") { subject.transmitted == 2 }
+        expect(scheduler.events).to be_empty
 
-        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
@@ -301,53 +348,48 @@ describe Appsignal::CheckIn::Scheduler do
         # immediately when the scheduler is stopped.
         stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
 
-        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)
-
+        stub_check_in_request(
+          :events => [
+            "identifier" => "first",
+            "kind" => "finish",
+            "check_in_type" => "cron"
+          ]
+        )
         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(
-          ["second", "third"].map do |identifier|
-            hash_including(
-              :identifier => identifier,
-              :check_in_type => "cron",
-              :kind => "finish"
-            )
-          end, :format => :ndjson
+        wait_for("the event to be transmitted") { scheduler.transmitted == 1 }
+
+        stub_check_in_request(
+          :events => [
+            {
+              "identifier" => "second",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            },
+            {
+              "identifier" => "third",
+              "kind" => "finish",
+              "check_in_type" => "cron"
+            }
+          ]
         )
 
-        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(scheduler.events).to_not be_empty
 
-        expect(Appsignal.internal_logger).to receive(:debug).with(
-          "Transmitted 2 check-in events"
-        )
+        scheduler.stop
 
-        subject.stop
+        wait_for("the other events to be transmitted") { scheduler.transmitted == 2 }
 
-        wait_for("the other events to be transmitted") { subject.transmitted == 2 }
+        expect(scheduler.events).to be_empty
 
-        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
@@ -358,127 +400,158 @@ describe Appsignal::CheckIn::Scheduler do
       # `.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)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
+      stub_check_in_request(
+        :events => [
+          "identifier" => "test",
+          "kind" => "start",
+          "check_in_type" => "cron"
+        ]
       )
 
       cron.start
+      cron.start
+
+      wait_for("the event to be transmitted") { scheduler.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
 
   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
-
-      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)
+      scheduler.stop
 
       Appsignal::CheckIn.cron("test")
 
-      expect(subject.events).to be_empty
+      expect(scheduler.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 } }
 
-      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)
+    it "does not schedule any events to be transmitted" do
+      scheduler.stop
 
       Appsignal::CheckIn.cron("test")
 
-      expect(subject.events).to be_empty
+      expect(scheduler.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")
+      stub_check_in_request(
+        :events => [
+          "identifier" => "first",
+          "kind" => "start",
+          "check_in_type" => "cron"
+        ],
+        :response => { :status => 404 }
+      )
+      stub_check_in_request(
+        :events => [
+          "identifier" => "first",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ],
+        :response => { :status => 404 }
       )
 
       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 }
+      wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
 
-      expect(transmitter).to receive(:transmit).and_return(
-        Net::HTTPSuccess.new("1.1", 200, "OK")
+      stub_check_in_request(
+        :events => [
+          "identifier" => "second",
+          "kind" => "start",
+          "check_in_type" => "cron"
+        ]
+      )
+      stub_check_in_request(
+        :events => [
+          "identifier" => "second",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
       )
 
       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") { scheduler.transmitted == 2 }
 
-      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")
+      stub_check_in_request(
+        :events => [
+          "identifier" => "first",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ],
+        :response => ExampleStandardError.new("Something went wrong")
+      )
 
       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") { scheduler.transmitted == 1 }
 
-      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")
+      stub_check_in_request(
+        :events => [
+          "identifier" => "second",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
       )
 
       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") { scheduler.transmitted == 2 }
 
-      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 .+: ExampleStandardError: Something went wrong/ # rubocop:disable Layout/LineLength
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `second` finish event"
+      )
     end
   end
 end