appsignal 4.6.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f788b7bfb3d2b44efa664bc031df2a2af56085daef2ff224144d6b06e96912ea
-  data.tar.gz: 8600017362cafa764b5ed3f8dbfc41e083b110bcc49374fc66a9a3583ca12f5a
+  metadata.gz: 882fa8b34594a9f3bf529528056c1578707ec0cd45f5ef1563933863e6690bc4
+  data.tar.gz: a0e19b771ec45cd1b6e734e7e04b6f26ca2bb9abc6b713fca7b752ec93f2f427
 SHA512:
-  metadata.gz: a22051b87cae3d4f9d93f34b0cc41765feba84b7eccf8842c178954bf6ba0dbe6977222646c860f0afdf83a26b61ca493728255113455aa1fe49e151604cfc66
-  data.tar.gz: 442959e2bb59a79878852cb1397b477b6100645f95a98a121ce0c83d6d8aea7cfb8d9e78a6ce8235d5482a625a3e4b19495b3da1ac0b3e9029ec0052801ae668
+  metadata.gz: 0aaa738024f11463a5731dc423891ce7bcc34b124ed5db021b6456ddbf4cd42b735e024c5cfba390aea82f6578d6070f17e7cd03cb70f51f1aa78172c34735aa
+  data.tar.gz: 20c7183bd8fbb5848c469fdd5b2103041fdd09f4e8e45caa81df31e539e4fc76eaf728b0c6de169043c9ede80c91694606fcaa0dd5fad77660a7b47b38a839a1

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.7.0
+
+_Published on 2025-08-29._
+
+### Added
+
+- Add Sidekiq worker-level job status metric: `worker_job_count`. This new counter metric's `status` tag will be `processed` for each job that's processed and reports another counter with the `failure` status if the job encountered an error. (minor [fa9859af](https://github.com/appsignal/appsignal-ruby/commit/fa9859af3c82c34201cf68c80858596014fe9c34))
+
+### Fixed
+
+- Support streaming bodies. AppSignal's Rack instrumentation now supports streaming bodies in responses, such as those produced by `Async::Cable`. This fixes an issue where AppSignal's Rack instrumentation would cause requests with streaming bodies to crash.
+
+  If you use our Rack instrumentation through a framework that is automatically instrumented by AppSignal, such as Rails, Hanami, Padrino or Sinatra, this fix is applied automatically.
+
+  If your application instruments Rack manually, you must remove the following line from your application's initial setup:
+
+  ```ruby
+  use Rack::Events, [Appsignal::Rack::EventHandler.new]
+  ```
+
+  And replace it with the following line:
+
+  ```ruby
+  use Appsignal::Rack::EventMiddleware
+  ```
+
+  (minor [c94315e3](https://github.com/appsignal/appsignal-ruby/commit/c94315e337801347620826504a24f44ba3ee2b53))
+- Avoid instrumenting Rails when AppSignal is not active. If AppSignal is configured to start when the Rails application loads, rather than after it has initialised, only add Rails' instrumentation middlewares if AppSignal was actually started. (patch [0239a2c3](https://github.com/appsignal/appsignal-ruby/commit/0239a2c32d0835af00a4659cc7533465ef17f451))
+
 ## 4.6.0
 
 _Published on 2025-07-29._

data/CLAUDE.md

@@ -142,6 +142,21 @@ rake extension:install
 cd ext && rake
 ```
 
+### Type signatures
+
+The Ruby gem includes type signatures for better IDE support and static analysis:
+
+- `sig/appsignal.rbi` - Sorbet type signatures
+- `sig/appsignal.rbs` - RBS type signatures
+
+To regenerate type signatures from YARD documentation:
+
+```bash
+script/generate_signatures
+```
+
+This script uses [sord](https://github.com/AaronC81/sord) to generate both RBI and RBS files from YARD comments in the source code.
+
 ## File organization
 
 ### Configuration files

data/lib/appsignal/integrations/railtie.rb

@@ -28,11 +28,19 @@ module Appsignal
 
       def self.on_load(app)
         load_default_config
-        Appsignal::Integrations::Railtie.add_instrumentation_middleware(app)
 
-        return unless app.config.appsignal.start_at == :on_load
+        Appsignal::Integrations::Railtie.start if app.config.appsignal.start_at == :on_load
 
-        Appsignal::Integrations::Railtie.start
+        # If AppSignal is supposed to start after initialization, we need to add the
+        # instrumentation middleware now, even if AppSignal may not actually start
+        # later, because the middleware stack will be frozen after initialization.
+        #
+        # Otherwise, only add the instrumentation middleware if AppSignal did actually
+        # start before this point, preventing the middleware from being added when
+        # AppSignal is not active.
+        return unless app.config.appsignal.start_at == :after_initialize || Appsignal.started?
+
+        add_instrumentation_middleware(app)
       end
 
       def self.after_initialize(app)
@@ -52,14 +60,15 @@ module Appsignal
 
       def self.start
         Appsignal.start
-        initialize_error_reporter if Appsignal.started?
+        return unless Appsignal.started?
+
+        initialize_error_reporter
       end
 
       def self.add_instrumentation_middleware(app)
         app.middleware.insert(
           0,
-          ::Rack::Events,
-          [Appsignal::Rack::EventHandler.new]
+          ::Appsignal::Rack::EventMiddleware
         )
         app.middleware.insert_after(
           ActionDispatch::DebugExceptions,

data/lib/appsignal/integrations/sidekiq.rb

@@ -66,8 +66,9 @@ module Appsignal
 
       def call(_worker, item, _queue, &block)
         job_status = nil
+        action_name = formatted_action_name(item)
         transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
-        transaction.set_action_if_nil(formatted_action_name(item))
+        transaction.set_action_if_nil(action_name)
 
         formatted_metadata(item).each do |key, value|
           transaction.set_metadata key, value
@@ -93,14 +94,24 @@ module Appsignal
           Appsignal::Transaction.complete_current! unless exception
 
           queue = item["queue"] || "unknown"
+
           if job_status
             increment_counter "queue_job_count", 1,
               :queue => queue,
               :status => job_status
+            increment_counter "worker_job_count", 1,
+              :worker => action_name,
+              :queue => queue,
+              :status => job_status
           end
           increment_counter "queue_job_count", 1,
             :queue => queue,
             :status => :processed
+          increment_counter "worker_job_count", 1,
+            :worker => action_name,
+            :queue => queue,
+            :status => :processed
+
         end
       end
 

data/lib/appsignal/loaders/hanami.rb

@@ -21,10 +21,7 @@ module Appsignal
         require "appsignal/rack/hanami_middleware"
 
         hanami_app_config = ::Hanami.app.config
-        hanami_app_config.middleware.use(
-          ::Rack::Events,
-          [Appsignal::Rack::EventHandler.new]
-        )
+        hanami_app_config.middleware.use(Appsignal::Rack::EventMiddleware)
         hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
 
         return unless Gem::Version.new(Hanami::VERSION) < Gem::Version.new("2.2.0")

data/lib/appsignal/loaders/padrino.rb

@@ -18,7 +18,7 @@ module Appsignal
         Padrino::Application.prepend(Appsignal::Loaders::PadrinoLoader::PadrinoIntegration)
 
         Padrino.before_load do
-          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+          Padrino.use Appsignal::Rack::EventMiddleware
           Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
             :instrument_event_name => "process_action.padrino"
         end

data/lib/appsignal/loaders/sinatra.rb

@@ -16,7 +16,7 @@ module Appsignal
       def on_start
         require "appsignal/rack/sinatra_instrumentation"
 
-        ::Sinatra::Base.use(::Rack::Events, [Appsignal::Rack::EventHandler.new])
+        ::Sinatra::Base.use(Appsignal::Rack::EventMiddleware)
         ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
       end
     end

data/lib/appsignal/rack/event_handler.rb

@@ -2,10 +2,11 @@
 
 module Appsignal
   module Rack
-    # Instrumentation middleware using Rack's Events module.
+    # Instrumentation event handler for `Rack::Events`.
     #
-    # We recommend using this in combination with the
-    # {InstrumentationMiddleware}.
+    # Using this middleware directly with `Rack::Events` is deprecated.
+    # We recommend using {EventMiddleware} instead, which is compatible with
+    # streaming bodies, in combination with the {InstrumentationMiddleware}.
     #
     # This middleware will report the response status code as the
     # `response_status` tag on the sample. It will also report the response
@@ -38,10 +39,12 @@ module Appsignal
 
       # @api private
       attr_reader :id
+      attr_writer :using_appsignal_rack_events_middleware
 
       # @api private
       def initialize
         @id = SecureRandom.uuid
+        @using_appsignal_rack_events_middleware = false
       end
 
       # @api private
@@ -51,6 +54,8 @@ module Appsignal
 
       # @api private
       def on_start(request, _response)
+        emit_warning_once
+
         return unless Appsignal.active?
 
         event_handler = self
@@ -152,6 +157,19 @@ module Appsignal
           namespace
         end
       end
+
+      def emit_warning_once
+        return if @using_appsignal_rack_events_middleware
+
+        Appsignal.internal_logger.warn <<~MSG
+          Rack::Events is not compatible with streaming bodies. Using `Appsignal::Rack::EventHandler`#{" "}
+          with `Rack::Events` will break streaming responses in your application and is deprecated.#{" "}
+          To silence this warning, use `Appsignal::Rack::EventMiddleware` instead, which is compatible#{" "}
+          with streaming bodies.#{" "}
+          See https://docs.appsignal.com/ruby/integrations/rack.html for more information.
+        MSG
+        @using_appsignal_rack_events_middleware = true
+      end
     end
   end
 end

data/lib/appsignal/rack/event_middleware.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    # Modified version of the {::Rack::Events} instrumentation
+    # middleware.
+    #
+    # We recommend using this instead of {::Rack::Events}, as it
+    # is compatible with streaming bodies.
+    #
+    # We do not recommend using this middleware directly, instead
+    # recommending the use of {EventMiddleware}, which is a
+    # convenience wrapper around this middleware that includes
+    # AppSignal's {EventHandler}.
+    #
+    # See the original implementation at:
+    # https://github.com/rack/rack/blob/8d3d7857fcd9e5df057a6c22458bab35b3a19c12/lib/rack/events.rb
+    class Events < ::Rack::Events
+      # A stub for {::Rack::Events::EventedBodyProxy}. It
+      # allows the same initialization arguments, but
+      # otherwise behaves identically to {::Rack::BodyProxy}.
+      #
+      # It does not implement `#each`, fixing an issue
+      # where the evented body proxy would break
+      # streaming responses by always responding to `#each`
+      # even if the proxied body did not implement it.
+      #
+      # Because it ignores the handlers passed to it and
+      # behaves like a normal body proxy, the `on_send`
+      # event on the handlers is never called.
+      class EventedBodyProxy < ::Rack::BodyProxy
+        def initialize(body, _request, _response, _handlers, &block)
+          super(body, &block)
+        end
+      end
+
+      # Notifies the AppSignal event handler that it's being
+      # used with the modified middleware, suppressing a
+      # deprecation warning.
+      def initialize(app, handlers = [])
+        super
+        handlers.each do |handler|
+          if handler.respond_to?(:using_appsignal_rack_events_middleware=)
+            handler.using_appsignal_rack_events_middleware = true
+          end
+        end
+      end
+
+      # The `call` method, exactly as implemented by {::Rack::Events},
+      # but redefined here so that it uses our {EventedBodyProxy}
+      # instead of the original {::Rack::Events::EventedBodyProxy}.
+      #
+      # This fixes streaming bodies, but it also means that the
+      # `on_send` event on the handlers is never called.
+      #
+      # See the original implementation at:
+      # https://github.com/rack/rack/blob/8d3d7857fcd9e5df057a6c22458bab35b3a19c12/lib/rack/events.rb#L111-L129
+      def call(env)
+        request = make_request env
+        on_start request, nil
+
+        begin
+          status, headers, body = @app.call request.env
+          response = make_response status, headers, body
+          on_commit request, response
+        rescue StandardError => e
+          on_error request, response, e
+          on_finish request, response
+          raise
+        end
+
+        body = EventedBodyProxy.new(body, request, response, @handlers) do
+          on_finish request, response
+        end
+        [response.status, response.headers, body]
+      end
+    end
+
+    # Instrumentation middleware using Rack's Events module.
+    #
+    # A convenience wrapper around our {Events} middleware,
+    # modified to be compatible with streaming bodies,
+    # that automatically includes AppSignal's {EventHandler}.
+    #
+    # We recommend using this in combination with the
+    # {InstrumentationMiddleware}.
+    #
+    # This middleware will report the response status code as the
+    # `response_status` tag on the sample. It will also report the response
+    # status as the `response_status` metric.
+    #
+    # This middleware will ensure the AppSignal transaction is always completed
+    # for every request.
+    #
+    # @example Add EventMiddleware to a Rack app
+    #   # Add this middleware as the first middleware of an app
+    #   use Appsignal::Rack::EventMiddleware
+    #
+    #   # Then add the InstrumentationMiddleware
+    #   use Appsignal::Rack::InstrumentationMiddleware
+    #
+    # @see https://docs.appsignal.com/ruby/integrations/rack.html
+    #   Rack integration documentation.
+    # @api public
+    class EventMiddleware < Events
+      def initialize(app)
+        super(app, [Appsignal::Rack::EventHandler.new])
+      end
+    end
+  end
+end

data/lib/appsignal/rack/instrumentation_middleware.rb

@@ -27,8 +27,8 @@ module Appsignal
     #   require "appsignal"
     #   # Configure and start AppSignal
     #
-    #   # Add the EventHandler first
-    #   use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+    #   # Add the EventMiddleware first
+    #   use Appsignal::Rack::EventMiddleware
     #   # Add the instrumentation middleware second
     #   use Appsignal::Rack::InstrumentationMiddleware
     #

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -643,6 +643,7 @@ require "appsignal/rack/body_wrapper"
 require "appsignal/rack/abstract_middleware"
 require "appsignal/rack/instrumentation_middleware"
 require "appsignal/rack/event_handler"
+require "appsignal/rack/event_middleware"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"

data/sig/appsignal.rbi

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

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.7.0
 platform: ruby
 authors:
 - Robert Beekman
 - Thijs Cadier
 - Tom de Bruijn
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-29 00:00:00.000000000 Z
+date: 2025-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -279,6 +280,7 @@ files:
 - lib/appsignal/rack/abstract_middleware.rb
 - lib/appsignal/rack/body_wrapper.rb
 - lib/appsignal/rack/event_handler.rb
+- lib/appsignal/rack/event_middleware.rb
 - lib/appsignal/rack/grape_middleware.rb
 - lib/appsignal/rack/hanami_middleware.rb
 - lib/appsignal/rack/instrumentation_middleware.rb
@@ -317,6 +319,7 @@ metadata:
   documentation_uri: https://docs.appsignal.com/ruby/
   homepage_uri: https://docs.appsignal.com/ruby/
   source_code_uri: https://github.com/appsignal/appsignal-ruby
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -332,7 +335,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com
 test_files: []