appsignal 3.1.5-java → 3.1.6-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20749c0f3826167272d727c37dd1e881502a9654f8b499d4f3fcdf40dd386178
-  data.tar.gz: 90ddbe20ee5243338aefdfbefbb1989bbe1df5cc57a56a4f277bcfa789086b41
+  metadata.gz: b0739a45917b16eb1bc1a3d181f6c7d247faca2cd4cc095aae13a186e71a3817
+  data.tar.gz: a5e646a6124dd3a9173d3a30ec19463076a50b96e8b4320ef54c909fdc2aad22
 SHA512:
-  metadata.gz: c9f2133fe6f929ebbbee6b9c8f47f85bd3c895b518daf6a69b5ad8a2e9a29ebcd72ca1c25a7aef8512a8493f8941ab711fda9b0f16fff30cac73c40701376a47
-  data.tar.gz: bfe585b6c6ce5f8cc5e470c9a164e6690fc1834e40bb4bd27491f719cbdaf6ebd4b92d1f1ba2bc3001e157f5c35786f12143b29d9908e9ce73d9ca9712c7c5ef
+  metadata.gz: 464672760abe3fed2b7e36a8812b19377ed5596bbaadd34bcdc22775a0696ff8fc2698a002c0fce8113f3215a594943ee7e15ef8e9dfdae609ce847b9b45b8da
+  data.tar.gz: 3761cf3f55137ac16e63a740d917e0f83a75d8d72ad93cbd52aa1de09a61bd3631dc8e6f537ada82d36c7e8a0395b1e05f5d76084508dd00169a2ef67c77a83d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.1.6
+
+### Fixed
+
+- [a03b7246](https://github.com/appsignal/appsignal-ruby/commit/a03b72461f5f3b047ca81368cf2bdbeadf078e08) patch - Support Sidekiq 7 in the Sidekiq minutely probe. It will now report metrics to Sidekiq magic dashboard for Sidekiq version 7 and newer.
+
 ## 3.1.5
 
 ### Changed

data/lib/appsignal/probes/sidekiq.rb

@@ -3,17 +3,59 @@ module Appsignal
     class SidekiqProbe
       include Helpers
 
+      class Sidekiq7Adapter
+        def self.redis_info
+          redis_info = nil
+          ::Sidekiq.redis { |c| redis_info = c.info }
+          redis_info
+        end
+
+        def self.hostname
+          host = nil
+          ::Sidekiq.redis do |c|
+            host = c.config.host
+          end
+          host
+        end
+      end
+
+      class Sidekiq6Adapter
+        def self.redis_info
+          return unless ::Sidekiq.respond_to?(:redis_info)
+
+          ::Sidekiq.redis_info
+        end
+
+        def self.hostname
+          host = nil
+          ::Sidekiq.redis do |c|
+            host = c.connection[:host] if c.respond_to? :connection
+          end
+          host
+        end
+      end
+
       # @api private
       attr_reader :config
 
+      def self.sidekiq7_and_greater?
+        Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("7.0.0")
+      end
+
       # @api private
       def self.dependencies_present?
+        return true if sidekiq7_and_greater?
+        return unless defined?(::Redis::VERSION) # Sidekiq <= 6
+
         Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
       end
 
       def initialize(config = {})
         @config = config
         @cache = {}
+        is_sidekiq7 = self.class.sidekiq7_and_greater?
+        @adapter = is_sidekiq7 ? Sidekiq7Adapter : Sidekiq6Adapter
+
         config_string = " with config: #{config}" unless config.empty?
         Appsignal.logger.debug("Initializing Sidekiq probe#{config_string}")
         require "sidekiq/api"
@@ -28,11 +70,11 @@ module Appsignal
 
       private
 
-      attr_reader :cache
+      attr_reader :adapter, :cache
 
       def track_redis_info
-        return unless ::Sidekiq.respond_to?(:redis_info)
-        redis_info = ::Sidekiq.redis_info
+        redis_info = adapter.redis_info
+        return unless redis_info
 
         gauge "connection_count", redis_info.fetch("connected_clients")
         gauge "memory_usage", redis_info.fetch("used_memory")
@@ -81,8 +123,7 @@ module Appsignal
           return @hostname
         end
 
-        host = nil
-        ::Sidekiq.redis { |c| host = c.connection[:host] }
+        host = adapter.hostname
         Appsignal.logger.debug "Sidekiq probe: Using Redis server hostname " \
           "#{host.inspect} as hostname"
         @hostname = host

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.1.5".freeze
+  VERSION = "3.1.6".freeze
 end

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

@@ -7,114 +7,177 @@ describe Appsignal::Probes::SidekiqProbe do
     let(:expected_default_tags) { { :hostname => "localhost" } }
     before do
       Appsignal.config = project_fixture_config
-      module SidekiqMock
-        def self.redis_info
-          {
-            "connected_clients" => 2,
-            "used_memory" => 1024,
-            "used_memory_rss" => 512
-          }
+
+      class SidekiqStats
+        class << self
+          attr_reader :calls
+
+          def count_call
+            @calls ||= -1
+            @calls += 1
+          end
         end
 
-        def self.redis
-          yield Client.new
+        def workers_size
+          # First method called, so count it towards a call
+          self.class.count_call
+          24
         end
 
-        class Client
-          def connection
-            { :host => "localhost" }
-          end
+        def processes_size
+          25
         end
 
-        class Stats
-          class << self
-            attr_reader :calls
+        # 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
 
-            def count_call
-              @calls ||= -1
-              @calls += 1
-            end
-          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 workers_size
-            # First method called, so count it towards a call
-            self.class.count_call
-            24
-          end
+        def retry_size
+          12
+        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 dead_size
+          [10, 12][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 processed
-            [10, 15][self.class.calls]
-          end
+        def scheduled_size
+          14
+        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 enqueued
+          15
+        end
+      end
 
-          def retry_size
-            12
-          end
+      class SidekiqQueue
+        Queue = Struct.new(:name, :size, :latency)
+
+        def self.all
+          [
+            Queue.new("default", 10, 12),
+            Queue.new("critical", 1, 2)
+          ]
+        end
+      end
+
+      module Sidekiq7Mock
+        VERSION = "7.0.0".freeze
+
+        def self.redis
+          yield Client.new
+        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]
+        class Client
+          def config
+            Config.new
           end
 
-          def scheduled_size
-            14
+          def info
+            {
+              "connected_clients" => 2,
+              "used_memory" => 1024,
+              "used_memory_rss" => 512
+            }
           end
+        end
 
-          def enqueued
-            15
+        class Config
+          def host
+            "localhost"
           end
         end
 
-        class Queue
-          Queue = Struct.new(:name, :size, :latency)
+        Stats = ::SidekiqStats
+        Queue = ::SidekiqQueue
+      end
+
+      module Sidekiq6Mock
+        VERSION = "6.9.9".freeze
+
+        def self.redis_info
+          {
+            "connected_clients" => 2,
+            "used_memory" => 1024,
+            "used_memory_rss" => 512
+          }
+        end
+
+        def self.redis
+          yield Client.new
+        end
 
-          def self.all
-            [
-              Queue.new("default", 10, 12),
-              Queue.new("critical", 1, 2)
-            ]
+        class Client
+          def connection
+            { :host => "localhost" }
           end
         end
+
+        Stats = ::SidekiqStats
+        Queue = ::SidekiqQueue
       end
-      stub_const("Sidekiq", SidekiqMock)
     end
-    after { Object.send(:remove_const, :SidekiqMock) }
+    after do
+      Object.send(:remove_const, :SidekiqStats)
+      Object.send(:remove_const, :SidekiqQueue)
+      Object.send(:remove_const, :Sidekiq6Mock)
+      Object.send(:remove_const, :Sidekiq7Mock)
+    end
+
+    def with_sidekiq7!
+      stub_const("Sidekiq", Sidekiq7Mock)
+    end
+    # Version not relevant, but requires any version for tests
+    alias_method :with_sidekiq!, :with_sidekiq7!
+
+    def with_sidekiq6!
+      stub_const("Sidekiq", Sidekiq6Mock)
+    end
 
     describe ".dependencies_present?" do
-      before do
-        stub_const("Redis::VERSION", version)
+      context "when Sidekiq 7" do
+        before { with_sidekiq7! }
+
+        it "starts the probe" do
+          expect(described_class.dependencies_present?).to be_truthy
+        end
       end
 
-      context "when Redis version is < 3.3.5" do
-        let(:version) { "3.3.4" }
+      context "when Sidekiq 6" do
+        before do
+          with_sidekiq6!
+          stub_const("Redis::VERSION", version)
+        end
+
+        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
+          it "does not start probe" do
+            expect(described_class.dependencies_present?).to be_falsy
+          end
         end
-      end
 
-      context "when Redis version is >= 3.3.5" do
-        let(:version) { "3.3.5" }
+        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
+          it "starts the probe" do
+            expect(described_class.dependencies_present?).to be_truthy
+          end
         end
       end
     end
 
     it "loads Sidekiq::API" do
+      with_sidekiq!
       # Hide the Sidekiq constant if it was already loaded. It will be
       # redefined by loading "sidekiq/api" in the probe.
       hide_const "Sidekiq::Stats"
@@ -125,53 +188,94 @@ describe Appsignal::Probes::SidekiqProbe do
     end
 
     it "logs config on initialize" do
+      with_sidekiq!
       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
+    context "with Sidekiq 7" do
+      before { with_sidekiq7! }
 
-    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
+      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
     end
 
-    context "when `redis_info` is not defined" do
-      before do
-        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
+    context "with Sidekiq 6" do
+      before { with_sidekiq6! }
+
+      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 "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
+      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 Sidekiq `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
     end
 
     context "when hostname is configured for probe" do
@@ -179,6 +283,8 @@ describe Appsignal::Probes::SidekiqProbe do
       let(:probe) { described_class.new(:hostname => redis_hostname) }
 
       it "uses the redis hostname for the hostname tag" do
+        with_sidekiq!
+
         allow(Appsignal).to receive(:set_gauge).and_call_original
         log = capture_logs { probe }
         expect(log).to contains_log(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.1.5
+  version: 3.1.6
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 2022-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack