appsignal 3.7.0-java → 3.7.1-java

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

@@ -16,7 +16,7 @@ describe Appsignal::Hooks::MriHook do
       end
 
       it "should be added to minutely probes" do
-        expect(Appsignal::Minutely.probes[:mri]).to be Appsignal::Probes::MriProbe
+        expect(Appsignal::Probes.probes[:mri]).to be Appsignal::Probes::MriProbe
       end
     end
   end

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

@@ -27,7 +27,7 @@ describe Appsignal::Hooks::PumaHook do
     end
 
     describe "installation" do
-      before { Appsignal::Minutely.probes.clear }
+      before { Appsignal::Probes.probes.clear }
 
       context "when not clustered mode" do
         it "does not add AppSignal stop behavior Puma::Cluster" do

data/spec/lib/appsignal/{minutely_spec.rb → probes_spec.rb}

@@ -1,11 +1,40 @@
-describe Appsignal::Minutely do
+describe Appsignal::Probes do
   include WaitForHelper
 
-  before { Appsignal::Minutely.probes.clear }
+  before { Appsignal::Probes.probes.clear }
+
+  context "Minutely constant" do
+    let(:err_stream) { std_stream }
+    let(:stderr) { err_stream.read }
+
+    it "returns the Probes constant calling the Minutely constant" do
+      silence { expect(Appsignal::Minutely).to be(Appsignal::Probes) }
+    end
+
+    it "prints a deprecation warning to STDERR" do
+      capture_std_streams(std_stream, err_stream) do
+        expect(Appsignal::Minutely).to be(Appsignal::Probes)
+      end
+
+      expect(stderr)
+        .to include("appsignal WARNING: The constant Appsignal::Minutely has been deprecated.")
+    end
+
+    it "logs a warning to STDERR" do
+      logs =
+        capture_logs do
+          silence do
+            expect(Appsignal::Minutely).to be(Appsignal::Probes)
+          end
+        end
+
+      expect(logs).to include("The constant Appsignal::Minutely has been deprecated.")
+    end
+  end
 
   it "returns a ProbeCollection" do
-    expect(Appsignal::Minutely.probes)
-      .to be_instance_of(Appsignal::Minutely::ProbeCollection)
+    expect(Appsignal::Probes.probes)
+      .to be_instance_of(Appsignal::Probes::ProbeCollection)
   end
 
   describe ".start" do
@@ -43,16 +72,31 @@ describe Appsignal::Minutely do
     let(:log) { log_contents(log_stream) }
     before do
       Appsignal.internal_logger = test_logger(log_stream)
-      # Speed up test time
-      allow(Appsignal::Minutely).to receive(:initial_wait_time).and_return(0.001)
-      allow(Appsignal::Minutely).to receive(:wait_time).and_return(0.001)
+      speed_up_tests!
+    end
+
+    describe ".started?" do
+      it "returns true when the probes thread has been started" do
+        expect(Appsignal::Probes.started?).to be_falsy
+        Appsignal::Probes.register :my_probe, (lambda {})
+        Appsignal::Probes.start
+        expect(Appsignal::Probes.started?).to be_truthy
+      end
+
+      it "returns false when the probes thread has been stopped" do
+        Appsignal::Probes.register :my_probe, lambda {}
+        Appsignal::Probes.start
+        expect(Appsignal::Probes.started?).to be_truthy
+        Appsignal::Probes.stop
+        expect(Appsignal::Probes.started?).to be_falsy
+      end
     end
 
     context "with an instance of a class" do
       it "calls the probe every <wait_time>" do
         probe = MockProbe.new
-        Appsignal::Minutely.probes.register :my_probe, probe
-        Appsignal::Minutely.start
+        Appsignal::Probes.register :my_probe, probe
+        Appsignal::Probes.start
 
         wait_for("enough probe calls") { probe.calls >= 2 }
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
@@ -63,11 +107,11 @@ describe Appsignal::Minutely do
         it "does not initialize the probe" do
           # Working probe which we can use to wait for X ticks
           working_probe = ProbeWithoutDependency.new
-          Appsignal::Minutely.probes.register :probe_without_dep, working_probe
+          Appsignal::Probes.register :probe_without_dep, working_probe
 
           probe = ProbeWithMissingDependency.new
-          Appsignal::Minutely.probes.register :probe_with_missing_dep, probe
-          Appsignal::Minutely.start
+          Appsignal::Probes.register :probe_with_missing_dep, probe
+          Appsignal::Probes.start
 
           wait_for("enough probe calls") { working_probe.calls >= 2 }
           # Only counts initialized probes
@@ -83,8 +127,8 @@ describe Appsignal::Minutely do
         probe = MockProbe
         probe_instance = MockProbe.new
         expect(probe).to receive(:new).and_return(probe_instance)
-        Appsignal::Minutely.probes.register :my_probe, probe
-        Appsignal::Minutely.start
+        Appsignal::Probes.register :my_probe, probe
+        Appsignal::Probes.start
 
         wait_for("enough probe calls") { probe_instance.calls >= 2 }
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
@@ -97,11 +141,11 @@ describe Appsignal::Minutely do
           working_probe = ProbeWithoutDependency
           working_probe_instance = working_probe.new
           expect(working_probe).to receive(:new).and_return(working_probe_instance)
-          Appsignal::Minutely.probes.register :probe_without_dep, working_probe
+          Appsignal::Probes.register :probe_without_dep, working_probe
 
           probe = ProbeWithMissingDependency
-          Appsignal::Minutely.probes.register :probe_with_missing_dep, probe
-          Appsignal::Minutely.start
+          Appsignal::Probes.register :probe_with_missing_dep, probe
+          Appsignal::Probes.start
 
           wait_for("enough probe calls") { working_probe_instance.calls >= 2 }
           # Only counts initialized probes
@@ -117,11 +161,11 @@ describe Appsignal::Minutely do
           working_probe = ProbeWithoutDependency
           working_probe_instance = working_probe.new
           expect(working_probe).to receive(:new).and_return(working_probe_instance)
-          Appsignal::Minutely.probes.register :probe_without_dep, working_probe
+          Appsignal::Probes.register :probe_without_dep, working_probe
 
           probe = BrokenProbeOnInitialize
-          Appsignal::Minutely.probes.register :broken_probe_on_initialize, probe
-          Appsignal::Minutely.start
+          Appsignal::Probes.register :broken_probe_on_initialize, probe
+          Appsignal::Probes.start
 
           wait_for("enough probe calls") { working_probe_instance.calls >= 2 }
           # Only counts initialized probes
@@ -142,8 +186,8 @@ describe Appsignal::Minutely do
       it "calls the lambda every <wait time>" do
         calls = 0
         probe = lambda { calls += 1 }
-        Appsignal::Minutely.probes.register :my_probe, probe
-        Appsignal::Minutely.start
+        Appsignal::Probes.register :my_probe, probe
+        Appsignal::Probes.start
 
         wait_for("enough probe calls") { calls >= 2 }
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
@@ -155,9 +199,9 @@ describe Appsignal::Minutely do
       it "logs the error and continues calling the probes every <wait_time>" do
         probe = MockProbe.new
         broken_probe = BrokenProbe.new
-        Appsignal::Minutely.probes.register :my_probe, probe
-        Appsignal::Minutely.probes.register :broken_probe, broken_probe
-        Appsignal::Minutely.start
+        Appsignal::Probes.register :my_probe, probe
+        Appsignal::Probes.register :broken_probe, broken_probe
+        Appsignal::Probes.start
 
         wait_for("enough probe calls") { probe.calls >= 2 }
         wait_for("enough broken_probe calls") { broken_probe.calls >= 2 }
@@ -174,53 +218,101 @@ describe Appsignal::Minutely do
     it "ensures only one minutely probes thread is active at a time" do
       alive_thread_counter = proc { Thread.list.reject { |t| t.status == "dead" }.length }
       probe = MockProbe.new
-      Appsignal::Minutely.probes.register :my_probe, probe
+      Appsignal::Probes.register :my_probe, probe
       expect do
-        Appsignal::Minutely.start
+        Appsignal::Probes.start
       end.to change { alive_thread_counter.call }.by(1)
 
       wait_for("enough probe calls") { probe.calls >= 2 }
-      expect(Appsignal::Minutely).to have_received(:initial_wait_time).once
-      expect(Appsignal::Minutely).to have_received(:wait_time).at_least(:once)
+      expect(Appsignal::Probes).to have_received(:initial_wait_time).once
+      expect(Appsignal::Probes).to have_received(:wait_time).at_least(:once)
       expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
       expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
 
       # Starting twice in this spec, so expecting it more than once
-      expect(Appsignal::Minutely).to have_received(:initial_wait_time).once
+      expect(Appsignal::Probes).to have_received(:initial_wait_time).once
       expect do
         # Fetch old thread
-        thread = Appsignal::Minutely.instance_variable_get(:@thread)
-        Appsignal::Minutely.start
+        thread = Appsignal::Probes.instance_variable_get(:@thread)
+        Appsignal::Probes.start
         thread&.join # Wait for old thread to exit
       end.to_not(change { alive_thread_counter.call })
     end
+
+    context "with thread already started" do
+      before do
+        allow(Appsignal::Probes).to receive(:initial_wait_time).and_return(0.00001)
+      end
+
+      it "auto starts probes added after the thread is started" do
+        Appsignal::Probes.start
+        wait_for("Probes thread to start") { Appsignal::Probes.started? }
+
+        calls = 0
+        probe = lambda { calls += 1 }
+        Appsignal::Probes.register :late_probe, probe
+
+        wait_for("enough probe calls") { calls >= 2 }
+        expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
+        expect(log).to contains_log(:debug, "Gathering minutely metrics with 'late_probe' probe")
+      end
+    end
+  end
+
+  describe ".unregister" do
+    let(:log_stream) { StringIO.new }
+    let(:log) { log_contents(log_stream) }
+    before do
+      Appsignal.internal_logger = test_logger(log_stream)
+      speed_up_tests!
+    end
+
+    it "does not call the initialized probe after unregistering" do
+      probe1_calls = 0
+      probe2_calls = 0
+      probe1 = lambda { probe1_calls += 1 }
+      probe2 = lambda { probe2_calls += 1 }
+      Appsignal::Probes.register :probe1, probe1
+      Appsignal::Probes.register :probe2, probe2
+      Appsignal::Probes.start
+      wait_for("enough probe1 calls") { probe1_calls >= 2 }
+      wait_for("enough probe2 calls") { probe2_calls >= 2 }
+
+      Appsignal::Probes.unregister :probe2
+      probe1_calls = 0
+      probe2_calls = 0
+      # Check the probe 1 calls to make sure the probes have been called before
+      # testing if the unregistered probe has not been called
+      wait_for("enough probe1 calls") { probe1_calls >= 2 }
+      expect(probe2_calls).to eq(0)
+    end
   end
 
   describe ".stop" do
     before do
-      allow(Appsignal::Minutely).to receive(:initial_wait_time).and_return(0.001)
+      allow(Appsignal::Probes).to receive(:initial_wait_time).and_return(0.001)
     end
 
     it "stops the minutely thread" do
-      Appsignal::Minutely.start
-      thread = Appsignal::Minutely.instance_variable_get(:@thread)
+      Appsignal::Probes.start
+      thread = Appsignal::Probes.instance_variable_get(:@thread)
       expect(%w[sleep run]).to include(thread.status)
-      Appsignal::Minutely.stop
+      Appsignal::Probes.stop
       thread.join
       expect(thread.status).to eql(false)
     end
 
     it "clears the probe instances array" do
-      Appsignal::Minutely.probes.register :my_probe, lambda {}
-      Appsignal::Minutely.start
-      thread = Appsignal::Minutely.instance_variable_get(:@thread)
+      Appsignal::Probes.register :my_probe, lambda {}
+      Appsignal::Probes.start
+      thread = Appsignal::Probes.instance_variable_get(:@thread)
       wait_for("probes initialized") do
-        !Appsignal::Minutely.send(:probe_instances).empty?
+        !Appsignal::Probes.send(:probe_instances).empty?
       end
-      expect(Appsignal::Minutely.send(:probe_instances)).to_not be_empty
-      Appsignal::Minutely.stop
+      expect(Appsignal::Probes.send(:probe_instances)).to_not be_empty
+      Appsignal::Probes.stop
       thread.join
-      expect(Appsignal::Minutely.send(:probe_instances)).to be_empty
+      expect(Appsignal::Probes.send(:probe_instances)).to be_empty
     end
   end
 
@@ -228,7 +320,7 @@ describe Appsignal::Minutely do
     it "gets the time to the next minute" do
       time = Time.new(2019, 4, 9, 12, 0, 20)
       Timecop.freeze time do
-        expect(Appsignal::Minutely.wait_time).to eq 40
+        expect(Appsignal::Probes.wait_time).to eq 40
       end
     end
   end
@@ -238,7 +330,7 @@ describe Appsignal::Minutely do
       it "waits for the number of seconds + 60" do
         time = Time.new(2019, 4, 9, 12, 0, 31)
         Timecop.freeze time do
-          expect(Appsignal::Minutely.send(:initial_wait_time)).to eql(29 + 60)
+          expect(Appsignal::Probes.send(:initial_wait_time)).to eql(29 + 60)
         end
       end
     end
@@ -247,29 +339,29 @@ describe Appsignal::Minutely do
       it "waits the remaining seconds in the minute" do
         time = Time.new(2019, 4, 9, 12, 0, 29)
         Timecop.freeze time do
-          expect(Appsignal::Minutely.send(:initial_wait_time)).to eql(31)
+          expect(Appsignal::Probes.send(:initial_wait_time)).to eql(31)
         end
       end
     end
   end
 
-  describe Appsignal::Minutely::ProbeCollection do
+  describe Appsignal::Probes::ProbeCollection do
     let(:collection) { described_class.new }
 
     describe "#count" do
       it "returns how many probes are registered" do
         expect(collection.count).to eql(0)
-        collection.register :my_probe_1, lambda {}
+        collection.internal_register :my_probe_1, lambda {}
         expect(collection.count).to eql(1)
-        collection.register :my_probe_2, lambda {}
+        collection.internal_register :my_probe_2, lambda {}
         expect(collection.count).to eql(2)
       end
     end
 
     describe "#clear" do
       it "clears the list of probes" do
-        collection.register :my_probe_1, lambda {}
-        collection.register :my_probe_2, lambda {}
+        collection.internal_register :my_probe_1, lambda {}
+        collection.internal_register :my_probe_2, lambda {}
         expect(collection.count).to eql(2)
         collection.clear
         expect(collection.count).to eql(0)
@@ -279,27 +371,65 @@ describe Appsignal::Minutely do
     describe "#[]" do
       it "returns the probe for that name" do
         probe = lambda {}
-        collection.register :my_probe, probe
+        collection.internal_register :my_probe, probe
         expect(collection[:my_probe]).to eql(probe)
       end
     end
 
     describe "#register" do
+      it "adds the probe by key" do
+        expect(Appsignal::Probes).to receive(:probes).and_return(collection)
+
+        probe = lambda {}
+        silence { collection.register :my_probe, probe }
+        expect(collection[:my_probe]).to eql(probe)
+      end
+
+      context "logger" do
+        let(:log_stream) { std_stream }
+        let(:log) { log_contents(log_stream) }
+
+        around { |example| use_logger_with(log_stream) { example.run } }
+        it "logs a deprecation message" do
+          silence { collection.register :my_probe, lambda {} }
+          expect(log).to contains_log :warn,
+            "The method 'Appsignal::Probes.probes.register' is deprecated. " \
+              "Use 'Appsignal::Probes.register' instead."
+        end
+      end
+
+      context "stderr" do
+        let(:err_stream) { std_stream }
+        let(:stderr) { err_stream.read }
+
+        it "prints a deprecation warning" do
+          capture_std_streams(std_stream, err_stream) do
+            collection.register :my_probe, lambda {}
+          end
+          deprecation_message =
+            "The method 'Appsignal::Probes.probes.register' is deprecated. " \
+              "Use 'Appsignal::Probes.register' instead."
+          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
+        end
+      end
+    end
+
+    describe "#internal_register" do
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }
       before { Appsignal.internal_logger = test_logger(log_stream) }
 
-      it "adds the by key probe" do
+      it "adds the probe by key" do
         probe = lambda {}
-        collection.register :my_probe, probe
+        collection.internal_register :my_probe, probe
         expect(collection[:my_probe]).to eql(probe)
       end
 
       context "when a probe is already registered with the same key" do
         it "logs a debug message" do
           probe = lambda {}
-          collection.register :my_probe, probe
-          collection.register :my_probe, probe
+          collection.internal_register :my_probe, probe
+          collection.internal_register :my_probe, probe
           expect(log).to contains_log :debug, "A probe with the name " \
             "`my_probe` is already registered. Overwriting the entry " \
             "with the new probe."
@@ -308,10 +438,23 @@ describe Appsignal::Minutely do
       end
     end
 
+    describe "#unregister" do
+      it "removes the probe from the collection" do
+        expect(Appsignal::Probes).to receive(:probes).and_return(collection)
+
+        probe = lambda {}
+        silence { collection.register :my_probe, probe }
+        expect(collection[:my_probe]).to eql(probe)
+
+        silence { collection.unregister :my_probe }
+        expect(collection[:my_probe]).to be_nil
+      end
+    end
+
     describe "#each" do
       it "loops over the registered probes" do
         probe = lambda {}
-        collection.register :my_probe, probe
+        collection.internal_register :my_probe, probe
         list = []
         collection.each do |name, p|
           list << [name, p]
@@ -320,4 +463,10 @@ describe Appsignal::Minutely do
       end
     end
   end
+
+  # Speed up test time by decreasing wait times in the probes mechanism
+  def speed_up_tests!
+    allow(Appsignal::Probes).to receive(:initial_wait_time).and_return(0.001)
+    allow(Appsignal::Probes).to receive(:wait_time).and_return(0.001)
+  end
 end

data/spec/lib/appsignal_spec.rb

@@ -87,7 +87,7 @@ describe Appsignal do
         end
 
         it "should start minutely" do
-          expect(Appsignal::Minutely).to receive(:start)
+          expect(Appsignal::Probes).to receive(:start)
           Appsignal.start
         end
       end
@@ -98,7 +98,7 @@ describe Appsignal do
         end
 
         it "should not start minutely" do
-          expect(Appsignal::Minutely).to_not receive(:start)
+          expect(Appsignal::Probes).to_not receive(:start)
           Appsignal.start
         end
       end
@@ -151,13 +151,20 @@ describe Appsignal do
   end
 
   describe ".stop" do
-    it "should call stop on the extension" do
+    it "calls stop on the extension" do
       expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal")
       expect(Appsignal::Extension).to receive(:stop)
       Appsignal.stop
       expect(Appsignal.active?).to be_falsy
     end
 
+    it "stops the minutely probes" do
+      Appsignal::Probes.start
+      expect(Appsignal::Probes.started?).to be_truthy
+      Appsignal.stop
+      expect(Appsignal::Probes.started?).to be_falsy
+    end
+
     context "with context specified" do
       it "should log the context" do
         expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal (something)")
@@ -1121,7 +1128,14 @@ describe Appsignal do
     let(:log_path) { File.join(tmp_dir, "log") }
     let(:log_file) { File.join(log_path, "appsignal.log") }
 
-    before { FileUtils.mkdir_p(log_path) }
+    before do
+      FileUtils.mkdir_p(log_path)
+      # Clear state from previous test
+      Appsignal.internal_logger = nil
+      if Appsignal.instance_variable_defined?(:@in_memory_log)
+        Appsignal.remove_instance_variable(:@in_memory_log)
+      end
+    end
     after { FileUtils.rm_rf(log_path) }
 
     def initialize_config
@@ -1130,6 +1144,7 @@ describe Appsignal do
         :log_path => log_path
       )
       Appsignal.internal_logger.error("Log in memory")
+      expect(Appsignal.in_memory_log.string).to_not be_empty
     end
 
     context "when the log path is writable" do
@@ -1154,6 +1169,10 @@ describe Appsignal do
         it "amends in memory log to log file" do
           expect(log_file_contents).to include "[ERROR] appsignal: Log in memory"
         end
+
+        it "clears the in memory log after writing to the new logger" do
+          expect(Appsignal.in_memory_log.string).to be_empty
+        end
       end
 
       context "when the log file is not writable" do
@@ -1178,8 +1197,11 @@ describe Appsignal do
           expect(output).to include "[ERROR] appsignal: Log in memory"
         end
 
+        it "clears the in memory log after writing to the new logger" do
+          expect(Appsignal.in_memory_log.string).to be_empty
+        end
+
         it "outputs a warning" do
-          puts output
           expect(output).to include \
             "[WARN] appsignal: Unable to start internal logger with log path '#{log_file}'.",
             "[WARN] appsignal: Permission denied"
@@ -1237,6 +1259,10 @@ describe Appsignal do
       it "amends in memory log to stdout" do
         expect(output).to include "[ERROR] appsignal: Log in memory"
       end
+
+      it "clears the in memory log after writing to the new logger" do
+        expect(Appsignal.in_memory_log.string).to be_empty
+      end
     end
 
     describe "#logger#level" do

data/spec/lib/puma/appsignal_spec.rb

@@ -32,10 +32,14 @@ RSpec.describe "Puma plugin" do
   # StatsD server used for these tests.
   # Open a UDPSocket and listen for messages sent by the AppSignal Puma plugin.
   class StatsdServer
+    def initialize(statsd_port)
+      @statsd_port = statsd_port
+    end
+
     def start
       stop
       @socket = UDPSocket.new
-      @socket.bind("127.0.0.1", 8125)
+      @socket.bind("127.0.0.1", @statsd_port)
 
       loop do
         # Listen for messages and track them on the messages Array.
@@ -115,13 +119,15 @@ RSpec.describe "Puma plugin" do
 
   def run_plugin(stats_data, plugin, &block)
     Puma._set_stats = stats_data
-    @statsd = StatsdServer.new
+    ENV["APPSIGNAL_STATSD_PORT"] = "8126"
+    @statsd = StatsdServer.new(ENV.fetch("APPSIGNAL_STATSD_PORT"))
     @server_thread = Thread.new { @statsd.start }
     @server_thread.abort_on_exception = true
     @client_thread = Thread.new { start_plugin(plugin) }
     @client_thread.abort_on_exception = true
     wait_for(:puma_client_wait, &block)
   ensure
+    ENV["APPSIGNAL_STATSD_PORT"] = nil
     Puma._set_stats = nil
     # Stop all threads in test and stop listening on the UDPSocket
     @client_thread.kill if defined?(@client_thread) && @client_thread

data/spec/spec_helper.rb

@@ -171,11 +171,11 @@ RSpec.configure do |config|
   def stop_minutely_probes
     thread =
       begin
-        Appsignal::Minutely.class_variable_get(:@@thread) # Fetch old thread
+        Appsignal::Probes.class_variable_get(:@@thread) # Fetch old thread
       rescue NameError
         nil
       end
-    Appsignal::Minutely.stop
+    Appsignal::Probes.stop
     thread&.join # Wait for old thread to exit
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.7.1
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -277,7 +277,6 @@ files:
 - lib/appsignal/integrations/webmachine.rb
 - lib/appsignal/logger.rb
 - lib/appsignal/marker.rb
-- lib/appsignal/minutely.rb
 - lib/appsignal/probes.rb
 - lib/appsignal/probes/gvl.rb
 - lib/appsignal/probes/helpers.rb
@@ -293,12 +292,12 @@ files:
 - lib/appsignal/transmitter.rb
 - lib/appsignal/utils.rb
 - lib/appsignal/utils/data.rb
-- lib/appsignal/utils/deprecation_message.rb
 - lib/appsignal/utils/hash_sanitizer.rb
 - lib/appsignal/utils/integration_logger.rb
 - lib/appsignal/utils/json.rb
 - lib/appsignal/utils/query_params_sanitizer.rb
 - lib/appsignal/utils/rails_helper.rb
+- lib/appsignal/utils/stdout_and_logger_message.rb
 - lib/appsignal/version.rb
 - lib/puma/plugin/appsignal.rb
 - lib/sequel/extensions/appsignal_integration.rb
@@ -378,10 +377,10 @@ files:
 - spec/lib/appsignal/integrations/webmachine_spec.rb
 - spec/lib/appsignal/logger_spec.rb
 - spec/lib/appsignal/marker_spec.rb
-- spec/lib/appsignal/minutely_spec.rb
 - spec/lib/appsignal/probes/gvl_spec.rb
 - spec/lib/appsignal/probes/mri_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
+- spec/lib/appsignal/probes_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
 - spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb
@@ -467,7 +466,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com