safe_request_timeout 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fb790302089e758479b7c2ec238ba5ad66d5f2cd01388c4be8679b3c15c7057
-  data.tar.gz: 9358570335e15cfe58340edb0c7b9ec9d3cf436b698fe34dd5164c8532101c6b
+  metadata.gz: c87a2c51edeb0644cea9c06b230dcc657b38fa61cf294dc395cd93396dc8e13a
+  data.tar.gz: 2b025ed3a1e7e4d1f40b29e4699ab24184de1924eaa417042c9a6cc411a03c2e
 SHA512:
-  metadata.gz: 431be87c04f338cca58f4376cbcc71a7dbe2dbafd09457d9cc427cb96a8130bbd01b5e19bc45bbb895927119b55e50ff4ba023d1e6e009a25b481866fad55091
-  data.tar.gz: 010ebff4d68d374cd403a5480a856a20d84b9fb5b73d931ec32f4821e1c7cd298c08bf0fdd4d8840c1b4297df0e75ffa6bac7be27764c4b209284635002eeb07
+  metadata.gz: a7826eb9467f5b842be5d54c5044d693288dfcf7439075e3e36b8adc7197e3100929e3505b7c2421f9e3c1b00a68388b21065f08503e64b5da20a40a69d50812
+  data.tar.gz: 6f126f39f97f17fbe778ebf3db11bf2b1c5cb5cab300bd5a98489b80f60acc9c5c27ad494035a34dc1bf9289550c77a55ba5b92709ea878e621951ecbd11f625

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.0.3
+
+### Fixed
+- Removed unused runtime dependency on the redis gem.
+- The ActiveJob timeout block no longer clears a timeout already established for the request or worker running the job (e.g. jobs run with `perform_now` inside a request, or ActiveJob jobs running with the Sidekiq middleware).
+- `SafeRequestTimeout.check_timeout!` no longer raises a second error from an enclosing timeout block when a deadline shared by nested timeout blocks has already raised.
+- ActiveRecord hooks no longer require a live database connection when they are installed. They are now added to each adapter class the first time a connection is instantiated, so applications that boot while the database is unavailable and applications with multiple databases are fully covered.
+- Registering the same hooks more than once is now a no-op instead of raising an error.
+- The transaction commit hook now clears the timeout after the commit succeeds instead of before it runs.
+
+### Changed
+- Timeout state is stored in `ActiveSupport::IsolatedExecutionState` when available (ActiveSupport 7+) so that it follows the application's configured isolation level. Otherwise it is stored in fiber-local variables as before.
+- ActiveJob and ActiveRecord integrations in the Railtie are now set up with lazy load hooks instead of loading the frameworks during initialization.
+
 ## 1.0.2
 
 ### Added

data/README.md

@@ -1,8 +1,8 @@
 # Safe Request Timeout
 
 [![Continuous Integration](https://github.com/bdurand/safe_request_timeout/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/safe_request_timeout/actions/workflows/continuous_integration.yml)
-[![Regression Test](https://github.com/bdurand/safe_request_timeout/actions/workflows/regression_test.yml/badge.svg)](https://github.com/bdurand/safe_request_timeout/actions/workflows/regression_test.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/safe_request_timeout.svg)](https://badge.fury.io/rb/safe_request_timeout)
 
 This gem provides a safe and convenient mechanism for adding a timeout mechanism to a block of code. The gem ensures that the timeout is safe to call and will not raise timeout errors from random places in your code which can leave your application in an indeterminate state.
 
@@ -16,7 +16,7 @@ There is built in support for Rails applications. For other frameworks you will
 
 ## Usage
 
-You can wrap code in a timout block.
+You can wrap code in a timeout block.
 
 ```ruby
 SafeRequestTimeout.timeout(15) do
@@ -33,7 +33,7 @@ SafeRequestTimeout.timeout(5) do
   1000.times do
     # This will raise an error if the loop takes longer than 5 seconds.
     SafeRequestTimeout.check_timeout!
-    do_somthing
+    do_something
   end
 end
 ```
@@ -41,7 +41,7 @@ end
 You can also set a timeout value retroactively from within a `timeout` block. You can use this feature to change the timeout based on application state.
 
 ```ruby
-# Setting a timeout of nil will set up a block that will never timout.
+# Setting a timeout of nil will set up a block that will never time out.
 SafeRequestTimeout.timeout(nil) do
   # Set the timeout duration to 5 seconds for non-admin users
   SafeRequestTimeout.set_timeout(5) unless current_user.admin?
@@ -58,7 +58,7 @@ SafeRequestTimeout.timeout(lambda { CurrentUser.new.admin? ? nil : 5 })
 end
 ```
 
-You can clear the timeout if you want to ensure a block of code can run without begin timed out (i.e. if you need to run cleanup code).
+You can clear the timeout if you want to ensure a block of code can run without being timed out (i.e. if you need to run cleanup code).
 
 ```ruby
 SafeRequestTimeout.timeout(5) do
@@ -71,9 +71,17 @@ SafeRequestTimeout.timeout(5) do
 end
 ```
 
+### Behavior notes
+
+- Timeout blocks can be nested. A nested block will use the soonest deadline of the nested blocks, so a nested block cannot extend a timeout set by an enclosing block. Calling `set_timeout` inside a nested block, however, replaces the deadline for that block even if it extends past the enclosing block's deadline; the enclosing deadline is restored when the nested block exits.
+
+- `SafeRequestTimeout::TimeoutError` is a subclass of `Timeout::Error` from the Ruby standard library. Generic error handling that rescues or retries on `Timeout::Error` will catch it as well.
+
+- The timeout state is stored per thread or fiber. When ActiveSupport 7+ is available, the state is stored in `ActiveSupport::IsolatedExecutionState` and follows the application's configured `active_support.isolation_level`. Otherwise the state is stored in fiber-local variables. In either case, the timeout will not be visible in new threads spawned within a timeout block (including ActiveRecord `load_async` queries), so `check_timeout!` calls in those threads will do nothing.
+
 ### Hooks
 
-You can add hooks into other classes to check the current timeout if you don't want to have to sprinkle `SafeRequestTimeout.check_timeout!` throughout your code. To do this, use the `SafeRequestTimeout.add_timeout!` method. You need to specify the class and methods where you want to add the timeout hooks:
+You can add hooks into other classes to check the current timeout if you don't want to have to sprinkle `SafeRequestTimeout.check_timeout!` throughout your code. To do this, use the `SafeRequestTimeout::Hooks.add_timeout!` method. You need to specify the class and methods where you want to add the timeout hooks:
 
 ```ruby
 # Add a timeout check to the MyDriver#make_request method.
@@ -129,13 +137,13 @@ end
 
 This gem comes with built in support for Rails applications.
 
-- The Rack middleware is added to the middleware chain. There is no timeout value set by default. You can specify a global one by setting `safe_request_timout.rack_timeout` in your Rails configuration.
+- The Rack middleware is added to the middleware chain. There is no timeout value set by default. You can specify a global one by setting `safe_request_timeout.rack_timeout` in your Rails configuration.
 
 - If Sidekiq is being used, then the Sidekiq middleware is added. Sidekiq workers can specify a timeout with the `safe_request_timeout` option.
 
-- A timeout block is added around ActiveJob execution. Jobs can specify a timeout by calling `SafeRequestTimeout.set_timeout` in the `perform` method or in a `before_perform` callback.
+- A timeout block is added around ActiveJob execution. Jobs can specify a timeout by calling `SafeRequestTimeout.set_timeout` in the `perform` method or in a `before_perform` callback. If a timeout has already been set up for the request or worker running the job (i.e. a job run with `perform_now` inside a request, or an ActiveJob running on Sidekiq with the Sidekiq middleware), then that timeout is kept rather than replaced.
 
-- A timeout check is added on all ActiveRecord queries. The timeout is cleared when a database transaction is committed so that you won't unexpectedly timeout a request after making persistent changes. You can disable these hooks by setting `safe_request_timeout.active_record_hook` to false in your Rails configuration.
+- A timeout check is added on all ActiveRecord queries. The timeout is cleared when a database transaction is committed so that you won't unexpectedly timeout a request after making persistent changes. You can disable these hooks by setting `safe_request_timeout.active_record_hook` to false in your Rails configuration. The hooks are installed on each database adapter class the first time a connection is instantiated, so no database connection is required at boot time and all databases in a multiple database configuration are covered.
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/lib/safe_request_timeout/active_record_hook.rb

@@ -2,19 +2,60 @@
 
 module SafeRequestTimeout
   class ActiveRecordHook
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    @hooked_classes = []
+
     class << self
-      # Add the timeout hook to the connection class.
+      # Add the timeout hook to a connection adapter class. If no class is given, then the
+      # hooks will be added to each connection adapter class the first time it is instantiated.
+      # This does not require a database connection to be established and covers every adapter
+      # in use, including applications with multiple databases.
       #
       # @param connection_class [Class] The class to add the timeout hook to.
       # @return [void]
       def add_timeout!(connection_class = nil)
-        connection_class ||= ::ActiveRecord::Base.connection.class
-        exec_method = (connection_class.instance_methods.include?(:internal_exec_query) ? :internal_exec_query : :exec_query)
+        if connection_class
+          add_hooks(connection_class)
+        else
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(AdapterInitializer)
+          # Add the hooks to any adapter that already has a live connection.
+          if ::ActiveRecord::Base.connected?
+            ::ActiveRecord::Base.connection_pool.with_connection do |connection|
+              add_hooks(connection.class)
+            end
+          end
+        end
+      end
+
+      private
 
-        SafeRequestTimeout::Hooks.add_timeout!(connection_class, [exec_method])
+      def add_hooks(connection_class)
+        MUTEX.synchronize do
+          return if @hooked_classes.include?(connection_class)
 
-        SafeRequestTimeout::Hooks.clear_timeout!(connection_class, [:commit_db_transaction])
+          exec_method = (connection_class.method_defined?(:internal_exec_query) ? :internal_exec_query : :exec_query)
+          SafeRequestTimeout::Hooks.add_timeout!(connection_class, [exec_method])
+          SafeRequestTimeout::Hooks.clear_timeout!(connection_class, [:commit_db_transaction])
+
+          @hooked_classes << connection_class
+        end
       end
     end
+
+    # Prepended to AbstractAdapter so the timeout hooks are added to each concrete adapter
+    # class the first time it is instantiated. The hooks must go on the concrete class since
+    # adapters can override the hooked methods.
+    module AdapterInitializer
+      ruby_major, ruby_minor, _ = RUBY_VERSION.split(".").collect(&:to_i)
+      splat_args = ((ruby_major >= 3 || (ruby_major == 2 && ruby_minor >= 7)) ? "..." : "*args, &block")
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def initialize(#{splat_args})
+          super(#{splat_args})
+          SafeRequestTimeout::ActiveRecordHook.add_timeout!(self.class)
+        end
+      RUBY
+    end
   end
 end

data/lib/safe_request_timeout/hooks.rb

@@ -4,12 +4,17 @@ module SafeRequestTimeout
   # Hooks into other classes from other libraries with timeout blocks. This allows
   # timeouts to be automatically checked before making requests to external services.
   module Hooks
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
     class << self
       # Hooks into a class by surrounding specified instance methods with timeout checks.
       def add_timeout!(klass, methods, module_name = nil)
         hooks_module = create_module(klass, module_name, "AddTimeout")
 
         Array(methods).each do |method_name|
+          next if hooks_module.method_defined?(method_name)
+
           hooks_module.class_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{method_name}(#{splat_args})
               SafeRequestTimeout.check_timeout!
@@ -25,10 +30,13 @@ module SafeRequestTimeout
         hooks_module = create_module(klass, module_name, "ClearTimeout")
 
         Array(methods).each do |method_name|
+          next if hooks_module.method_defined?(method_name)
+
           hooks_module.class_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{method_name}(#{splat_args})
+              result = super(#{splat_args})
               SafeRequestTimeout.clear_timeout
-              super(#{splat_args})
+              result
             end
           RUBY
         end
@@ -41,17 +49,20 @@ module SafeRequestTimeout
       def create_module(klass, module_name, module_type)
         # Create a module that will be prepended to the specified class.
         unless module_name
-          camelized_name = name.to_s.gsub(/[^a-z0-9]+([a-z0-9])/i) { |m| m[m.length - 1, m.length].upcase }
+          camelized_name = name.to_s.gsub(/[^a-z0-9]+([a-z0-9])/i) { |m| m[-1].upcase }
           camelized_name = "#{camelized_name[0].upcase}#{camelized_name[1, camelized_name.length]}"
           module_name = "#{klass.name.split("::").join}#{camelized_name}#{module_type}"
         end
 
-        if const_defined?(module_name)
-          raise ArgumentError.new("Cannot create duplicate #{module_name} for hooking #{name} into #{klass.name}")
+        # Reuse an existing module so that registering the same hooks twice is a no-op.
+        MUTEX.synchronize do
+          if const_defined?(module_name, false)
+            const_get(module_name, false)
+          else
+            # Dark arts & witchery to dynamically generate the module methods.
+            const_set(module_name, Module.new)
+          end
         end
-
-        # Dark arts & witchery to dynamically generate the module methods.
-        const_set(module_name, Module.new)
       end
 
       def splat_args

data/lib/safe_request_timeout/railtie.rb

@@ -9,17 +9,24 @@ module SafeRequestTimeout
     initializer "safe_request_timeout" do |app|
       if app.config.safe_request_timeout.active_record_hook
         ActiveSupport.on_load(:active_record) do
-          begin
-            SafeRequestTimeout::ActiveRecordHook.add_timeout!
-          rescue ActiveRecord::ActiveRecordError => e
-            Rails.logger&.warn("Could not add ActiveRecord hook for SafeRequestTimeout: #{e.inspect}")
-          end
+          SafeRequestTimeout::ActiveRecordHook.add_timeout!
+        rescue => e
+          # The hook is an optional safeguard, so any error installing it (including an
+          # unexpected incompatibility with the ActiveRecord version in use) is logged
+          # rather than allowed to prevent the application from booting.
+          Rails.logger&.warn("Could not add ActiveRecord hook for SafeRequestTimeout: #{e.inspect}")
         end
       end
 
-      if defined?(ActiveJob::Base.around_perform)
-        ActiveJob::Base.around_perform do |job, block|
-          SafeRequestTimeout.timeout(nil, &block)
+      ActiveSupport.on_load(:active_job) do
+        around_perform do |job, block|
+          # Open a timeout context so jobs can call set_timeout, but don't replace a timeout
+          # already established for the request or worker that is running the job.
+          if SafeRequestTimeout.time_elapsed
+            block.call
+          else
+            SafeRequestTimeout.timeout(nil, &block)
+          end
         end
       end
 

data/lib/safe_request_timeout.rb

@@ -31,8 +31,9 @@ module SafeRequestTimeout
     def timeout(duration, &block)
       duration = duration.call if duration.respond_to?(:call)
 
-      previous_start_at = Thread.current[:safe_request_timeout_started_at]
-      previous_timeout_at = Thread.current[:safe_request_timeout_timeout_at]
+      state = current_state
+      previous_start_at = state[:safe_request_timeout_started_at]
+      previous_timeout_at = state[:safe_request_timeout_timeout_at]
 
       start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       timeout_at = start_at + duration if duration
@@ -41,12 +42,18 @@ module SafeRequestTimeout
       end
 
       begin
-        Thread.current[:safe_request_timeout_started_at] = start_at
-        Thread.current[:safe_request_timeout_timeout_at] = timeout_at
+        state[:safe_request_timeout_started_at] = start_at
+        state[:safe_request_timeout_timeout_at] = timeout_at
         yield
       ensure
-        Thread.current[:safe_request_timeout_started_at] = previous_start_at
-        Thread.current[:safe_request_timeout_timeout_at] = previous_timeout_at
+        # If the deadline shared with the parent block was already raised by check_timeout!,
+        # don't re-arm it when restoring the parent block's state.
+        if previous_timeout_at && previous_timeout_at == state[:safe_request_timeout_fired_at]
+          previous_timeout_at = nil
+        end
+        state[:safe_request_timeout_started_at] = previous_start_at
+        state[:safe_request_timeout_timeout_at] = previous_timeout_at
+        state[:safe_request_timeout_fired_at] = nil if previous_start_at.nil?
       end
     end
 
@@ -54,7 +61,7 @@ module SafeRequestTimeout
     #
     # @return [Boolean] true if the current timeout block has timed out
     def timed_out?
-      timeout_at = Thread.current[:safe_request_timeout_timeout_at]
+      timeout_at = current_state[:safe_request_timeout_timeout_at]
       !!timeout_at && Process.clock_gettime(Process::CLOCK_MONOTONIC) > timeout_at
     end
 
@@ -66,7 +73,9 @@ module SafeRequestTimeout
     # @raise [SafeRequestTimeout::TimeoutError] if the current timeout block has timed out
     def check_timeout!
       if timed_out?
-        Thread.current[:safe_request_timeout_timeout_at] = nil
+        state = current_state
+        state[:safe_request_timeout_fired_at] = state[:safe_request_timeout_timeout_at]
+        state[:safe_request_timeout_timeout_at] = nil
         raise TimeoutError.new("after #{time_elapsed.round(6)} seconds")
       end
     end
@@ -76,7 +85,7 @@ module SafeRequestTimeout
     #
     # @return [Float, nil] the number of seconds remaining in the current timeout block
     def time_remaining
-      timeout_at = Thread.current[:safe_request_timeout_timeout_at]
+      timeout_at = current_state[:safe_request_timeout_timeout_at]
       [timeout_at - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0.0].max if timeout_at
     end
 
@@ -85,7 +94,7 @@ module SafeRequestTimeout
     #
     # @return [Float, nil] the number of seconds elapsed in the current timeout block began
     def time_elapsed
-      start_at = Thread.current[:safe_request_timeout_started_at]
+      start_at = current_state[:safe_request_timeout_started_at]
       Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_at if start_at
     end
 
@@ -95,12 +104,17 @@ module SafeRequestTimeout
     #
     # @return [void]
     def set_timeout(duration)
-      if Thread.current[:safe_request_timeout_started_at]
+      state = current_state
+      if state[:safe_request_timeout_started_at]
         start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         duration = duration.call if duration.respond_to?(:call)
         timeout_at = start_at + duration if duration
-        Thread.current[:safe_request_timeout_started_at] = start_at
-        Thread.current[:safe_request_timeout_timeout_at] = timeout_at
+        state[:safe_request_timeout_started_at] = start_at
+        state[:safe_request_timeout_timeout_at] = timeout_at
+        # Arming a new deadline invalidates any record of a previously fired deadline so
+        # that the ensure block in `timeout` cannot mistake the new deadline for one that
+        # has already raised.
+        state[:safe_request_timeout_fired_at] = nil if timeout_at
       end
     end
 
@@ -116,6 +130,19 @@ module SafeRequestTimeout
         set_timeout(nil)
       end
     end
+
+    private
+
+    # Storage for the timeout state. ActiveSupport::IsolatedExecutionState is used when it
+    # is available so that the state follows the application's configured isolation level
+    # (:thread or :fiber). Otherwise the state is fiber local.
+    def current_state
+      if defined?(::ActiveSupport::IsolatedExecutionState)
+        ::ActiveSupport::IsolatedExecutionState
+      else
+        ::Thread.current
+      end
+    end
   end
 end
 

data/safe_request_timeout.gemspec

@@ -8,6 +8,12 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/bdurand/safe_request_timeout"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
@@ -26,9 +32,5 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "redis"
-
-  spec.add_development_dependency "bundler"
-
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 2.6"
 end

metadata

@@ -1,44 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safe_request_timeout
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-11 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description:
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 email:
 - bbdurand@gmail.com
 executables: []
@@ -49,7 +19,6 @@ files:
 - MIT_LICENSE.txt
 - README.md
 - VERSION
-- dependabot.yml
 - lib/safe_request_timeout.rb
 - lib/safe_request_timeout/active_record_hook.rb
 - lib/safe_request_timeout/hooks.rb
@@ -61,8 +30,10 @@ files:
 homepage: https://github.com/bdurand/safe_request_timeout
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://github.com/bdurand/safe_request_timeout
+  source_code_uri: https://github.com/bdurand/safe_request_timeout
+  changelog_uri: https://github.com/bdurand/safe_request_timeout/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -70,15 +41,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Mechanism for safely aborting long-running requests after a specified timeout.
 test_files: []

data/dependabot.yml

@@ -1,12 +0,0 @@
-# Dependabot update strategy
-version: 2
-updates:
-  - package-ecosystem: bundler
-    directory: "/"
-    schedule:
-      interval: daily
-    allow:
-      # Automatically keep all runtime dependencies updated
-      - dependency-name: "*"
-        dependency-type: "production"
-    versioning-strategy: lockfile-only