appsignal 2.9.2.alpha.1 → 2.9.18.beta.1

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

@@ -8,11 +8,6 @@ describe Appsignal::Hooks::PumaHook do
         def self.cli_config
           @cli_config ||= CliConfig.new
         end
-
-        class Cluster
-          def stop_workers
-          end
-        end
       end
 
       class CliConfig
@@ -31,49 +26,84 @@ describe Appsignal::Hooks::PumaHook do
       it { is_expected.to be_truthy }
     end
 
-    context "when installed" do
-      before do
-        Appsignal::Hooks::PumaHook.new.install
-      end
+    describe "installation" do
+      before { Appsignal::Minutely.probes.clear }
 
-      it "adds behavior to Unicorn::Worker#close" do
-        cluster = Puma::Cluster.new
+      context "when not clustered mode" do
+        it "does not add AppSignal stop behavior Puma::Cluster" do
+          expect(defined?(::Puma::Cluster)).to be_falsy
+          # Does not error on call
+          Appsignal::Hooks::PumaHook.new.install
+        end
 
-        expect(Appsignal).to receive(:stop)
-        expect(cluster).to receive(:stop_workers_without_appsignal)
+        context "with APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
+          before do
+            # Set in lib/puma/appsignal.rb
+            APPSIGNAL_PUMA_PLUGIN_LOADED = true
+          end
+          after { Object.send :remove_const, :APPSIGNAL_PUMA_PLUGIN_LOADED }
 
-        cluster.stop_workers
-      end
+          it "does not add the Puma minutely probe" do
+            Appsignal::Hooks::PumaHook.new.install
+            expect(Appsignal::Minutely.probes[:puma]).to be_nil
+          end
+        end
 
-      it "adds the Puma minutely probe" do
-        probe = Appsignal::Minutely.probes[:puma]
-        expect(probe).to eql(Appsignal::Hooks::PumaProbe)
-      end
-    end
+        context "without APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
+          it "adds the Puma minutely probe" do
+            expect(defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)).to be_nil
 
-    context "with nil hooks" do
-      before do
-        Puma.cli_config.options.delete(:before_worker_boot)
-        Puma.cli_config.options.delete(:before_worker_shutdown)
-        Appsignal::Hooks::PumaHook.new.install
+            Appsignal::Hooks::PumaHook.new.install
+            probe = Appsignal::Minutely.probes[:puma]
+            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+          end
+        end
       end
 
-      it "should add a before shutdown worker callback" do
-        expect(Puma.cli_config.options[:before_worker_boot].first).to be_a(Proc)
-        expect(Puma.cli_config.options[:before_worker_shutdown].first).to be_a(Proc)
-      end
-    end
+      context "when in clustered mode" do
+        before do
+          class Puma
+            class Cluster
+              def stop_workers
+                @called = true
+              end
+            end
+          end
+        end
+        after { Puma.send(:remove_const, :Cluster) }
 
-    context "with existing hooks" do
-      before do
-        Puma.cli_config.options[:before_worker_boot] = []
-        Puma.cli_config.options[:before_worker_shutdown] = []
-        Appsignal::Hooks::PumaHook.new.install
-      end
+        it "adds behavior to Puma::Cluster.stop_workers" do
+          Appsignal::Hooks::PumaHook.new.install
+          cluster = Puma::Cluster.new
+
+          expect(cluster.instance_variable_defined?(:@called)).to be_falsy
+          expect(Appsignal).to receive(:stop).and_call_original
+          cluster.stop_workers
+          expect(cluster.instance_variable_get(:@called)).to be(true)
+        end
+
+        context "with APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
+          before do
+            # Set in lib/puma/appsignal.rb
+            APPSIGNAL_PUMA_PLUGIN_LOADED = true
+          end
+          after { Object.send :remove_const, :APPSIGNAL_PUMA_PLUGIN_LOADED }
+
+          it "does not add the Puma minutely probe" do
+            Appsignal::Hooks::PumaHook.new.install
+            expect(Appsignal::Minutely.probes[:puma]).to be_nil
+          end
+        end
 
-      it "should add a before shutdown worker callback" do
-        expect(Puma.cli_config.options[:before_worker_boot].first).to be_a(Proc)
-        expect(Puma.cli_config.options[:before_worker_shutdown].first).to be_a(Proc)
+        context "without APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
+          it "adds the Puma minutely probe" do
+            expect(defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)).to be_nil
+
+            Appsignal::Hooks::PumaHook.new.install
+            probe = Appsignal::Minutely.probes[:puma]
+            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+          end
+        end
       end
     end
   end

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

@@ -665,12 +665,52 @@ describe Appsignal::Hooks::SidekiqProbe do
     end
     after { Object.send(:remove_const, "Sidekiq") }
 
+    describe ".dependencies_present?" do
+      before do
+        class Redis; end
+        Redis.const_set(:VERSION, version)
+      end
+      after { Object.send(:remove_const, "Redis") }
+
+      context "when Redis version is < 3.3.5" do
+        let(:version) { "3.3.4" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_falsy
+        end
+      end
+
+      context "when Redis version is >= 3.3.5" do
+        let(:version) { "3.3.5" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_truthy
+        end
+      end
+    end
+
     it "loads Sidekiq::API" do
       expect(defined?(Sidekiq::API)).to be_falsy
       probe
       expect(defined?(Sidekiq::API)).to be_truthy
     end
 
+    it "logs config on initialize" do
+      log = capture_logs { probe }
+      expect(log).to contains_log(:debug, "Initializing Sidekiq probe\n")
+    end
+
+    it "logs used hostname on call once" do
+      log = capture_logs { probe.call }
+      expect(log).to contains_log(
+        :debug,
+        %(Sidekiq probe: Using Redis server hostname "localhost" as hostname)
+      )
+      log = capture_logs { probe.call }
+      # Match more logs with incompelete message
+      expect(log).to_not contains_log(:debug, %(Sidekiq probe: ))
+    end
+
     it "collects custom metrics" do
       expect_gauge("worker_count", 24).twice
       expect_gauge("process_count", 25).twice
@@ -684,21 +724,43 @@ describe Appsignal::Hooks::SidekiqProbe do
       expect_gauge("job_count", 14, :status => :scheduled).twice
       expect_gauge("job_count", 15, :status => :enqueued).twice
       expect_gauge("queue_length", 10, :queue => "default").twice
-      expect_gauge("queue_latency", 12, :queue => "default").twice
+      expect_gauge("queue_latency", 12_000, :queue => "default").twice
       expect_gauge("queue_length", 1, :queue => "critical").twice
-      expect_gauge("queue_latency", 2, :queue => "critical").twice
+      expect_gauge("queue_latency", 2_000, :queue => "critical").twice
       # Call probe twice so we can calculate the delta for some gauge values
       probe.call
       probe.call
     end
 
+    context "when `redis_info` is not defined" do
+      before do
+        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
+      end
+
+      it "does not collect redis metrics" do
+        expect_gauge("connection_count", 2).never
+        expect_gauge("memory_usage", 1024).never
+        expect_gauge("memory_usage_rss", 512).never
+        probe.call
+      end
+    end
+
     context "when hostname is configured for probe" do
       let(:redis_hostname) { "my_redis_server" }
       let(:probe) { described_class.new(:hostname => redis_hostname) }
 
       it "uses the redis hostname for the hostname tag" do
         allow(Appsignal).to receive(:set_gauge).and_call_original
-        probe.call
+        log = capture_logs { probe }
+        expect(log).to contains_log(
+          :debug,
+          %(Initializing Sidekiq probe with config: {:hostname=>"#{redis_hostname}"})
+        )
+        log = capture_logs { probe.call }
+        expect(log).to contains_log(
+          :debug,
+          "Sidekiq probe: Using hostname config option #{redis_hostname.inspect} as hostname"
+        )
         expect(Appsignal).to have_received(:set_gauge)
           .with(anything, anything, :hostname => redis_hostname).at_least(:once)
       end

data/spec/lib/appsignal/hooks_spec.rb

@@ -68,6 +68,10 @@ describe Appsignal::Hooks do
     expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
 
     expect(Appsignal.logger).to receive(:error).with("Error while installing mock_error_hook hook: error").once
+    expect(Appsignal.logger).to receive(:debug).once do |message|
+      # Start of the error backtrace as debug log
+      expect(message).to start_with(File.expand_path("../../../../", __FILE__))
+    end
 
     Appsignal::Hooks.load_hooks
 

data/spec/lib/appsignal/minutely_spec.rb

@@ -1,4 +1,6 @@
 describe Appsignal::Minutely do
+  include WaitForHelper
+
   before { Appsignal::Minutely.probes.clear }
 
   it "returns a ProbeCollection" do
@@ -7,78 +9,151 @@ describe Appsignal::Minutely do
   end
 
   describe ".start" do
-    class Probe
-      attr_reader :calls
-
-      def initialize
-        @calls = 0
+    class ProbeWithoutDependency < MockProbe
+      def self.dependencies_present?
+        true
       end
+    end
 
-      def call
-        @calls += 1
+    class ProbeWithMissingDependency < MockProbe
+      def self.dependencies_present?
+        false
       end
     end
 
-    class BrokenProbe < Probe
+    class BrokenProbe < MockProbe
       def call
         super
         raise "oh no!"
       end
     end
 
-    let(:log_stream) { StringIO.new }
-    let(:log) do
-      log_stream.rewind
-      log_stream.read
+    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.logger = Logger.new(log_stream)
+      Appsignal.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)
     end
 
     context "with an instance of a class" do
       it "calls the probe every <wait_time>" do
-        probe = Probe.new
+        probe = MockProbe.new
         Appsignal::Minutely.probes.register :my_probe, probe
         Appsignal::Minutely.start
 
         wait_for("enough probe calls") { probe.calls >= 2 }
-        expect(log).to include("Gathering minutely metrics with 1 probe")
-        expect(log).to include("Gathering minutely metrics with 'my_probe' probe")
+        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::Minutely.probes.register :probe_without_dep, working_probe
+
+          probe = ProbeWithMissingDependency.new
+          Appsignal::Minutely.probes.register :probe_with_missing_dep, probe
+          Appsignal::Minutely.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 = Probe
-        probe_instance = Probe.new
+        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
 
         wait_for("enough probe calls") { probe_instance.calls >= 2 }
-        expect(log).to include("Gathering minutely metrics with 1 probe")
-        expect(log).to include("Gathering minutely metrics with 'my_probe' probe")
+        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
+          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
+
+          probe = ProbeWithMissingDependency
+          Appsignal::Minutely.probes.register :probe_with_missing_dep, probe
+          Appsignal::Minutely.start
+
+          wait_for("enough probe calls") { working_probe_instance.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
+
+      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
+          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
+
+          probe = BrokenProbeOnInitialize
+          Appsignal::Minutely.probes.register :broken_probe_on_initialize, probe
+          Appsignal::Minutely.start
+
+          wait_for("enough probe calls") { working_probe_instance.calls >= 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("../../../../", __FILE__)
+        end
       end
     end
 
     context "with a lambda" do
       it "calls the lambda every <wait time>" do
         calls = 0
-        probe = -> { calls += 1 }
+        probe = lambda { calls += 1 }
         Appsignal::Minutely.probes.register :my_probe, probe
         Appsignal::Minutely.start
 
         wait_for("enough probe calls") { calls >= 2 }
-        expect(log).to include("Gathering minutely metrics with 1 probe")
-        expect(log).to include("Gathering minutely metrics with 'my_probe' probe")
+        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 = Probe.new
+        probe = MockProbe.new
         broken_probe = BrokenProbe.new
         Appsignal::Minutely.probes.register :my_probe, probe
         Appsignal::Minutely.probes.register :broken_probe, broken_probe
@@ -87,24 +162,31 @@ describe Appsignal::Minutely do
         wait_for("enough probe calls") { probe.calls >= 2 }
         wait_for("enough broken_probe calls") { broken_probe.calls >= 2 }
 
-        expect(log).to include("Gathering minutely metrics with 2 probes")
-        expect(log).to include("Gathering minutely metrics with 'my_probe' probe")
-        expect(log).to include("Gathering minutely metrics with 'broken_probe' probe")
-        expect(log).to include("Error in minutely probe 'broken_probe': oh no!")
+        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("../../../../", __FILE__) # Start of backtrace
+        expect(log).to contains_log(:debug, gem_path)
       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 = Probe.new
+      probe = MockProbe.new
       Appsignal::Minutely.probes.register :my_probe, probe
       expect do
         Appsignal::Minutely.start
       end.to change { alive_thread_counter.call }.by(1)
 
       wait_for("enough probe calls") { probe.calls >= 2 }
-      expect(log).to include("Gathering minutely metrics with 1 probe")
-      expect(log).to include("Gathering minutely metrics with 'my_probe' probe")
+      expect(Appsignal::Minutely).to have_received(:initial_wait_time).once
+      expect(Appsignal::Minutely).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 do
         # Fetch old thread
         thread = Appsignal::Minutely.class_variable_get(:@@thread)
@@ -112,36 +194,13 @@ describe Appsignal::Minutely do
         thread && thread.join # Wait for old thread to exit
       end.to_not(change { alive_thread_counter.call })
     end
-
-    # Wait for a condition to be met
-    #
-    # @example
-    #   # Perform threaded operation
-    #   wait_for("enough probe calls") { probe.calls >= 2 }
-    #   # Assert on result
-    #
-    # @param name [String] The name of the condition to check. Used in the
-    #   error when it fails.
-    # @yield Assertion to check.
-    # @yieldreturn [Boolean] True/False value that indicates if the condition
-    #   is met.
-    # @raise [StandardError] Raises error if the condition is not met after 5
-    #   seconds, 5_000 tries.
-    def wait_for(name)
-      max_wait = 5_000
-      i = 0
-      while i <= max_wait
-        break if yield
-        i += 1
-        sleep 0.001
-      end
-
-      return unless i == max_wait
-      raise "Waited 5 seconds for #{name} condition, but was not met."
-    end
   end
 
   describe ".stop" do
+    before do
+      allow(Appsignal::Minutely).to receive(:initial_wait_time).and_return(0.001)
+    end
+
     it "stops the minutely thread" do
       Appsignal::Minutely.start
       thread = Appsignal::Minutely.class_variable_get(:@@thread)
@@ -152,9 +211,12 @@ describe Appsignal::Minutely do
     end
 
     it "clears the probe instances array" do
-      Appsignal::Minutely.probes.register :my_probe, -> {}
+      Appsignal::Minutely.probes.register :my_probe, lambda {}
       Appsignal::Minutely.start
       thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      wait_for("probes initialized") do
+        !Appsignal::Minutely.send(:probe_instances).empty?
+      end
       expect(Appsignal::Minutely.send(:probe_instances)).to_not be_empty
       Appsignal::Minutely.stop
       thread.join
@@ -164,20 +226,30 @@ describe Appsignal::Minutely do
 
   describe ".wait_time" do
     it "gets the time to the next minute" do
-      allow_any_instance_of(Time).to receive(:sec).and_return(20)
-      expect(Appsignal::Minutely.wait_time).to eq 40
+      time = Time.new(2019, 4, 9, 12, 0, 20)
+      Timecop.freeze time do
+        expect(Appsignal::Minutely.wait_time).to eq 40
+      end
     end
   end
 
-  describe ".register_garbage_collection_probe" do
-    it "adds the GC probe to the probes list" do
-      expect(Appsignal::Minutely.probes.count).to eql(0)
-
-      Appsignal::Minutely.register_garbage_collection_probe
+  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::Minutely.send(:initial_wait_time)).to eql(29 + 60)
+        end
+      end
+    end
 
-      expect(Appsignal::Minutely.probes.count).to eql(1)
-      expect(Appsignal::Minutely.probes[:garbage_collection])
-        .to be_instance_of(Appsignal::Minutely::GCProbe)
+    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::Minutely.send(:initial_wait_time)).to eql(31)
+        end
+      end
     end
   end
 
@@ -187,17 +259,17 @@ describe Appsignal::Minutely do
     describe "#count" do
       it "returns how many probes are registered" do
         expect(collection.count).to eql(0)
-        collection.register :my_probe_1, -> {}
+        collection.register :my_probe_1, lambda {}
         expect(collection.count).to eql(1)
-        collection.register :my_probe_2, -> {}
+        collection.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, -> {}
-        collection.register :my_probe_2, -> {}
+        collection.register :my_probe_1, lambda {}
+        collection.register :my_probe_2, lambda {}
         expect(collection.count).to eql(2)
         collection.clear
         expect(collection.count).to eql(0)
@@ -206,7 +278,7 @@ describe Appsignal::Minutely do
 
     describe "#[]" do
       it "returns the probe for that name" do
-        probe = -> {}
+        probe = lambda {}
         collection.register :my_probe, probe
         expect(collection[:my_probe]).to eql(probe)
       end
@@ -220,7 +292,7 @@ describe Appsignal::Minutely do
       before { Appsignal.logger = test_logger(log_stream) }
 
       it "adds the probe, but prints a deprecation warning" do
-        probe = -> {}
+        probe = lambda {}
         capture_stdout(out_stream) { collection << probe }
         deprecation_message = "Deprecated " \
           "`Appsignal::Minute.probes <<` call. Please use " \
@@ -237,14 +309,14 @@ describe Appsignal::Minutely do
       before { Appsignal.logger = test_logger(log_stream) }
 
       it "adds the by key probe" do
-        probe = -> {}
+        probe = lambda {}
         collection.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 = -> {}
+          probe = lambda {}
           collection.register :my_probe, probe
           collection.register :my_probe, probe
           expect(log).to contains_log :debug, "A probe with the name " \
@@ -257,7 +329,7 @@ describe Appsignal::Minutely do
 
     describe "#each" do
       it "loops over the registered probes" do
-        probe = -> {}
+        probe = lambda {}
         collection.register :my_probe, probe
         list = []
         collection.each do |name, p|
@@ -267,14 +339,4 @@ describe Appsignal::Minutely do
       end
     end
   end
-
-  describe Appsignal::Minutely::GCProbe do
-    describe "#call" do
-      it "collects GC metrics" do
-        expect(Appsignal).to receive(:set_process_gauge).at_least(8).times
-
-        Appsignal::Minutely::GCProbe.new.call
-      end
-    end
-  end
 end