appsignal 2.8.4.beta.1 → 2.9.18.beta.1

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

@@ -431,6 +431,11 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     let(:error) { ExampleException }
 
     it "creates a transaction and adds the error" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :failed)
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :processed)
+
       expect do
         perform_job { raise error, "uh oh" }
       end.to raise_error(error)
@@ -466,6 +471,9 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
 
   context "without an error" do
     it "creates a transaction with events" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :processed)
+
       perform_job
 
       transaction_hash = transaction.to_h
@@ -541,6 +549,7 @@ describe Appsignal::Hooks::SidekiqHook do
 
   describe "#install" do
     before do
+      Appsignal.config = project_fixture_config
       class Sidekiq
         def self.middlewares
           @middlewares ||= Set.new
@@ -564,3 +573,203 @@ describe Appsignal::Hooks::SidekiqHook do
     end
   end
 end
+
+describe Appsignal::Hooks::SidekiqProbe do
+  describe "#call" do
+    let(:probe) { described_class.new }
+    let(:redis_hostname) { "localhost" }
+    let(:expected_default_tags) { { :hostname => "localhost" } }
+    before do
+      Appsignal.config = project_fixture_config
+      class Sidekiq
+        def self.redis_info
+          {
+            "connected_clients" => 2,
+            "used_memory" => 1024,
+            "used_memory_rss" => 512
+          }
+        end
+
+        def self.redis
+          yield Client.new
+        end
+
+        class Client
+          def connection
+            { :host => "localhost" }
+          end
+        end
+
+        class Stats
+          class << self
+            attr_reader :calls
+
+            def count_call
+              @calls ||= -1
+              @calls += 1
+            end
+          end
+
+          def workers_size
+            # First method called, so count it towards a call
+            self.class.count_call
+            24
+          end
+
+          def processes_size
+            25
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def processed
+            [10, 15][self.class.calls]
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def failed
+            [10, 13][self.class.calls]
+          end
+
+          def retry_size
+            12
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def dead_size
+            [10, 12][self.class.calls]
+          end
+
+          def scheduled_size
+            14
+          end
+
+          def enqueued
+            15
+          end
+        end
+
+        class Queue
+          Queue = Struct.new(:name, :size, :latency)
+
+          def self.all
+            [
+              Queue.new("default", 10, 12),
+              Queue.new("critical", 1, 2)
+            ]
+          end
+        end
+      end
+    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
+      expect_gauge("connection_count", 2).twice
+      expect_gauge("memory_usage", 1024).twice
+      expect_gauge("memory_usage_rss", 512).twice
+      expect_gauge("job_count", 5, :status => :processed) # Gauge delta
+      expect_gauge("job_count", 3, :status => :failed) # Gauge delta
+      expect_gauge("job_count", 12, :status => :retry_queue).twice
+      expect_gauge("job_count", 2, :status => :died) # Gauge delta
+      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_000, :queue => "default").twice
+      expect_gauge("queue_length", 1, :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
+        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
+    end
+
+    def expect_gauge(key, value, tags = {})
+      expect(Appsignal).to receive(:set_gauge)
+        .with("sidekiq_#{key}", value, expected_default_tags.merge(tags))
+        .and_call_original
+    end
+  end
+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/integrations/mongo_ruby_driver_spec.rb

@@ -62,7 +62,8 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
         double(
           :request_id    => 2,
           :command_name  => :find,
-          :database_name => "test"
+          :database_name => "test",
+          :duration      => 0.9919
         )
       end
 
@@ -71,6 +72,16 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
         store[2] = command
       end
 
+      it "should emit a measurement" do
+        expect(Appsignal).to receive(:add_distribution_value).with(
+          "mongodb_query_duration",
+          0.9919,
+          :database => "test"
+        ).and_call_original
+
+        subscriber.finish("SUCCEEDED", event)
+      end
+
       it "should get the query from the store" do
         expect(transaction).to receive(:store).with("mongo_driver").and_return(command)
 
@@ -106,6 +117,12 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
 
       subscriber.finish("SUCCEEDED", double)
     end
+
+    it "should not attempt to send duration metrics" do
+      expect(Appsignal).to_not receive(:add_distribution_value)
+
+      subscriber.finish("SUCCEEDED", double)
+    end
   end
 
   context "when appsignal is paused" do
@@ -123,5 +140,11 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
 
       subscriber.finish("SUCCEEDED", double)
     end
+
+    it "should not attempt to send duration metrics" do
+      expect(Appsignal).to_not receive(:add_distribution_value)
+
+      subscriber.finish("SUCCEEDED", double)
+    end
   end
 end

data/spec/lib/appsignal/minutely_spec.rb

@@ -1,49 +1,341 @@
 describe Appsignal::Minutely do
-  before do
-    Appsignal::Minutely.probes.clear
-  end
+  include WaitForHelper
+
+  before { Appsignal::Minutely.probes.clear }
 
-  it "should have a list of probes" do
-    expect(Appsignal::Minutely.probes).to be_instance_of(Array)
+  it "returns a ProbeCollection" do
+    expect(Appsignal::Minutely.probes)
+      .to be_instance_of(Appsignal::Minutely::ProbeCollection)
   end
 
   describe ".start" do
-    it "should call the probes periodically" do
-      probe = double
-      expect(probe).to receive(:call).at_least(:twice)
-      Appsignal::Minutely.probes << probe
-      allow(Appsignal::Minutely).to receive(:wait_time).and_return(0.1)
+    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.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 = MockProbe.new
+        Appsignal::Minutely.probes.register :my_probe, probe
+        Appsignal::Minutely.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::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 = 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 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 = lambda { calls += 1 }
+        Appsignal::Minutely.probes.register :my_probe, probe
+        Appsignal::Minutely.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::Minutely.probes.register :my_probe, probe
+        Appsignal::Minutely.probes.register :broken_probe, broken_probe
+        Appsignal::Minutely.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("../../../../", __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 = 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(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)
+        Appsignal::Minutely.start
+        thread && thread.join # Wait for old thread to exit
+      end.to_not(change { alive_thread_counter.call })
+    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)
+      expect(%w[sleep run]).to include(thread.status)
+      Appsignal::Minutely.stop
+      thread.join
+      expect(thread.status).to eql(false)
+    end
 
-      sleep 0.5
+    it "clears the probe instances array" do
+      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
+      expect(Appsignal::Minutely.send(:probe_instances)).to be_empty
     end
   end
 
   describe ".wait_time" do
-    it "should get the time to the next minute" do
-      allow_any_instance_of(Time).to receive(:sec).and_return(30)
-      expect(Appsignal::Minutely.wait_time).to eq 30
+    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
+      end
     end
   end
 
-  describe ".add_gc_probe" do
-    it "should add the gc probe to the list" do
-      expect(Appsignal::Minutely.probes).to be_empty
-
-      Appsignal::Minutely.add_gc_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.size).to eq(1)
-      expect(Appsignal::Minutely.probes[0]).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
 
-  describe Appsignal::Minutely::GCProbe do
-    describe "#call" do
-      it "should collect GC metrics" do
-        expect(Appsignal).to receive(:set_process_gauge).at_least(8).times
+  describe Appsignal::Minutely::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 {}
+        expect(collection.count).to eql(1)
+        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, lambda {}
+        collection.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.register :my_probe, probe
+        expect(collection[:my_probe]).to eql(probe)
+      end
+    end
+
+    describe "#<<" do
+      let(:out_stream) { std_stream }
+      let(:output) { out_stream.read }
+      let(:log_stream) { std_stream }
+      let(:log) { log_contents(log_stream) }
+      before { Appsignal.logger = test_logger(log_stream) }
+
+      it "adds the probe, but prints a deprecation warning" do
+        probe = lambda {}
+        capture_stdout(out_stream) { collection << probe }
+        deprecation_message = "Deprecated " \
+          "`Appsignal::Minute.probes <<` call. Please use " \
+          "`Appsignal::Minutely.probes.register` instead."
+        expect(output).to include "appsignal WARNING: #{deprecation_message}"
+        expect(log).to contains_log :warn, deprecation_message
+        expect(collection[probe.object_id]).to eql(probe)
+      end
+    end
+
+    describe "#register" do
+      let(:log_stream) { std_stream }
+      let(:log) { log_contents(log_stream) }
+      before { Appsignal.logger = test_logger(log_stream) }
+
+      it "adds the by key probe" do
+        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 = lambda {}
+          collection.register :my_probe, probe
+          collection.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
 
-        Appsignal::Minutely::GCProbe.new.call
+    describe "#each" do
+      it "loops over the registered probes" do
+        probe = lambda {}
+        collection.register :my_probe, probe
+        list = []
+        collection.each do |name, p|
+          list << [name, p]
+        end
+        expect(list).to eql([[:my_probe, probe]])
       end
     end
   end