appsignal 3.0.6-java → 3.0.7-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a1324bce086be01b0dfae65d0b46f4b985707ca35da77699cbe9f7335f84080
-  data.tar.gz: 4e74a0eaac0b0e6330ecfcbd63762d80359ff880395e66644d39db4879c823a8
+  metadata.gz: b855b4dfbc358cac71b515acfa9060d0fe285bc166088a2ca8c350e13bb2e026
+  data.tar.gz: 4ea9db25ed39f99052d8e83a83513a8f75363a028895f15e09e23a18774d633c
 SHA512:
-  metadata.gz: 6c9d4481e24413363bbfe8bfdb0486968d9b5bc45bd0e898e535762f9372e153dfa81890cc8a3f567a1a884f8ba431d5c7c1b543b61cb1eb6ced57a060372c00
-  data.tar.gz: 1b728a26ade2bbcdedea7d454e9bb7ad548c1931a2503b79a5ed265e6d768e9f403b268f7e4984a62c5d9f6c679c08fbf6fa23d0365592b6dd2c34b68013a0dd
+  metadata.gz: 7c603ff374341866922386c85f3ed9ee8a842c632fa35c9be60e975afa33f8bb8262f4f7e70fce3e3b4503626825a4425481c5ee3fa259ff8aa6475aca813604
+  data.tar.gz: f91fcf688355c79d562fabda066473e3942aa1f174f3ce22485a43fe9aac6c530c2200b0f2be0af09a5b2568ca43e9a001d0a0293c5eaea6f989ff83027f709b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.0.7
+
+- [27f9b178](https://github.com/appsignal/appsignal-ruby/commit/27f9b178c20006ee15e69bdf878f3a0c9975b1f4) patch - Bump agent to 6caf6d0. Replaces curl HTTP client and includes various other maintenance updates.
+- [665d883a](https://github.com/appsignal/appsignal-ruby/commit/665d883a529e5c14b28e73eeb3ae6410deb3e182) patch - Improve Puma plugin stats collection. Instead of starting the AppSignal gem in the main process we send the stats to the AppSignal agent directly using StatsD. This should improve compatibility with phased restarts. If you use `prune_bundler`, you will need to add AppSignal to the extra `extra_runtime_dependencies` list.
+  
+  ```
+  # config/puma.rb
+  plugin :appsignal
+  extra_runtime_dependencies ["appsignal"]
+  ```
+
 ## 3.0.6
 
 - [d354d79b](https://github.com/appsignal/appsignal-ruby/commit/d354d79b293fd549e66cae60d805d1b1e9e9d2d8) patch - Add Excon integration. Track requests and responses from the Excon gem.

data/README.md

@@ -161,9 +161,13 @@ systems][supported-systems] page.
 
 Following the process below to release a new version of the Ruby gem.
 
-1. Run: `rake publish`
-  1. Update the Ruby gem version number when prompted.
-  1. Update the `CHANGELOG` file with the changes since the last release.
+1. Make sure [mono](https://github.com/appsignal/mono/) is installed by
+   following the installation instructions.
+1. Run: `mono publish`
+   - Mono will automatically bump the version number based on the
+     `.changesets/`.
+   - Mono will automatically update the `CHANGELOG.md` file based on the
+     `.changesets/`.
 1. Confirm with your two-factor authentication token for Rubygems.org, _twice_.
 
 ## Development
@@ -176,6 +180,8 @@ install all possible dependencies.
 ```bash
 # Install Bundler
 gem install bundler
+# Bootstrap the project
+mono bootstrap
 # Install the AppSignal extension and _all_ gems we support.
 bundle exec rake install
 # Only install the AppSignal extension.

data/ext/agent.yml

@@ -1,62 +1,62 @@
 ---
-version: 75e76ad
+version: 3ecd06f
 mirrors:
 - https://appsignal-agent-releases.global.ssl.fastly.net
 - https://d135dj0rjqvssy.cloudfront.net
 triples:
   x86_64-darwin:
     static:
-      checksum: 81edea50b934fe5b42c0081a1de5782bc477c321c1c76127d7fa525917f70a04
+      checksum: 39839e64832d7964fad51d9acc95374654446ade04d06cbba4d052e4483a8516
       filename: appsignal-x86_64-darwin-all-static.tar.gz
     dynamic:
-      checksum: 60befd59ac704ee21d5881ca0aef6b38caa50b1d1972425bf8f40b4f9710ec1e
+      checksum: 841b82677aaf553219f689b92b6dc6988278420e2e72dcab28a6c5915a0e4158
       filename: appsignal-x86_64-darwin-all-dynamic.tar.gz
   universal-darwin:
     static:
-      checksum: 81edea50b934fe5b42c0081a1de5782bc477c321c1c76127d7fa525917f70a04
+      checksum: 39839e64832d7964fad51d9acc95374654446ade04d06cbba4d052e4483a8516
       filename: appsignal-x86_64-darwin-all-static.tar.gz
     dynamic:
-      checksum: 60befd59ac704ee21d5881ca0aef6b38caa50b1d1972425bf8f40b4f9710ec1e
+      checksum: 841b82677aaf553219f689b92b6dc6988278420e2e72dcab28a6c5915a0e4158
       filename: appsignal-x86_64-darwin-all-dynamic.tar.gz
   i686-linux:
     static:
-      checksum: 60ad6a1f69c8f89b5642f49fbf794409e8ada7d63a9126b2c59832c2a92d5b22
+      checksum: fdf923153992816c813f938f41feadafbf80d8fa10a785123ee23184945047a0
       filename: appsignal-i686-linux-all-static.tar.gz
     dynamic:
-      checksum: aedf259de392ea00fd17bc30924cde70d9a1d82a62c6eeefc881cd5ea5dcce63
+      checksum: d2b8635199a73a1769ee7495acac0cdc69c4f964fef9ec7749fde517d789e1dd
       filename: appsignal-i686-linux-all-dynamic.tar.gz
   x86-linux:
     static:
-      checksum: 60ad6a1f69c8f89b5642f49fbf794409e8ada7d63a9126b2c59832c2a92d5b22
+      checksum: fdf923153992816c813f938f41feadafbf80d8fa10a785123ee23184945047a0
       filename: appsignal-i686-linux-all-static.tar.gz
     dynamic:
-      checksum: aedf259de392ea00fd17bc30924cde70d9a1d82a62c6eeefc881cd5ea5dcce63
+      checksum: d2b8635199a73a1769ee7495acac0cdc69c4f964fef9ec7749fde517d789e1dd
       filename: appsignal-i686-linux-all-dynamic.tar.gz
   x86_64-linux:
     static:
-      checksum: 7e3cf760f9bd364a6602f05e5014ce1c8e8ac9a97f7a533769711e0fb21e1f45
+      checksum: d81383dedb228f484e1d1e28a76ddc017d788fa62270b6e3f5a55765a4fb89d9
       filename: appsignal-x86_64-linux-all-static.tar.gz
     dynamic:
-      checksum: 4a9a4ea22abc93c3afa7d5bfd6f442cd69bf4d672e8db2df1aa2157cfb3fcc4b
+      checksum: f98948600345ee4726712937b13059fe7145d9b83273fc6efc6e0fd6a255381a
       filename: appsignal-x86_64-linux-all-dynamic.tar.gz
   x86_64-linux-musl:
     static:
-      checksum: 4d4dd00607cbe0fb4d14a15e74990f207eba90134c2d1a079b58f0d50f1ab76b
+      checksum: be2c414da7eb0837f23a8791b369e650aea26afbf9d3be9f530bc2de11fc888f
       filename: appsignal-x86_64-linux-musl-all-static.tar.gz
     dynamic:
-      checksum: 067a6d821e220c9c88ceb8f936390ce458fa94f41c13d32603d773485a8cdfd2
+      checksum: 3d04b9dcfbfe7696e028f9205dcae08e41bd87d162f7f37d04cc3d4a7442a9ec
       filename: appsignal-x86_64-linux-musl-all-dynamic.tar.gz
   x86_64-freebsd:
     static:
-      checksum: 176bc1ff1ad40a585ea10456a8ae3f6502c614d713dcbb957d550fa1ae44e7ca
+      checksum: fcbfabaa51f9004ed697e9000bfc1a7d71f48f40c04f9c9588a5c8f09cddf0ea
       filename: appsignal-x86_64-freebsd-all-static.tar.gz
     dynamic:
-      checksum: 88c6f3e03f8f6c25a4705f7d6c4286eaa563069a9fb8fad3c0a19e5b9a09f80b
+      checksum: ffc261d6d2a799e9bbf1cee3f9134da60cd72cd6b47a72e8c63a5a11e4d0b472
       filename: appsignal-x86_64-freebsd-all-dynamic.tar.gz
   amd64-freebsd:
     static:
-      checksum: 176bc1ff1ad40a585ea10456a8ae3f6502c614d713dcbb957d550fa1ae44e7ca
+      checksum: fcbfabaa51f9004ed697e9000bfc1a7d71f48f40c04f9c9588a5c8f09cddf0ea
       filename: appsignal-x86_64-freebsd-all-static.tar.gz
     dynamic:
-      checksum: 88c6f3e03f8f6c25a4705f7d6c4286eaa563069a9fb8fad3c0a19e5b9a09f80b
+      checksum: ffc261d6d2a799e9bbf1cee3f9134da60cd72cd6b47a72e8c63a5a11e4d0b472
       filename: appsignal-x86_64-freebsd-all-dynamic.tar.gz

data/lib/appsignal/config.rb

@@ -290,6 +290,7 @@ module Appsignal
       ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]       = config_hash[:files_world_accessible].to_s
       ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]       = config_hash[:transaction_debug_mode].to_s
       ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]    = config_hash[:send_environment_metadata].to_s
+      ENV["_APPSIGNAL_ENABLE_STATSD"]                = "true"
       ENV["_APP_REVISION"]                           = config_hash[:revision].to_s
     end
 

data/lib/appsignal/hooks/puma.rb

@@ -11,23 +11,8 @@ module Appsignal
       end
 
       def install
-        if ::Puma.respond_to?(:stats) && !defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)
-          # Only install the minutely probe if a user isn't using our Puma
-          # plugin, which lives in `lib/puma/appsignal.rb`. This plugin defines
-          # the {APPSIGNAL_PUMA_PLUGIN_LOADED} constant.
-          #
-          # We prefer people use the AppSignal Puma plugin. This fallback is
-          # only there when users relied on our *magic* integration.
-          #
-          # Using the Puma plugin, the minutely probe thread will still run in
-          # Puma workers, for other non-Puma probes, but the Puma probe only
-          # runs in the Puma main process.
-          # For more information:
-          # https://docs.appsignal.com/ruby/integrations/puma.html
-          Appsignal::Minutely.probes.register :puma, ::Appsignal::Probes::PumaProbe
-        end
-
         return unless defined?(::Puma::Cluster)
+
         # For clustered mode with multiple workers
         ::Puma::Cluster.send(:prepend, Module.new do
           def stop_workers

data/lib/appsignal/probes.rb

@@ -3,5 +3,4 @@ module Appsignal
   end
 end
 
-require "appsignal/probes/puma"
 require "appsignal/probes/sidekiq"

data/lib/appsignal/version.rb

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

data/lib/puma/plugin/appsignal.rb

@@ -1,27 +1,156 @@
-APPSIGNAL_PUMA_PLUGIN_LOADED = true
+# frozen_string_literal: true
+
+require "json"
 
 # AppSignal Puma plugin
 #
-# This plugin ensures the minutely probe thread is started with the Puma
-# minutely probe in the Puma master process.
-#
-# The constant {APPSIGNAL_PUMA_PLUGIN_LOADED} is here to mark the Plugin as
-# loaded by the rest of the AppSignal gem. This ensures that the Puma minutely
-# probe is not also started in every Puma workers, which was the old behavior.
-# See {Appsignal::Hooks::PumaHook#install} for more information.
+# This plugin ensures Puma metrics are sent to the AppSignal agent using StatsD.
 #
 # For even more information:
 # https://docs.appsignal.com/ruby/integrations/puma.html
-Puma::Plugin.create do
-  def start(launcher = nil)
-    launcher.events.on_booted do
-      require "appsignal"
-      if ::Puma.respond_to?(:stats)
-        require "appsignal/probes/puma"
-        Appsignal::Minutely.probes.register :puma, Appsignal::Probes::PumaProbe
+Puma::Plugin.create do # rubocop:disable Metrics/BlockLength
+  def start(launcher)
+    @launcher = launcher
+    @launcher.events.debug "AppSignal: Puma plugin start."
+    in_background do
+      @launcher.events.debug "AppSignal: Start Puma stats collection loop."
+      plugin = AppsignalPumaPlugin.new
+
+      loop do
+        begin
+          # Implement similar behavior to minutely probes.
+          # Initial sleep to wait until the app is fully initalized.
+          # Then loop every 60 seconds and collect the Puma stats as AppSignal
+          # metrics.
+          sleep sleep_time
+
+          @launcher.events.debug "AppSignal: Collecting Puma stats."
+          stats = fetch_puma_stats
+          if stats
+            plugin.call(stats)
+          else
+            @launcher.events.log "AppSignal: No Puma stats to report."
+          end
+        rescue StandardError => error
+          log_error "Error while processing metrics.", error
+        end
       end
-      Appsignal.start
-      Appsignal.start_logger
+    end
+  end
+
+  private
+
+  def sleep_time
+    60 # seconds
+  end
+
+  def log_error(message, error)
+    @launcher.events.log "AppSignal: #{message}\n" \
+      "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+  end
+
+  def fetch_puma_stats
+    if Puma.respond_to? :stats_hash # Puma >= 5.0.0
+      Puma.stats_hash
+    elsif Puma.respond_to? :stats # Puma < 5.0.0
+      # Puma.stats_hash returns symbolized keys as well
+      JSON.parse Puma.stats, :symbolize_names => true
+    end
+  rescue StandardError => error
+    log_error "Error while parsing Puma stats.", error
+    nil
+  end
+end
+
+# AppsignalPumaPlugin
+#
+# Class to handle the logic of translating the Puma stats to AppSignal metrics.
+#
+# @api private
+class AppsignalPumaPlugin
+  def initialize
+    @hostname = fetch_hostname
+    @statsd = Statsd.new
+  end
+
+  def call(stats)
+    counts = {}
+    count_keys = [:backlog, :running, :pool_capacity, :max_threads]
+
+    if stats[:worker_status] # Clustered mode - Multiple workers
+      stats[:worker_status].each do |worker|
+        stat = worker[:last_status]
+        count_keys.each do |key|
+          count_if_present counts, key, stat
+        end
+      end
+
+      gauge(:workers, stats[:workers], :type => :count)
+      gauge(:workers, stats[:booted_workers], :type => :booted)
+      gauge(:workers, stats[:old_workers], :type => :old)
+    else # Single mode - Single worker
+      count_keys.each do |key|
+        count_if_present counts, key, stats
+      end
+    end
+
+    gauge(:connection_backlog, counts[:backlog]) if counts[:backlog]
+    gauge(:pool_capacity, counts[:pool_capacity]) if counts[:pool_capacity]
+    gauge(:threads, counts[:running], :type => :running) if counts[:running]
+    gauge(:threads, counts[:max_threads], :type => :max) if counts[:max_threads]
+  end
+
+  private
+
+  attr_reader :hostname
+
+  def fetch_hostname
+    # Configure hostname as reported for the Puma metrics with the
+    # APPSIGNAL_HOSTNAME environment variable.
+    env_hostname = ENV["APPSIGNAL_HOSTNAME"]
+    return env_hostname if env_hostname
+
+    # Auto detect hostname as fallback. May be inaccurate.
+    Socket.gethostname
+  end
+
+  def gauge(field, count, tags = {})
+    @statsd.gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
+  end
+
+  def count_if_present(counts, key, stats)
+    stat_value = stats[key]
+    return unless stat_value
+
+    counts[key] ||= 0
+    counts[key] += stat_value
+  end
+
+  class Statsd
+    def initialize
+      # StatsD server location as configured in AppSignal agent StatsD server.
+      @host = "127.0.0.1"
+      @port = 8125
+    end
+
+    def gauge(metric_name, value, tags)
+      send_metric "g", metric_name, value, tags
+    end
+
+    private
+
+    attr_reader :host, :port
+
+    def send_metric(type, metric_name, metric_value, tags_hash)
+      tags = tags_hash.map { |key, value| "#{key}:#{value}" }.join(",")
+      data = "#{metric_name}:#{metric_value}|#{type}|##{tags}"
+
+      # Open (and close) a new socket every time because we don't know when the
+      # plugin will exit and when to cleanly close the socket connection.
+      socket = UDPSocket.new
+      socket.send(data, 0, host, port)
+    ensure
+      socket && socket.close
     end
   end
 end

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

@@ -35,29 +35,6 @@ describe Appsignal::Hooks::PumaHook do
           # 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::Probes::PumaProbe)
-          end
-        end
       end
 
       context "when in clustered mode" do
@@ -81,29 +58,6 @@ describe Appsignal::Hooks::PumaHook do
           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
-
-        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::Probes::PumaProbe)
-          end
-        end
       end
     end
   end

data/spec/lib/puma/appsignal_spec.rb

@@ -1,6 +1,4 @@
 RSpec.describe "Puma plugin" do
-  include WaitForHelper
-
   class MockPumaLauncher
     def events
       return @events if defined?(@events)
@@ -10,110 +8,288 @@ RSpec.describe "Puma plugin" do
   end
 
   class MockPumaEvents
-    def on_booted(&block)
-      @on_booted = block if block_given?
-      @on_booted if defined?(@on_booted)
+    attr_reader :logs
+
+    def initialize
+      @logs = []
+    end
+
+    def log(message)
+      @logs << [:log, message]
+    end
+
+    def debug(message)
+      @logs << [:debug, message]
+    end
+
+    def error(message)
+      @logs << [:error, message]
+    end
+  end
+
+  # StatsD server used for these tests.
+  # Open a UDPSocket and listen for messages sent by the AppSignal Puma plugin.
+  class StatsdServer
+    def start
+      stop
+      @socket = UDPSocket.new
+      @socket.bind("127.0.0.1", 8125)
+
+      loop do
+        begin
+          # Listen for messages and track them on the messages Array.
+          packet = @socket.recvfrom(1024)
+          track_message packet.first
+        rescue Errno::EBADF # rubocop:disable Lint/HandleExceptions
+          # Ignore error for JRuby 9.1.17.0 specifically, it doesn't appear to
+          # happen on 9.2.18.0. It doesn't break the tests themselves, ignoring
+          # this error. It's probably a timing issue where it tries to read
+          # from the socket after it's closed.
+        end
+      end
+    end
+
+    def stop
+      @socket && @socket.close
+    ensure
+      @socket = nil
+    end
+
+    def messages
+      @messages ||= []
+    end
+
+    private
+
+    def track_message(message)
+      @messages_mutex ||= Mutex.new
+      @messages_mutex.synchronize { messages << message }
     end
   end
 
   let(:probe) { MockProbe.new }
   let(:launcher) { MockPumaLauncher.new }
+  let(:hostname) { Socket.gethostname }
+  let(:expected_default_tags) { { "hostname" => hostname } }
+  let(:stats_data) { { :backlog => 1 } }
   before do
     module Puma
       def self.stats
+        JSON.dump(@_stats_data)
+      end
+
+      def self.stats_hash
+        @_stats_data
       end
 
-      def self.run
-        # Capture threads running before application is preloaded
-        before = Thread.list.reject { |t| t.thread_variable_get(:fork_safe) }
-
-        # An abbreviated version of what happens in Puma::Cluster#run
-        launcher = MockPumaLauncher.new
-        plugin = Plugin.plugin.new
-        plugin.start(launcher)
-        launcher.events.on_booted.call
-
-        # Wait for minutely probe thread to finish starting
-        sleep 0.005
-
-        # Capture any new threads running after application is preloaded.
-        # Any threads created during the preloading phase will not be
-        # carried over into the forked workers. Puma warns about these
-        # but the minutely probe thread should only exist in the main process.
-        after = Thread.list.reject { |t| t.thread_variable_get(:fork_safe) }
-        $stdout.puts "! WARNING: Detected #{after.size - before.size} Thread(s) started in app boot" if after.size > before.size
+      def self._set_stats=(data)
+        @_stats_data = data
       end
 
       class Plugin
         class << self
-          attr_reader :plugin
+          attr_reader :appsignal_plugin
 
           def create(&block)
-            @plugin = Class.new(::Puma::Plugin)
-            @plugin.class_eval(&block)
+            @appsignal_plugin = Class.new(::Puma::Plugin)
+            @appsignal_plugin.class_eval(&block)
           end
         end
-      end
-    end
 
-    Appsignal::Minutely.probes.clear
-    ENV["APPSIGNAL_ENABLE_MINUTELY_PROBES"] = "true"
-    Appsignal.config = project_fixture_config
-    # 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)
+        attr_reader :in_background_block
 
-    Appsignal::Minutely.probes.register :my_probe, probe
+        def in_background(&block)
+          @in_background_block = block
+        end
+      end
+    end
+    Puma._set_stats = stats_data
     load File.expand_path("../lib/puma/plugin/appsignal.rb", APPSIGNAL_SPEC_DIR)
+
+    @statsd = StatsdServer.new
+    @server_thread = Thread.new { @statsd.start }
+    @server_thread.abort_on_exception = true
   end
   after do
-    Appsignal.config = nil
-    Object.send :remove_const, :Puma
-    Object.send :remove_const, :APPSIGNAL_PUMA_PLUGIN_LOADED
+    @statsd = nil
+
+    Object.send(:remove_const, :Puma)
+    Object.send(:remove_const, :AppsignalPumaPlugin)
+  end
+
+  def run(plugin)
+    @client_thread = Thread.new { start_plugin(plugin) }
+    @client_thread.abort_on_exception = true
+    sleep 0.03
+  ensure
+    stop_all
   end
 
-  it "registers the PumaProbe" do
-    expect(Appsignal::Minutely.probes[:my_probe]).to eql(probe)
-    expect(Appsignal::Minutely.probes[:puma]).to be_nil
-    plugin = Puma::Plugin.plugin.new
-    expect(launcher.events.on_booted).to be_nil
+  def appsignal_plugin
+    Puma::Plugin.appsignal_plugin
+  end
 
+  def start_plugin(plugin_class)
+    plugin = plugin_class.new
+    # Speed up test by not waiting for 60 seconds initial wait time and loop
+    # interval.
+    allow(plugin).to receive(:sleep_time).and_return(0.01)
     plugin.start(launcher)
-    expect(Appsignal::Minutely.probes[:puma]).to be_nil
-    expect(launcher.events.on_booted).to_not be_nil
+    plugin.in_background_block.call
+  end
+
+  # Stop all threads in test and stop listening on the UDPSocket
+  def stop_all
+    @client_thread.kill if defined?(@client_thread) && @client_thread
+    @server_thread.kill if defined?(@server_thread) && @server_thread
+    @statsd.stop if defined?(@statsd) && @statsd
+    @client_thread = nil
+    @server_thread = nil
+  end
+
+  def logs
+    launcher.events.logs
+  end
+
+  def messages
+    @statsd.messages.map do |message|
+      metric, type, tags_string = message.split("|")
+      metric_name, metric_value = metric.split(":")
+      tags = {}
+      tags_string[1..-1].split(",").each do |tag|
+        key, value = tag.split(":")
+        tags[key] = value
+      end
+      {
+        :name => metric_name,
+        :value => metric_value.to_i,
+        :type => type,
+        :tags => tags
+      }
+    end
+  end
+
+  def expect_gauge(metric_name, metric_value, tags_hash = {})
+    expect(messages).to include(
+      :name => "puma_#{metric_name}",
+      :value => metric_value,
+      :type => "g",
+      :tags => expected_default_tags.merge(tags_hash)
+    )
+  end
+
+  context "with multiple worker stats" do
+    let(:stats_data) do
+      {
+        :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
+            }
+          }
+        ]
+      }
+    end
+
+    it "collects puma stats as guage metrics with the (summed) worker metrics" do
+      run(appsignal_plugin)
+
+      expect(logs).to_not include([:error, kind_of(String)])
+      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
+    let(:stats_data) do
+      {
+        :backlog => 0,
+        :running => 5,
+        :pool_capacity => 5,
+        :max_threads => 5
+      }
+    end
+
+    it "calls `puma_gauge` with the (summed) worker metrics" do
+      run(appsignal_plugin)
+
+      expect(logs).to_not include([:error, kind_of(String)])
+      expect_gauge(:connection_backlog, 0)
+      expect_gauge(:pool_capacity, 5)
+      expect_gauge(:threads, 5, "type" => "running")
+      expect_gauge(:threads, 5, "type" => "max")
+    end
+  end
 
-    launcher.events.on_booted.call
-    expect(Appsignal::Minutely.probes[:puma]).to eql(Appsignal::Probes::PumaProbe)
+  context "when using APPSIGNAL_HOSTNAME" do
+    let(:hostname) { "my-host-name" }
+    before { ENV["APPSIGNAL_HOSTNAME"] = hostname }
+    after { ENV.delete("APPSIGNAL_HOSTNAME") }
 
-    # Minutely probes started and called
-    wait_for("enough probe calls") { probe.calls >= 2 }
+    it "reports the APPSIGNAL_HOSTNAME as the hostname tag value" do
+      run(appsignal_plugin)
+
+      expect(logs).to_not include([:error, kind_of(String)])
+      expect_gauge(:connection_backlog, 1)
+    end
   end
 
-  it "marks the PumaProbe thread as fork-safe" do
-    out_stream = std_stream
-    capture_stdout(out_stream) { Puma.run }
+  context "without Puma.stats_hash" do
+    before do
+      Puma.singleton_class.send(:remove_method, :stats_hash)
+    end
+
+    it "fetches metrics from Puma.stats instead" do
+      run(appsignal_plugin)
 
-    expect(out_stream.read).not_to include("WARNING: Detected 1 Thread")
+      expect(logs).to_not include([:error, kind_of(String)])
+      expect(logs).to_not include([kind_of(Symbol), "AppSignal: No Puma stats to report."])
+      expect_gauge(:connection_backlog, 1)
+    end
   end
 
-  context "without Puma.stats" do
-    before { Puma.singleton_class.send(:remove_method, :stats) }
+  context "without Puma.stats and Puma.stats_hash" do
+    before do
+      Puma.singleton_class.send(:remove_method, :stats)
+      Puma.singleton_class.send(:remove_method, :stats_hash)
+    end
 
-    it "does not register the PumaProbe" do
-      expect(Appsignal::Minutely.probes[:my_probe]).to eql(probe)
-      expect(Appsignal::Minutely.probes[:puma]).to be_nil
-      plugin = Puma::Plugin.plugin.new
-      expect(launcher.events.on_booted).to be_nil
+    it "does not fetch metrics" do
+      run(appsignal_plugin)
 
-      plugin.start(launcher)
-      expect(Appsignal::Minutely.probes[:puma]).to be_nil
-      expect(launcher.events.on_booted).to_not be_nil
+      expect(logs).to_not include([:error, kind_of(String)])
+      expect(logs).to include([:log, "AppSignal: No Puma stats to report."])
+      expect(messages).to be_empty
+    end
+  end
 
-      launcher.events.on_booted.call
-      expect(Appsignal::Minutely.probes[:puma]).to be_nil
+  context "without running StatsD server" do
+    it "does nothing" do
+      Appsignal.stop
+      stop_all
+      run(appsignal_plugin)
 
-      # Minutely probes started and called
-      wait_for("enough probe calls") { probe.calls >= 2 }
+      expect(logs).to_not include([:error, kind_of(String)])
+      expect(messages).to be_empty
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.0.7
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-31 00:00:00.000000000 Z
+date: 2021-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -263,7 +263,6 @@ files:
 - lib/appsignal/marker.rb
 - lib/appsignal/minutely.rb
 - lib/appsignal/probes.rb
-- lib/appsignal/probes/puma.rb
 - lib/appsignal/probes/sidekiq.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/rails_instrumentation.rb
@@ -349,7 +348,6 @@ files:
 - spec/lib/appsignal/logger_spec.rb
 - spec/lib/appsignal/marker_spec.rb
 - spec/lib/appsignal/minutely_spec.rb
-- spec/lib/appsignal/probes/puma_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
@@ -498,7 +496,6 @@ test_files:
 - spec/lib/appsignal/logger_spec.rb
 - spec/lib/appsignal/marker_spec.rb
 - spec/lib/appsignal/minutely_spec.rb
-- spec/lib/appsignal/probes/puma_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb

data/lib/appsignal/probes/puma.rb

@@ -1,61 +0,0 @@
-module Appsignal
-  module Probes
-    class PumaProbe
-      def initialize
-        @hostname = Appsignal.config[:hostname] || Socket.gethostname
-      end
-
-      # @api private
-      def call
-        puma_stats = fetch_puma_stats
-        return unless puma_stats
-
-        stats = JSON.parse puma_stats, :symbolize_names => true
-        counts = {}
-        count_keys = [:backlog, :running, :pool_capacity, :max_threads]
-
-        if stats[:worker_status] # Multiple workers
-          stats[:worker_status].each do |worker|
-            stat = worker[:last_status]
-            count_keys.each do |key|
-              count_if_present counts, key, stat
-            end
-          end
-
-          gauge(:workers, stats[:workers], :type => :count)
-          gauge(:workers, stats[:booted_workers], :type => :booted)
-          gauge(:workers, stats[:old_workers], :type => :old)
-        else # Single worker
-          count_keys.each do |key|
-            count_if_present counts, key, stats
-          end
-        end
-
-        gauge(:connection_backlog, counts[:backlog]) if counts[:backlog]
-        gauge(:pool_capacity, counts[:pool_capacity]) if counts[:pool_capacity]
-        gauge(:threads, counts[:running], :type => :running) if counts[:running]
-        gauge(:threads, counts[:max_threads], :type => :max) if counts[:max_threads]
-      end
-
-      private
-
-      attr_reader :hostname
-
-      def gauge(field, count, tags = {})
-        Appsignal.set_gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
-      end
-
-      def count_if_present(counts, key, stats)
-        stat_value = stats[key]
-        return unless stat_value
-        counts[key] ||= 0
-        counts[key] += stat_value
-      end
-
-      def fetch_puma_stats
-        ::Puma.stats
-      rescue NoMethodError # rubocop:disable Lint/HandleExceptions
-      end
-    end
-  end
-end

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

@@ -1,180 +0,0 @@
-require "appsignal/probes/puma"
-
-describe Appsignal::Probes::PumaProbe do
-  before(:context) do
-    Appsignal.config = project_fixture_config
-  end
-  after(:context) do
-    Appsignal.config = nil
-  end
-
-  let(:probe) { described_class.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)
-
-        probe.call
-      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)
-        probe.call
-      end
-    end
-
-    context "without stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      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