rack-timeout 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87b7082006e199c0aafd7a9f3da42cd99c58c242
-  data.tar.gz: 46fbc6fbfb1ee52bba6dcfdc39b63764cc9ef283
+  metadata.gz: b9883fb70f10b92813db0e39769ab134f581c62a
+  data.tar.gz: a31ef775470b03bedeb09981dd9e4d5967879518
 SHA512:
-  metadata.gz: 8985ff46ae3101ad1da50fe9cd56c25d384f57f4e4065feb893e5176a4cd51a53cb926862ea876ea0bf2ae636f0c7275d0a63b91cd172bd91c02c7031aa3026f
-  data.tar.gz: f7ae0275dc85808da16fd0de36396a9b6c53ce8e19d6e562e1fd90315c0cb3485469745ce480a9b8633d2d497fc8ee6a1716e538c3258a76b2d42879a7a3ac75
+  metadata.gz: 3a1b07a8dcf61cb71ef95300eb03b8b7b2a2a436def96fd832d4438d46fc09dc0419d51c15340b52c7022ffabff25c3db60b8e575c7c90bd18bc2e733bbcb2d0
+  data.tar.gz: a6e9ff8614f66a81086125b80037b7e4610860f6e5aea41be08305f477ad825f0e984171e55a83ae7e1e6baa1237b38691b9e89fc394dd146e41e82b932634ba

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.5.0
+=====
+- Add support to configure via environment variables (#105)
+- Adds support for ActionDispatch::RequestId generated request ids (#115)
+- Changes uuid format to proper uuid (#115)
+- Remove Rollbar module (#124)
+- Remove legacy class setters (#125)
+
 0.4.2
 =====
 - Ruby 2.0 compatible
@@ -13,6 +21,7 @@
 - Settings are now passable to the middleware initializer instead of class-level
 - Rollbar module may take a custom fingerprint block
 - Rollbar module considered final
+- Fixed an issue where some heartbeats would live on forever (#103, /ht @0x0badc0de)
 
 0.3.2
 =====

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.markdown

@@ -22,14 +22,7 @@ The following covers currently supported versions of Rails, Rack, Ruby, and Bund
 gem "rack-timeout"
 ```
 
-That'll load rack-timeout and set it up as a Rails middleware using the default timeout of 15s. The middleware is not inserted for the test environment.
-
-To use a custom timeout, create an initializer file:
-
-```ruby
-# config/initializers/rack_timeout.rb
-Rack::Timeout.service_timeout = 5  # seconds
-```
+This will load rack-timeout and set it up as a Rails middleware using the default timeout of 15s. The middleware is not inserted for the test environment. You can modify the timeout by setting a `RACK_TIMEOUT_SERVICE_TIMEOUT` environment variable.
 
 ### Rails apps, manually
 
@@ -43,7 +36,7 @@ gem "rack-timeout", require:"rack/timeout/base"
 ```ruby
 # config/initializers/rack_timeout.rb
 
-# insert middleware wherever you want in the stack, optionally pass initialization arguments
+# insert middleware wherever you want in the stack, optionally pass initialization arguments or use environment variables
 Rails.application.config.middleware.insert_before Rack::Runtime, Rack::Timeout, service_timeout: 5
 ```
 
@@ -54,7 +47,7 @@ Rails.application.config.middleware.insert_before Rack::Runtime, Rack::Timeout,
 require "rack-timeout"
 
 # Call as early as possible so rack-timeout runs before all other middleware.
-# Setting service_timeout is recommended. If omitted, defaults to 15 seconds.
+# Setting service_timeout or `RACK_TIMEOUT_SERVICE_TIMEOUT` environment variable is recommended. If omitted, defaults to 15 seconds.
 use Rack::Timeout, service_timeout: 5
 ```
 
@@ -65,21 +58,18 @@ The Rabbit Hole
 Rack::Timeout takes the following settings, shown here with their default values:
 
 ```
-service_timeout:   15
-wait_timeout:      30
-wait_overtime:     60
-service_past_wait: false
+service_timeout:   15     # RACK_TIMEOUT_SERVICE_TIMEOUT
+wait_timeout:      30     # RACK_TIMEOUT_WAIT_TIMEOUT
+wait_overtime:     60     # RACK_TIMEOUT_WAIT_OVERTIME
+service_past_wait: false  # RACK_TIMEOUT_SERVICE_PAST_WAIT
 ```
 
-As shown earlier, these settings can be overriden during middleware initialization:
+As shown earlier, these settings can be overriden during middleware initialization or environment variables `RACK_TIMEOUT_*` mentioned above. Middleware parameters take precedence:
 
 ```ruby
 use Rack::Timeout, service_timeout: 5, wait_timeout: false
 ```
 
-For legacy reasons, it's also possible to set these at the class level (e.g. `Rack::Timeout.service_timeout = 3`). This is, however, not recommended. Also beware this style takes precedence over all instances' initialization settings.
-
-
 ### Service Timeout
 
 `service_timeout` is our most important setting.
@@ -102,7 +92,7 @@ On Heroku, a request will be dropped when the routing layer sees no data being t
 
 Wait timeout can be disabled entirely by setting the property to `0` or `false`.
 
-A request's computed wait time may affect the service timeout used for it. Basically, a request's wait time plus service time may not exceed the wait timeout. The reasoning for that is based on Heroku router's behavior, that the request would be dropped anyway after the wait timeout. So, for example, with the default settings of `service_timeout=15`, `wait_timeout=30`, a request that had 20 seconds of wait time will not have a service timeout of 15, but instead of 10, as there are only 10 seconds left before `wait_timeout` is reached. This behavior can be disabled by setting `service_past_wait` to `true`. When set, the `service_timeout` setting will always be honored.
+A request's computed wait time may affect the service timeout used for it. Basically, a request's wait time plus service time may not exceed the wait timeout. The reasoning for that is based on Heroku router's behavior, that the request would be dropped anyway after the wait timeout. So, for example, with the default settings of `service_timeout=15`, `wait_timeout=30`, a request that had 20 seconds of wait time will not have a service timeout of 15, but instead of 10, as there are only 10 seconds left before `wait_timeout` is reached. This behavior can be disabled by setting `service_past_wait` to `true`. When set, the `service_timeout` setting will always be honored. Please note that if you're using the `RACK_TIMEOUT_SERVICE_PAST_WAIT` environment variable, any value different than `"false"` will be considered `true`.
 
 The way we're able to infer a request's start time, and from that its wait time, is through the availability of the `X-Request-Start` HTTP header, which is expected to contain the time since epoch in milliseconds. (A concession is made for nginx's sec.msec notation.)
 
@@ -137,8 +127,6 @@ At the moment rack-timeout does not try to address this issue. As a fail-safe ag
 More detailed explanations of the issues surrounding timing out in ruby during IO blocks can be found at:
 
 - http://redgetan.cc/understanding-timeouts-in-cruby/
-- https://shellycloud.com/blog/2013/06/the-pesky-problem-of-freezing-thin
-
 
 ### Timing Out Inherently Unsafe
 
@@ -199,17 +187,17 @@ Errors
 
 Rack::Timeout can raise three types of exceptions. They are:
 
-Two descend from `Rack::Timeout::Error`, which itself descends from `RuntimeError` and is generally caught by an unqualified `raise`. The third, `RequestTimeoutException`, is more complicated and the most important.
-
-*   `Rack::Timeout::RequestExpiryError`: this is raised when a request is skipped for being too old (see Wait Timeout section). This error cannot generally be rescued from inside a Rails controller action as it happens before the request has a chance to enter Rails.
-
-    This shouldn't be different for other frameworks, unless you have something above Rack::Timeout in the middleware stack, which you generally shouldn't.
+Two descend from `Rack::Timeout::Error`, which itself descends from `RuntimeError` and is generally caught by an unqualified `rescue`. The third, `RequestTimeoutException`, is more complicated and the most important.
 
 *   `Rack::Timeout::RequestTimeoutException`: this is raised when a request has run for longer than the specified timeout. This descends from `Exception`, not from `Rack::Timeout::Error` (it has to be rescued from explicitly). It's raised by the rack-timeout timer thread in the application thread, at the point in the stack the app happens to be in when the timeout is triggered. This exception could be caught explicitly within the application, but in doing so you're working past the timeout. This is ok for quick cleanup work but shouldn't be abused as Rack::Timeout will not kick in twice for the same request.
 
     Rails will generally intercept `Exception`s, but in plain Rack apps, this exception will be caught by rack-timeout and re-raised as a `Rack::Timeout::RequestTimeoutError`. This is to prevent an `Exception` from bubbling up beyond rack-timeout and to the server.
 
-*   `Rack::Timeout::RequestTimeoutError` is the third type, it descends from `Rack::Timeout::Error`, but it's only really seen in the case described above. It'll not be seen in a standard Rails app, and will only be seen in Sinatra if rescuing from exceptions is disabled.
+*   `Rack::Timeout::RequestTimeoutError` descends from `Rack::Timeout::Error`, but it's only really seen in the case described above. It'll not be seen in a standard Rails app, and will only be seen in Sinatra if rescuing from exceptions is disabled.
+
+*   `Rack::Timeout::RequestExpiryError`: this is raised when a request is skipped for being too old (see Wait Timeout section). This error cannot generally be rescued from inside a Rails controller action as it happens before the request has a chance to enter Rails.
+
+    This shouldn't be different for other frameworks, unless you have something above Rack::Timeout in the middleware stack, which you generally shouldn't.
 
 You shouldn't rescue from these errors for reporting purposes. Instead, you can subscribe for state change notifications with observers.
 
@@ -224,22 +212,32 @@ If you're trying to test that a `Rack::Timeout::RequestTimeoutException` is rais
 
 Because rack-timeout may raise at any point in the codepath of a timed-out request, the stack traces for similar requests may differ, causing rollbar to create separate entries for each timeout.
 
-A Rollbar module is provided which causes rack-timeout errors to be grouped by exception type, request HTTP method, and URL, so all timeouts for a particular endpoint are reported under the same entry.
+The recommended practice is to configure [Custom Fingerprints][rollbar-customfingerprint] on Rollbar.
 
-To enable it, simply require it after having required rollbar. For example, in your rollbar initializer file, do:
+[rollbar-customfingerprint]: https://docs.rollbar.com/docs/custom-grouping/
 
-    require "rollbar"
-    require "rack/timeout/rollbar"
+Example:
 
-It'll set itself up.
+```json
+[
+  {
+    "condition": {
+      "eq": "Rack::Timeout::RequestTimeoutException",
+      "path": "body.trace.exception.class"
+    },
+    "fingerprint": "Rack::Timeout::RequestTimeoutException {{context}}",
+    "title": "Rack::Timeout::RequestTimeoutException {{context}}"
+   }
+]
 
-If you wish to use a custom fingerprint for grouping:
+```
 
-    Rack::Timeout::Rollbar.fingerprint do |exception, env|
-      # return a string derived from exception and env
-    end
+This configuration will generate exceptions following the pattern: `Rack::Timeout::RequestTimeoutException controller#action
+`
 
+On previous versions this configuration was made using `Rack::Timeout::Rollbar` which was removed. [More details on the Issue #122][rollbar-removal-issue].
 
+[rollbar-removal-issue]: https://github.com/heroku/rack-timeout/issues/122
 
 Observers
 ---------
@@ -315,5 +313,5 @@ This version of Rack::Timeout is compatible with Ruby 2.1 and up, and, for Rails
 
 
 ---
-Copyright © 2010-2016 Caio Chassot, released under the MIT license  
+Copyright © 2010-2016 Caio Chassot, released under the MIT license
 <http://github.com/heroku/rack-timeout>

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

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
@@ -43,7 +42,9 @@ 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
@@ -63,11 +64,11 @@ module Rack
       :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
+    def initialize(app, service_timeout:nil, wait_timeout:nil, wait_overtime:nil, service_past_wait:"not_specified")
+      @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
       @app = app
     end
 
@@ -75,7 +76,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

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

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/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

data/test/basic_test.rb

@@ -0,0 +1,32 @@
+require "test/unit"
+require "rack/test"
+require "rack-timeout"
+
+class BasicTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.new do
+      use Rack::Timeout, service_timeout: 1
+
+      map "/" do
+        run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+      end
+
+      map "/sleep" do
+        run lambda { |env| sleep }
+      end
+    end
+  end
+
+  def test_ok
+    get "/"
+    assert last_response.ok?
+  end
+
+  def test_timeout
+    assert_raises(Rack::Timeout::RequestTimeoutError) do
+      get "/sleep"
+    end
+  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.5.0
 platform: ruby
 authors:
 - Caio Chassot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
-dependencies: []
+date: 2018-05-18 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
@@ -18,12 +60,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG
+- Gemfile
 - MIT-LICENSE
 - README.markdown
+- Rakefile
 - 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,6 +75,7 @@ files:
 - lib/rack/timeout/support/namespace.rb
 - lib/rack/timeout/support/scheduler.rb
 - lib/rack/timeout/support/timeout.rb
+- test/basic_test.rb
 homepage: http://github.com/heroku/rack-timeout
 licenses:
 - MIT
@@ -52,9 +96,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Abort requests that are taking too long
-test_files: []
-has_rdoc: 
+test_files:
+- test/basic_test.rb
+- Gemfile
+- Rakefile

data/lib/rack/timeout/legacy.rb

@@ -1,43 +0,0 @@
-require_relative "support/namespace"
-
-
-# This provides compatibility with versions <= 0.3.x where timeout settings were class-level.
-# Beware that, unintuitively, a class-level setting overrides local settings for all instances.
-# Generally speaking, everyone should migrate to instance-level settings.
-
-module Rack::Timeout::ClassLevelProperties
-
-  module ClassMethods
-    attr_accessor :service_timeout, :wait_timeout, :wait_overtime, :service_past_wait
-    alias_method :timeout=, :service_timeout=
-
-    [ :service_timeout=,
-      :timeout=,
-      :wait_timeout=,
-      :wait_overtime=,
-      :service_past_wait=,
-    ].each do |isetter|
-      setter = instance_method(isetter)
-      define_method(isetter) do |x|
-        defined?(Rails) or warn "`Rack::Timeout.#{isetter}`: class-level settings are deprecated. See README for examples on using the middleware initializer instead."
-        setter.bind(self).call(x)
-      end
-    end
-  end
-
-  module InstanceMethods
-
-    [:service_timeout, :wait_timeout, :wait_overtime].each do |m|
-      define_method(m) { read_timeout_property self.class.send(m), super() }
-    end
-
-    def service_past_wait
-      self.class.service_past_wait || super
-    end
-  end
-
-end
-
-
-Rack::Timeout.extend  Rack::Timeout::ClassLevelProperties::ClassMethods
-Rack::Timeout.send :prepend, Rack::Timeout::ClassLevelProperties::InstanceMethods