appsignal 5.0.2 → 5.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c73f2ecdc63058c7961981d8fc044c0b2b0801d4cd2887dd1295ffd356975e5
-  data.tar.gz: d28d7b78d58597f8e4ce6f37111110405acd0cdcdc38efc290b6131c57501c86
+  metadata.gz: 9297a2ba1c7e66ca0b87fb0e905576fe99c7ff197a591abfbd13d05c79f75ba3
+  data.tar.gz: 94ca97dc758b43867456f9ca351085ba0f43945d55c94ef777d83af89a77c2d2
 SHA512:
-  metadata.gz: 63f7e6922357cb88e8b52623278deb0bc1037087f8df262798a53af3a3ac5e66f0340959ca5b9858d391ac50f7ebc8923b91381331f09b62b2d39a9401af18fe
-  data.tar.gz: 1dcb25bc71bed601aac8cf9a499182227f8f8b36c2550a203780b57a80f8758a061fb6a7c7b9427ec39b46828abfb6a6c47225aa602f89516d0d6142aa36878c
+  metadata.gz: 133d0b1b1ed03a1ab40eb3cbc56e37171d50d4c1699727fe5e145be3b5af98b3fd87f587abae49918bd967ceebb0c7918f58b416b6b63870db843f7d79adb1b9
+  data.tar.gz: c848362c51a845da9b0f5be46180d857b14a58152765664d24abdf89244fb4c7efe9569a18dda2a3549e04cbb21465468eef5d6fd12164c8c5e73954f777921f

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # AppSignal for Ruby gem Changelog
 
+## 5.0.4
+
+_Published on 2026-10-09._
+
+### Fixed
+
+- Fix an issue where transactions would be reused across requests when an error happened before the transaction could be closed, which would lead to errors being returned by the app itself. (patch [65ff0be0](https://github.com/appsignal/appsignal-ruby/commit/65ff0be0c3d4dea2eb9ed5bdb81004e899e6edf4))
+
+## 5.0.3
+
+_Published on 2026-10-08._
+
+### Fixed
+
+- In collector mode, report counter metrics correctly from processes forked after AppSignal starts, such as Puma workers when using `preload_app!`. Before this change, applications running several forked processes would lose data points or report incorrect values for them. (patch [4e5a3e78](https://github.com/appsignal/appsignal-ruby/commit/4e5a3e781b4ce2b2620b172a15198a2a59e0ebee))
+
 ## 5.0.2
 
 _Published on 2026-10-06._

data/lib/appsignal/opentelemetry/process_resource.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Appsignal
+  module OpenTelemetry
+    # @!visibility private
+    #
+    # The resource attributes that identify the current process:
+    # `service.instance.id` and `process.pid`. The OpenTelemetry providers are
+    # built once, so a process forked after that inherits its parent's values
+    # until {.attach_fork_hook} refreshes them in the child.
+    module ProcessResource
+      SERVICE_INSTANCE_ID = "service.instance.id"
+      PROCESS_PID = "process.pid"
+      REFRESH_FAILED = "Could not refresh the OpenTelemetry resource after fork"
+
+      class << self
+        # A random UUIDv4, generated again when the process ID changes.
+        def service_instance_id
+          pid = Process.pid
+          unless @service_instance_id_pid == pid
+            @service_instance_id = SecureRandom.uuid
+            @service_instance_id_pid = pid
+          end
+          @service_instance_id
+        end
+
+        def resource
+          ::OpenTelemetry::SDK::Resources::Resource.create(
+            SERVICE_INSTANCE_ID => service_instance_id,
+            PROCESS_PID => Process.pid
+          )
+        end
+
+        def attach_fork_hook
+          return if @fork_hook_attached
+
+          Process.singleton_class.prepend(ForkHook)
+          @fork_hook_attached = true
+        end
+
+        def before_fork
+          return unless Appsignal::OpenTelemetry.started?
+
+          providers.transform_values do |provider|
+            current = current_resource(provider)
+            current && attribute(current, SERVICE_INSTANCE_ID)
+          end
+        rescue => e
+          log_failure("#{e.class}: #{e.message}")
+          nil
+        end
+
+        def after_fork(instance_ids_before_fork)
+          return unless instance_ids_before_fork
+
+          update = resource
+          providers.each do |name, provider|
+            refresh(name, provider, update, instance_ids_before_fork[name])
+          end
+        rescue => e
+          log_failure("#{e.class}: #{e.message}")
+        end
+
+        private
+
+        def providers
+          {
+            "tracer" => ::OpenTelemetry.tracer_provider,
+            "meter" => ::OpenTelemetry.meter_provider,
+            "logger" => ::OpenTelemetry.logger_provider
+          }
+        end
+
+        def refresh(name, provider, update, instance_id_before_fork)
+          current = current_resource(provider)
+          unless current
+            log_failure("the #{name} provider's resource could not be read")
+            return
+          end
+          return unless attribute(current, SERVICE_INSTANCE_ID) == instance_id_before_fork
+
+          refreshed = current.merge(update)
+          write_resource(provider, refreshed)
+          return if current_resource(provider).equal?(refreshed)
+
+          log_failure("the #{name} provider did not keep the new resource")
+        end
+
+        # The SDK providers take their resource only in their constructors, and
+        # read it from `@resource` when they export.
+        def current_resource(provider)
+          if provider.respond_to?(:resource)
+            resource = provider.resource
+            unless provider.respond_to?(:resource=)
+              # Without a setter, only `@resource` can be written, and it isn't there.
+              return unless provider.instance_variable_defined?(:@resource)
+              # The reader returns something else, so writing `@resource` would change nothing.
+              return unless provider.instance_variable_get(:@resource).equal?(resource)
+            end
+          elsif provider.instance_variable_defined?(:@resource)
+            resource = provider.instance_variable_get(:@resource)
+          end
+          # If it's not a resource, it isn't what the provider exports.
+          resource if resource.is_a?(::OpenTelemetry::SDK::Resources::Resource)
+        end
+
+        def write_resource(provider, resource)
+          if provider.respond_to?(:resource=)
+            provider.resource = resource
+          else
+            provider.instance_variable_set(:@resource, resource)
+          end
+        end
+
+        def attribute(resource, key)
+          resource.attribute_enumerator.each { |k, v| return v if k == key }
+          nil
+        end
+
+        def log_failure(reason)
+          Appsignal.internal_logger.warn("#{REFRESH_FAILED}: #{reason}")
+        end
+      end
+
+      module ForkHook
+        def _fork
+          instance_ids = ProcessResource.before_fork
+          pid = super
+          ProcessResource.after_fork(instance_ids) if pid.zero?
+          pid
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/opentelemetry.rb

@@ -8,6 +8,7 @@ require "appsignal/opentelemetry/http_method"
 require "appsignal/opentelemetry/http_response"
 require "appsignal/opentelemetry/http_server_request"
 require "appsignal/opentelemetry/messaging"
+require "appsignal/opentelemetry/process_resource"
 require "appsignal/opentelemetry/proxied_exporter"
 require "appsignal/opentelemetry/rendering"
 require "appsignal/opentelemetry/sql_db_system"
@@ -59,7 +60,9 @@ module Appsignal
         # `LoggerProvider` take a `resource:` kwarg that replaces (not
         # merges), so we do the merge ourselves and use the same merged
         # resource for the tracer provider to keep all three in sync.
-        resource = ::OpenTelemetry::SDK::Resources::Resource.default.merge(build_resource(config))
+        resource = ProcessResource.resource
+          .merge(::OpenTelemetry::SDK::Resources::Resource.default)
+          .merge(build_resource(config))
 
         span_exporter = build_exporter(
           ::OpenTelemetry::Exporter::OTLP::Exporter,
@@ -103,6 +106,7 @@ module Appsignal
         )
 
         @started = true
+        ProcessResource.attach_fork_hook
       rescue LoadError => e
         @started = false
         Appsignal::Utils::StdoutAndLoggerMessage.error(

data/lib/appsignal/rack/event_handler.rb

@@ -37,6 +37,15 @@ module Appsignal
         )
       end
 
+      # @api private
+      def self.complete_transaction(transaction)
+        safe_execution("Appsignal::Rack::EventHandler#complete_transaction") do
+          transaction.complete
+        end
+      ensure
+        Appsignal::Transaction.clear_current_transaction!
+      end
+
       # @api private
       attr_reader :id
       attr_writer :using_appsignal_event_middleware
@@ -68,29 +77,7 @@ module Appsignal
             :opentelemetry_context => Appsignal::OpenTelemetry.extract_rack_context(request.env),
             :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
           )
-          # Describes the transaction's span as an incoming HTTP request.
-          # Together with the SERVER span kind the transaction already carries,
-          # this is what the trace timeline reads to recognize a web request.
-          #
-          # Set before the event below starts, because attributes go on
-          # whichever span is open and these belong on the transaction's own
-          # span. That event stays open until the response finishes, so there is
-          # no later point in the request at which these could be set.
-          transaction.add_opentelemetry_attributes(
-            Appsignal::OpenTelemetry::HttpServerRequest.attributes_for(
-              :method => Appsignal::Rack::Utils.request_method_from(request),
-              :path => Appsignal::Rack::Utils.request_value_from(request, :path),
-              :scheme => Appsignal::Rack::Utils.request_value_from(request, :scheme),
-              :query => Appsignal::Rack::Utils.request_value_from(request, :query_string),
-              :host => Appsignal::Rack::Utils.request_value_from(request, :hostname),
-              :port => Appsignal::Rack::Utils.request_value_from(request, :port),
-              :protocol =>
-                Appsignal::Rack::Utils.request_env_value_from(request, "SERVER_PROTOCOL")
-            )
-          )
-          transaction.start_event(
-            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
-          )
+          # Register cleanup before request instrumentation can raise.
           request.env[APPSIGNAL_TRANSACTION] = transaction
 
           request.env[RACK_AFTER_REPLY] ||= []
@@ -113,9 +100,32 @@ module Appsignal
             # just a fallback if that doesn't get called.
             #
             # One such scenario is when a Puma "lowlevel_error" occurs.
-            transaction.complete
-            Appsignal::Transaction.clear_current_transaction!
+            Appsignal::Rack::EventHandler.complete_transaction(transaction)
           end
+
+          # Describes the transaction's span as an incoming HTTP request.
+          # Together with the SERVER span kind the transaction already carries,
+          # this is what the trace timeline reads to recognize a web request.
+          #
+          # Set before the event below starts, because attributes go on
+          # whichever span is open and these belong on the transaction's own
+          # span. That event stays open until the response finishes, so there is
+          # no later point in the request at which these could be set.
+          transaction.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpServerRequest.attributes_for(
+              :method => Appsignal::Rack::Utils.request_method_from(request),
+              :path => Appsignal::Rack::Utils.request_value_from(request, :path),
+              :scheme => Appsignal::Rack::Utils.request_value_from(request, :scheme),
+              :query => Appsignal::Rack::Utils.request_value_from(request, :query_string),
+              :host => Appsignal::Rack::Utils.request_value_from(request, :hostname),
+              :port => Appsignal::Rack::Utils.request_value_from(request, :port),
+              :protocol =>
+                Appsignal::Rack::Utils.request_env_value_from(request, "SERVER_PROTOCOL")
+            )
+          )
+          transaction.start_event(
+            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+          )
         end
       end
 
@@ -188,8 +198,7 @@ module Appsignal
 
         # Make sure the current transaction is always closed when the request
         # is finished
-        transaction.complete
-        Appsignal::Transaction.clear_current_transaction!
+        self.class.complete_transaction(transaction)
       end
 
       private

data/lib/appsignal/transaction/opentelemetry_backend.rb

@@ -446,6 +446,7 @@ module Appsignal
           emit_queue_duration_metric if should_report?
           report_allocation_count
         end
+      ensure
         teardown
       end
 

data/lib/appsignal/transaction.rb

@@ -316,26 +316,30 @@ module Appsignal
         return
       end
 
-      # If the transaction is a duplicate, we don't want to finish it,
-      # because we want its finish time to be the finish time of the
-      # original transaction.
-      # Duplicate transactions should always be sampled, as we only
-      # create duplicates for errors, which are always sampled.
-      should_sample = true
-
-      unless duplicate?
-        self.class.last_errors = @errors.to_a
-        should_sample = @backend.finish
-      end
-
-      report_errors
+      begin
+        # If the transaction is a duplicate, we don't want to finish it,
+        # because we want its finish time to be the finish time of the
+        # original transaction.
+        # Duplicate transactions should always be sampled, as we only
+        # create duplicates for errors, which are always sampled.
+        should_sample = true
+
+        unless duplicate?
+          self.class.last_errors = @errors.to_a
+          should_sample = @backend.finish
+        end
 
-      run_before_complete_hooks
+        report_errors
 
-      sample_data if should_sample
+        run_before_complete_hooks
 
-      @completed = true
-      @backend.complete
+        sample_data if should_sample
+      ensure
+        # Release backend resources even when sample data cannot be collected
+        # or serialized. In collector mode this also detaches the span context.
+        @completed = true
+        @backend.complete
+      end
     end
 
     # @!visibility private

data/lib/appsignal/version.rb

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

data/sig/appsignal.rbi

@@ -8,7 +8,7 @@
 module Appsignal
   extend Appsignal::Helpers::Metrics
   extend Appsignal::Helpers::Instrumentation
-  VERSION = T.let("5.0.2", T.untyped)
+  VERSION = T.let("5.0.4", 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: 5.0.2
+  version: 5.0.4
 platform: ruby
 authors:
 - Robert Beekman
@@ -292,6 +292,7 @@ files:
 - lib/appsignal/opentelemetry/http_response.rb
 - lib/appsignal/opentelemetry/http_server_request.rb
 - lib/appsignal/opentelemetry/messaging.rb
+- lib/appsignal/opentelemetry/process_resource.rb
 - lib/appsignal/opentelemetry/proxied_exporter.rb
 - lib/appsignal/opentelemetry/rendering.rb
 - lib/appsignal/opentelemetry/sql_db_system.rb