appsignal 2.11.4 → 2.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45c9fdd117de8725c710d2fce51acbb6427184981a2691b1166e0f7f90c45dc2
-  data.tar.gz: 0b0e58c57c07ea20524c4f40a57ad3390834707e6f5319a20559b8285ff7d550
+  metadata.gz: 60535b76df01cdf84e0a7a0e018cb3822e56de610cbfd7694bdb10c06ba32b64
+  data.tar.gz: '092acba4f404fafd21333649bdd65c190da7b31507172f7da91c9a56debe2c5a'
 SHA512:
-  metadata.gz: 5099393d24fd8dde16ae56a49ae43a7282e3b1c713756e441e34c753686b4dec5cbec58be5646efc2334362634cddd5d821e7eff314a704069eec8a841536955
-  data.tar.gz: fa3192e852d1e6e77ab137c18d3c75ca2b67cd751d0de97cc1bacc8512e49eb76a2c01100a232c0dc6de1fd67a91b05f56d0a236104edab7321d44a110b47f4f
+  metadata.gz: 1e6a54ec292287cd2944032aa00af8d15505cb52c33e8b697d1659fa4ceaa8e89ffca68d6050ca2cad05a3b537838e5f6439cbfe4fd3301f220279fe266c4759
+  data.tar.gz: 843ccd65902958efcd641d09d8c65e9ec55ac0a908ac16651a4016fb99329bfa6b1c903472a59182e21f56f83ac738e7dd0eb03d957bbaed4bba550b8a8ce76b

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+# 2.11.9
+- Fix and simplify Ruby method delegation for object method instrumentation in
+  the different Ruby versions. PR #706
+
+# 2.11.8
+- Mark minutely probe thread as fork-safe by @pixeltrix. PR #704
+
+# 2.11.7
+- Fix ActionCable integration in test environment using `stub_connection`.
+  PR #705
+
+# 2.11.6
+- Prepend Sidekiq middleware to wrap all Sidekiq middleware. Catches more
+  errors and provide more complete performance measurements. PR #698
+
+# 2.11.5
+- Add more detailed logging to finish_event calls when the event is unknown, so
+  we know what event is being tried to finish. Commit
+  c888a04d1b9ac947652b29c111c650fb5a5cf71c
+
 # 2.11.4
 - Support Ruby 3.0 for Object method instrumentation with keyword arguments
   (https://docs.appsignal.com/ruby/instrumentation/method-instrumentation.html)

data/ext/agent.yml

@@ -1,62 +1,62 @@
 ---
-version: 361340a
+version: d98461b
 mirrors:
 - https://appsignal-agent-releases.global.ssl.fastly.net
 - https://d135dj0rjqvssy.cloudfront.net
 triples:
   x86_64-darwin:
     static:
-      checksum: 4e08cb0cef0ea7e30f8d507380b923f6cfa14adaea12c81804e118acd6395b57
+      checksum: 178ab2329c7b29cf45140e4707e75c20379fa0c7dfd7f39266a7a95aea510780
       filename: appsignal-x86_64-darwin-all-static.tar.gz
     dynamic:
-      checksum: 1a9c3e26bd453fe60a2f511d536e64bdeddb1f939664bda90d6a41eaeedf5250
+      checksum: '0923985cc78c5cf278f45d530679954b94b1a91c87453369116fc05525e29864'
       filename: appsignal-x86_64-darwin-all-dynamic.tar.gz
   universal-darwin:
     static:
-      checksum: 4e08cb0cef0ea7e30f8d507380b923f6cfa14adaea12c81804e118acd6395b57
+      checksum: 178ab2329c7b29cf45140e4707e75c20379fa0c7dfd7f39266a7a95aea510780
       filename: appsignal-x86_64-darwin-all-static.tar.gz
     dynamic:
-      checksum: 1a9c3e26bd453fe60a2f511d536e64bdeddb1f939664bda90d6a41eaeedf5250
+      checksum: '0923985cc78c5cf278f45d530679954b94b1a91c87453369116fc05525e29864'
       filename: appsignal-x86_64-darwin-all-dynamic.tar.gz
   i686-linux:
     static:
-      checksum: 01c027b3e472cb39d844284fcc8ba532628c00731b912e0e9718646ed124ae6e
+      checksum: cb772a8a178edb25d666b650efda80149c98e80e4264435d6176f8a6104f959a
       filename: appsignal-i686-linux-all-static.tar.gz
     dynamic:
-      checksum: 30696eac3ae5646bcb21ff86a1824dd4511a41dd323514e4a97a41b5ff09e2f8
+      checksum: c9ac51f4d1b3cc13773d8fa8ea5cfad6af7909144d85186cef9324ec0531bdac
       filename: appsignal-i686-linux-all-dynamic.tar.gz
   x86-linux:
     static:
-      checksum: 01c027b3e472cb39d844284fcc8ba532628c00731b912e0e9718646ed124ae6e
+      checksum: cb772a8a178edb25d666b650efda80149c98e80e4264435d6176f8a6104f959a
       filename: appsignal-i686-linux-all-static.tar.gz
     dynamic:
-      checksum: 30696eac3ae5646bcb21ff86a1824dd4511a41dd323514e4a97a41b5ff09e2f8
+      checksum: c9ac51f4d1b3cc13773d8fa8ea5cfad6af7909144d85186cef9324ec0531bdac
       filename: appsignal-i686-linux-all-dynamic.tar.gz
   x86_64-linux:
     static:
-      checksum: fe2038d6fa468fc23900fea6d8179d2b37d41d54f4ff33c573116183ac1cb491
+      checksum: d6c280e992d74f97d59da9827ec5707ca4f6776b0568cde1c083c1113e4b7104
       filename: appsignal-x86_64-linux-all-static.tar.gz
     dynamic:
-      checksum: bcbf9546b078fb8bbaae5e7df4ed84831346c814bc865a47d32a3a095a84acbb
+      checksum: ef1a3f5d4b2ed61ea2ae4d5cb1a261a0e685fb9d3e7ea9efe455498aad386e59
       filename: appsignal-x86_64-linux-all-dynamic.tar.gz
   x86_64-linux-musl:
     static:
-      checksum: b2ee5579a62b76a1d2f41f4e06749c4c549f9aaa40764862eff49c5a6a8841f1
+      checksum: 9cf8ad34392662746a45cfce18113ad19cc29954789e2058f30e527163f2e98a
       filename: appsignal-x86_64-linux-musl-all-static.tar.gz
     dynamic:
-      checksum: 53cd2464853e61c2d8f911ec32ff98cb48f824293ffd575da6743bc34625a7eb
+      checksum: 01bd76983227648d9bc41d035e1552fcf18d62f0d6818bf7bb7fc2e7c166513d
       filename: appsignal-x86_64-linux-musl-all-dynamic.tar.gz
   x86_64-freebsd:
     static:
-      checksum: f228dd2f2cf951c9eb9f04487be50fdfdc3d29a956e639787a4022bd73f02e53
+      checksum: 403a597cbdbdba08460c5c9e93347ed9ad1d24333204e6d72db342deb266a296
       filename: appsignal-x86_64-freebsd-all-static.tar.gz
     dynamic:
-      checksum: 030b322b2cb15607260cbb0424c03f6e41646dca7aacc43a30279ad63a336541
+      checksum: a1faae80ae09a6588c4cd35cb91dfa4b2176fc3cb17fbf79db80194c21e75bf9
       filename: appsignal-x86_64-freebsd-all-dynamic.tar.gz
   amd64-freebsd:
     static:
-      checksum: f228dd2f2cf951c9eb9f04487be50fdfdc3d29a956e639787a4022bd73f02e53
+      checksum: 403a597cbdbdba08460c5c9e93347ed9ad1d24333204e6d72db342deb266a296
       filename: appsignal-x86_64-freebsd-all-static.tar.gz
     dynamic:
-      checksum: 030b322b2cb15607260cbb0424c03f6e41646dca7aacc43a30279ad63a336541
+      checksum: a1faae80ae09a6588c4cd35cb91dfa4b2176fc3cb17fbf79db80194c21e75bf9
       filename: appsignal-x86_64-freebsd-all-dynamic.tar.gz

data/lib/appsignal/hooks/action_cable.rb

@@ -56,7 +56,11 @@ module Appsignal
       def install_callbacks
         ActionCable::Channel::Base.set_callback :subscribe, :around, :prepend => true do |channel, inner|
           # The request is only the original websocket request
-          env = channel.connection.env
+          connection = channel.connection
+          # #env is not available on the Rails ConnectionStub class used in the
+          # Rails app test suite. If we call `#env` it causes an error to occur
+          # in apps' test suites.
+          env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
             request.request_id || SecureRandom.uuid
@@ -84,7 +88,11 @@ module Appsignal
 
         ActionCable::Channel::Base.set_callback :unsubscribe, :around, :prepend => true do |channel, inner|
           # The request is only the original websocket request
-          env = channel.connection.env
+          connection = channel.connection
+          # #env is not available on the Rails ConnectionStub class used in the
+          # Rails app test suite. If we call `#env` it causes an error to occur
+          # in apps' test suites.
+          env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
             request.request_id || SecureRandom.uuid

data/lib/appsignal/hooks/sidekiq.rb

@@ -16,7 +16,11 @@ module Appsignal
 
         ::Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
-            chain.add Appsignal::Hooks::SidekiqPlugin
+            if chain.respond_to? :prepend
+              chain.prepend Appsignal::Hooks::SidekiqPlugin
+            else
+              chain.add Appsignal::Hooks::SidekiqPlugin
+            end
           end
         end
       end

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -1,56 +1,33 @@
 # frozen_string_literal: true
 
 class Object
-  if Appsignal::System.ruby_2_7_or_newer?
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
       end
-    end
-
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
-  else
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
-      end
+    if singleton_class.respond_to?(:ruby2_keywords, true)
+      singleton_class.send(:ruby2_keywords, method_name)
     end
+  end
 
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
+    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
   end
 
   def self.appsignal_reverse_class_name

data/lib/appsignal/minutely.rb

@@ -135,6 +135,12 @@ module Appsignal
       def start
         stop
         @thread = Thread.new do
+          # Advise multi-threaded app servers to ignore this thread
+          # for the purposes of fork safety warnings
+          if Thread.current.respond_to?(:thread_variable_set)
+            Thread.current.thread_variable_set(:fork_safe, true)
+          end
+
           sleep initial_wait_time
           initialize_probes
           loop do

data/lib/appsignal/version.rb

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

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

@@ -2,6 +2,8 @@ describe Appsignal::Hooks::ActionCableHook do
   if DependencyHelper.action_cable_present?
     context "with ActionCable" do
       require "action_cable/engine"
+      # Require test helper to test with ConnectionStub
+      require "action_cable/channel/test_case" if DependencyHelper.rails6_present?
 
       describe ".dependencies_present?" do
         subject { described_class.new.dependencies_present? }
@@ -262,6 +264,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.subscribe_to_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#subscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "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,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "subscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
 
         describe "unsubscribe callback" do
@@ -349,6 +394,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.unsubscribe_from_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#unsubscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "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,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "unsubscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
       end
     end

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

@@ -16,14 +16,31 @@ describe Appsignal::Hooks::SidekiqHook do
   end
 
   describe "#install" do
-    class SidekiqMiddlewareMock < Set
-      def exists?(middleware)
-        include?(middleware)
+    class SidekiqMiddlewareMockWithPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      unless method_defined? :prepend
+        def prepend(middleware) # For Ruby < 2.5
+          insert(0, middleware)
+        end
       end
     end
+
+    class SidekiqMiddlewareMockWithoutPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      undef_method :prepend if method_defined? :prepend # For Ruby >= 2.5
+    end
+
     module SidekiqMock
+      def self.middleware_mock=(mock)
+        @middlewares = mock.new
+      end
+
       def self.middlewares
-        @middlewares ||= SidekiqMiddlewareMock.new
+        @middlewares
       end
 
       def self.configure_server
@@ -36,15 +53,52 @@ describe Appsignal::Hooks::SidekiqHook do
       end
     end
 
+    def add_middleware(middleware)
+      Sidekiq.configure_server do |sidekiq_config|
+        sidekiq_config.middlewares.add(middleware)
+      end
+    end
+
     before do
       Appsignal.config = project_fixture_config
       stub_const "Sidekiq", SidekiqMock
     end
 
-    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
-      described_class.new.install
+    context "when Sidekiq middleware responds to prepend method" do # Sidekiq 3.3.0 and newer
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain in the first position" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
 
-      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
+        expect(Sidekiq.server_middleware).to eql([
+          Appsignal::Hooks::SidekiqPlugin, # Prepend makes it the first entry
+          user_middleware1,
+          user_middleware2
+        ])
+      end
+    end
+
+    context "when Sidekiq middleware does not respond to prepend method" do
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithoutPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
+
+        # Add middlewares in whatever order they were added
+        expect(Sidekiq.server_middleware).to eql([
+          user_middleware1,
+          Appsignal::Hooks::SidekiqPlugin,
+          user_middleware2
+        ])
+      end
     end
   end
 end

data/spec/lib/appsignal/integrations/object_spec.rb

@@ -30,12 +30,57 @@ describe Object do
         before do
           Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+          expect(Appsignal.active?).to be_truthy
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_method :positional_arguments
+
+              def positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_method :positional_arguments_splat
+
+              def keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_method :keyword_arguments
+
+              def keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_method :keyword_arguments_splat
+
+              def splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(instance.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(instance.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(instance.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(instance.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(instance.splat).to eq([[], {}])
+            expect(instance.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(instance.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(instance.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -56,7 +101,6 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -81,7 +125,6 @@ describe Object do
           let(:klass) { MyModule::NestedModule::NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
@@ -101,7 +144,6 @@ describe Object do
           end
 
           it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -162,6 +204,51 @@ describe Object do
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def self.positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_class_method :positional_arguments
+
+              def self.positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_class_method :positional_arguments_splat
+
+              def self.keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_class_method :keyword_arguments
+
+              def self.keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_class_method :keyword_arguments_splat
+
+              def self.splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_class_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(klass.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(klass.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(klass.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(klass.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(klass.splat).to eq([[], {}])
+            expect(klass.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(klass.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(klass.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
             expect(Appsignal.active?).to be_truthy

data/spec/lib/puma/appsignal_spec.rb

@@ -23,6 +23,27 @@ RSpec.describe "Puma plugin" do
       def self.stats
       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
+      end
+
       class Plugin
         class << self
           attr_reader :plugin
@@ -68,6 +89,13 @@ RSpec.describe "Puma plugin" do
     wait_for("enough probe calls") { probe.calls >= 2 }
   end
 
+  it "marks the PumaProbe thread as fork-safe", :not_ruby19 do
+    out_stream = std_stream
+    capture_stdout(out_stream) { Puma.run }
+
+    expect(out_stream.read).not_to include("WARNING: Detected 1 Thread")
+  end
+
   context "without Puma.stats" do
     before { Puma.singleton_class.send(:remove_method, :stats) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.11.4
+  version: 2.11.9
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-21 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -418,7 +418,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.6
+rubygems_version: 3.2.8
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com