appsignal 3.7.0-java → 3.7.2-java

data/lib/appsignal.rb

@@ -5,7 +5,7 @@ require "securerandom"
 require "stringio"
 
 require "appsignal/logger"
-require "appsignal/utils/deprecation_message"
+require "appsignal/utils/stdout_and_logger_message"
 require "appsignal/helpers/instrumentation"
 require "appsignal/helpers/metrics"
 
@@ -120,7 +120,7 @@ module Appsignal
             Appsignal::Environment.report_enabled("allocation_tracking")
           end
 
-          Appsignal::Minutely.start if config[:enable_minutely_probes]
+          Appsignal::Probes.start if config[:enable_minutely_probes]
 
           collect_environment_metadata
         else
@@ -152,6 +152,7 @@ module Appsignal
         internal_logger.debug("Stopping appsignal")
       end
       Appsignal::Extension.stop
+      Appsignal::Probes.stop
     end
 
     def forked
@@ -218,7 +219,10 @@ module Appsignal
         else
           Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-      internal_logger << @in_memory_log.string if @in_memory_log
+      return unless @in_memory_log
+
+      internal_logger << @in_memory_log.string
+      @in_memory_log = nil
     end
 
     # Returns if the C-extension was loaded properly.
@@ -287,6 +291,22 @@ module Appsignal
       end
       Appsignal::Environment.report_supported_gems
     end
+
+    # Alias constants that have moved with a warning message that points to the
+    # place to update the reference.
+    def const_missing(name)
+      case name
+      when :Minutely
+        callers = caller
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The constant Appsignal::Minutely has been deprecated. " \
+            "Please update the constant name to Appsignal::Probes " \
+            "in the following file to remove this message.\n#{callers.first}"
+        Appsignal::Probes
+      else
+        super
+      end
+    end
   end
 end
 
@@ -300,7 +320,6 @@ require "appsignal/event_formatter"
 require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
-require "appsignal/minutely"
 require "appsignal/garbage_collection"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"

data/spec/lib/appsignal/config_spec.rb

@@ -757,7 +757,10 @@ describe Appsignal::Config do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
     let(:config) { project_fixture_config("production", :log_path => log_path) }
-    subject { capture_stdout(out_stream) { config.log_file_path } }
+
+    def log_file_path
+      capture_stdout(out_stream) { config.log_file_path }
+    end
 
     context "when path is writable" do
       let(:log_path) { File.join(tmp_dir, "writable-path") }
@@ -765,11 +768,11 @@ describe Appsignal::Config do
       after { FileUtils.rm_rf(log_path) }
 
       it "returns log file path" do
-        expect(subject).to eq File.join(log_path, "appsignal.log")
+        expect(log_file_path).to eq File.join(log_path, "appsignal.log")
       end
 
       it "prints no warning" do
-        subject
+        log_file_path
         expect(output).to be_empty
       end
     end
@@ -783,28 +786,47 @@ describe Appsignal::Config do
         before { FileUtils.chmod(0o777, system_tmp_dir) }
 
         it "returns returns the tmp location" do
-          expect(subject).to eq(File.join(system_tmp_dir, "appsignal.log"))
+          expect(log_file_path).to eq(File.join(system_tmp_dir, "appsignal.log"))
         end
 
         it "prints a warning" do
-          subject
+          log_file_path
           expect(output).to include "appsignal: Unable to log to '#{log_path}'. " \
             "Logging to '#{system_tmp_dir}' instead."
         end
+
+        it "prints a warning once" do
+          capture_stdout(out_stream) do
+            log_file_path
+            log_file_path
+          end
+          message = "appsignal: Unable to log to '#{log_path}'. " \
+            "Logging to '#{system_tmp_dir}' instead."
+          expect(output.scan(message).count).to eq(1)
+        end
       end
 
       context "when the /tmp fallback path is not writable" do
         before { FileUtils.chmod(0o555, system_tmp_dir) }
 
         it "returns nil" do
-          expect(subject).to be_nil
+          expect(log_file_path).to be_nil
         end
 
         it "prints a warning" do
-          subject
+          log_file_path
           expect(output).to include "appsignal: Unable to log to '#{log_path}' " \
             "or the '#{system_tmp_dir}' fallback."
         end
+
+        it "prints a warning once" do
+          capture_stdout(out_stream) do
+            log_file_path
+            log_file_path
+          end
+          message = "appsignal: Unable to log to '#{log_path}' or the '#{system_tmp_dir}' fallback."
+          expect(output.scan(message).count).to eq(1)
+        end
       end
     end
 
@@ -819,11 +841,11 @@ describe Appsignal::Config do
 
       context "when root_path is set" do
         it "returns returns the project log location" do
-          expect(subject).to eq File.join(config.root_path, "log/appsignal.log")
+          expect(log_file_path).to eq File.join(config.root_path, "log/appsignal.log")
         end
 
         it "prints no warning" do
-          subject
+          log_file_path
           expect(output).to be_empty
         end
       end
@@ -883,7 +905,7 @@ describe Appsignal::Config do
           end
 
           it "returns real path of log path" do
-            expect(subject).to eq(File.join(real_path, "appsignal.log"))
+            expect(log_file_path).to eq(File.join(real_path, "appsignal.log"))
           end
         end
       end

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

@@ -93,7 +93,7 @@ describe Appsignal::Hooks::GvlHook do
           it "is added to minutely probes" do
             Appsignal::Hooks.load_hooks
 
-            expect(Appsignal::Minutely.probes[:gvl]).to be Appsignal::Probes::GvlProbe
+            expect(Appsignal::Probes.probes[:gvl]).to be Appsignal::Probes::GvlProbe
           end
         end
       end

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