appsignal 4.10.1-java → 4.10.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1484edc2b0257539896eed6be1f56407fcaf454ab7c200c6bf798fea67d75c05
-  data.tar.gz: bc1cd76fce693264350284284af84e86bbc4956e84e36fc30af4b8d9b8ab5811
+  metadata.gz: 39bff03e12f0f39edebab29adeb15d316efb0fe813ca087b1b914d083081cbd6
+  data.tar.gz: 88b3ce4fabea7ad7c05306c0d0f5763d844c2dcf249c2168d46cc8f964646601
 SHA512:
-  metadata.gz: ce745eea54bcb98d7c2cf87acd060a1c6e162a25090bc0c653491fd926ef6ef26dd6e4f4a88516d4ac2560d943b7f720c88fade34276481d51c0a1cf277b7318
-  data.tar.gz: 35f4295a1a9685e44719a1a6723e3933a3777e495ffeb862884c4e1dc61979cb990ef093136ecea5a9040d05790c0925464eb0b9481fdfcd0f66da85747c3f7a
+  metadata.gz: e7984a466bf5356a1b6856508a18d44972cb06c3b509aa2f1113e079602b9188f5b4708fbcb83b4bcfd9ef604c0a6b65a97b70afc9656e3553fe3227734d8c69
+  data.tar.gz: 6f6f74a33b99c1ddccee87234580e7fb876bce230045a29b14942abc1460e6b6926e2274c96c121e2336d9c060699b05d7a89d410061ba25ace46eeb4f9de5a2

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.10.2
+
+_Published on 2026-09-09._
+
+### Added
+
+- Add support for Grape 4. On Grape 4, every request through a Grape API raised a `NoMethodError`. Applications on Grape 3 and below were not affected.
+
+  On Grape 4, the action name and the reported path now describe the endpoint's full route, so they include the API prefix, the path version and the mount point. They also no longer end in a trailing slash when the endpoint declares no path of its own, so an endpoint reported as `GET::My::Api#/users/:id/` is now reported as `GET::My::Api#/users/:id`. Action names on Grape 3 and below do not change.
+
+  (patch [bdea5c1b](https://github.com/appsignal/appsignal-ruby/commit/bdea5c1b6f02c902d0ba195eff3544545bee2547))
+
+### Changed
+
+- Update the agent to handle high traffic apps. On high-traffic apps that would exceed the maximum accepted internal payload size, send data to the Push API more frequently. (patch [a1c3033e](https://github.com/appsignal/appsignal-ruby/commit/a1c3033e1b255371a2d71d4519506a67dbfa2b82))
+
+### Fixed
+
+- Load the host Rails application before the `appsignal demo` command reads the
+  AppSignal configuration. This matches the behavior of `appsignal diagnose`.
+
+  Thanks [@Guflly](https://github.com/Guflly) for your contribution!
+
+  (patch [3249a376](https://github.com/appsignal/appsignal-ruby/commit/3249a376a6fb7a10c990e0f49f7907dc40b03a12))
+- Fix events showing as unknown in long-running applications. An application process that kept running for thirty days without restarting could lose the names and queries of the events it recorded, both in slow traces and in the "Slow events" panel. (patch [a1c3033e](https://github.com/appsignal/appsignal-ruby/commit/a1c3033e1b255371a2d71d4519506a67dbfa2b82))
+- Prevent `gc` events from appearing in the "Slow events" panel. (patch [a1c3033e](https://github.com/appsignal/appsignal-ruby/commit/a1c3033e1b255371a2d71d4519506a67dbfa2b82))
+- Report Delayed Job jobs that fail to load. Before this change, a job whose
+  payload could not be deserialized was not reported to AppSignal at all.
+
+  This can happen when a deploy removes or renames a job class while jobs of that
+  class are still queued. Those jobs are now reported as failed, with the
+  `Delayed::DeserializationError` they raised, and are named after the class
+  recorded in the job's handler. When even that cannot be read, they are named
+  `DelayedJobInternal`.
+
+  (patch [ea294440](https://github.com/appsignal/appsignal-ruby/commit/ea29444069ef78347ad1e8266869b7d9aa2caa50))
+- Record a single event for a bulk enqueue of Active Job jobs. Before this change,
+  enqueuing jobs with `ActiveJob.perform_all_later` would record an event for the
+  batch and, if the adapter was instrumented with AppSignal, another event for each
+  job in it. A job that slices a large collection and enqueues it in batches was
+  therefore reported with an event per job enqueued, where before version 4.9.0 it
+  had one event per batch.
+
+  A bulk enqueue is now recorded as a single `enqueue_all.active_job` event, named
+  after the job class when every job in the batch shares one.
+
+  (patch [fe82dc60](https://github.com/appsignal/appsignal-ruby/commit/fe82dc60bc8b52d466c0c9b673adbae29f79449e))
+
 ## 4.10.1
 
 _Published on 2026-08-20._

data/README.md

@@ -240,7 +240,8 @@ configurations you need to run the spec suite with a specific Gemfile.
 BUNDLE_GEMFILE=gemfiles/capistrano2.gemfile bundle exec rspec
 BUNDLE_GEMFILE=gemfiles/capistrano3.gemfile bundle exec rspec
 BUNDLE_GEMFILE=gemfiles/dry-monitor.gemfile bundle exec rspec
-BUNDLE_GEMFILE=gemfiles/grape.gemfile bundle exec rspec
+BUNDLE_GEMFILE=gemfiles/grape-3.gemfile bundle exec rspec
+BUNDLE_GEMFILE=gemfiles/grape-4.gemfile bundle exec rspec
 BUNDLE_GEMFILE=gemfiles/hanami.gemfile bundle exec rspec
 BUNDLE_GEMFILE=gemfiles/http5.gemfile bundle exec rspec
 BUNDLE_GEMFILE=gemfiles/no_dependencies.gemfile bundle exec rspec

data/appsignal.gemspec

@@ -61,6 +61,13 @@ Gem::Specification.new do |gem|
   gem.add_dependency "rack", ">= 2.0.0"
 
   gem.add_development_dependency "pry"
+  # Reached through webmock's addressable. Version 7 requires Ruby 3.2 and
+  # version 6 requires 3.0, so an older Ruby cannot resolve the development
+  # dependencies unless this is held back. The cop guards the requirements of
+  # the released gem, which a development dependency is not part of.
+  # rubocop:disable Gemspec/RubyVersionGlobalsUsage
+  gem.add_development_dependency "public_suffix", "< 6" if RUBY_VERSION < "3.2"
+  # rubocop:enable Gemspec/RubyVersionGlobalsUsage
   gem.add_development_dependency "rake", ">= 12"
   gem.add_development_dependency "rspec", "~> 3.8"
   gem.add_development_dependency "rubocop", "~> 1.87.0"

data/build_matrix.yml

@@ -2,7 +2,7 @@ github:
   name: Ruby gem CI
   "on":
     push:
-      branches: ["main", "develop"]
+      branches: ["main", "develop", "*-stable"]
     pull_request:
       types: [opened, reopened, synchronize]
     schedule:
@@ -162,7 +162,13 @@ matrix:
           - "3.2.5"
           - "3.1.6"
           - "3.0.7"
-    - gem: "grape"
+    - gem: "grape-3"
+    - gem: "grape-4"
+      only:
+        ruby:
+          - "4.0.0"
+          - "3.4.1"
+          - "3.3.4"
     - gem: "hanami-2.0"
       only:
         ruby:

data/ext/agent.rb

@@ -6,7 +6,7 @@
 # Modifications to this file will be overwritten with the next agent release.
 
 APPSIGNAL_AGENT_CONFIG = {
-  "version" => "0.36.12",
+  "version" => "0.37.0",
   "mirrors" => [
     "https://d135dj0rjqvssy.cloudfront.net",
     "https://appsignal-agent-releases.global.ssl.fastly.net"
@@ -14,131 +14,131 @@ APPSIGNAL_AGENT_CONFIG = {
   "triples" => {
     "x86_64-darwin" => {
       "static" => {
-        "checksum" => "a63189a2ba6b500e038e5658f97478ceae27a956baa2f89a4e79ee5a1dadace6",
+        "checksum" => "1c05ef4cd4f0d0646bbc00a61568448cafd6c8cd23e152a4d7e22bab7e733cf1",
         "filename" => "appsignal-x86_64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "ecfb108dcc4d10f442415debaceed6d2e568b44ab938cf0ed6fee3ccfbdc5379",
+        "checksum" => "0c74689a0bc204e0ce462c875f46ea458aa63705956f1adb9daa72dbce47e736",
         "filename" => "appsignal-x86_64-darwin-all-dynamic.tar.gz"
       }
     },
     "universal-darwin" => {
       "static" => {
-        "checksum" => "a63189a2ba6b500e038e5658f97478ceae27a956baa2f89a4e79ee5a1dadace6",
+        "checksum" => "1c05ef4cd4f0d0646bbc00a61568448cafd6c8cd23e152a4d7e22bab7e733cf1",
         "filename" => "appsignal-x86_64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "ecfb108dcc4d10f442415debaceed6d2e568b44ab938cf0ed6fee3ccfbdc5379",
+        "checksum" => "0c74689a0bc204e0ce462c875f46ea458aa63705956f1adb9daa72dbce47e736",
         "filename" => "appsignal-x86_64-darwin-all-dynamic.tar.gz"
       }
     },
     "aarch64-darwin" => {
       "static" => {
-        "checksum" => "d23d6cc15e7df1c810b55dc33905002c5a1d6bc3f7cb10690d7e21398aabdac0",
+        "checksum" => "031d0f3c32302271274d1e602c9cecb2b037e9dd338001901ff4ed4d0e457075",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "b4f9bf20f87fc7ddd8cc307646a956f734a2153323cc01487ced322263f32c2b",
+        "checksum" => "5aadc22281991a97250bd6bf12dd5dd764ffc4da72301d745f86d63542159436",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "arm64-darwin" => {
       "static" => {
-        "checksum" => "d23d6cc15e7df1c810b55dc33905002c5a1d6bc3f7cb10690d7e21398aabdac0",
+        "checksum" => "031d0f3c32302271274d1e602c9cecb2b037e9dd338001901ff4ed4d0e457075",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "b4f9bf20f87fc7ddd8cc307646a956f734a2153323cc01487ced322263f32c2b",
+        "checksum" => "5aadc22281991a97250bd6bf12dd5dd764ffc4da72301d745f86d63542159436",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "arm-darwin" => {
       "static" => {
-        "checksum" => "d23d6cc15e7df1c810b55dc33905002c5a1d6bc3f7cb10690d7e21398aabdac0",
+        "checksum" => "031d0f3c32302271274d1e602c9cecb2b037e9dd338001901ff4ed4d0e457075",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "b4f9bf20f87fc7ddd8cc307646a956f734a2153323cc01487ced322263f32c2b",
+        "checksum" => "5aadc22281991a97250bd6bf12dd5dd764ffc4da72301d745f86d63542159436",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "aarch64-linux" => {
       "static" => {
-        "checksum" => "0a277e682f1568fbc54df849a46f21f155643b40c285a5bd30294c9d046e49c2",
+        "checksum" => "48499ed06fda433dc7347a4a3d23944d0bfb31604e5d7f52db0a0bbe437f8e03",
         "filename" => "appsignal-aarch64-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "94e0193908955e7a3a274a37947e234c5b038aa26c0ea9b371a08fd63441a940",
+        "checksum" => "d943b05951cce5d797c0fe7aeacafc9b6870a0d72aa7869b9aa16f5add82fcc6",
         "filename" => "appsignal-aarch64-linux-all-dynamic.tar.gz"
       }
     },
     "i686-linux" => {
       "static" => {
-        "checksum" => "0d4536a2b1c9b6915f0f8597bd858988e284e7dbc4a14488332ffa7e401a1134",
+        "checksum" => "41600ba4171cb8549ff9c8b675e9b4ef100eb7ef0a001a970964af04dc209738",
         "filename" => "appsignal-i686-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "c5df66876e4611d5ef8798013f0188469cbdea6753a9b9d6cf54bd858e6331e9",
+        "checksum" => "ada062a08dc531421141330764e4a0b9a05b34b52b922c1c705ffbac604eb332",
         "filename" => "appsignal-i686-linux-all-dynamic.tar.gz"
       }
     },
     "x86-linux" => {
       "static" => {
-        "checksum" => "0d4536a2b1c9b6915f0f8597bd858988e284e7dbc4a14488332ffa7e401a1134",
+        "checksum" => "41600ba4171cb8549ff9c8b675e9b4ef100eb7ef0a001a970964af04dc209738",
         "filename" => "appsignal-i686-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "c5df66876e4611d5ef8798013f0188469cbdea6753a9b9d6cf54bd858e6331e9",
+        "checksum" => "ada062a08dc531421141330764e4a0b9a05b34b52b922c1c705ffbac604eb332",
         "filename" => "appsignal-i686-linux-all-dynamic.tar.gz"
       }
     },
     "x86_64-linux" => {
       "static" => {
-        "checksum" => "eec59a3e46dd5d5baff044465b4e314f21edf6270500bf24e3bc50afcee5f2e2",
+        "checksum" => "8240c494573360ad147aa56a973fe809bf1f3976383b8cd990fc0824e5554913",
         "filename" => "appsignal-x86_64-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "37471e17c5cb9f252d039cfbc0c01d570698c2245f6c8783fd2778e640b59a54",
+        "checksum" => "ec07ea8188c3589c7c9a401d7555b51fdd052f07b05fc62e3801288493f85ca8",
         "filename" => "appsignal-x86_64-linux-all-dynamic.tar.gz"
       }
     },
     "x86_64-linux-musl" => {
       "static" => {
-        "checksum" => "4454ec095ad14813bedea20a110a26235dbc6e8e33538219fad325792c0d888e",
+        "checksum" => "39de4602e300f701ed28748bd1c523bedf44f2d0f6241fffe370485185a895cc",
         "filename" => "appsignal-x86_64-linux-musl-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "4c21039b077b0c292d530210e077d942694f4c533d3761ed11e27ca932215131",
+        "checksum" => "8a9fd74a6a7589b842a8297025656e7ccc995c9df40c09cf45b39382d3d4a507",
         "filename" => "appsignal-x86_64-linux-musl-all-dynamic.tar.gz"
       }
     },
     "aarch64-linux-musl" => {
       "static" => {
-        "checksum" => "048a55f0f10087e7954559d6cd09b371a0b532673f7ca769bcfde5729e297a72",
+        "checksum" => "13fa41ad765a9c79f374dad4d131e7860afb8760c11508af1de982580798a3bc",
         "filename" => "appsignal-aarch64-linux-musl-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "8dc336cffcb2cffe85daa8c70b02b0af7e626ed81c8873cdbb627216a411d59a",
+        "checksum" => "8193f5925818164390aac737d15a3d86706fce7aad81c4d5e84a3b0552b407a5",
         "filename" => "appsignal-aarch64-linux-musl-all-dynamic.tar.gz"
       }
     },
     "x86_64-freebsd" => {
       "static" => {
-        "checksum" => "d81d039a3c1936bd393a6140b46f48092da31600b0311eab819acd777521a588",
+        "checksum" => "c519b132c7a1de2a8dbb8c36d87fe91b4c0451d2c65d8bd4f44b748bb2ad2904",
         "filename" => "appsignal-x86_64-freebsd-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "cc345d4a791200e5af53c533e7ad83d278e98ee0becb5b54e502ba8934094372",
+        "checksum" => "fb5ea3aac557543de74842d668c66ede00d125e1e86f601fa5ffe002edbd6c62",
         "filename" => "appsignal-x86_64-freebsd-all-dynamic.tar.gz"
       }
     },
     "amd64-freebsd" => {
       "static" => {
-        "checksum" => "d81d039a3c1936bd393a6140b46f48092da31600b0311eab819acd777521a588",
+        "checksum" => "c519b132c7a1de2a8dbb8c36d87fe91b4c0451d2c65d8bd4f44b748bb2ad2904",
         "filename" => "appsignal-x86_64-freebsd-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "cc345d4a791200e5af53c533e7ad83d278e98ee0becb5b54e502ba8934094372",
+        "checksum" => "fb5ea3aac557543de74842d668c66ede00d125e1e86f601fa5ffe002edbd6c62",
         "filename" => "appsignal-x86_64-freebsd-all-dynamic.tar.gz"
       }
     }

data/lib/appsignal/cli/demo.rb

@@ -40,6 +40,8 @@ module Appsignal
     # @see https://docs.appsignal.com/support/debugging.html
     #   Debugging AppSignal guide
     class Demo
+      extend CLI::Helpers
+
       class << self
         # @param options [Hash]
         # @option options :environment [String] environment to load
@@ -47,6 +49,9 @@ module Appsignal
         # @return [void]
         def run(options = {})
           ENV["APPSIGNAL_APP_ENV"] = options[:environment] if options[:environment]
+          # Load the host Rails app, if any, so that the AppSignal config file
+          # can use the application when it is read.
+          require_rails_app_if_present(options[:environment])
 
           puts "Sending demonstration sample data..."
           if Appsignal::Demo.transmit

data/lib/appsignal/cli/diagnose.rb

@@ -189,10 +189,15 @@ module Appsignal
 
         def configure_appsignal(options)
           env_option = options.fetch(:environment, nil)
+          # Mark app as Rails app
+          data[:app][:rails] = true if rails_present?
           # Try and load the Rails app, if any.
           # This will configure AppSignal through the config file or an
           # initializer.
-          require_rails_app_if_present(env_option)
+          require_rails_app_if_present(env_option) do |error|
+            data[:app][:load_error] =
+              "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+          end
 
           # No config loaded yet, try loading as normal
           Appsignal._load_config!(env_option) unless Appsignal.config
@@ -627,43 +632,6 @@ module Appsignal
           puts "    Read error: #{path[:read_error]}"
           print_empty_line
         end
-
-        def print_empty_line
-          puts "\n"
-        end
-
-        def require_rails_app_if_present(env_option)
-          return unless rails_present?
-
-          # Set the environment given as an option to the diagnose CLI so the
-          # Rails app uses it when loaded.
-          ENV["_APPSIGNAL_CONFIG_FILE_ENV"] = env_option
-          # Mark app as Rails app
-          data[:app][:rails] = true
-          # Manually require the railtie, because it wasn't loaded when the CLI
-          # started and AppSignal loaded, because the `Rails` constant wasn't
-          # present.
-          require "appsignal/integrations/railtie"
-          # Start the Rails app, including railties and initializers.
-          require Appsignal::Utils::RailsHelper.environment_config_path
-        rescue LoadError, StandardError => error
-          print_empty_line
-          puts "ERROR: Error encountered while loading the Rails app"
-          puts "#{error.class}: #{error.message}"
-          puts error.backtrace
-          data[:app][:load_error] =
-            "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
-        ensure
-          ENV.delete("_APPSIGNAL_CONFIG_FILE_ENV")
-        end
-
-        def rails_present?
-          # Try and load the Rails gem
-          require "rails"
-          true
-        rescue LoadError
-          false
-        end
       end
     end
   end

data/lib/appsignal/cli/helpers.rb

@@ -36,6 +36,51 @@ module Appsignal
         "\e[#{color_code}m#{text}\e[#{reset_color_code}m"
       end
 
+      def print_empty_line
+        puts "\n"
+      end
+
+      def rails_present?
+        require "rails"
+        true
+      rescue LoadError
+        false
+      end
+
+      # The Rails gem being loadable says nothing about the directory the
+      # command runs in, so check for the app itself as well.
+      def rails_app_present?
+        rails_present? &&
+          File.exist?(Appsignal::Utils::RailsHelper.environment_config_path)
+      end
+
+      def load_rails_app(environment)
+        # Pass the environment given as a command line option to the app, so
+        # that the AppSignal config file uses it when the app loads it.
+        ENV["_APPSIGNAL_CONFIG_FILE_ENV"] = environment
+        # Require the railtie manually. It was not loaded when AppSignal
+        # loaded, because the `Rails` constant was not present at that point.
+        require "appsignal/integrations/railtie"
+        # Start the Rails app, including its railties and initializers.
+        require Appsignal::Utils::RailsHelper.environment_config_path
+      ensure
+        ENV.delete("_APPSIGNAL_CONFIG_FILE_ENV")
+      end
+
+      # Yields the error when the app fails to load, so that a command can
+      # report it in its own way.
+      def require_rails_app_if_present(environment)
+        return unless rails_app_present?
+
+        load_rails_app(environment)
+      rescue LoadError, StandardError => error
+        print_empty_line
+        puts "ERROR: Error encountered while loading the Rails app"
+        puts "#{error.class}: #{error.message}"
+        puts error.backtrace
+        yield error if block_given?
+      end
+
       def periods
         3.times do
           print "."

data/lib/appsignal/hooks/active_job.rb

@@ -21,6 +21,59 @@ module Appsignal
         defined?(::ActiveJob)
       end
 
+      # The parameters of the Active Job method this hook wraps to record a
+      # bulk enqueue. The wrapper reads the array of jobs out of the second
+      # one, so it is only safe to wrap a method that still takes these.
+      EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS = [
+        [:req, :queue_adapter],
+        [:req, :jobs]
+      ].freeze
+
+      # Whether Active Job records a bulk enqueue through a method at all. It
+      # only does so from version 7.1 on. Checking for the method, rather than
+      # for the version, keeps us from wrapping one on a version that has no
+      # bulk enqueue path to instrument.
+      def self.instrument_enqueue_all_defined?
+        ::ActiveJob.singleton_class.private_method_defined?(:instrument_enqueue_all)
+      end
+
+      # Whether that method still takes the arguments the wrapper reads.
+      #
+      # The method is private, so a later version of Active Job can change
+      # what it takes. Wrapping one that takes something else raises an
+      # ArgumentError inside every `ActiveJob.perform_all_later` call an
+      # application makes, which breaks enqueuing and not just its
+      # instrumentation. Refusing to wrap it is therefore the safe direction,
+      # whatever the refusal costs us.
+      def self.instrument_enqueue_all_parameters_match?
+        instrument_enqueue_all_parameters == EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS
+      end
+
+      # Active Job's own definition of the method, looked up past the wrapper
+      # this hook prepends. Installing twice would otherwise find that wrapper
+      # rather than the method it wraps, and so check it against itself. Only
+      # the wrapper is skipped, so a version of Active Job that defines the
+      # method somewhere else is still found.
+      def self.instrument_enqueue_all_method
+        method = ::ActiveJob.singleton_class.instance_method(:instrument_enqueue_all)
+        method = method.super_method while method&.owner == ActiveJobBulkEnqueueInstrumentation
+        method
+      end
+
+      def self.instrument_enqueue_all_parameters
+        instrument_enqueue_all_method&.parameters
+      end
+
+      # Names both sides of the mismatch, so a log line is enough to tell what
+      # Active Job changed and what the wrapper was written against.
+      def self.instrument_enqueue_all_mismatch_message
+        "Not instrumenting Active Job bulk enqueues: " \
+          "`ActiveJob.instrument_enqueue_all` takes " \
+          "#{instrument_enqueue_all_parameters.inspect} in this version of " \
+          "Active Job, where AppSignal expects " \
+          "#{EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS.inspect}."
+      end
+
       def dependencies_present?
         self.class.dependencies_present? && Appsignal.config &&
           Appsignal.config[:instrument_active_job]
@@ -33,6 +86,32 @@ module Appsignal
           ::ActiveJob::Base
             .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobEnqueueInstrumentation
 
+          # Wrap the method Active Job records a bulk enqueue through, but only
+          # when it is still the method the wrapper knows how to read. When it
+          # is not, the batch goes unrecorded: Rails' own notification stays
+          # suppressed, because a worse event is not worth reporting in place
+          # of the one we set out to report.
+          if !Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_defined?
+            # Nothing to instrument on a version with no bulk enqueue path, so
+            # there is nothing to report either.
+            Appsignal.internal_logger.debug(
+              "Not instrumenting Active Job bulk enqueues: this version of " \
+                "Active Job does not record them through " \
+                "`ActiveJob.instrument_enqueue_all`."
+            )
+          elsif !Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_parameters_match?
+            # A bulk enqueue path exists, but not one that can be wrapped
+            # without breaking `ActiveJob.perform_all_later` for the whole
+            # application. Report that at a level someone will see, because a
+            # batch that used to be recorded no longer is.
+            Appsignal.internal_logger.warn(
+              Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_mismatch_message
+            )
+          else
+            ::ActiveJob.singleton_class
+              .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobBulkEnqueueInstrumentation
+          end
+
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
           # Only works on Active Job 7.1 and newer
@@ -80,6 +159,67 @@ module Appsignal
         end
       end
 
+      # Records an `enqueue_all.active_job` event when a batch of jobs is
+      # enqueued with `ActiveJob.perform_all_later`, so the batch shows up on the
+      # active transaction's timeline as one event.
+      #
+      # This wraps `instrument_enqueue_all` rather than `perform_all_later`, for
+      # two reasons. It is the method that records the batch, so it is called
+      # once for each queue adapter the batch spans, which is the same event
+      # count as the native notification it replaces. And it runs inside
+      # `perform_all_later`, after Active Job has split off the jobs it defers
+      # until the database transaction commits, so each of those halves is
+      # recorded when it is really enqueued.
+      #
+      # @!visibility private
+      module ActiveJobBulkEnqueueInstrumentation
+        private
+
+        def instrument_enqueue_all(_queue_adapter, jobs)
+          # Skip recording the event when enqueue events are suppressed, which is
+          # also the case when enqueue instrumentation is disabled. Same check as
+          # the single-job path above.
+          if Appsignal::Transaction.current? &&
+              Appsignal::Transaction.current.job_enqueue_events_suppressed?
+            return super
+          end
+
+          Appsignal.instrument("enqueue_all.active_job", bulk_enqueue_title(jobs)) do
+            # A bulk enqueue does not go through `ActiveJob::Base#enqueue`, so
+            # nothing has suppressed the adapter (Sidekiq, Resque, ...) yet, and
+            # its own enqueue instrumentation would record an event for every job
+            # in the batch. Suppress it so the batch is recorded once, as this
+            # event.
+            if Appsignal::Transaction.current?
+              Appsignal::Transaction.current.suppress_job_enqueue_events { super }
+            else
+              super
+            end
+          end
+        end
+
+        # The batch's job class, when every job in it has the same one. Active
+        # Job groups the jobs it enqueues by queue adapter rather than by class,
+        # so a batch can mix classes, and then there is no one class to name.
+        def bulk_enqueue_title(jobs)
+          job_class = shared_across(jobs) { |job| job.class.name }
+          return "bulk enqueue jobs" unless job_class
+
+          "bulk enqueue #{job_class} jobs"
+        end
+
+        # The one value every job in the batch shares, or nil when they differ
+        # or the batch is empty. Stops at the first job that disagrees, because
+        # a batch is as large as the caller made it and a single mismatch is
+        # enough to know.
+        def shared_across(jobs)
+          return if jobs.empty?
+
+          first = yield(jobs.first)
+          jobs.all? { |job| yield(job) == first } ? first : nil
+        end
+      end
+
       module ActiveJobClassInstrumentation
         def execute(job)
           enqueued_at = job["enqueued_at"]

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -9,10 +9,15 @@ module Appsignal
 
         # Events a dedicated AppSignal integration already records, so the
         # generic notifications path must not record them a second time. The
-        # ActiveJob hook owns `enqueue.active_job` (it wraps the enqueue in its
-        # own event, with Rails' native notification nested inside), and the
+        # ActiveJob hook owns `enqueue.active_job` and `enqueue_all.active_job`.
+        # It records its own event for a single enqueue, and one event for a
+        # whole batch, with Rails' native notification nested inside. The
         # Faraday integration owns `request.faraday`.
-        SUPPRESSED_EVENT_NAMES = ["enqueue.active_job", "request.faraday"].freeze
+        SUPPRESSED_EVENT_NAMES = [
+          "enqueue.active_job",
+          "enqueue_all.active_job",
+          "request.faraday"
+        ].freeze
 
         def start_event(name)
           return unless record_event?(name)

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -11,6 +11,18 @@ module Appsignal
           enqueue_with_instrumentation(job, block)
         end
 
+        # Delayed Job asks a job for its own maximum run time before it invokes
+        # it, and answering that question reads the job's payload. A job whose
+        # payload will not deserialize therefore raises inside the worker and
+        # never reaches `invoke_job`, so the callback below does not run and the
+        # failure goes unreported. This callback sits one step further out, on
+        # the worker's whole run of the job, which is where such a job can still
+        # be seen.
+        lifecycle.around(:perform) do |worker, job, &block|
+          report_job_that_cannot_be_loaded(job)
+          block.call(worker, job)
+        end
+
         lifecycle.around(:invoke_job) do |job, &block|
           invoke_with_instrumentation(job, block)
         end
@@ -51,6 +63,34 @@ module Appsignal
         job.name
       end
 
+      # Reports a job whose payload cannot be read, and does nothing at all for
+      # a job that loads. That is what keeps every ordinary job instrumented by
+      # the `:invoke_job` callback alone: no transaction is opened here, so an
+      # ordinary job's reported duration and its reported error are exactly
+      # what they were before this callback existed.
+      #
+      # Reading the payload here reads it a moment before the worker would have
+      # read it anyway. Delayed Job memoizes a payload that loads, so a job
+      # that is fine is deserialized once either way.
+      #
+      # Nothing is re-raised. The worker reads the same payload immediately
+      # after this returns, raises the same error, and fails the job as it
+      # always has. Raising here instead would move that error out of the
+      # worker's own handling and into the loop that reserves jobs.
+      def self.report_job_that_cannot_be_loaded(job)
+        job.payload_object
+        nil
+      rescue Exception => error
+        warn_unreadable_payload_once(error)
+
+        transaction =
+          Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
+        transaction.set_action_if_nil(action_name_without_payload(job))
+        transaction.set_error(error)
+        add_job_metadata(transaction, job)
+        Appsignal::Transaction.complete_current!
+      end
+
       def self.invoke_with_instrumentation(job, block)
         transaction =
           Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
@@ -63,39 +103,106 @@ module Appsignal
           transaction.set_error(error)
           raise
         ensure
-          payload = job.payload_object
-          if payload.respond_to? :job_data
-            # ActiveJob
-            job_data = payload.job_data
-            transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
-            transaction.add_params_if_nil(job_data.fetch("arguments", {}))
-          else
-            # Delayed Job
-            transaction.set_action_if_nil(action_name_from_payload(payload, job.name))
-            transaction.add_params_if_nil(extract_value(payload, :args, {}))
+          # Delayed Job raises when a job's handler will not deserialize, and it
+          # raises again on every further attempt to read it. Reading the payload
+          # here without a guard therefore replaces the error the job already
+          # failed with, and skips the rest of this block, so the transaction is
+          # never completed and the failure is never reported.
+          begin
+            payload = job.payload_object
+            if payload.respond_to? :job_data
+              # ActiveJob
+              job_data = payload.job_data
+              transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
+              transaction.add_params_if_nil(job_data.fetch("arguments", {}))
+            else
+              # Delayed Job
+              transaction.set_action_if_nil(action_name_from_payload(payload, job.name))
+              transaction.add_params_if_nil(extract_value(payload, :args, {}))
+            end
+          rescue => error
+            warn_unreadable_payload_once(error)
+            transaction.set_action_if_nil(action_name_without_payload(job))
           end
 
-          transaction.add_tags(
-            :id => extract_value(job, :id, nil, true),
-            :queue => extract_value(job, :queue),
-            :priority => extract_value(job, :priority, 0),
-            :attempts => extract_value(job, :attempts, 0)
-          )
-
-          transaction.set_queue_start(extract_value(job, :run_at)&.to_i&.* 1_000)
+          add_job_metadata(transaction, job)
 
           Appsignal::Transaction.complete_current!
         end
       end
 
+      def self.add_job_metadata(transaction, job)
+        transaction.add_tags(
+          :id => extract_value(job, :id, nil, true),
+          :queue => extract_value(job, :queue),
+          :priority => extract_value(job, :priority, 0),
+          :attempts => extract_value(job, :attempts, 0)
+        )
+
+        transaction.set_queue_start(extract_value(job, :run_at)&.to_i&.* 1_000)
+      end
+
+      # The name Delayed Job derives from the raw handler when the payload will
+      # not deserialize. It reads the class name out of the handler with a
+      # regular expression, which covers the job class a deploy removed. That
+      # expression raises for a handler it does not match, and it is skipped
+      # altogether when the payload raised something Delayed Job does not wrap,
+      # so fall back to a name that says the failure came from inside Delayed
+      # Job. The failure is then reported under a name that can be found, and
+      # every job this happens to is grouped together.
+      def self.action_name_without_payload(job)
+        with_perform_suffix(job.name)
+      rescue
+        "DelayedJobInternal"
+      end
+
+      # Guards the check-and-set below, so two threads that read an unreadable
+      # payload at the same time cannot both warn. A constant so it is created
+      # once at load time, because creating it lazily would race in turn.
+      WARN_ONCE_LOCK = Mutex.new
+
+      # A deploy that removes a job class leaves every job of that class unable
+      # to deserialize, so this can be reached once per job. Each of those jobs
+      # reports its own error to AppSignal, so the log only has to say once that
+      # it is happening.
+      def self.warn_unreadable_payload_once(error)
+        should_warn = WARN_ONCE_LOCK.synchronize do
+          next false if @warned_unreadable_payload
+
+          @warned_unreadable_payload = true
+        end
+        return unless should_warn
+
+        Appsignal.internal_logger.warn(
+          "Unable to read a Delayed Job job's payload: #{error.class}: " \
+            "#{error.message}. Jobs whose payload cannot be read are reported " \
+            "without parameters. They are named after the class in their raw " \
+            "handler, or DelayedJobInternal when that cannot be read either."
+        )
+      end
+
+      # @!visibility private
+      #
+      # Resets the warn-once state. Only used to keep test runs isolated.
+      def self.reset_unreadable_payload_warning!
+        WARN_ONCE_LOCK.synchronize { @warned_unreadable_payload = false }
+      end
+
       def self.action_name_from_payload(payload, default_name)
         # Attempt to find appsignal_name override
         class_and_method_name = extract_value(payload, :appsignal_name, nil)
         return class_and_method_name if class_and_method_name.is_a?(String)
-        return default_name if default_name.split("#").length == 2
-        return default_name if default_name.split(".").length == 2
 
-        "#{default_name}#perform"
+        with_perform_suffix(default_name)
+      end
+
+      # An action name is a class and a method. A name that already names both,
+      # separated either way, is left alone.
+      def self.with_perform_suffix(name)
+        return name if name.split("#").length == 2
+        return name if name.split(".").length == 2
+
+        "#{name}#perform"
       end
 
       # rubocop:disable Style/OptionalBooleanParameter

data/lib/appsignal/rack/grape_middleware.rb

@@ -15,26 +15,56 @@ module Appsignal
 
       def add_transaction_metadata_after(transaction, request)
         endpoint = request.env["api.endpoint"]
-        unless endpoint&.options
+        request_method, klass, path = endpoint && endpoint_action(endpoint)
+        unless path
           super
           return
         end
 
+        transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+
+        super
+
+        transaction.set_metadata("path", path)
+      end
+
+      # Returns the HTTP method, API class and path that make up the action
+      # name, or nil when the endpoint does not describe a route.
+      def endpoint_action(endpoint)
         options = endpoint.options
-        request_method = options[:method].first.to_s.upcase
-        klass = options[:for]
+        return unless options
+
+        if options.key?(:path)
+          # Only Grape 3 and older populate `options[:path]`. Their route is
+          # readable too, but its path is the full route template, so reading
+          # it would rename the actions these applications already report.
+          endpoint_action_from_options(endpoint, options)
+        else
+          # Grape 4 keeps these three in a value object behind a protected
+          # reader, leaving the route as the only public source.
+          endpoint_action_from_route(endpoint)
+        end
+      end
+
+      def endpoint_action_from_options(endpoint, options)
         namespace = endpoint.namespace
         namespace = "" if namespace == "/"
 
         path = options[:path].first.to_s
         path = "/#{path}" if path[0] != "/"
-        path = "#{namespace}#{path}"
 
-        transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+        [
+          options[:method].first.to_s.upcase,
+          options[:for],
+          "#{namespace}#{path}"
+        ]
+      end
 
-        super
+      def endpoint_action_from_route(endpoint)
+        route = endpoint.routes.first
+        return unless route
 
-        transaction.set_metadata("path", path)
+        [route.request_method.to_s.upcase, endpoint.api, route.origin]
       end
     end
   end

data/lib/appsignal/version.rb

@@ -2,5 +2,5 @@
 
 module Appsignal
   # @return [String]
-  VERSION = "4.10.1"
+  VERSION = "4.10.2"
 end

data/sig/appsignal.rbi

@@ -8,7 +8,7 @@
 module Appsignal
   extend Appsignal::Helpers::Metrics
   extend Appsignal::Helpers::Instrumentation
-  VERSION = T.let("4.10.1", T.untyped)
+  VERSION = T.let("4.10.2", T.untyped)
 
   class << self
     # The loaded AppSignal configuration.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 4.10.1
+  version: 4.10.2
 platform: java
 authors:
 - Robert Beekman