rack-timeout 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9ae29d987db68c611785883420553a2f6f40ee7
-  data.tar.gz: 1c1785b62a64d3a6cf5b5937baae4dec0a092ddd
+  metadata.gz: 3c6085bc1b83e9bb9f2b9e461a397dc4764fffe1
+  data.tar.gz: 30290762388e9fc3512a48e962b4101817b7d53f
 SHA512:
-  metadata.gz: 22dd8d23074301936134273f9dd3763c1dfb03a42ad49ea0e63f53f0db64095135e00b33fdcc08f9b10fb9a8d43ad94c3dc94bf527e054e6e0376c65a8c6d131
-  data.tar.gz: 114c9f37b4b435d213eb33fa4596cc18b0949f1c670fd2c9c25b3a4a061666ffb7a1bd52540d46b752d1795b224455ab9399b8d496e8e5f62cfb9812c0a8270a
+  metadata.gz: 58a88b26d6aad37c19e15ddac0db4b8b77684542c02ab00670a76bb36db01a98b2dbf9dadf0e2b34402a4e971eaf7f4d653311708c1e36ed52f64d09073d0c7a
+  data.tar.gz: c542d17400ea593c1b85192a3e68917880a83dc89d274598566111c5f20d3c611e2fee7228bcaabe8fae18782bb65014a7ffff315157d04894287651874e53bb

data/CHANGELOG

@@ -1,3 +1,10 @@
+0.4.0
+=====
+- Using monotonic time instead of Time.now where available (/ht concurrent-ruby)
+- Settings are now passable to the middleware initializer instead of class-level
+- Rollbar module may take a custom fingerprint block
+- Rollbar module considered final
+
 0.3.2
 =====
 - Fixes calling timeout with a value of 0 (issue #90)
@@ -13,7 +20,7 @@
 - reshuffle error types: RequestExpiryError is again a RuntimeError, and timeouts raise a RequestTimeoutException, an Exception, and not descending from Rack::Timeout::Error (see README for more)
 - don't insert middleware for rails in test environment
 - add convenience module Rack::Timeout::Logger (see README for more)
-- StageChangeLoggingObserver renamed to StageChangeLoggingObserver, works slightly differently too
+- StageChangeLoggingObserver renamed to StateChangeLoggingObserver, works slightly differently too
 - file layout reorganization (see 6e82c276 for details)
 - CHANGELOG file is now in the gem (@dbackeus)
 - add optional and experimental support for grouping errors by url under rollbar. see "rack/timeout/rollbar" for usage

data/README.markdown

@@ -27,8 +27,8 @@ That'll load rack-timeout and set it up as a Rails middleware using the default
 To use a custom timeout, create an initializer file:
 
 ```ruby
-# config/initializers/timeout.rb
-Rack::Timeout.timeout = 5  # seconds
+# config/initializers/rack_timeout.rb
+Rack::Timeout.service_timeout = 5  # seconds
 ```
 
 ### Rails apps, manually
@@ -41,13 +41,10 @@ gem "rack-timeout", require:"rack/timeout/base"
 ```
 
 ```ruby
-# config/initializers/timeout.rb
+# config/initializers/rack_timeout.rb
 
-#  insert middleware wherever you want in the stack
-Rails.application.config.middleware.insert_before Rack::Runtime, Rack::Timeout
-
-# customize seconds before timeout
-Rack::Timeout.timeout = 5
+# insert middleware wherever you want in the stack, optionally pass initialization arguments
+Rails.application.config.middleware.insert_before Rack::Runtime, Rack::Timeout, service_timeout: 5
 ```
 
 ### Sinatra and other Rack apps
@@ -55,17 +52,37 @@ Rack::Timeout.timeout = 5
 ```ruby
 # config.ru
 require "rack-timeout"
-use Rack::Timeout          # Call as early as possible so rack-timeout runs before all other middleware.
-Rack::Timeout.timeout = 5  # Recommended. If omitted, defaults to 15 seconds.
+
+# Call as early as possible so rack-timeout runs before all other middleware.
+# Setting service_timeout is recommended. If omitted, defaults to 15 seconds.
+use Rack::Timeout, service_timeout: 5
 ```
 
 
 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
+```
+
+As shown earlier, these settings can be overriden during middleware initialization:
+
+```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
 
-`Rack::Timeout.timeout` (or `Rack::Timeout.service_timeout`) is our principal setting.
+`service_timeout` is our most important setting.
 
 *Service time* is the time taken from when a request first enters rack to when its response is sent back. When the application takes longer than `service_timeout` to process a request, the request's status is logged as `timed_out` and `Rack::Timeout::RequestTimeoutException` or `Rack::Timeout::RequestTimeoutError` is raised on the application thread. This may be automatically caught by the framework or plugins, so beware. Also, the exception is not guaranteed to be raised in a timely fashion, see section below about IO blocks.
 
@@ -76,16 +93,16 @@ Service timeout can be disabled entirely by setting the property to `0` or `fals
 
 Before a request reaches the rack application, it may have spent some time being received by the web server, or waiting in the application server's queue before being dispatched to rack. The time between when a request is received by the web server and when rack starts handling it is called the *wait time*.
 
-On Heroku, a request will be dropped when the routing layer sees no data being transferred for over 30 seconds. (You can read more about the specifics of Heroku routing's timeout [here][heroku-routing] and [here][heroku-timeout].) In this case, it makes no sense to process a request that reaches the application after having waited more than 30 seconds. That's where the `Rack::Timeout.wait_timeout` setting comes in. When a request has a wait time greater than `wait_timeout`, it'll be dropped without ever being sent down to the application, and a `Rack::Timeout::RequestExpiryError` is raised. Such requests are logged as `expired`.
+On Heroku, a request will be dropped when the routing layer sees no data being transferred for over 30 seconds. (You can read more about the specifics of Heroku routing's timeout [here][heroku-routing] and [here][heroku-timeout].) In this case, it makes no sense to process a request that reaches the application after having waited more than 30 seconds. That's where the `wait_timeout` setting comes in. When a request has a wait time greater than `wait_timeout`, it'll be dropped without ever being sent down to the application, and a `Rack::Timeout::RequestExpiryError` is raised. Such requests are logged as `expired`.
 
 [heroku-routing]: https://devcenter.heroku.com/articles/http-routing#timeouts
 [heroku-timeout]: https://devcenter.heroku.com/articles/request-timeout
 
-`Rack::Timeout.wait_timeout` is set at a default of 30 seconds, matching Heroku's router's timeout.
+`wait_timeout` is set at a default of 30 seconds, matching Heroku's router's timeout.
 
 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 `Rack::Timeout.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.
 
 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.)
 
@@ -104,7 +121,7 @@ A request that took longer than 30s to be fully received, but that had been uplo
 
 As a concession to these shortcomings, for requests that have a body present, we allow some additional wait time on top of `wait_timeout`. This aims to make up for time lost to long uploads.
 
-This extra time is called *wait overtime* and can be set via `Rack::Timeout.wait_overtime`. It defaults to 60 seconds. This can be disabled as usual by setting the property to `0` or `false`. When disabled, there's no overtime. If you want lengthy requests to never get expired, set `wait_overtime` to a very high number.
+This extra time is called *wait overtime* and can be set via `wait_overtime`. It defaults to 60 seconds. This can be disabled as usual by setting the property to `0` or `false`. When disabled, there's no overtime. If you want lengthy requests to never get expired, set `wait_overtime` to a very high number.
 
 Keep in mind that Heroku [recommends][uploads] uploading large files directly to S3, so as to prevent the dyno from being blocked for too long and hence unable to handle further incoming requests.
 
@@ -139,6 +156,15 @@ That said, it's something to be aware of, and may explain some eerie wonkiness s
 [handle-interrupt]: http://www.ruby-doc.org/core-2.1.3/Thread.html#method-c-handle_interrupt
 
 
+### Time Out Early and Often
+
+Because of the aforementioned issues, it's recommended you set library-specific timeouts and leave Rack::Timeout as a last resort measure. Library timeouts will generally take care of IO issues and abort the operation safely. See [The Ultimate Guide to Ruby Timeouts][ruby-timeouts].
+
+You'll want to set all relevant timeouts to something lower than Rack::Timeout's `service_timeout`. Generally you want them to be at least 1s lower, so as to account for time spent elsewhere during the request's lifetime while still giving libraries a chance to time out before Rack::Timeout.
+
+[ruby-timeouts]: https://github.com/ankane/the-ultimate-guide-to-ruby-timeouts
+
+
 Request Lifetime
 ----------------
 
@@ -163,9 +189,9 @@ The value of that entry is an instance of `Rack::Timeout::RequestDetails`, which
 
     *   `active` (`DEBUG`): the request is being actively processed in the application thread. This is signaled repeatedly every ~1s until the request completes or times out.
 
-    *   `timed_out` (`ERROR`): the request ran for longer than the determined timeout and was aborted. `Rack::Timeout::RequestTimeoutException` is raised in the application when this occurs. If this exception gets caught, handled, and not re-raised in the app or framework (which will generally happen with Rails and Sinatra), this state will not be final, `completed` will be set after the framework is done with it. (If the exception does bubble up, it's caught by rack-timeout and re-raised as `Rack::Timeout::RequestTimeoutError`, which descends from RuntimeError.)
+    *   `timed_out` (`ERROR`): the request ran for longer than the determined timeout and was aborted. `Rack::Timeout::RequestTimeoutException` is raised in the application when this occurs. This state is not the final one, `completed` will be set after the framework is done with it. (If the exception does bubble up, it's caught by rack-timeout and re-raised as `Rack::Timeout::RequestTimeoutError`, which descends from RuntimeError.)
 
-    *   `completed` (`INFO`): the request completed and Rack::Timeout is done with it. This does not mean the request completed *successfully*. Rack::Timeout does not concern itself with that. As mentioned just above, a timed out request may still end up with a `completed` state if the framework has dealt with the timeout exception.
+    *   `completed` (`INFO`): the request completed and Rack::Timeout is done with it. This does not mean the request completed *successfully*. Rack::Timeout does not concern itself with that. As mentioned just above, a timed out request will still end up with a `completed` state.
 
 
 Errors
@@ -194,6 +220,27 @@ If you're trying to test that a `Rack::Timeout::RequestTimeoutException` is rais
 [pablobm]: http://stackoverflow.com/a/8681208/13989
 
 
+### Rollbar
+
+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.
+
+To enable it, simply require it after having required rollbar. For example, in your rollbar initializer file, do:
+
+    require "rollbar"
+    require "rack/timeout/rollbar"
+
+It'll set itself up.
+
+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
+
+
+
 Observers
 ---------
 
@@ -264,11 +311,7 @@ source=rack-timeout id=ea7bd3 wait=371ms timeout=10000ms state=timed_out at=erro
 Compatibility
 -------------
 
-This version of Rack::Timeout is compatible with Ruby 1.9.1 and up, and, for Rails apps, Rails 3.x and up.
-
-For applications running Ruby 1.8.x and/or Rails 2.x, use [version 0.0.4][v0.0.4].
-
-[v0.0.4]: https://github.com/heroku/rack-timeout/tree/v0.0.4
+This version of Rack::Timeout is compatible with Ruby 2.1 and up, and, for Rails apps, Rails 3.x and up.
 
 
 ---

data/lib/rack/timeout/core.rb

@@ -1,10 +1,14 @@
 # encoding: utf-8
 require "securerandom"
+require_relative "support/monotonic_time"
 require_relative "support/scheduler"
 require_relative "support/timeout"
+require_relative "legacy"
 
 module Rack
   class Timeout
+    include Rack::Timeout::MonotonicTime # gets us the #fsecs method
+
     module ExceptionWithEnv # shared by the following exceptions, allows them to receive the current env
       attr :env
       def initialize(env)
@@ -26,7 +30,7 @@ module Rack
       :wait,      # seconds the request spent in the web server before being serviced by 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 below:
+      :state,     # the request's current state, see VALID_STATES below
     ) {
       def ms(k)   # helper method used for formatting values in milliseconds
         "%.fms" % (self[k] * 1000) if self[k]
@@ -41,37 +45,29 @@ module Rack
       ]
     ENV_INFO_KEY = "rack-timeout.info" # key under which each request's RequestDetails instance is stored in its env.
 
-    # helper methods to setup getter/setters for timeout properties. Ensure they're always positive numbers or false. When set to false (or 0), their behaviour is disabled.
-    class << self
-      def set_timeout_property(property_name, value)
-        unless value == false || (value.is_a?(Numeric) && value >= 0)
-          raise ArgumentError, "value for #{property_name} should be false, zero, or a positive number."
-        end
-        value = false if value && value.zero? # zero means we're disabling the feature
-        instance_variable_set("@#{property_name}", value)
-      end
-
-      def timeout_property(property_name, start_value)
-        singleton_class.instance_eval do
-          attr_reader property_name
-          define_method("#{property_name}=") { |v| set_timeout_property(property_name, v) }
-        end
-        set_timeout_property(property_name, start_value)
+    # 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 false ; false
+      when 0     ; false
+      else
+        value.is_a?(Numeric) && value > 0 or raise ArgumentError, "value #{value.inspect} should be false, zero, or a positive number."
+        value
       end
     end
 
-    # all values are in seconds
-    timeout_property :wait_timeout,    30 # 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.
-    timeout_property :wait_overtime,   60 # 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.
-    timeout_property :service_timeout, 15 # How long the application can take to complete handling the request once it's passed down to it.
-
-    class << self
-      alias_method :timeout=, :service_timeout= # legacy compatibility setter
-      attr_accessor :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.
-      @service_past_wait = false          # 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.
-    end
-
-    def initialize(app)
+    attr_reader \
+      :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
       @app = app
     end
 
@@ -81,16 +77,17 @@ module Rack
       info      = (env[ENV_INFO_KEY] ||= RequestDetails.new)
       info.id ||= env["HTTP_X_REQUEST_ID"] || SecureRandom.hex
 
-      time_started_service = Time.now                      # The time the request started being processed by rack
+      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
       time_started_wait    = RT._read_x_request_start(env) # The time the request was initially received by the web server (if available)
-      effective_overtime   = (RT.wait_overtime && RT._request_has_body?(env)) ? RT.wait_overtime : 0 # additional wait timeout (if set and applicable)
+      effective_overtime   = (wait_overtime && RT._request_has_body?(env)) ? wait_overtime : 0 # additional wait timeout (if set and applicable)
       seconds_service_left = nil
 
       # if X-Request-Start is present and wait_timeout is set, expire requests older than wait_timeout (+wait_overtime when applicable)
-      if time_started_wait && RT.wait_timeout
+      if time_started_wait && wait_timeout
         seconds_waited          = time_started_service - time_started_wait # how long it took between the web server first receiving the request and rack being able to handle it
         seconds_waited          = 0 if seconds_waited < 0                  # make up for potential time drift between the routing server and the application server
-        final_wait_timeout      = RT.wait_timeout + effective_overtime     # how long the request will be allowed to have waited
+        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
         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)
@@ -100,18 +97,18 @@ module Rack
       end
 
       # pass request through if service_timeout is false (i.e., don't time it out at all.)
-      return @app.call(env) unless RT.service_timeout
+      return @app.call(env) unless service_timeout
 
       # 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 = RT.service_timeout # nice and simple, when service_past_wait is true, not so much otherwise:
-      info.timeout = seconds_service_left if !RT.service_past_wait && seconds_service_left && seconds_service_left > 0 && seconds_service_left < RT.service_timeout
+      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
 
       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
       register_state_change = ->(status = :active) {        # updates service time and state; will run every second
         heartbeat_event.cancel! if status != :active        # if the request is no longer active we should stop updating every second
-        info.service = Time.now - time_started_service      # update service time
+        info.service = fsecs - ts_started_service           # update service time
         RT._set_state! env, status                          # update status
       }
       heartbeat_event = RT::Scheduler.run_every(1) { register_state_change.call :active }  # start updating every second while active; if log level is debug, this will log every sec
@@ -124,11 +121,12 @@ module Rack
       response = timeout.timeout(info.timeout) do           # perform request with timeout
         begin  @app.call(env)                               # boom, send request down the middleware chain
         rescue RequestTimeoutException => e                 # will actually hardly ever get to this point because frameworks tend to catch this. see README for more
-          raise RequestTimeoutError.new(env), e.message, e.backtrace  # but in case it does get here, re-reaise RequestTimeoutException as RequestTimeoutError
+          raise RequestTimeoutError.new(env), e.message, e.backtrace  # but in case it does get here, re-raise RequestTimeoutException as RequestTimeoutError
+        ensure
+          register_state_change.call :completed
         end
       end
 
-      register_state_change.call :completed
       response
     end
 

data/lib/rack/timeout/legacy.rb

@@ -0,0 +1,46 @@
+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|
+        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
+    def read_timeout_property_with_class_override property_name
+      read_timeout_property self.class.send(property_name), method(property_name).super_method.call
+    end
+
+    [:service_timeout, :wait_timeout, :wait_overtime].each do |m|
+      define_method(m) { read_timeout_property_with_class_override m }
+    end
+
+    def service_past_wait
+      self.class.service_past_wait || super
+    end
+  end
+
+end
+
+
+Rack::Timeout.extend  Rack::Timeout::ClassLevelProperties::ClassMethods
+Rack::Timeout.prepend Rack::Timeout::ClassLevelProperties::InstanceMethods

data/lib/rack/timeout/rollbar.rb

@@ -6,11 +6,31 @@ require_relative "core"
 #
 #   require "rack/timeout/rollbar"
 #
-# This is somewhat experimental and very lightly tested.
-#
 # Ruby 2.0 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)
 
@@ -21,16 +41,10 @@ module Rack::Timeout::Rollbar
     data = payload["data"]
     return payload unless data.respond_to?(:[]=)
 
-    request = ::Rack::Request.new(exception.env)
-    payload = payload.dup
-    data    = data.dup
-    payload["data"] = data
-
-    data["fingerprint"] = [
-      exception.class.name,
-      request.request_method,
-      request.fullpath
-      ].join(" ")
+    payload             = payload.dup
+    data                = data.dup
+    data["fingerprint"] = rack_timeout_fingerprint(exception, exception.env)
+    payload["data"]     = data
 
     return payload
   end

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

@@ -0,0 +1,29 @@
+require_relative "namespace"
+
+# lifted from https://github.com/ruby-concurrency/concurrent-ruby/blob/master/lib/concurrent/utility/monotonic_time.rb
+
+module Rack::Timeout::MonotonicTime
+  extend self
+
+  def fsecs_mono
+    Process.clock_gettime Process::CLOCK_MONOTONIC
+  end
+
+  def fsecs_java
+    java.lang.System.nanoTime() / 1_000_000_000.0
+  end
+
+  mutex = Mutex.new
+  last_time = Time.now.to_f
+  define_method(:fsecs_ruby) do
+    now = Time.now.to_f
+    mutex.synchronize { last_time = last_time < now ? now : last_time + 1e-6 }
+  end
+
+  case
+  when defined? Process::CLOCK_MONOTONIC ; alias fsecs fsecs_mono
+  when RUBY_PLATFORM == "java"           ; alias fsecs fsecs_java
+  else                                   ; alias fsecs fsecs_ruby
+  end
+
+end

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 require_relative "namespace"
-require_relative "assert-types"
+require_relative "monotonic_time"
 
 # Runs code at a later time
 #
@@ -17,15 +17,10 @@ require_relative "assert-types"
 # One could also instantiate separate instances which would get you separate run threads, but generally there's no point in it.
 class Rack::Timeout::Scheduler
   MAX_IDLE_SECS = 30 # how long the runner thread is allowed to live doing nothing
-  include Rack::Timeout::AssertTypes
+  include Rack::Timeout::MonotonicTime # gets us the #fsecs method
 
   # stores a proc to run later, and the time it should run at
-  class RunEvent < Struct.new(:time, :proc)
-    def initialize(time, proc)
-      Rack::Timeout::AssertTypes.assert_types! time => Time, proc => Proc
-      super
-    end
-
+  class RunEvent < Struct.new(:monotime, :proc)
     def cancel!
       @cancelled = true
     end
@@ -41,17 +36,17 @@ class Rack::Timeout::Scheduler
   end
 
   class RepeatEvent < RunEvent
-    def initialize(time, proc, every)
-      @start = time
+    def initialize(monotime, proc, every)
+      @start = monotime
       @every = every
       @iter  = 0
-      super(time, proc)
+      super(monotime, proc)
     end
 
     def run!
       super
     ensure
-      self.time = @start + @every * (@iter += 1) until time >= Time.now
+      self.monotime = @start + @every * (@iter += 1) until monotime >= Rack::Timeout::MonotonicTime.fsecs
     end
   end
 
@@ -65,7 +60,7 @@ class Rack::Timeout::Scheduler
   private
 
   # returns the runner thread, creating it if needed
-   def runner
+  def runner
     @mx_runner.synchronize {
       return @runner unless @runner.nil? || !@runner.alive?
       @joined = false
@@ -76,28 +71,28 @@ class Rack::Timeout::Scheduler
   # the actual runner thread loop
   def run_loop!
     Thread.current.abort_on_exception = true                       # always be aborting
-    sleep_for, run, last_run = nil, nil, Time.now                  # sleep_for: how long to sleep before next run; last_run: time of last run; run: just initializing it outside of the synchronize scope, will contain events to run now
+    sleep_for, run, last_run = nil, nil, fsecs                     # sleep_for: how long to sleep before next run; last_run: time of last run; run: just initializing it outside of the synchronize scope, will contain events to run now
     loop do                                                        # begin event reader loop
       @mx_events.synchronize {                                     #
         @events.reject!(&:cancelled?)                              # get rid of cancelled events
         if @events.empty?                                          # if there are no further events …
           return if @joined                                        # exit the run loop if this runner thread has been joined (the thread will die and the join will return)
-          return if Time.now - last_run > MAX_IDLE_SECS            # exit the run loop if done nothing for the past MAX_IDLE_SECS seconds
+          return if fsecs - last_run > MAX_IDLE_SECS               # exit the run loop if done nothing for the past MAX_IDLE_SECS seconds
           sleep_for = MAX_IDLE_SECS                                # sleep for MAX_IDLE_SECS (mind it that we get awaken when new events are scheduled)
         else                                                       #
-          sleep_for = [@events.map(&:time).min - Time.now, 0].max  # if we have events, set to sleep until it's time for the next one to run. (the max bit ensure we don't have negative sleep times)
+          sleep_for = [@events.map(&:monotime).min - fsecs, 0].max # if we have events, set to sleep until it's time for the next one to run. (the max bit ensure we don't have negative sleep times)
         end                                                        #
         @mx_events.sleep sleep_for                                 # do sleep
                                                                    #
-        now = Time.now                                             #
-        run, defer = @events.partition { |ev| ev.time <= now }     # separate events to run now and events to run later
+        now = fsecs                                                #
+        run, defer = @events.partition { |ev| ev.monotime <= now } # separate events to run now and events to run later
         defer += run.select { |ev| ev.is_a? RepeatEvent }          # repeat events both run and are deferred
         @events.replace(defer)                                     # keep only events to run later
       }                                                            #
                                                                    #
       next if run.empty?                                           # done here if there's nothing to run now
-      run.sort_by(&:time).each { |ev| ev.run! }                    # run the events scheduled to run now
-      last_run = Time.now                                          # store that we did run things at this time, go immediately on to the next loop iteration as it may be time to run more things
+      run.sort_by(&:monotime).each { |ev| ev.run! }                # run the events scheduled to run now
+      last_run = fsecs                                             # store that we did run things at this time, go immediately on to the next loop iteration as it may be time to run more things
     end
   end
 
@@ -112,41 +107,30 @@ class Rack::Timeout::Scheduler
 
   # adds a RunEvent struct to the run schedule
   def schedule(event)
-    assert_types! event => RunEvent
     @mx_events.synchronize { @events << event }
     runner.run  # wakes up the runner thread so it can recalculate sleep length taking this new event into consideration
     return event
   end
 
-  # reschedules an event to run at a different time. returns nil and does nothing if the event is not already in the queue (might've run already), otherwise updates the event time in-place; returns the updated event
-  def reschedule(event, time)
-    assert_types! event => RunEvent, time => Time
+  # reschedules an event by the given number of seconds. can be negative to run sooner.
+  # returns nil and does nothing if the event is not already in the queue (might've run already), otherwise updates the event time in-place; returns the updated event.
+  def delay(event, secs)
     @mx_events.synchronize {
       return unless @events.include? event
-      event.time = time
+      event.monotime += secs
       runner.run
       return event
     }
   end
 
-  # reschedules an event by the given number of seconds. can be negative to run sooner.
-  def delay(event, secs)
-    reschedule(event, event.time + secs)
-  end
-
-  # schedules a block to run at a given time; returns the created event object
-  def run_at(time, &block)
-    schedule RunEvent.new(time, block)
-  end
-
   # schedules a block to run in the given number of seconds; returns the created event object
   def run_in(secs, &block)
-    run_at(Time.now + secs, &block)
+    schedule RunEvent.new(fsecs + secs, block)
   end
 
   # schedules a block to run every x seconds; returns the created event object
   def run_every(seconds, &block)
-    schedule RepeatEvent.new(Time.now, block, seconds)
+    schedule RepeatEvent.new(fsecs, block, seconds)
   end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-timeout
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Caio Chassot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-07 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies: []
 description: Rack middleware which aborts requests that have been running for longer
   than a specified timeout.
@@ -23,11 +23,12 @@ files:
 - 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
 - lib/rack/timeout/rollbar.rb
-- lib/rack/timeout/support/assert-types.rb
+- lib/rack/timeout/support/monotonic_time.rb
 - lib/rack/timeout/support/namespace.rb
 - lib/rack/timeout/support/scheduler.rb
 - lib/rack/timeout/support/timeout.rb
@@ -51,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Abort requests that are taking too long

data/lib/rack/timeout/support/assert-types.rb

@@ -1,14 +0,0 @@
-require_relative "namespace"
-
-module Rack::Timeout::AssertTypes
-  extend self
-
-  def assert_types! value_type_map
-    value_type_map.each do |val, types|
-      types = [types] unless types.is_a? Array
-      next if types.any? { |type| val.is_a? type }
-      raise TypeError, "#{val.inspect} is not a #{types.join(" | ")}"
-    end
-  end
-
-end