appsignal 3.8.0-java → 3.9.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea91daa3ea445a106491fad55612667e26c7198f1e601308dffae2bec2ccb0f9
-  data.tar.gz: 152b8860752631fd41779d8648a0236ee34a7bd2629452011926d6d9cb9aea2d
+  metadata.gz: 87ae30cedc24d783bcd6f28bb01bb19384e0f7a280fe2c8b89585a5161aaaf77
+  data.tar.gz: 36c1760ff247804c579bb0b7bf3db2aee1d4ed53ede1a1920d5a8a1fa762f032
 SHA512:
-  metadata.gz: 5b26be3efaa921c8402c47d6b28fd8c5603d2c3b43e496c8645b5d154f85084def2f32ac6512d708501f215072edfebf27a0fd5524031cb736e29ae4b8c113b8
-  data.tar.gz: fdc354654701f26ae6124df92b45453f1791e3fe9d66ebb36dde90492a98da9fda3394dbc30d7940d53205700a8b558b566243ca0d09e4de847dc1b07ee99c18
+  metadata.gz: ed40403d826734ba4725b087b4d52d75be79d9bfd7172d12ceba70da3393de9bf55ca02964a81104082e9058eb44d1c3795623a21b244b13905a0310f2961d16
+  data.tar.gz: 66832484c634de15a474774f49e8c38838faf4b71889c68c4ad7ef897d1ad64c119b926152a228117409103b657f8523599597394b989bbf87553d1c072bf5a1

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.9.0
+
+_Published on 2024-06-21._
+
+### Added
+
+- [500b2b4b](https://github.com/appsignal/appsignal-ruby/commit/500b2b4bb57a29663a197ff063c672e6b0c44769) minor - Report Sidekiq errors when a job is dead/discarded. Configure the new `sidekiq_report_errors` config option to "discard" to only report errors when the job is not retried further.
+
+### Changed
+
+- [c76952ff](https://github.com/appsignal/appsignal-ruby/commit/c76952ff5c8bd6e9d1d841a3aeb600b27494bb43) patch - Improve instrumentation for mounted Sinatra apps in Rails apps. The sample reported for the Sinatra request will now include the time spent in Rails and its middleware.
+- [661b8e08](https://github.com/appsignal/appsignal-ruby/commit/661b8e08de962e8f95326f0bbc9c0061b8cc0a62) patch - Support apps that have multiple Appsignal::Rack::EventHandler-s in the middleware stack.
+- [7382afa3](https://github.com/appsignal/appsignal-ruby/commit/7382afa3e9c89ce0c9f3430fb71825736e484e82) patch - Improve support for instrumentation of nested pure Rack and Sinatra apps. It will now report more of the request's duration and events. This also improves support for apps that have multiple Rack GenericInstrumentation or SinatraInstrumentation middlewares.
+
+### Fixed
+
+- [2478eb19](https://github.com/appsignal/appsignal-ruby/commit/2478eb19f51c18433785347d02af18f405eeeabd) patch - Fix issue with AppSignal getting stuck in a boot loop when loading the Sinatra integration with: `require "appsignal/integrations/sinatra"`
+  This could happen in nested applications, like a Sinatra app in a Rails app. It will now use the first config AppSignal starts with.
+
+## 3.8.1
+
+_Published on 2024-06-17._
+
+### Added
+
+- [5459a021](https://github.com/appsignal/appsignal-ruby/commit/5459a021d7d4bbbd09a0dcbdf5f3af7bf861b6f5) patch - Report the response status for Rails requests as the `response_status` tag on samples, e.g. 200, 301, 500. This tag is visible on the sample detail page.
+  
+  The response status is also reported as the `response_status` metric.
+
 ## 3.8.0
 
 _Published on 2024-06-17._

data/lib/appsignal/config.rb

@@ -47,6 +47,7 @@ module Appsignal
       ],
       :send_environment_metadata => true,
       :send_params => true,
+      :sidekiq_report_errors => "all",
       :transaction_debug_mode => false
     }.freeze
 
@@ -67,7 +68,7 @@ module Appsignal
 
     ENV_TO_KEY_MAPPING = {
       "APPSIGNAL_ACTIVE" => :active,
-      "APPSIGNAL_ACTIVE_JOB_REPORT_ERRORS" => :activejob_report_errors,
+      "APPSIGNAL_ACTIVEJOB_REPORT_ERRORS" => :activejob_report_errors,
       "APPSIGNAL_APP_NAME" => :name,
       "APPSIGNAL_BIND_ADDRESS" => :bind_address,
       "APPSIGNAL_CA_FILE_PATH" => :ca_file_path,
@@ -108,6 +109,7 @@ module Appsignal
       "APPSIGNAL_SEND_ENVIRONMENT_METADATA" => :send_environment_metadata,
       "APPSIGNAL_SEND_PARAMS" => :send_params,
       "APPSIGNAL_SEND_SESSION_DATA" => :send_session_data,
+      "APPSIGNAL_SIDEKIQ_REPORT_ERRORS" => :sidekiq_report_errors,
       "APPSIGNAL_SKIP_SESSION_DATA" => :skip_session_data,
       "APPSIGNAL_STATSD_PORT" => :statsd_port,
       "APPSIGNAL_TRANSACTION_DEBUG_MODE" => :transaction_debug_mode,
@@ -117,7 +119,7 @@ module Appsignal
     }.freeze
     # @api private
     ENV_STRING_KEYS = %w[
-      APPSIGNAL_ACTIVE_JOB_REPORT_ERRORS
+      APPSIGNAL_ACTIVEJOB_REPORT_ERRORS
       APPSIGNAL_APP_NAME
       APPSIGNAL_BIND_ADDRESS
       APPSIGNAL_CA_FILE_PATH
@@ -130,6 +132,7 @@ module Appsignal
       APPSIGNAL_LOGGING_ENDPOINT
       APPSIGNAL_PUSH_API_ENDPOINT
       APPSIGNAL_PUSH_API_KEY
+      APPSIGNAL_SIDEKIQ_REPORT_ERRORS
       APPSIGNAL_STATSD_PORT
       APPSIGNAL_WORKING_DIRECTORY_PATH
       APPSIGNAL_WORKING_DIR_PATH
@@ -563,6 +566,11 @@ module Appsignal
         config[:activejob_report_errors] = "all"
       end
 
+      if config_hash[:sidekiq_report_errors] == "discard" &&
+          !Appsignal::Hooks::SidekiqHook.version_5_1_or_higher?
+        config[:sidekiq_report_errors] = "all"
+      end
+
       config
     end
 

data/lib/appsignal/hooks/sidekiq.rb

@@ -5,10 +5,23 @@ module Appsignal
     class SidekiqHook < Appsignal::Hooks::Hook
       register :sidekiq
 
-      def dependencies_present?
+      def self.version_5_1_or_higher?
+        @version_5_1_or_higher ||=
+          if dependencies_present?
+            Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("5.1.0")
+          else
+            false
+          end
+      end
+
+      def self.dependencies_present?
         defined?(::Sidekiq)
       end
 
+      def dependencies_present?
+        self.class.dependencies_present?
+      end
+
       def install
         require "appsignal/integrations/sidekiq"
         Appsignal::Probes.register :sidekiq, Appsignal::Probes::SidekiqProbe
@@ -16,6 +29,10 @@ module Appsignal
         ::Sidekiq.configure_server do |config|
           config.error_handlers <<
             Appsignal::Integrations::SidekiqErrorHandler.new
+          if config.respond_to? :death_handlers
+            config.death_handlers <<
+              Appsignal::Integrations::SidekiqDeathHandler.new
+          end
 
           config.server_middleware do |chain|
             if chain.respond_to? :prepend

data/lib/appsignal/integrations/sidekiq.rb

@@ -4,32 +4,51 @@ require "yaml"
 
 module Appsignal
   module Integrations
+    # Handler for job death events. We get notified when a job has exhausted
+    # its retries.
+    #
+    # This is called before the SidekiqErrorHandler so it doesn't need to worry
+    # about completing the transaction.
+    #
+    # Introduced in Sidekiq 5.1.
+    class SidekiqDeathHandler
+      def call(_job_context, exception)
+        return unless Appsignal.config[:sidekiq_report_errors] == "discard"
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_error(exception)
+      end
+    end
+
     # Error handler for Sidekiq to report errors from jobs and internal Sidekiq
     # errors.
     #
     # @api private
     class SidekiqErrorHandler
+      # Sidekiq 7.1.5 introduced the third sidekiq_config argument. It is not
+      # given on older Sidekiq versions.
       def call(exception, sidekiq_context, _sidekiq_config = nil)
-        transaction =
-          if Appsignal::Transaction.current?
-            Appsignal::Transaction.current
-          else
-            # Sidekiq error outside of the middleware scope.
-            # Can be a job JSON parse error or some other error happening in
-            # Sidekiq.
-            transaction =
-              Appsignal::Transaction.create(
-                SecureRandom.uuid, # Newly generated job id
-                Appsignal::Transaction::BACKGROUND_JOB,
-                Appsignal::Transaction::GenericRequest.new({})
-              )
-            transaction.set_action_if_nil("SidekiqInternal")
-            transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
-            transaction.params = { :jobstr => sidekiq_context[:jobstr] }
-            transaction
+        if Appsignal::Transaction.current?
+          if Appsignal.config[:sidekiq_report_errors] == "all"
+            transaction = Appsignal::Transaction.current
+            transaction.set_error(exception)
           end
+        else
+          # Sidekiq error outside of the middleware scope.
+          # Can be a job JSON parse error or some other error happening in
+          # Sidekiq.
+          transaction =
+            Appsignal::Transaction.create(
+              SecureRandom.uuid, # Newly generated job id
+              Appsignal::Transaction::BACKGROUND_JOB,
+              Appsignal::Transaction::GenericRequest.new({})
+            )
+          transaction.set_action_if_nil("SidekiqInternal")
+          transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
+          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+          transaction.set_error(exception)
+        end
 
-        transaction.set_error(exception)
         Appsignal::Transaction.complete_current!
       end
     end

data/lib/appsignal/integrations/sinatra.rb

@@ -5,13 +5,15 @@ require "appsignal/rack/sinatra_instrumentation"
 
 Appsignal.internal_logger.debug("Loading Sinatra (#{Sinatra::VERSION}) integration")
 
-app_settings = ::Sinatra::Application.settings
-Appsignal.config = Appsignal::Config.new(
-  app_settings.root || Dir.pwd,
-  app_settings.environment
-)
+unless Appsignal.active?
+  app_settings = ::Sinatra::Application.settings
+  Appsignal.config = Appsignal::Config.new(
+    app_settings.root || Dir.pwd,
+    app_settings.environment
+  )
 
-Appsignal.start_logger
-Appsignal.start
+  Appsignal.start_logger
+  Appsignal.start
+end
 
 ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation) if Appsignal.active?

data/lib/appsignal/rack/abstract_middleware.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Appsignal
+  # @api private
+  module Rack
+    class AbstractMiddleware
+      def initialize(app, options = {})
+        Appsignal.internal_logger.debug "Initializing #{self.class}"
+        @app = app
+        @options = options
+        @request_class = options.fetch(:request_class, ::Rack::Request)
+        @params_method = options.fetch(:params_method, :params)
+        @instrument_span_name = options.fetch(:instrument_span_name, "process.abstract")
+      end
+
+      def call(env)
+        if Appsignal.active?
+          request = request_for(env)
+          # Supported nested instrumentation middlewares by checking if there's
+          # already a transaction active for this request.
+          wrapped_instrumentation = env.key?(Appsignal::Rack::APPSIGNAL_TRANSACTION)
+          transaction =
+            if wrapped_instrumentation
+              env[Appsignal::Rack::APPSIGNAL_TRANSACTION]
+            else
+              Appsignal::Transaction.create(
+                SecureRandom.uuid,
+                Appsignal::Transaction::HTTP_REQUEST,
+                request
+              )
+            end
+
+          add_transaction_metadata_before(transaction, request)
+          if wrapped_instrumentation
+            instrument_wrapped_request(request, transaction)
+          else
+            # Set transaction on the request environment so other nested
+            # middleware can detect if there is parent instrumentation
+            # middleware active.
+            env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
+            instrument_request(request, transaction)
+          end
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      # Another instrumentation middleware is active earlier in the stack, so
+      # don't report any exceptions here, the top instrumentation middleware
+      # will be the one reporting the exception.
+      #
+      # Either another {GenericInstrumentation} or {EventHandler} is higher in
+      # the stack and will report the exception and complete the transaction.
+      #
+      # @see {#instrument_request}
+      def instrument_wrapped_request(request, transaction)
+        instrument_app_call(request.env)
+      ensure
+        add_transaction_metadata_after(transaction, request)
+      end
+
+      # Instrument the request fully. This is used by the top instrumentation
+      # middleware in the middleware stack. Unlike
+      # {#instrument_wrapped_request} this will report any exceptions being
+      # raised.
+      #
+      # @see {#instrument_wrapped_request}
+      def instrument_request(request, transaction)
+        instrument_app_call(request.env)
+      rescue Exception => error # rubocop:disable Lint/RescueException
+        transaction.set_error(error)
+        raise error
+      ensure
+        add_transaction_metadata_after(transaction, request)
+
+        # Complete transaction because this is the top instrumentation middleware.
+        Appsignal::Transaction.complete_current!
+      end
+
+      def instrument_app_call(env)
+        Appsignal.instrument(@instrument_span_name) do
+          @app.call(env)
+        end
+      end
+
+      # Add metadata to the transaction based on the request environment.
+      # Override this method to set metadata before the app is called.
+      # Call `super` to also include the default set metadata.
+      def add_transaction_metadata_before(transaction, request)
+        params = params_for(request)
+        transaction.params = params if params
+      end
+
+      # Add metadata to the transaction based on the request environment.
+      # Override this method to set metadata after the app is called.
+      # Call `super` to also include the default set metadata.
+      def add_transaction_metadata_after(transaction, request)
+        default_action =
+          request.env["appsignal.route"] || request.env["appsignal.action"]
+        transaction.set_action_if_nil(default_action)
+        transaction.set_metadata("path", request.path)
+        transaction.set_metadata("method", request.request_method)
+        transaction.set_http_or_background_queue_start
+      end
+
+      def params_for(request)
+        return unless request.respond_to?(@params_method)
+
+        request.send(@params_method)
+      rescue => error
+        # Getting params from the request has been know to fail.
+        Appsignal.internal_logger.debug(
+          "Exception while getting params in #{self.class} from '#{@params_method}': #{error}"
+        )
+        nil
+      end
+
+      def request_for(env)
+        @request_class.new(env)
+      end
+    end
+  end
+end

data/lib/appsignal/rack/event_handler.rb

@@ -3,6 +3,7 @@
 module Appsignal
   module Rack
     APPSIGNAL_TRANSACTION = "appsignal.transaction"
+    APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
     RACK_AFTER_REPLY = "rack.after_reply"
 
     class EventHandler
@@ -16,8 +17,22 @@ module Appsignal
         )
       end
 
+      attr_reader :id
+
+      def initialize
+        @id = SecureRandom.uuid
+      end
+
+      def request_handler?(given_id)
+        id == given_id
+      end
+
       def on_start(request, _response)
+        event_handler = self
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_start") do
+          request.env[APPSIGNAL_EVENT_HANDLER_ID] ||= id
+          return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
           transaction = Appsignal::Transaction.create(
             SecureRandom.uuid,
             Appsignal::Transaction::HTTP_REQUEST,
@@ -29,6 +44,8 @@ module Appsignal
           request.env[RACK_AFTER_REPLY] << proc do
             Appsignal::Rack::EventHandler
               .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
+              next unless event_handler.request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
               transaction.finish_event("process_request.rack", "", "")
               transaction.set_http_or_background_queue_start
 
@@ -48,6 +65,8 @@ module Appsignal
 
       def on_error(request, _response, error)
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
+          return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
           transaction = request.env[APPSIGNAL_TRANSACTION]
           return unless transaction
 
@@ -55,13 +74,22 @@ module Appsignal
         end
       end
 
-      def on_finish(request, _response)
+      def on_finish(request, response)
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
+          return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
           transaction = request.env[APPSIGNAL_TRANSACTION]
           return unless transaction
 
           transaction.finish_event("process_request.rack", "", "")
+          transaction.set_tags(:response_status => response.status)
           transaction.set_http_or_background_queue_start
+          Appsignal.increment_counter(
+            :response_status,
+            1,
+            :status => response.status,
+            :namespace => format_namespace(transaction.namespace)
+          )
 
           # Make sure the current transaction is always closed when the request
           # is finished

data/lib/appsignal/rack/generic_instrumentation.rb

@@ -5,42 +5,15 @@ require "rack"
 module Appsignal
   # @api private
   module Rack
-    class GenericInstrumentation
+    class GenericInstrumentation < AbstractMiddleware
       def initialize(app, options = {})
-        Appsignal.internal_logger.debug "Initializing Appsignal::Rack::GenericInstrumentation"
-        @app = app
-        @options = options
+        options[:instrument_span_name] ||= "process_action.generic"
+        super
       end
 
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def call_with_appsignal_monitoring(env)
-        request = ::Rack::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request
-        )
-        begin
-          Appsignal.instrument("process_action.generic") do
-            @app.call(env)
-          end
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          transaction.set_error(error)
-          raise error
-        ensure
-          transaction.set_action_if_nil(env["appsignal.route"] || "unknown")
-          transaction.set_metadata("path", request.path)
-          transaction.set_metadata("method", request.request_method)
-          transaction.set_http_or_background_queue_start
-          Appsignal::Transaction.complete_current!
-        end
+      def add_transaction_metadata_after(transaction, request)
+        super
+        transaction.set_action_if_nil("unknown")
       end
     end
   end

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -28,53 +28,29 @@ module Appsignal
       end
     end
 
-    class SinatraBaseInstrumentation
+    class SinatraBaseInstrumentation < AbstractMiddleware
       attr_reader :raise_errors_on
 
       def initialize(app, options = {})
-        Appsignal.internal_logger.debug "Initializing Appsignal::Rack::SinatraBaseInstrumentation"
-        @app = app
-        @options = options
-        @raise_errors_on = raise_errors?(@app)
+        options[:request_class] ||= Sinatra::Request
+        options[:params_method] ||= :params
+        options[:instrument_span_name] ||= "process_action.sinatra"
+        super
+        @raise_errors_on = raise_errors?(app)
       end
 
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
-      end
+      private
 
-      def call_with_appsignal_monitoring(env)
-        options = { :force => @options.include?(:force) && @options[:force] }
-        options.merge!(:params_method => @options[:params_method]) if @options[:params_method]
-        request = @options.fetch(:request_class, Sinatra::Request).new(env)
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          options
-        )
-        begin
-          Appsignal.instrument("process_action.sinatra") do
-            @app.call(env)
-          end
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          transaction.set_error(error)
-          raise error
-        ensure
-          # If raise_error is off versions of Sinatra don't raise errors, but store
-          # them in the sinatra.error env var.
-          if !raise_errors_on && env["sinatra.error"] && !env["sinatra.skip_appsignal_error"]
-            transaction.set_error(env["sinatra.error"])
-          end
-          transaction.set_action_if_nil(action_name(env))
-          transaction.set_metadata("path", request.path)
-          transaction.set_metadata("method", request.request_method)
-          transaction.set_http_or_background_queue_start
-          Appsignal::Transaction.complete_current!
+      def add_transaction_metadata_after(transaction, request)
+        env = request.env
+        transaction.set_action_if_nil(action_name(env))
+        # If raise_error is off versions of Sinatra don't raise errors, but store
+        # them in the sinatra.error env var.
+        if !raise_errors_on && env["sinatra.error"] && !env["sinatra.skip_appsignal_error"]
+          transaction.set_error(env["sinatra.error"])
         end
+
+        super
       end
 
       def action_name(env)
@@ -88,8 +64,6 @@ module Appsignal
         end
       end
 
-      private
-
       def raise_errors?(app)
         app.respond_to?(:settings) &&
           app.settings.respond_to?(:raise_errors) &&

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.8.0"
+  VERSION = "3.9.0"
 end

data/lib/appsignal.rb

@@ -326,6 +326,7 @@ require "appsignal/garbage_collection"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
+require "appsignal/rack/abstract_middleware"
 require "appsignal/rack/generic_instrumentation"
 require "appsignal/rack/event_handler"
 require "appsignal/transmitter"

data/spec/lib/appsignal/config_spec.rb

@@ -187,6 +187,7 @@ describe Appsignal::Config do
         :send_environment_metadata      => true,
         :send_params                    => true,
         :send_session_data              => true,
+        :sidekiq_report_errors          => "all",
         :transaction_debug_mode         => false
       )
     end
@@ -583,6 +584,33 @@ describe Appsignal::Config do
         end
       end
     end
+
+    context "sidekiq_report_errors" do
+      let(:config_options) { { :sidekiq_report_errors => "discard" } }
+      before do
+        if Appsignal::Hooks::SidekiqHook.instance_variable_defined?(:@version_5_1_or_higher)
+          Appsignal::Hooks::SidekiqHook.remove_instance_variable(:@version_5_1_or_higher)
+        end
+      end
+
+      context "when Sidekiq >= 5.1 and 'discard'" do
+        before { stub_const("Sidekiq::VERSION", "5.1.0") }
+
+        it "does not override the sidekiq_report_errors value" do
+          expect(config[:sidekiq_report_errors]).to eq("discard")
+          expect(config.override_config[:sidekiq_report_errors]).to be_nil
+        end
+      end
+
+      context "when Sidekiq < 5.1 and 'discard'" do
+        before { stub_const("Sidekiq::VERSION", "5.0.0") }
+
+        it "sets sidekiq_report_errors to 'all'" do
+          expect(config[:sidekiq_report_errors]).to eq("all")
+          expect(config.override_config[:sidekiq_report_errors]).to eq("all")
+        end
+      end
+    end
   end
 
   describe "config keys" do