appsignal 2.11.3 → 2.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 140c8dc48aa610503d589cbadbd8080234498628f73570eb9dec1fe40d43e7c6
-  data.tar.gz: 9d3bda2c23f46391752218d6a08290e19ffe59a9cdabd3d89841f208a5a4499c
+  metadata.gz: 8cb57893fb10d1d54593fcf13b4d2b13ac728e9d0c5c16f046580b1befb6048d
+  data.tar.gz: ef465afb88df2f8f53015e84192159d464c4827e66a1ee19bed38b73712e810c
 SHA512:
-  metadata.gz: 1496d2e2ab87742b5ede043d513a290aa95679445c7dd5a1f041c90bb2e05fc983e558733b974a60ed880c1db3ac9faabfc431ed4c3e1cf68fad150dd5cd4e61
-  data.tar.gz: 62052287406db0bb8e95c6e9130886f9db8f7e9822b9d835a9faec3090facd4990addf13b99f107a26e777a37354bbe8ea795c392917cfe2c0884772000b0b3c
+  metadata.gz: 663ba5e66fd1bad997a27c164d7e9845effb7d419b6b23a3b33a1f0f71f50d18071194f75216e347956f11e3ad2730f82e7c24fb4029b2c9daf4bd597c289450
+  data.tar.gz: e7a8ba54779115a77703090837a9814e017884607d3b059b620a875cba9c52bc449fa56006ad443ecc076d1bf8bfc7b8c109bd7d61c811c8f5748e683b94f3d4

data/.rubocop.yml

@@ -13,6 +13,8 @@ AllCops:
     - "gemfiles/vendor/**/*"
     - "vendor/**/*"
     - "benchmark.rake"
+    - "lib/appsignal/integrations/object_ruby_modern.rb"
+    - "spec/lib/appsignal/integrations/object_spec.rb"
   DisplayCopNames: true
   UseCache: true
   CacheRootDirectory: ./tmp

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+# 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)
+  PR #693
+
 # 2.11.3
 - Support Shoryuken batch workers. PR #687
 

data/Rakefile

@@ -275,7 +275,8 @@ namespace :publish do
     Dir.chdir("#{File.dirname(__FILE__)}/pkg") do
       Dir["*.gem"].each do |gem_package|
         puts "## Publishing gem package: #{gem_package}"
-        system "gem push #{gem_package}"
+        result = system "gem push #{gem_package}"
+        raise "Failed to Push gem" unless result
       end
     end
   end
@@ -374,19 +375,21 @@ end
 begin
   require "rspec/core/rake_task"
   is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  unless is_jruby
-    jruby_opts = "--exclude-pattern=spec/lib/appsignal/extension/jruby_spec.rb"
-  end
+  excludes = []
+  excludes << "spec/lib/appsignal/extension/jruby_spec.rb" unless is_jruby
+  is_ruby19 = RUBY_VERSION < "2.0"
+  excludes << "spec/lib/appsignal/integrations/object_spec.rb" if is_ruby19
+  exclude_pattern = "--exclude-pattern=#{excludes.join(",")}" if excludes.any?
 
   desc "Run the AppSignal gem test suite."
   RSpec::Core::RakeTask.new :test do |t|
-    t.rspec_opts = jruby_opts
+    t.rspec_opts = exclude_pattern
   end
 
   namespace :test do
     desc "Run the Appsignal gem test in an extension failure scenario"
     RSpec::Core::RakeTask.new :failure do |t|
-      t.rspec_opts = "#{jruby_opts} --tag extension_installation_failure"
+      t.rspec_opts = "#{exclude_pattern} --tag extension_installation_failure"
     end
   end
 rescue LoadError # rubocop:disable Lint/HandleExceptions

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.rb

@@ -4,38 +4,8 @@ if defined?(Appsignal)
   Appsignal::Environment.report_enabled("object_instrumentation")
 end
 
-class Object
-  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
-  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
-  end
-
-  def self.appsignal_reverse_class_name
-    return "AnonymousClass" unless name
-    name.split("::").reverse.join(".")
-  end
-
-  def appsignal_reverse_class_name
-    self.class.appsignal_reverse_class_name
-  end
+if RUBY_VERSION < "2.0"
+  require "appsignal/integrations/object_ruby_19"
+else
+  require "appsignal/integrations/object_ruby_modern"
 end

data/lib/appsignal/integrations/object_ruby_19.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Object
+  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
+  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
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -0,0 +1,64 @@
+# 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
+      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
+      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
+    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
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

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/system.rb

@@ -79,5 +79,9 @@ module Appsignal
     def self.jruby?
       RUBY_PLATFORM == "java"
     end
+
+    def self.ruby_2_7_or_newer?
+      RUBY_VERSION > "2.7"
+    end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.3".freeze
+  VERSION = "2.11.8".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_19_spec.rb

@@ -0,0 +1,266 @@
+require "appsignal/integrations/object"
+
+def is_ruby_19
+  RUBY_VERSION < "2.0"
+end
+
+describe Object do
+  describe "#instrument_method" do
+    context "with instance method" do
+      let(:klass) do
+        Class.new do
+          def foo(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_method :foo
+        end
+      end
+      let(:instance) { klass.new }
+
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        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
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          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
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with nested named class" do
+          before do
+            module MyModule
+              module NestedModule
+                class NamedClass
+                  def bar
+                    2
+                  end
+                  appsignal_instrument_method :bar
+                end
+              end
+            end
+          end
+          after { Object.send(:remove_const, :MyModule) }
+          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,
+              Appsignal::EventFormatter::DEFAULT
+            expect(instance.bar).to eq(2)
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo, :name => "my_method.group"
+            end
+          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
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def foo
+                yield
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+
+          it "should yield the block" do
+            expect(instance.foo { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still calls the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+
+    context "with class method" do
+      let(:klass) do
+        Class.new do
+          def self.bar(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_class_method :bar
+        end
+      end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
+            .and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        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 \
+              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          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 \
+              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+
+          context "with nested named class" do
+            before do
+              module MyModule
+                module NestedModule
+                  class NamedClass
+                    def self.bar
+                      2
+                    end
+                    appsignal_instrument_class_method :bar
+                  end
+                end
+              end
+            end
+            after { Object.send(:remove_const, :MyModule) }
+            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.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
+                Appsignal::EventFormatter::DEFAULT
+              expect(klass.bar).to eq(2)
+            end
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar, :name => "my_method.group"
+            end
+          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
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                yield
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+
+          it "should yield the block" do
+            expect(klass.bar { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,30 @@
 require "appsignal/integrations/object"
 
+def is_ruby_19
+  RUBY_VERSION < "2.0"
+end
+
 describe Object do
   describe "#instrument_method" do
     context "with instance method" do
       let(:klass) do
         Class.new do
-          def foo
-            1
+          def foo(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_method :foo
         end
       end
       let(:instance) { klass.new }
 
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
+
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
@@ -27,7 +39,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -116,10 +128,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still calls the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(instance.foo).to eq(1)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end
@@ -127,12 +139,19 @@ describe Object do
     context "with class method" do
       let(:klass) do
         Class.new do
-          def self.bar
-            2
+          def self.bar(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_class_method :bar
         end
       end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
 
       context "when active" do
         let(:transaction) { http_request_transaction }
@@ -149,7 +168,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -238,10 +257,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still call the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(klass.bar).to eq(2)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end

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.3
+  version: 2.11.8
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-19 00:00:00.000000000 Z
+date: 2021-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -233,6 +233,8 @@ files:
 - lib/appsignal/integrations/grape.rb
 - lib/appsignal/integrations/mongo_ruby_driver.rb
 - lib/appsignal/integrations/object.rb
+- lib/appsignal/integrations/object_ruby_19.rb
+- lib/appsignal/integrations/object_ruby_modern.rb
 - lib/appsignal/integrations/padrino.rb
 - lib/appsignal/integrations/que.rb
 - lib/appsignal/integrations/railtie.rb
@@ -322,6 +324,7 @@ files:
 - spec/lib/appsignal/integrations/data_mapper_spec.rb
 - spec/lib/appsignal/integrations/grape_spec.rb
 - spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb
+- spec/lib/appsignal/integrations/object_19_spec.rb
 - spec/lib/appsignal/integrations/object_spec.rb
 - spec/lib/appsignal/integrations/padrino_spec.rb
 - spec/lib/appsignal/integrations/que_spec.rb
@@ -415,7 +418,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
+rubygems_version: 3.2.8
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com
@@ -474,6 +477,7 @@ test_files:
 - spec/lib/appsignal/integrations/data_mapper_spec.rb
 - spec/lib/appsignal/integrations/grape_spec.rb
 - spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb
+- spec/lib/appsignal/integrations/object_19_spec.rb
 - spec/lib/appsignal/integrations/object_spec.rb
 - spec/lib/appsignal/integrations/padrino_spec.rb
 - spec/lib/appsignal/integrations/que_spec.rb