rack-timeout 0.4.2 → 0.6.3

data/lib/rack/timeout/core.rb

@@ -3,7 +3,6 @@ require "securerandom"
 require_relative "support/monotonic_time"
 require_relative "support/scheduler"
 require_relative "support/timeout"
-require_relative "legacy"
 
 module Rack
   class Timeout
@@ -31,6 +30,7 @@ module Rack
       :service,   # time rack spent processing the request (updated ~ every second)
       :timeout,   # the actual computed timeout to be used for this request
       :state,     # the request's current state, see VALID_STATES below
+      :term,
     ) {
       def ms(k)   # helper method used for formatting values in milliseconds
         "%.fms" % (self[k] * 1000) if self[k]
@@ -43,12 +43,14 @@ module Rack
       :timed_out, # This request has run for too long and we're raising a timeout error in it
       :completed, # We're done with this request (also set after having timed out a request)
       ]
-    ENV_INFO_KEY = "rack-timeout.info" # key under which each request's RequestDetails instance is stored in its env.
+    ENV_INFO_KEY = "rack-timeout.info".freeze # key under which each request's RequestDetails instance is stored in its env.
+    HTTP_X_REQUEST_ID = "HTTP_X_REQUEST_ID".freeze # key where request id is stored if generated by upstream client/proxy
+    ACTION_DISPATCH_REQUEST_ID = "action_dispatch.request_id".freeze # key where request id is stored if generated by action dispatch
 
     # helper methods to read timeout properties. Ensure they're always positive numbers or false. When set to false (or 0), their behaviour is disabled.
     def read_timeout_property value, default
       case value
-      when nil   ; default
+      when nil   ; read_timeout_property default, default
       when false ; false
       when 0     ; false
       else
@@ -61,13 +63,20 @@ module Rack
       :service_timeout,   # How long the application can take to complete handling the request once it's passed down to it.
       :wait_timeout,      # How long the request is allowed to have waited before reaching rack. If exceeded, the request is 'expired', i.e. dropped entirely without being passed down to the application.
       :wait_overtime,     # Additional time over @wait_timeout for requests with a body, like POST requests. These may take longer to be received by the server before being passed down to the application, but should not be expired.
-      :service_past_wait  # when false, reduces the request's computed timeout from the service_timeout value if the complete request lifetime (wait + service) would have been longer than wait_timeout (+ wait_overtime when applicable). When true, always uses the service_timeout value. we default to false under the assumption that the router would drop a request that's not responded within wait_timeout, thus being there no point in servicing beyond seconds_service_left (see code further down) up until service_timeout.
-
-    def initialize(app, service_timeout:nil, wait_timeout:nil, wait_overtime:nil, service_past_wait:false)
-      @service_timeout   = read_timeout_property service_timeout, 15
-      @wait_timeout      = read_timeout_property wait_timeout,    30
-      @wait_overtime     = read_timeout_property wait_overtime,   60
-      @service_past_wait = service_past_wait
+      :service_past_wait, # when false, reduces the request's computed timeout from the service_timeout value if the complete request lifetime (wait + service) would have been longer than wait_timeout (+ wait_overtime when applicable). When true, always uses the service_timeout value. we default to false under the assumption that the router would drop a request that's not responded within wait_timeout, thus being there no point in servicing beyond seconds_service_left (see code further down) up until service_timeout.
+      :term_on_timeout
+
+    def initialize(app, service_timeout:nil, wait_timeout:nil, wait_overtime:nil, service_past_wait:"not_specified", term_on_timeout: nil)
+      @term_on_timeout   = read_timeout_property term_on_timeout, ENV.fetch("RACK_TIMEOUT_TERM_ON_TIMEOUT", 0).to_i
+      @service_timeout   = read_timeout_property service_timeout, ENV.fetch("RACK_TIMEOUT_SERVICE_TIMEOUT", 15).to_i
+      @wait_timeout      = read_timeout_property wait_timeout,    ENV.fetch("RACK_TIMEOUT_WAIT_TIMEOUT", 30).to_i
+      @wait_overtime     = read_timeout_property wait_overtime,   ENV.fetch("RACK_TIMEOUT_WAIT_OVERTIME", 60).to_i
+      @service_past_wait = service_past_wait == "not_specified" ? ENV.fetch("RACK_TIMEOUT_SERVICE_PAST_WAIT", false).to_s != "false" : service_past_wait
+
+      Thread.main['RACK_TIMEOUT_COUNT'] ||= 0
+      if @term_on_timeout
+        raise "Current Runtime does not support processes" unless ::Process.respond_to?(:fork)
+      end
       @app = app
     end
 
@@ -75,7 +84,7 @@ module Rack
     RT = self # shorthand reference
     def call(env)
       info      = (env[ENV_INFO_KEY] ||= RequestDetails.new)
-      info.id ||= env["HTTP_X_REQUEST_ID"] || SecureRandom.hex
+      info.id ||= env[HTTP_X_REQUEST_ID] || env[ACTION_DISPATCH_REQUEST_ID] || SecureRandom.uuid
 
       time_started_service = Time.now                      # The wall time the request started being processed by rack
       ts_started_service   = fsecs                         # The monotonic time the request started being processed by rack
@@ -89,7 +98,9 @@ module Rack
         seconds_waited          = 0 if seconds_waited < 0                  # make up for potential time drift between the routing server and the application server
         final_wait_timeout      = wait_timeout + effective_overtime        # how long the request will be allowed to have waited
         seconds_service_left    = final_wait_timeout - seconds_waited      # first calculation of service timeout (relevant if request doesn't get expired, may be overriden later)
-        info.wait, info.timeout = seconds_waited, final_wait_timeout       # updating the info properties; info.timeout will be the wait timeout at this point
+        info.wait               = seconds_waited                           # updating the info properties; info.timeout will be the wait timeout at this point
+        info.timeout            = final_wait_timeout
+
         if seconds_service_left <= 0 # expire requests that have waited for too long in the queue (as they are assumed to have been dropped by the web server / routing layer at this point)
           RT._set_state! env, :expired
           raise RequestExpiryError.new(env), "Request older than #{info.ms(:timeout)}."
@@ -102,7 +113,7 @@ module Rack
       # compute actual timeout to be used for this request; if service_past_wait is true, this is just service_timeout. If false (the default), and wait time was determined, we'll use the shortest value between seconds_service_left and service_timeout. See comment above at service_past_wait for justification.
       info.timeout = service_timeout # nice and simple, when service_past_wait is true, not so much otherwise:
       info.timeout = seconds_service_left if !service_past_wait && seconds_service_left && seconds_service_left > 0 && seconds_service_left < service_timeout
-
+      info.term    = term_on_timeout
       RT._set_state! env, :ready                            # we're good to go, but have done nothing yet
 
       heartbeat_event = nil                                 # init var so it's in scope for following proc
@@ -115,7 +126,22 @@ module Rack
 
       timeout = RT::Scheduler::Timeout.new do |app_thread|  # creates a timeout instance responsible for timing out the request. the given block runs if timed out
         register_state_change.call :timed_out
-        app_thread.raise(RequestTimeoutException.new(env), "Request #{"waited #{info.ms(:wait)}, then " if info.wait}ran for longer than #{info.ms(:timeout)}")
+
+        message = "Request "
+        message << "waited #{info.ms(:wait)}, then " if info.wait
+        message << "ran for longer than #{info.ms(:timeout)} "
+        if term_on_timeout
+          Thread.main['RACK_TIMEOUT_COUNT'] += 1
+
+          if Thread.main['RACK_TIMEOUT_COUNT'] >= @term_on_timeout
+            message << ", sending SIGTERM to process #{Process.pid}"
+            Process.kill("SIGTERM", Process.pid)
+          else
+            message << ", #{Thread.main['RACK_TIMEOUT_COUNT']}/#{term_on_timeout} timeouts allowed before SIGTERM for process #{Process.pid}"
+          end
+        end
+
+        app_thread.raise(RequestTimeoutException.new(env), message)
       end
 
       response = timeout.timeout(info.timeout) do           # perform request with timeout
@@ -146,8 +172,9 @@ module Rack
     # This is a code extraction for readability, this method is only called from a single point.
     RX_NGINX_X_REQUEST_START  = /^(?:t=)?(\d+)\.(\d{3})$/
     RX_HEROKU_X_REQUEST_START = /^(\d+)$/
+    HTTP_X_REQUEST_START = "HTTP_X_REQUEST_START".freeze
     def self._read_x_request_start(env)
-      return unless s = env["HTTP_X_REQUEST_START"]
+      return unless s = env[HTTP_X_REQUEST_START]
       return unless m = s.match(RX_HEROKU_X_REQUEST_START) || s.match(RX_NGINX_X_REQUEST_START)
       Time.at(m[1,2].join.to_f / 1000)
     end
@@ -189,6 +216,5 @@ module Rack
     def self.notify_state_change_observers(env)
       @state_change_observers.values.each { |observer| observer.call(env) }
     end
-
   end
 end

data/lib/rack/timeout/logger.rb

@@ -35,5 +35,4 @@ module Rack::Timeout::Logger
     @level      = new_level  || ::Logger::INFO
     self.logger = ::Rack::Timeout::StateChangeLoggingObserver.mk_logger(device, level)
   end
-
 end

data/lib/rack/timeout/logging-observer.rb

@@ -8,6 +8,9 @@ class Rack::Timeout::StateChangeLoggingObserver
                       :timed_out => :error,
                       :completed => :info,
                     }
+  def initialize
+    @logger = nil
+  end
 
   # returns the Proc to be used as the observer callback block
   def callback
@@ -29,7 +32,7 @@ class Rack::Timeout::StateChangeLoggingObserver
 
   def logger(env = nil)
     @logger ||
-      (defined?(::Rails) && ::Rails.logger) ||
+      (defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger) ||
       (env && !env["rack.logger"].is_a?(::Rack::NullLogger) && env["rack.logger"]) ||
       (env && env["rack.errors"] && self.class.mk_logger(env["rack.errors"]))      ||
       (@fallback_logger ||= self.class.mk_logger($stderr))
@@ -45,9 +48,9 @@ class Rack::Timeout::StateChangeLoggingObserver
       s << " wait="    << info.ms(:wait)    if info.wait
       s << " timeout=" << info.ms(:timeout) if info.timeout
       s << " service=" << info.ms(:service) if info.service
+      s << " term_on_timeout=" << info.term.to_s if info.term
       s << " state="   << info.state.to_s   if info.state
       s
     end
   end
-
 end

data/lib/rack/timeout/rails.rb

@@ -3,6 +3,11 @@ require_relative "base"
 class Rack::Timeout::Railtie < Rails::Railtie
   initializer("rack-timeout.prepend") do |app|
     next if Rails.env.test?
-    app.config.middleware.insert_before Rack::Runtime, Rack::Timeout
+
+    if defined?(ActionDispatch::RequestId)
+      app.config.middleware.insert_after(ActionDispatch::RequestId, Rack::Timeout)
+    else
+      app.config.middleware.insert_before(Rack::Runtime, Rack::Timeout)
+    end
   end
-end
+end

data/lib/rack/timeout/rollbar.rb

@@ -1,53 +1 @@
-require_relative "core"
-
-# Groups timeout exceptions in rollbar by exception class, http method, and url.
-#
-# Usage: after requiring rollbar (say, in your rollbar initializer file), call:
-#
-#   require "rack/timeout/rollbar"
-#
-# Ruby 2.1 is required as we use `Module.prepend`.
-#
-# To use a custom fingerprint for grouping:
-#
-#   Rack::Timeout::Rollbar.fingerprint do |exception, env|
-#     # … return some kind of string derived from exception and env
-#   end
-
-module Rack::Timeout::Rollbar
-
-  def self.fingerprint(&block)
-    define_method(:rack_timeout_fingerprint) { |exception, env| block[exception, env] }
-  end
-
-  def self.default_rack_timeout_fingerprint(exception, env)
-    request = ::Rack::Request.new(env)
-    [ exception.class.name,
-      request.request_method,
-      request.path
-    ].join(" ")
-  end
-
-  fingerprint &method(:default_rack_timeout_fingerprint)
-
-
-  def build_payload(level, message, exception, extra)
-    payload = super(level, message, exception, extra)
-
-    return payload unless exception.is_a?(::Rack::Timeout::ExceptionWithEnv) \
-                       && payload.respond_to?(:[])                           \
-                       && payload.respond_to?(:[]=)
-
-    data = payload["data"]
-    return payload unless data.respond_to?(:[]=)
-
-    payload             = payload.dup
-    data                = data.dup
-    data["fingerprint"] = rack_timeout_fingerprint(exception, exception.env)
-    payload["data"]     = data
-
-    return payload
-  end
-end
-
-::Rollbar::Notifier.prepend ::Rack::Timeout::Rollbar
+warn 'DEPRECATION WARNING: The Rollbar module was removed from rack-timeout. For more details check the README on heroku/rack-timeout'

data/lib/rack/timeout/support/monotonic_time.rb

@@ -25,5 +25,4 @@ module Rack::Timeout::MonotonicTime
   when RUBY_PLATFORM == "java"           ; alias fsecs fsecs_java
   else                                   ; alias fsecs fsecs_ruby
   end
-
 end

data/lib/rack/timeout/support/scheduler.rb

@@ -21,6 +21,11 @@ class Rack::Timeout::Scheduler
 
   # stores a proc to run later, and the time it should run at
   class RunEvent < Struct.new(:monotime, :proc)
+    def initialize(*args)
+      @cancelled = false
+      super(*args)
+    end
+
     def cancel!
       @cancelled = true
     end
@@ -51,6 +56,7 @@ class Rack::Timeout::Scheduler
   end
 
   def initialize
+    @runner    = nil
     @events    = []         # array of `RunEvent`s
     @mx_events = Mutex.new  # mutex to change said array
     @mx_runner = Mutex.new  # mutex for creating a runner thread
@@ -145,5 +151,4 @@ class Rack::Timeout::Scheduler
   instance_methods(false).each do |m|
     define_singleton_method(m) { |*a, &b| singleton.send(m, *a, &b) }
   end
-
 end

data/lib/rack/timeout/support/timeout.rb

@@ -25,5 +25,4 @@ class Rack::Timeout::Scheduler::Timeout
   def self.timeout(secs, &block)
     (@singleton ||= new).timeout(secs, &block)
   end
-
 end

data/lib/rack-timeout.rb

@@ -1,2 +1,2 @@
 require_relative "rack/timeout/base"
-require_relative "rack/timeout/rails" if defined?(Rails) && [3,4,5].include?(Rails::VERSION::MAJOR)
+require_relative "rack/timeout/rails" if defined?(Rails) && Rails::VERSION::MAJOR >= 3

data/test/basic_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class BasicTest < RackTimeoutTest
+  def test_ok
+    self.settings = { service_timeout: 1 }
+    get "/"
+    assert last_response.ok?
+  end
+
+  def test_timeout
+    self.settings = { service_timeout: 1 }
+    assert_raises(Rack::Timeout::RequestTimeoutError) do
+      get "/sleep"
+    end
+  end
+
+  def test_wait_timeout
+    self.settings = { service_timeout: 1, wait_timeout: 15 }
+    assert_raises(Rack::Timeout::RequestExpiryError) do
+      get "/", "", 'HTTP_X_REQUEST_START' => time_in_msec(Time.now - 100)
+    end
+  end
+end

data/test/env_settings_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class EnvSettingsTest < RackTimeoutTest
+
+  def test_service_timeout
+    with_env(RACK_TIMEOUT_SERVICE_TIMEOUT: 1) do
+      assert_raises(Rack::Timeout::RequestTimeoutError) do
+        get "/sleep"
+      end
+    end
+  end
+
+  def test_zero_wait_timeout
+    with_env(RACK_TIMEOUT_WAIT_TIMEOUT: 0) do
+      get "/", "", 'HTTP_X_REQUEST_START' => time_in_msec(Time.now - 100)
+      assert last_response.ok?
+    end
+  end
+
+  def test_term
+    with_env(RACK_TIMEOUT_TERM_ON_TIMEOUT: 1) do
+      assert_raises(SignalException) do
+        get "/sleep"
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+require "test/unit"
+require "rack/test"
+require "rack-timeout"
+
+class RackTimeoutTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  attr_accessor :settings
+
+  def initialize(*args)
+    self.settings ||= {}
+    super(*args)
+  end
+
+  def app
+    settings = self.settings
+    Rack::Builder.new do
+      use Rack::Timeout, **settings
+
+      map "/" do
+        run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+      end
+
+      map "/sleep" do
+        run lambda { |env| sleep }
+      end
+    end
+  end
+
+  # runs the test with the given environment, but doesnt restore the original
+  # environment afterwards. This should be sufficient for rack-timeout testing.
+  def with_env(hash)
+    hash.each_pair do |k, v|
+      ENV[k.to_s] = v.to_s
+    end
+    yield
+    hash.each_key do |k|
+      ENV[k.to_s] = nil
+    end
+  end
+
+  def time_in_msec(t = Time.now)
+    "#{t.tv_sec}#{t.tv_usec/1000}"
+  end
+end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: rack-timeout
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.6.3
 platform: ruby
 authors:
 - Caio Chassot
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
-dependencies: []
+date: 2022-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  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'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: Rack middleware which aborts requests that have been running for longer
   than a specified timeout.
 email: caio@heroku.com
@@ -17,13 +59,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG
+- CHANGELOG.md
+- Gemfile
 - MIT-LICENSE
-- README.markdown
+- README.md
+- Rakefile
+- UPGRADING.md
+- doc/exceptions.md
+- doc/logging.md
+- doc/observers.md
+- doc/request-lifecycle.md
+- doc/risks.md
+- doc/rollbar.md
+- doc/settings.md
 - lib/rack-timeout.rb
 - lib/rack/timeout/base.rb
 - lib/rack/timeout/core.rb
-- lib/rack/timeout/legacy.rb
 - lib/rack/timeout/logger.rb
 - lib/rack/timeout/logging-observer.rb
 - lib/rack/timeout/rails.rb
@@ -32,11 +83,18 @@ files:
 - lib/rack/timeout/support/namespace.rb
 - lib/rack/timeout/support/scheduler.rb
 - lib/rack/timeout/support/timeout.rb
-homepage: http://github.com/heroku/rack-timeout
+- test/basic_test.rb
+- test/env_settings_test.rb
+- test/test_helper.rb
+homepage: https://github.com/zombocom/rack-timeout
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/zombocom/rack-timeout/issues
+  changelog_uri: https://github.com/zombocom/rack-timeout/blob/v0.6.3/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/rack-timeout/0.6.3/
+  source_code_uri: https://github.com/zombocom/rack-timeout
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -51,10 +109,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Abort requests that are taking too long
-test_files: []
-has_rdoc: 
+test_files:
+- test/basic_test.rb
+- test/env_settings_test.rb
+- test/test_helper.rb
+- Gemfile
+- Rakefile