appsignal 4.9.1-java → 4.10.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ab7d841379d8fb72ce94d809133987920e063dbe72ec65b026360121685c83f
-  data.tar.gz: 253ac53b17b30ce57a5c25677b9c2dad9c33e6a20cd937311897a82a6301b33e
+  metadata.gz: f6d6acf8b543263a2008bfc4ea0f20a57194d01aa2acdc5886292e8ead23e112
+  data.tar.gz: b1f7a59ef1b33459306bfb60a0681e581e1c1dd9be78a315d08d419c310e3296
 SHA512:
-  metadata.gz: 9011847dfd4f4547dfa03f8b007d7f201dc82c1eec598e2f6ddc15a05ef6a0fd75e6a3a2cee45eeac79a48f9c4d01c69056c3cbe594a15c6dfd875e37bcc519f
-  data.tar.gz: 0cdf4856bbcd79f900569daf211e1e35e1e067ffaeb306ebc9af7eae4ec602299475f13e2cee474b8ed494853b3fa2e7eb33d90dbdad6f5a919f076a5a5a4938
+  metadata.gz: 7181d57c290de3067026ec31912c5da273b2dc7597453eda533f61b82f2654cbd467e81bb572ab93cd0fbdd38abdb582ba17a67de3a71185c1474724eba5254d
+  data.tar.gz: f4c27203476610873135cf6db61ae788c4f5bbab59b56f7cddd0a2bb2f657dfd19a3224ffddd240cde62b58dad51cfdfdaa078b1083ec81f33e75178e3cc445e

data/CHANGELOG.md

@@ -1,5 +1,85 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.10.0
+
+_Published on 2026-08-10._
+
+### Changed
+
+- Fix Excon requests being reported as taking almost no time. An Excon request was
+  recorded as two events, one for sending the request and one for reading the
+  response, and neither of them covered the wait for the remote service. So a slow
+  Excon request looked fast in the event timeline, however long it really took.
+
+  An Excon request is now recorded as a single `request.excon` event covering the
+  whole request, so the event lasts as long as the request did. A request that
+  Excon retried, or that was redirected, is also one event, covering every attempt
+  or every hop.
+
+  The `response.excon`, `retry.excon` and `error.excon` events no longer exist.
+  Excon does not tell an instrumentor which request those events belonged to, so
+  `response.excon` never had a title and `error.excon` was always titled `" ://"`.
+
+  AppSignal also no longer registers itself as Excon's instrumentor. Excon allows
+  only one instrumentor, so an application that set up its own was having it
+  replaced. Your own instrumentor now keeps working.
+
+  (minor [a931661f](https://github.com/appsignal/appsignal-ruby/commit/a931661f10c8a633384ba7ff71e01a03ae3cdbe5))
+- Report which template was rendered for collection and layout render events.
+
+  Rendering a template or a partial is reported with the template's path, so you
+  can tell one from another. Rendering a collection or a layout was reported
+  without one. Every collection render in an application was recorded as the same
+  event, however many different partials it rendered, and so was every layout
+  render.
+
+  They now carry the template's path as well. A collection render reports the
+  partial it rendered for each item in the collection, and a layout render
+  reports the layout.
+
+  This means an application that renders several collections, or several layouts,
+  now sees one event per template where it used to see one event in total. That
+  is what makes it possible to tell which of them is the slow one.
+
+  (patch [79d8987a](https://github.com/appsignal/appsignal-ruby/commit/79d8987acbeb0d6d935f52f95b789f2f6a993bef))
+- Name ROM query events after ROM, rather than after the database they ran
+  against.
+
+  A query made through ROM was reported as `query.postgres`, or `query.sqlite`,
+  or whatever else the application's database was. The part after the dot is what
+  AppSignal groups events by, so an application's queries were split into a group
+  per database engine, and the same application reported one group in production
+  and another one in its test suite. Those queries are now all reported as
+  `query.rom`.
+
+  Events that dry-monitor reports and AppSignal has no formatter for are now named
+  after their event id followed by `.dry`, so an event reported as `foo` becomes
+  `foo.dry`. They had no group at all before.
+
+  If you have a dashboard, trigger or saved filter that names one of these events,
+  point it at the new name.
+
+  (patch [effe80c7](https://github.com/appsignal/appsignal-ruby/commit/effe80c7c8341ceb2d4f99714d1130b292d2b16c))
+
+### Fixed
+
+- Fix a rare hang when stopping AppSignal in an application that sends check-ins.
+  Stopping AppSignal waits for any check-in events that have not been transmitted
+  yet, and it could wait forever instead of finishing.
+
+  (patch [8956d4b8](https://github.com/appsignal/appsignal-ruby/commit/8956d4b88db9ae88a9bcd7e781ee62a79154c093))
+- Fix event formatters that register or unregister themselves. Calling
+  `unregister` on the formatter itself, as in `MyFormatter.unregister("my.event")`,
+  did nothing at all. The formatter stayed registered, and no error was raised and
+  nothing was logged to say so. Calling `register` on the formatter itself stored
+  it where AppSignal never looked for it, so it was never used to format an event.
+
+  Registering and unregistering through `Appsignal::EventFormatter` itself, as in
+  `Appsignal::EventFormatter.unregister("my.event", MyFormatter)`, was not
+  affected and keeps working the same way.
+
+  (patch [ecfa4950](https://github.com/appsignal/appsignal-ruby/commit/ecfa495081c2a47c75017727e48bf17c7ae77351))
+
 ## 4.9.1
 
 _Published on 2026-07-27._

data/build_matrix.yml

@@ -151,6 +151,7 @@ matrix:
           - "3.2.5"
           - "3.1.6"
           - "3.0.7"
+    - gem: "excon"
     - gem: "faraday-1"
     - gem: "faraday-2"
       only:

data/lib/appsignal/check_in/scheduler.rb

@@ -60,21 +60,35 @@ module Appsignal
       end
 
       def stop
-        @mutex.synchronize do
-          # Flush all events before closing the queue.
-          push_events
-        rescue ClosedQueueError
-          # The queue is already closed (by a previous call to `#stop`)
-          # so it is not possible to push events to it anymore.
+        waker = nil
+        thread = nil
+
+        begin
+          @mutex.synchronize do
+            # Flush all events before closing the queue. Do not schedule another
+            # debounce, since no more events will be transmitted after this one.
+            push_events(:reschedule => false)
+          rescue ClosedQueueError
+            # The queue is already closed (by a previous call to `#stop`)
+            # so it is not possible to push events to it anymore.
+          ensure
+            # Ensure calling `#stop` closes the queue and kills
+            # the waker thread, disallowing any further events from being
+            # scheduled with `#schedule`.
+            waker = kill_waker
+            @queue.close
+            thread = @thread
+          end
         ensure
-          # Ensure calling `#stop` closes the queue and kills
-          # the waker thread, disallowing any further events from being
-          # scheduled with `#schedule`.
-          stop_waker
-          @queue.close
-
-          # Block until the thread has finished.
-          @thread&.join
+          # Block until both threads have finished, even when stopping raised,
+          # so that events that were already pushed are still transmitted.
+          #
+          # Wait for them after the mutex has been released, because the waker
+          # thread must acquire the mutex in order to finish. Waiting for it
+          # while holding the mutex would deadlock if killing it did not take
+          # effect before it awoke from its debounce.
+          waker&.join
+          thread&.join
         end
       end
 
@@ -135,12 +149,16 @@ module Appsignal
 
       # Must be called from within a `@mutex.synchronize` block.
       def start_waker(debounce)
-        stop_waker
+        kill_waker
 
         @waker = Thread.new do
           sleep(debounce)
 
           @mutex.synchronize do
+            # Do nothing if this waker was replaced while it slept, which can
+            # happen when killing it did not take effect.
+            next unless @waker == Thread.current
+
             # Make sure this waker doesn't get killed, so it can push
             # events and schedule a new waker.
             @waker = nil
@@ -150,14 +168,22 @@ module Appsignal
       end
 
       # Must be called from within a `@mutex.synchronize` block.
-      def stop_waker
-        @waker&.kill
-        @waker&.join
+      #
+      # Returns the waker thread that was killed, if there was one, so that the
+      # caller can wait for it to finish after releasing the mutex.
+      def kill_waker
+        waker = @waker
         @waker = nil
+        waker&.kill
+        waker
       end
 
       # Must be called from within a `@mutex.synchronize` block.
-      def push_events
+      def push_events(reschedule: true)
+        # Do nothing when the queue is closed. This can happen when killing a
+        # waker thread did not take effect, and it awoke after the scheduler
+        # had been stopped.
+        return if @queue.closed?
         return if @events.empty?
 
         # Push a copy of the events to the queue, and clear the events array.
@@ -168,7 +194,7 @@ module Appsignal
         @queue.push(events)
         @events.clear
 
-        start_waker(BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS)
+        start_waker(BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS) if reschedule
       end
     end
   end

data/lib/appsignal/event_formatter/action_view/render_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module ActionView
-      class RenderFormatter
+      class RenderFormatter < Appsignal::EventFormatter
         BLANK = ""
 
         def format(payload)
@@ -30,4 +30,15 @@ if defined?(Rails)
     "render_template.action_view",
     Appsignal::EventFormatter::ActionView::RenderFormatter
   )
+  # Action View reports the template's path for these two as well, so they are
+  # titled the same way. A collection reports the partial it rendered for each
+  # item, and a layout reports itself.
+  Appsignal::EventFormatter.register(
+    "render_collection.action_view",
+    Appsignal::EventFormatter::ActionView::RenderFormatter
+  )
+  Appsignal::EventFormatter.register(
+    "render_layout.action_view",
+    Appsignal::EventFormatter::ActionView::RenderFormatter
+  )
 end

data/lib/appsignal/event_formatter/active_record/instantiation_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module ActiveRecord
-      class InstantiationFormatter
+      class InstantiationFormatter < Appsignal::EventFormatter
         def format(payload)
           [payload[:class_name], nil]
         end

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module ActiveRecord
-      class SqlFormatter
+      class SqlFormatter < Appsignal::EventFormatter
         def format(payload)
           [payload[:name], payload[:sql], SQL_BODY_FORMAT]
         end

data/lib/appsignal/event_formatter/elastic_search/search_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module ElasticSearch
-      class SearchFormatter
+      class SearchFormatter < Appsignal::EventFormatter
         def format(payload)
           [
             "#{payload[:name]}: #{payload[:klass]}",

data/lib/appsignal/event_formatter/rom/sql_formatter.rb

@@ -4,9 +4,18 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module Rom
-      class SqlFormatter
+      class SqlFormatter < Appsignal::EventFormatter
+        # dry-monitor reports an event under an id rather than a name, so the
+        # first value here names the event. Naming it after ROM keeps every ROM
+        # query in one group.
+        #
+        # The payload also says which database ROM is talking to, as Sequel's
+        # database type. That is deliberately not part of the name. It would
+        # put an application's queries in a group per database engine, so the
+        # same application would report one group in production and another in
+        # its tests.
         def format(payload)
-          ["query.#{payload[:name]}", payload[:query], SQL_BODY_FORMAT]
+          ["query.rom", payload[:query], SQL_BODY_FORMAT]
         end
       end
     end

data/lib/appsignal/event_formatter/sequel/sql_formatter.rb

@@ -9,7 +9,7 @@ module Appsignal
       # that conflict with our own sequel instrumentor. Without this event
       # formatter the sequel-rails events are recorded without the SQL query
       # that's being executed.
-      class SqlFormatter
+      class SqlFormatter < Appsignal::EventFormatter
         def format(payload)
           [payload[:name].to_s, payload[:sql], SQL_BODY_FORMAT]
         end

data/lib/appsignal/event_formatter/view_component/render_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @!visibility private
     module ViewComponent
-      class RenderFormatter
+      class RenderFormatter < Appsignal::EventFormatter
         BLANK = ""
 
         def format(payload)

data/lib/appsignal/event_formatter.rb

@@ -11,15 +11,26 @@ module Appsignal
   # So only keep global configuration as state and pass the payload around as an
   # argument if you need to use helper methods.
   class EventFormatter
+    # There is one registry of event formatters, shared by this class and by
+    # every formatter that inherits from it. It is kept in a constant because a
+    # class instance variable is not shared with subclasses. Without this, a
+    # formatter that registers or unregisters itself would read and write a
+    # registry of its own that nothing else looks at.
+    REGISTRY = {
+      :formatters => {},
+      :formatter_classes => {}
+    }.freeze
+    private_constant :REGISTRY
+
     class << self
       # @!visibility private
       def formatters
-        @formatters ||= {}
+        REGISTRY[:formatters]
       end
 
       # @!visibility private
       def formatter_classes
-        @formatter_classes ||= {}
+        REGISTRY[:formatter_classes]
       end
 
       # Registers an event formatter for a specific event name.

data/lib/appsignal/hooks/excon.rb

@@ -12,7 +12,14 @@ module Appsignal
 
       def install
         require "appsignal/integrations/excon"
-        ::Excon.defaults[:instrumentor] = Appsignal::Integrations::ExconIntegration
+        # Instrument the request at the connection, rather than by registering
+        # AppSignal as Excon's instrumentor. An instrumentor is told about a
+        # request in pieces, none of which covers the wait for the response, and
+        # there is only room for one of them, so registering ours would replace
+        # any the application set up itself.
+        ::Excon::Connection.prepend Appsignal::Integrations::ExconIntegration
+
+        Appsignal::Environment.report_enabled("excon")
       end
     end
   end

data/lib/appsignal/integrations/dry_monitor.rb

@@ -9,11 +9,16 @@ module Appsignal
 
         super
       ensure
-        title, body, body_format = Appsignal::EventFormatter.format("#{event_id}.dry", payload)
+        name = "#{event_id}.dry"
+        event_name, body, body_format = Appsignal::EventFormatter.format(name, payload)
 
+        # dry-monitor reports an event under an id, such as `sql`, rather than
+        # a name. A formatter names the event it knows about, and an event
+        # without one is named after its id in the dry-monitor group. Either
+        # way the name has a group, which is what an event is listed under.
         Appsignal::Transaction.current.finish_event(
-          title || event_id.to_s,
-          title,
+          event_name || name,
+          nil,
           body,
           body_format
         )

data/lib/appsignal/integrations/excon.rb

@@ -4,25 +4,53 @@ module Appsignal
   module Integrations
     # @!visibility private
     module ExconIntegration
-      def self.instrument(name, data, &block)
+      # The title of the event, built the way the Net::HTTP integration builds
+      # its own: the request method and where the request went, without the
+      # path, so paths stay out of event titles.
+      #
+      # Excon splits a request's data between the connection it is made on and
+      # the call that makes it, so both are read to build this. Excon defaults
+      # the method to GET itself, so the same default is applied here.
+      def self.title_for(datum)
+        method = (datum[:method] || :get).to_s.upcase
+        "#{method} #{datum[:scheme]}://#{datum[:host]}"
+      end
+
+      def request(params = {})
         # Skip when an outer HTTP client integration (Faraday) already records
-        # this request, so it isn't instrumented twice. Excon calls the
-        # instrumentor for block-less notifications too, hence the `block_given?`.
+        # this request, so it isn't instrumented twice.
         if Appsignal::Transaction.current? &&
             Appsignal::Transaction.current.http_client_events_suppressed?
-          return block_given? ? yield : nil
+          return super
         end
 
-        namespace, *event = name.split(".")
-        rails_name = [event, namespace].flatten.join(".")
+        # This method is the whole of a request. Excon sends the request here,
+        # waits for the response, reads it, and only then returns.
+        #
+        # Excon can also report a request through an instrumentor, but an
+        # instrumentor cannot measure a request. Excon runs its middleware once
+        # to send the request and again to read the response, and the reading
+        # happens in a middleware that sits outside the one that calls the
+        # instrumentor. So the wait for the remote service, which is the part of
+        # a request worth measuring, falls outside everything an instrumentor is
+        # told about.
+        #
+        # A pipelined request is the exception to this method being the whole of
+        # a request. It returns before the response is read, so its event covers
+        # only the sending.
+        title = ExconIntegration.title_for(data.merge(params))
 
-        title =
-          if rails_name == "response.excon"
-            data[:host]
+        Appsignal.instrument("request.excon", title) do
+          if Appsignal::Transaction.current?
+            # Excon retries a request, and follows a redirect, by calling this
+            # method again from inside the request it is retrying or following.
+            # Suppressing those means they count towards this event rather than
+            # becoming events of their own, so one request stays one event.
+            Appsignal::Transaction.current.suppress_http_client_events { super }
           else
-            "#{data[:method].to_s.upcase} #{data[:scheme]}://#{data[:host]}"
+            super
           end
-        Appsignal.instrument(rails_name, title, &block)
+        end
       end
     end
   end

data/lib/appsignal/version.rb

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

data/sig/appsignal.rbi

@@ -8,7 +8,7 @@
 module Appsignal
   extend Appsignal::Helpers::Metrics
   extend Appsignal::Helpers::Instrumentation
-  VERSION = T.let("4.9.1", T.untyped)
+  VERSION = T.let("4.10.0", 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.9.1
+  version: 4.10.0
 platform: java
 authors:
 - Robert Beekman