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

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

@@ -2,12 +2,14 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
     let(:as) { ActiveSupport::Notifications }
+    let!(:transaction) do
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+    end
     before :context do
       start_agent
     end
     before do
       as.notifier = notifier
-      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
     end
 
     describe "#dependencies_present?" do
@@ -17,27 +19,71 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
     end
 
     it "instruments an ActiveSupport::Notifications.instrument event" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("sql.active_record", nil, "SQL", 1)
-
       return_value = as.instrument("sql.active_record", :sql => "SQL") do
         "value"
       end
 
       expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
-    it "should convert non-string names to strings" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("not_a_string", nil, nil, nil)
+    it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
+      return_value = as.instrument("no-registered.formatter", :key => "something") do
+        "value"
+      end
+
+      expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "no-registered.formatter",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
 
+    it "converts non-string names to strings" do
       as.instrument(:not_a_string) {}
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "not_a_string",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
     it "does not instrument events whose name starts with a bang" do
@@ -53,33 +99,66 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
 
     context "when an error is raised in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             raise ExampleException, "foo"
           end
         end.to raise_error(ExampleException, "foo")
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
       end
     end
 
     context "when a message is thrown in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             throw :foo
           end
         end.to throw_symbol(:foo)
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
+      end
+    end
+
+    context "when a transaction is completed in an instrumented block" do
+      it "does not complete the ActiveSupport::Notifications.instrument event" do
+        expect(transaction).to receive(:complete)
+        as.instrument("sql.active_record", :sql => "SQL") do
+          Appsignal::Transaction.complete_current!
+        end
+
+        expect(transaction.to_h["events"]).to match([])
       end
     end
   else

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

@@ -2,13 +2,11 @@ describe Appsignal::Hooks::PumaHook do
   context "with puma" do
     before(:context) do
       class Puma
-        def self.cli_config
-          @cli_config ||= CliConfig.new
+        def self.stats
         end
 
-        class Cluster
-          def stop_workers
-          end
+        def self.cli_config
+          @cli_config ||= CliConfig.new
         end
       end
 
@@ -28,53 +26,272 @@ describe Appsignal::Hooks::PumaHook do
       it { is_expected.to be_truthy }
     end
 
-    context "when installed" do
-      before do
-        Appsignal::Hooks::PumaHook.new.install
+    describe "installation" do
+      before { Appsignal::Minutely.probes.clear }
+
+      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
+
+        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
+
+        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
 
-      it "adds behavior to Unicorn::Worker#close" do
-        cluster = Puma::Cluster.new
+      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) }
+
+        it "adds behavior to Puma::Cluster.stop_workers" do
+          Appsignal::Hooks::PumaHook.new.install
+          cluster = Puma::Cluster.new
 
-        expect(Appsignal).to receive(:stop)
-        expect(cluster).to receive(:stop_workers_without_appsignal)
+          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 }
 
-        cluster.stop_workers
+          it "does not add the Puma minutely probe" do
+            Appsignal::Hooks::PumaHook.new.install
+            expect(Appsignal::Minutely.probes[:puma]).to be_nil
+          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
+
+            Appsignal::Hooks::PumaHook.new.install
+            probe = Appsignal::Minutely.probes[:puma]
+            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+          end
+        end
       end
     end
+  end
+
+  context "without puma" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
 
-    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
+      it { is_expected.to be_falsy }
+    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)
 
-      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)
+        probe.call
       end
     end
 
-    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
+    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 "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)
+      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)
+        probe.call
       end
     end
-  end
 
-  context "without puma" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+    context "without stats" do
+      before(:context) do
+        class Puma
+          def self.stats
+          end
+        end
+      end
+      after(:context) { Object.send(:remove_const, :Puma) }
 
-      it { is_expected.to be_falsy }
+      context "when it returns nil" do
+        it "does not track metrics" do
+          expect(probe).to_not receive(:puma_gauge)
+          probe.call
+        end
+      end
+
+      # Puma.stats raises a NoMethodError on a nil object on the first call.
+      context "when it returns a NoMethodError on the first call" do
+        let(:log) { StringIO.new }
+
+        it "ignores the first call and tracks the second call" do
+          use_logger_with log do
+            expect(Puma).to receive(:stats)
+              .and_raise(NoMethodError.new("undefined method `stats' for nil:NilClass"))
+            probe.call
+
+            expect(Puma).to receive(:stats).and_return({
+              "backlog" => 1,
+              "running" => 5,
+              "pool_capacity" => 4,
+              "max_threads" => 6
+            }.to_json)
+
+            expect_gauge(:connection_backlog, 1)
+            expect_gauge(:pool_capacity, 4)
+            expect_gauge(:threads, 5, :type => :running)
+            expect_gauge(:threads, 6, :type => :max)
+            probe.call
+          end
+
+          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
+        end
+      end
+
+      context "when it does not have a complete stats payload" do
+        let(:log) { StringIO.new }
+
+        it "tracks whatever metrics we do have" do
+          use_logger_with log do
+            expect(Puma).to receive(:stats).and_return({
+              "backlog" => 1,
+              "running" => 5
+            }.to_json)
+
+            expect_gauge(:connection_backlog, 1)
+            expect_no_gauge(:pool_capacity)
+            expect_gauge(:threads, 5, :type => :running)
+            expect_no_gauge(:threads, :type => :max)
+            probe.call
+          end
+
+          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
+        end
+      end
+    end
+
+    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
+
+    def expect_no_gauge(key, tags = {})
+      expect(Appsignal).to_not receive(:set_gauge)
+        .with("puma_#{key}", anything, tags)
     end
   end
 end