appsignal 2.8.4 → 2.9.0

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

@@ -2,6 +2,9 @@ describe Appsignal::Hooks::PumaHook do
   context "with puma" do
     before(:context) do
       class Puma
+        def self.stats
+        end
+
         def self.cli_config
           @cli_config ||= CliConfig.new
         end
@@ -41,6 +44,11 @@ describe Appsignal::Hooks::PumaHook do
 
         cluster.stop_workers
       end
+
+      it "adds the Puma minutely probe" do
+        probe = Appsignal::Minutely.probes[:puma]
+        expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+      end
     end
 
     context "with nil hooks" do
@@ -78,3 +86,124 @@ describe Appsignal::Hooks::PumaHook do
     end
   end
 end
+
+describe Appsignal::Hooks::PumaProbe do
+  before(:context) do
+    Appsignal.config = project_fixture_config
+  end
+  after(:context) do
+    Appsignal.config = nil
+  end
+
+  let(:probe) { Appsignal::Hooks::PumaProbe.new }
+
+  describe "hostname" do
+    it "returns the socket hostname" do
+      expect(probe.send(:hostname)).to eql(Socket.gethostname)
+    end
+
+    context "with overridden hostname" do
+      around do |sample|
+        Appsignal.config[:hostname] = "frontend1"
+        sample.run
+        Appsignal.config[:hostname] = nil
+      end
+      it "returns the configured host" do
+        expect(probe.send(:hostname)).to eql("frontend1")
+      end
+    end
+  end
+
+  describe "#call" do
+    let(:expected_default_tags) { { :hostname => Socket.gethostname } }
+
+    context "with multiple worker stats" do
+      before(:context) do
+        class Puma
+          def self.stats
+            {
+              "workers" => 2,
+              "booted_workers" => 2,
+              "old_workers" => 0,
+              "worker_status" => [
+                {
+                  "last_status" => {
+                    "backlog" => 0,
+                    "running" => 5,
+                    "pool_capacity" => 5,
+                    "max_threads" => 5
+                  }
+                },
+                {
+                  "last_status" => {
+                    "backlog" => 0,
+                    "running" => 5,
+                    "pool_capacity" => 5,
+                    "max_threads" => 5
+                  }
+                }
+              ]
+            }.to_json
+          end
+        end
+      end
+      after(:context) { Object.send(:remove_const, :Puma) }
+
+      it "calls `puma_gauge` with the (summed) worker metrics" do
+        expect_gauge(:workers, 2, :type => :count)
+        expect_gauge(:workers, 2, :type => :booted)
+        expect_gauge(:workers, 0, :type => :old)
+
+        expect_gauge(:connection_backlog, 0)
+        expect_gauge(:pool_capacity, 10)
+        expect_gauge(:threads, 10, :type => :running)
+        expect_gauge(:threads, 10, :type => :max)
+      end
+    end
+
+    context "with single worker stats" do
+      before(:context) do
+        class Puma
+          def self.stats
+            {
+              "backlog" => 0,
+              "running" => 5,
+              "pool_capacity" => 5,
+              "max_threads" => 5
+            }.to_json
+          end
+        end
+      end
+      after(:context) { Object.send(:remove_const, :Puma) }
+
+      it "calls `puma_gauge` with the (summed) worker metrics" do
+        expect_gauge(:connection_backlog, 0)
+        expect_gauge(:pool_capacity, 5)
+        expect_gauge(:threads, 5, :type => :running)
+        expect_gauge(:threads, 5, :type => :max)
+      end
+    end
+
+    context "without stats" do
+      before(:context) do
+        class Puma
+          def self.stats
+          end
+        end
+      end
+      after(:context) { Object.send(:remove_const, :Puma) }
+
+      it "does not track metrics" do
+        expect(probe).to_not receive(:puma_gauge)
+      end
+    end
+
+    after { probe.call }
+
+    def expect_gauge(key, value, tags = {})
+      expect(Appsignal).to receive(:set_gauge)
+        .with("puma_#{key}", value, expected_default_tags.merge(tags))
+        .and_call_original
+    end
+  end
+end

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,141 @@ 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") }
+
+    it "loads Sidekiq::API" do
+      expect(defined?(Sidekiq::API)).to be_falsy
+      probe
+      expect(defined?(Sidekiq::API)).to be_truthy
+    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, :queue => "default").twice
+      expect_gauge("queue_length", 1, :queue => "critical").twice
+      expect_gauge("queue_latency", 2, :queue => "critical").twice
+      # Call probe twice so we can calculate the delta for some gauge values
+      probe.call
+      probe.call
+    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
+        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/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,46 +1,276 @@
 describe Appsignal::Minutely do
-  before do
-    Appsignal::Minutely.probes.clear
-  end
+  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 Probe
+      attr_reader :calls
+
+      def initialize
+        @calls = 0
+      end
+
+      def call
+        @calls += 1
+      end
+    end
+
+    class BrokenProbe < Probe
+      def call
+        super
+        raise "oh no!"
+      end
+    end
+
+    let(:log_stream) { StringIO.new }
+    let(:log) do
+      log_stream.rewind
+      log_stream.read
+    end
+    before do
+      Appsignal.logger = Logger.new(log_stream)
+      # Speed up test time
+      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
+        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")
+      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
+        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")
+      end
+    end
+
+    context "with a lambda" do
+      it "calls the lambda every <wait time>" do
+        calls = 0
+        probe = -> { 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")
+      end
+    end
+
+    context "with a broken probe" do
+      it "logs the error and continues calling the probes every <wait_time>" do
+        probe = Probe.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 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!")
+      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
+      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 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
 
+    # 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
+    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, -> {}
+      Appsignal::Minutely.start
+      thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      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
+      allow_any_instance_of(Time).to receive(:sec).and_return(20)
+      expect(Appsignal::Minutely.wait_time).to eq 40
+    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
+
+      expect(Appsignal::Minutely.probes.count).to eql(1)
+      expect(Appsignal::Minutely.probes[:garbage_collection])
+        .to be_instance_of(Appsignal::Minutely::GCProbe)
     end
   end
 
-  describe ".add_gc_probe" do
-    it "should add the gc probe to the list" do
-      expect(Appsignal::Minutely.probes).to be_empty
+  describe Appsignal::Minutely::ProbeCollection do
+    let(:collection) { described_class.new }
 
-      Appsignal::Minutely.add_gc_probe
+    describe "#count" do
+      it "returns how many probes are registered" do
+        expect(collection.count).to eql(0)
+        collection.register :my_probe_1, -> {}
+        expect(collection.count).to eql(1)
+        collection.register :my_probe_2, -> {}
+        expect(collection.count).to eql(2)
+      end
+    end
 
-      expect(Appsignal::Minutely.probes.size).to eq(1)
-      expect(Appsignal::Minutely.probes[0]).to be_instance_of(Appsignal::Minutely::GCProbe)
+    describe "#clear" do
+      it "clears the list of probes" do
+        collection.register :my_probe_1, -> {}
+        collection.register :my_probe_2, -> {}
+        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 = -> {}
+        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 = -> {}
+        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 = -> {}
+        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 = -> {}
+          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
+
+    describe "#each" do
+      it "loops over the registered probes" do
+        probe = -> {}
+        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
 
   describe Appsignal::Minutely::GCProbe do
     describe "#call" do
-      it "should collect GC metrics" do
+      it "collects GC metrics" do
         expect(Appsignal).to receive(:set_process_gauge).at_least(8).times
 
         Appsignal::Minutely::GCProbe.new.call