appsignal 4.0.5 → 4.0.7

data/spec/lib/appsignal/probes_spec.rb

@@ -1,411 +0,0 @@
-describe Appsignal::Probes do
-  include WaitForHelper
-
-  before { Appsignal::Probes.probes.clear }
-
-  it "returns a ProbeCollection" do
-    expect(Appsignal::Probes.probes)
-      .to be_instance_of(Appsignal::Probes::ProbeCollection)
-  end
-
-  describe ".start" do
-    class ProbeWithoutDependency < MockProbe
-      def self.dependencies_present?
-        true
-      end
-    end
-
-    class ProbeWithMissingDependency < MockProbe
-      def self.dependencies_present?
-        false
-      end
-    end
-
-    class BrokenProbe < MockProbe
-      def call
-        super
-        raise "oh no!"
-      end
-    end
-
-    class BrokenProbeOnInitialize < MockProbe
-      def initialize
-        super
-        raise "oh no initialize!"
-      end
-
-      def call
-        true
-      end
-    end
-
-    let(:log_stream) { StringIO.new }
-    let(:log) { log_contents(log_stream) }
-    before do
-      Appsignal.internal_logger = test_logger(log_stream)
-      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::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")
-        expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
-      end
-
-      context "when dependency requirement is not met" do
-        it "does not initialize the probe" do
-          # Working probe which we can use to wait for X ticks
-          working_probe = ProbeWithoutDependency.new
-          Appsignal::Probes.register :probe_without_dep, working_probe
-
-          probe = ProbeWithMissingDependency.new
-          Appsignal::Probes.register :probe_with_missing_dep, probe
-          Appsignal::Probes.start
-
-          wait_for("enough probe calls") { working_probe.calls >= 2 }
-          # Only counts initialized probes
-          expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
-          expect(log).to contains_log :debug, "Skipping 'probe_with_missing_dep' probe, " \
-            "ProbeWithMissingDependency.dependency_present? returned falsy"
-        end
-      end
-    end
-
-    context "with probe class" do
-      it "creates an instance of the class and call that every <wait time>" do
-        probe = MockProbe
-        Appsignal::Probes.register :my_probe, probe
-        Appsignal::Probes.start
-
-        wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
-        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")
-      end
-
-      context "when dependency requirement is not met" do
-        it "does not initialize the probe" do
-          # Working probe which we can use to wait for X ticks
-          working_probe = ProbeWithoutDependency
-          Appsignal::Probes.register :probe_without_dep, working_probe
-
-          probe = ProbeWithMissingDependency
-          Appsignal::Probes.register :probe_with_missing_dep, probe
-          Appsignal::Probes.start
-
-          wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
-          # Only counts initialized probes
-          expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
-          expect(log).to contains_log :debug, "Skipping 'probe_with_missing_dep' probe, " \
-            "ProbeWithMissingDependency.dependency_present? returned falsy"
-        end
-      end
-
-      context "when there is a problem initializing the probe" do
-        it "logs an error" do
-          # Working probe which we can use to wait for X ticks
-          working_probe = ProbeWithoutDependency
-          Appsignal::Probes.register :probe_without_dep, working_probe
-
-          probe = BrokenProbeOnInitialize
-          Appsignal::Probes.register :broken_probe_on_initialize, probe
-          Appsignal::Probes.start
-
-          wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
-          # Only counts initialized probes
-          expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
-          # Logs error
-          expect(log).to contains_log(
-            :error,
-            "Error while initializing minutely probe 'broken_probe_on_initialize': " \
-              "oh no initialize!"
-          )
-          # Start of the error backtrace as debug log
-          expect(log).to contains_log :debug, File.expand_path("../../..", __dir__)
-        end
-      end
-    end
-
-    context "with a lambda" do
-      it "calls the lambda every <wait time>" do
-        calls = 0
-        probe = lambda { calls += 1 }
-        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")
-        expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
-      end
-    end
-
-    context "with a broken probe" do
-      it "logs the error and continues calling the probes every <wait_time>" do
-        probe = MockProbe.new
-        broken_probe = BrokenProbe.new
-        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 }
-
-        expect(log).to contains_log(:debug, "Gathering minutely metrics with 2 probes")
-        expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
-        expect(log).to contains_log(:debug, "Gathering minutely metrics with 'broken_probe' probe")
-        expect(log).to contains_log(:error, "Error in minutely probe 'broken_probe': oh no!")
-        gem_path = File.expand_path("../../..", __dir__) # Start of backtrace
-        expect(log).to contains_log(:debug, gem_path)
-      end
-    end
-
-    context "with a probe that takes 60 seconds" do
-      it "logs an error and continues calling the probes every <wait_time>" do
-        stub_const("Appsignal::Probes::ITERATION_IN_SECONDS", 0.2)
-        calls = 0
-        probe = lambda do
-          calls += 1
-          sleep 0.2
-        end
-        Appsignal::Probes.register :my_probe, probe
-        Appsignal::Probes.register :other_probe, lambda {}
-        Appsignal::Probes.start
-
-        wait_for("enough probe calls") { calls >= 2 }
-
-        expect(log).to contains_log(
-          :error,
-          "The minutely probes took more than 60 seconds. " \
-            "The probes should not take this long as metrics will not " \
-            "be accurately reported."
-        )
-      end
-    end
-
-    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::Probes.register :my_probe, probe
-      expect do
-        Appsignal::Probes.start
-      end.to change { alive_thread_counter.call }.by(1)
-
-      wait_for("enough probe calls") { probe.calls >= 2 }
-      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::Probes).to have_received(:initial_wait_time).once
-      expect do
-        # Fetch old thread
-        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
-      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
-    before { speed_up_tests! }
-
-    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
-      speed_up_tests!
-    end
-
-    it "stops the minutely thread" do
-      Appsignal::Probes.start
-      thread = Appsignal::Probes.instance_variable_get(:@thread)
-      expect(%w[sleep run]).to include(thread.status)
-      Appsignal::Probes.stop
-      thread.join
-      expect(thread.status).to eql(false)
-    end
-
-    it "clears the probe instances array" do
-      Appsignal::Probes.register :my_probe, lambda {}
-      Appsignal::Probes.start
-      thread = Appsignal::Probes.instance_variable_get(:@thread)
-      wait_for("probes initialized") do
-        !Appsignal::Probes.send(:probe_instances).empty?
-      end
-      expect(Appsignal::Probes.send(:probe_instances)).to_not be_empty
-      Appsignal::Probes.stop
-      thread.join
-      expect(Appsignal::Probes.send(:probe_instances)).to be_empty
-    end
-  end
-
-  describe ".wait_time" 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::Probes.wait_time).to eq 40
-      end
-    end
-  end
-
-  describe ".initial_wait_time" do
-    context "when started in the last 30 seconds of a minute" 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::Probes.send(:initial_wait_time)).to eql(29 + 60)
-        end
-      end
-    end
-
-    context "when started in the first 30 seconds of a minute" 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::Probes.send(:initial_wait_time)).to eql(31)
-        end
-      end
-    end
-  end
-
-  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.internal_register :my_probe_1, lambda {}
-        expect(collection.count).to eql(1)
-        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.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)
-      end
-    end
-
-    describe "#[]" do
-      it "returns the probe for that name" do
-        probe = lambda {}
-        collection.internal_register :my_probe, probe
-        expect(collection[:my_probe]).to eql(probe)
-      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 probe by key" do
-        probe = lambda {}
-        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.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."
-          expect(collection[:my_probe]).to eql(probe)
-        end
-      end
-    end
-
-    describe "#unregister" do
-      it "removes the probe from the collection" do
-        probe = lambda {}
-        silence { collection.internal_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.internal_register :my_probe, probe
-        list = []
-        collection.each do |name, p| # rubocop:disable Style/MapIntoArray
-          list << [name, p]
-        end
-        expect(list).to eql([[:my_probe, probe]])
-      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