rack-timeout 0.2.4 → 0.3.0.pre.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e81979fd4ab255202903c4725b6e606787a88488
-  data.tar.gz: 50c5e794cee0ac985afc5d408fb8493f61de3090
+  metadata.gz: 0115bc1c87b36ff9e6f74cb104e0c8fb13550685
+  data.tar.gz: d2eaf62f154d099701b263db687897e15d3104c5
 SHA512:
-  metadata.gz: eed8aa26bff0e4b772202c99fe14cd3ac52c0a36be3df866db8b47badc198beef350f47eb6f4c2700d65a7247201fbb5eb09752789a8db58fd22fcebff19f223
-  data.tar.gz: 6fb59f55bd49cd1db83c09560cc3ec81bf6e157b85ebd001aa06081c96616bd08cacbd197eb0de7cbdaf29e1b0e85e66cc77cef5801fb47a66be219761d5143a
+  metadata.gz: 61f9683c26d18d2da7b0b9d51834e86865af64b72ab2a54eea780b9522724c641a6156366122b9047f630298dd89d15c5d859ec539e88de0668a529aa2f71933
+  data.tar.gz: 75c7d46b222be49a805e992f3d7c3a9abe769614cfc7edbb65393d9a7922ad6fab5de75a5c607ac8cee2fb629822fcb3bbd3bef37cccd4c74cf0799fb3fafcc7

data/CHANGELOG

@@ -0,0 +1,59 @@
+0.3.0-beta.1
+============
+- instead of inserting middleware at position 0 for rails, insert before Rack::Runtime (which is right after Rack::Lock and the static file stuff)
+- 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
+- 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
+
+0.2.4
+=====
+- Previous fix was borked.
+
+0.2.3
+=====
+- Ignore Rack::NullLogger when picking a logger
+
+0.2.1
+=====
+- Fix raised error messages
+
+0.2.0
+=====
+- Added CHANGELOG
+- Rack::Timeout::Error now inherits from Exception instead of StandardError, with the hope users won't rescue from it accidentally
+
+0.1.2
+=====
+- improve RequestTimeoutError error string so @watsonian is happy
+
+0.1.1
+=====
+- README updates
+- fix that setting properties to false resulted in an error
+
+0.1.0
+=====
+- Rewrote README
+
+0.1.0beta4
+==========
+- Renamed `timeout` setting to `service_timeout`; `timeout=` still works for backwards compatibility
+– `MAX_REQUEST_AGE` is gone, the `wait_timeout` setting more or less replaces it
+- Renamed `overtime` setting to `wait_overtime`
+- overtime setting should actually work (It had never made it to beta3)
+- In the request info struct, renamed `age` to `wait`, `duration` to `service`
+- Rack::Timeout::StageChangeLogger is gone, replaced by Rack::Timeout::StageChangeLoggingObserver, which is an observer class that composites with a logger, instead of inheriting from Logger. Anything logging related will likely be incompatible with previous beta release.
+- Log level can no longer be set with env vars, has to be set in the logger being used. (Which can now be custom / user-provided.)
+
+0.1.0beta1,2,3
+==============
+- Dropped ruby 1.8.x support
+- Dropped rails 2 support
+- Added rails 4 support
+- Added much logging
+– Added support for dropping requests that waited too long in the queue without ever handling them
+- Other things I can't remember, see git logs :P

data/README.markdown

@@ -1,13 +1,13 @@
 Rack::Timeout
 =============
 
-Abort requests that are taking too long; a subclass of `Rack::Timeout::Error` is raised.
+Abort requests that are taking too long; an exception is raised.
 
 A generous timeout of 15s is the default. It's recommended to set the timeout as low as realistically viable for your application. Most applications will do fine with a setting between 2 and 5 seconds.
 
 There's a handful of other settings, read on for details.
 
-Rack::Timeout is not a solution to the problem of long-running requests, it's a debug and remediation tool. App developers should track rack-timeout's data and address recurring instances of particular timeouts, for example by refactoring code so it runs faster or offseting lengthy work to happen asynchronously.
+Rack::Timeout is not a solution to the problem of long-running requests, it's a debug and remediation tool. App developers should track rack-timeout's data and address recurring instances of particular timeouts, for example by refactoring code so it runs faster or offsetting lengthy work to happen asynchronously.
 
 
 Basic Usage
@@ -22,13 +22,34 @@ The following covers currently supported versions of Rails, Rack, Ruby, and Bund
 gem "rack-timeout"
 ```
 
-That's all that's required if you want to use the default timeout of 15s. To use a custom timeout, create an initializer file:
+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/timeout.rb
 Rack::Timeout.timeout = 5  # seconds
 ```
 
+### Rails apps, manually
+
+You'll need to do this if you removed `Rack::Runtime` from the middleware stack, or if you want to determine yourself where in the stack `Rack::Timeout` gets inserted.
+
+```ruby
+# Gemfile
+gem "rack-timeout", require:"rack/timeout/base"
+```
+
+```ruby
+# config/initializers/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
+```
+
 ### Sinatra and other Rack apps
 
 ```ruby
@@ -46,7 +67,7 @@ The Rabbit Hole
 
 `Rack::Timeout.timeout` (or `Rack::Timeout.service_timeout`) is our principal 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 a `Rack::Timeout::RequestTimeoutError` error is raised on the application thread. This may be automatically caught by the framework or plugins, so beware. Also, the error is not guaranteed to be raised in a timely fashion, see section below about IO blocks.
+*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.
 
 Service timeout can be disabled entirely by setting the property to `0` or `false`, at which point the request skips Rack::Timeout's machinery (so no logging will be present).
 
@@ -104,7 +125,7 @@ More detailed explanations of the issues surrounding timing out in ruby during I
 
 ### Timing Out Inherently Unsafe
 
-Raising mid-flight in stateful applications is inherently unsafe. A request can be aborted at any moment in the code flow, and the application cam be left in an inconsistent state. There's little way rack-timeout could be aware of ongoing state changes. Applications that rely on a set of globals (like class variables) or any other state that lives beyond a single request may find those left in an unexpected/inconsistent state after an aborted request. Some cleanup code might not have run, or only half of a set of related changes may have been applied.
+Raising mid-flight in stateful applications is inherently unsafe. A request can be aborted at any moment in the code flow, and the application can be left in an inconsistent state. There's little way rack-timeout could be aware of ongoing state changes. Applications that rely on a set of globals (like class variables) or any other state that lives beyond a single request may find those left in an unexpected/inconsistent state after an aborted request. Some cleanup code might not have run, or only half of a set of related changes may have been applied.
 
 A lot more can go wrong. An intricate explanation of the issue by JRuby's Charles Nutter can be found [here][broken-timeout].
 
@@ -136,13 +157,13 @@ The value of that entry is an instance of `Rack::Timeout::RequestDetails`, which
 
 *   `state`: the possible states, and their log level, are:
 
-    *   `expired` (`ERROR`): the request is considered too old and is skipped entirely. This happens when `X-Request-Start` is present and older than `wait_timeout`. When in this state, a `Rack::Timeout::RequestExpiryError` exception is raised. See earlier discussion about the `wait_overtime` setting, too.
+    *   `expired` (`ERROR`): the request is considered too old and is skipped entirely. This happens when `X-Request-Start` is present and older than `wait_timeout`. When in this state, `Rack::Timeout::RequestExpiryError` is raised. See earlier discussion about the `wait_overtime` setting, too.
 
     *   `ready` (`INFO`): this is the state a request is in right before it's passed down the middleware chain. Once it's being processed, it'll move on to `active`, and then on to `timed_out` and/or `completed`.
 
     *   `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. A `Rack::Timeout::RequestTimeoutError` error is raised in the application when this occurs. If this error 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.
+    *   `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.)
 
     *   `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.
 
@@ -150,17 +171,23 @@ The value of that entry is an instance of `Rack::Timeout::RequestDetails`, which
 Errors
 ------
 
-Rack::Timeout can raise two types of exceptions. Both descend from `Rack::Timeout::Error`, which itself descends from `RuntimeError`. They are:
+Rack::Timeout can raise three types of exceptions. They are:
 
-*   `Rack::Timeout::RequestTimeoutError`: this is raised when a request has run for longer than the specified timeout. 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 can generally be caught 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.
+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.
 
+*   `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.
+
 You shouldn't rescue from these errors for reporting purposes. Instead, you can subscribe for state change notifications with observers.
 
-If you're trying to test that a `Rack::Timeout::RequestTimeoutError` is raised in an action in your Rails application, you **must do so in integration tests**. Please note that Rack::Timeout will not kick in for functional tests as they bypass the rack middleware stack.
+If you're trying to test that a `Rack::Timeout::RequestTimeoutException` is raised in an action in your Rails application, you **must do so in integration tests**. Please note that Rack::Timeout will not kick in for functional tests as they bypass the rack middleware stack.
 
 [More details about testing middleware with Rails here][pablobm].
 
@@ -187,7 +214,7 @@ Rack::Timeout.unregister_state_change_observer(:a_unique_name)
 ```
 
 
-rack-timeout's logging is implemented using an observer; see `Rack::Timeout::StageChangeLoggingObserver` in logger.rb for the implementation.
+rack-timeout's logging is implemented using an observer; see `Rack::Timeout::StateChangeLoggingObserver` in logging-observer.rb for the implementation.
 
 Custom observers might be used to do cleanup, store statistics on request length, timeouts, etc., and potentially do performance tuning on the fly.
 
@@ -201,18 +228,27 @@ Request state changes into `timed_out` and `expired` are logged at the `ERROR` l
 
 Rack::Timeout will try to use `Rails.logger` if present, otherwise it'll look for a logger in `env['rack.logger']`, and if neither are present, it'll create its own logger, either writing to `env['rack.errors']`, or to `$stderr` if the former is not set.
 
-A custom logger can be set via `Rack::Timeout::StageChangeLoggingObserver.logger`. This takes priority over the automatic logger detection:
+When creating its own logger, rack-timeout will use a log level of `INFO`. Otherwise whatever log level is already set on the logger being used continues in effect.
+
+A custom logger can be set via `Rack::Timeout::Logger.logger`. This takes priority over the automatic logger detection:
 
 ```ruby
-Rack::Timeout::StageChangeLoggingObserver.logger = Logger.new
+Rack::Timeout::Logger.logger = Logger.new
 ```
 
-When creating its own logger, rack-timeout will use a log level of `INFO`. Otherwise whatever log level is already set on the logger being used continues in effect.
+There are helper setters that replace the logger:
+
+```ruby
+Rack::Timeout::Logger.device = $stderr
+Rack::Timeout::Logger.level  = Logger::INFO
+```
+
+Although each call replaces the logger, these can be use together and the final logger will retain both properties. (If only one is called, the defaults used above apply.)
 
-Logging is enabled by default if Rack::Timeout is loaded via the `rack-timeout` file (recommended), but can be removed by unregistering its observer:
+Logging is enabled by default, but can be removed with:
 
 ```ruby
-Rack::Timeout.unregister_state_change_observer(:logger)
+Rack::Timeout::Logger.disable
 ```
 
 Each log line is a set of `key=value` pairs, containing the entries from the `env["rack-timeout.info"]` struct that are not `nil`. See the Request Lifetime section above for a description of each field. Note that while the values for `wait`, `timeout`, and `service` are stored internally as seconds, they are logged as milliseconds for readability.
@@ -237,5 +273,5 @@ For applications running Ruby 1.8.x and/or Rails 2.x, use [version 0.0.4][v0.0.4
 
 
 ---
-Copyright © 2010-2014 Caio Chassot, released under the MIT license  
+Copyright © 2010-2015 Caio Chassot, released under the MIT license  
 <http://github.com/heroku/rack-timeout>

data/lib/rack-timeout.rb

@@ -1,11 +1,2 @@
-# encoding: utf-8
-require 'rack/timeout'
-require 'rack/timeout/logger'
-
-if defined?(Rails) && [3,4].include?(Rails::VERSION::MAJOR)
-  class Rack::Timeout::Railtie < Rails::Railtie
-    initializer('rack-timeout.prepend') { |app| app.config.middleware.insert 0, Rack::Timeout }
-  end
-end
-
-Rack::Timeout::StageChangeLoggingObserver.register!
+require_relative "rack/timeout/base"
+require_relative "rack/timeout/rails" if defined?(Rails) && [3,4].include?(Rails::VERSION::MAJOR)

data/lib/rack/timeout/base.rb

@@ -0,0 +1,4 @@
+require_relative "core"
+require_relative "logger"
+
+Rack::Timeout::Logger.init

data/lib/rack/{timeout.rb → timeout/core.rb}

@@ -1,11 +1,23 @@
 # encoding: utf-8
-require 'securerandom'
+require "securerandom"
 
 module Rack
   class Timeout
-    class Error < Exception;           end # superclass for the following…
-    class RequestExpiryError  < Error; end # raised when a request is dropped without being given a chance to run (because too old)
-    class RequestTimeoutError < Error; end # raised when a request has run for too long
+    module ExceptionWithEnv # shared by the following exceptions, allows them to receive the current env
+      attr :env
+      def initialize(env)
+        @env = env
+      end
+    end
+
+    class Error < RuntimeError
+      include ExceptionWithEnv
+    end
+    class RequestExpiryError  < Error; end    # raised when a request is dropped without being given a chance to run (because too old)
+    class RequestTimeoutError < Error; end    # raised when a request has run for too long
+    class RequestTimeoutException < Exception # This is first raised to help prevent an application from inadvertently catching the above. It's then caught by rack-timeout and replaced with RequestTimeoutError to bubble up to wrapping middlewares and the web server
+      include ExceptionWithEnv
+    end
 
     RequestDetails = Struct.new(
       :id,        # a unique identifier for the request. informative-only.
@@ -15,7 +27,7 @@ module Rack
       :state,     # the request's current state, see below:
     ) {
       def ms(k)   # helper method used for formatting values in milliseconds
-        '%.fms' % (self[k] * 1000) if self[k]
+        "%.fms" % (self[k] * 1000) if self[k]
       end
     }
     VALID_STATES = [
@@ -25,7 +37,7 @@ 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" # 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
@@ -64,10 +76,10 @@ 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"] || SecureRandom.hex
 
       time_started_service = Time.now                      # The time the request started being processed by rack
-      time_started_wait    = RT._read_x_request_start(env) # The time the request was initially receibed by the web server (if available)
+      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)
       seconds_service_left = nil
 
@@ -80,7 +92,7 @@ module Rack
         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)
           RT._set_state! env, :expired
-          raise RequestExpiryError, "Request older than #{info.ms(:timeout)}."
+          raise RequestExpiryError.new(env), "Request older than #{info.ms(:timeout)}."
         end
       end
 
@@ -103,9 +115,14 @@ module Rack
             sleep(sleep_seconds)
           end
           RT._set_state! env, :timed_out
-          app_thread.raise(RequestTimeoutError, "Request #{"waited #{info.ms(:wait)}, then " if info.wait}ran for longer than #{info.ms(:timeout)}")
+          app_thread.raise(RequestTimeoutException.new(env), "Request #{"waited #{info.ms(:wait)}, then " if info.wait}ran for longer than #{info.ms(:timeout)}")
         end
+
         response = @app.call(env)
+
+      rescue RequestTimeoutException => e
+        raise RequestTimeoutError.new(env), e.message, e.backtrace
+
       ensure
         timeout_thread.kill
         timeout_thread.join
@@ -133,7 +150,7 @@ module Rack
     RX_NGINX_X_REQUEST_START  = /^(?:t=)?(\d+)\.(\d{3})$/
     RX_HEROKU_X_REQUEST_START = /^(\d+)$/
     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
@@ -141,9 +158,9 @@ module Rack
     # This method determines if a body is present. requests with a body (generally POST, PUT) can have a lengthy body which may have taken a while to be received by the web server, inflating their computed wait time. This in turn could lead to unwanted expirations. See wait_overtime property as a way to overcome those.
     # This is a code extraction for readability, this method is only called from a single point.
     def self._request_has_body?(env)
-      return true  if env['HTTP_TRANSFER_ENCODING'] == 'chunked'
-      return false if env['CONTENT_LENGTH'].nil?
-      return false if env['CONTENT_LENGTH'].to_i.zero?
+      return true  if env["HTTP_TRANSFER_ENCODING"] == "chunked"
+      return false if env["CONTENT_LENGTH"].nil?
+      return false if env["CONTENT_LENGTH"].to_i.zero?
       true
     end
 

data/lib/rack/timeout/logger.rb

@@ -1,58 +1,39 @@
-require 'logger'
-
-class Rack::Timeout
-  class StageChangeLoggingObserver
-    STATE_LOG_LEVEL = { :expired   => :error,
-                        :ready     => :info,
-                        :active    => :debug,
-                        :timed_out => :error,
-                        :completed => :info,
-                      }
-
-    # creates a logger and registers for state change notifications in Rack::Timeout
-    def self.register!(logger = nil)
-      new.register!(logger)
-    end
-
-    # registers for state change notifications in Rack::Timeout (or other explicit target (potentially useful for testing))
-    def register!(logger = nil, target = ::Rack::Timeout)
-      @logger = logger
-      target.register_state_change_observer(:logger, &method(:log_state_change))
-    end
-
-    SIMPLE_FORMATTER = ->(severity, timestamp, progname, msg) { "#{msg} at=#{severity.downcase}\n" }
-    def self.mk_logger(device, level = ::Logger::INFO)
-      ::Logger.new(device).tap do |logger|
-        logger.level     = level
-        logger.formatter = SIMPLE_FORMATTER
-      end
-    end
-
-    class << self
-      attr_accessor :logger
-    end
-    def logger(env = nil)
-      self.class.logger ||
-        (defined?(::Rails) && 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))
-    end
-
-    # generates the actual log string
-    def log_state_change(env)
-      info = env[ENV_INFO_KEY]
-      level = STATE_LOG_LEVEL[info.state]
-      logger(env).send(level) do
-        s  = 'source=rack-timeout'
-        s << ' id='      << info.id           if info.id
-        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 << ' state='   << info.state.to_s   if info.state
-        s
-      end
-    end
+require "logger"
+require_relative "core"
+require_relative "logging-observer"
 
+module Rack::Timeout::Logger
+  extend self
+  attr :device, :level, :logger
+
+  def device=(new_device)
+    update(new_device, level)
+  end
+
+  def level=(new_level)
+    update(device, new_level)
+  end
+
+  def logger=(new_logger)
+    @logger = @observer.logger = new_logger
+  end
+
+  def init
+    @observer = ::Rack::Timeout::StateChangeLoggingObserver.new
+    ::Rack::Timeout.register_state_change_observer(:logger, &@observer.callback)
+    @inited = true
+  end
+
+  def disable
+    @observer, @logger, @level, @device, @inited = nil
+    ::Rack::Timeout.unregister_state_change_observer(:logger)
   end
+
+  def update(new_device, new_level)
+    init unless @inited
+    @device     = new_device || $stderr
+    @level      = new_level  || ::Logger::INFO
+    self.logger = ::Rack::Timeout::StateChangeLoggingObserver.mk_logger(device, level)
+  end
+
 end

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

@@ -0,0 +1,53 @@
+require "logger"
+require_relative "core"
+
+class Rack::Timeout::StateChangeLoggingObserver
+  STATE_LOG_LEVEL = { :expired   => :error,
+                      :ready     => :info,
+                      :active    => :debug,
+                      :timed_out => :error,
+                      :completed => :info,
+                    }
+
+  # returns the Proc to be used as the observer callback block
+  def callback
+    method(:log_state_change)
+  end
+
+  SIMPLE_FORMATTER = ->(severity, timestamp, progname, msg) { "#{msg} at=#{severity.downcase}\n" }
+  def self.mk_logger(device, level = ::Logger::INFO)
+    ::Logger.new(device).tap do |logger|
+      logger.level     = level
+      logger.formatter = SIMPLE_FORMATTER
+    end
+  end
+
+
+  attr_writer :logger
+
+  private
+
+  def logger(env = nil)
+    @logger ||
+      (defined?(::Rails) && ::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))
+  end
+
+  # generates the actual log string
+  def log_state_change(env)
+    info = env[::Rack::Timeout::ENV_INFO_KEY]
+    level = STATE_LOG_LEVEL[info.state]
+    logger(env).send(level) do
+      s  = "source=rack-timeout"
+      s << " id="      << info.id           if info.id
+      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 << " state="   << info.state.to_s   if info.state
+      s
+    end
+  end
+
+end

data/lib/rack/timeout/rails.rb

@@ -0,0 +1,8 @@
+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
+  end
+end

data/lib/rack/timeout/rollbar.rb

@@ -0,0 +1,31 @@
+require_relative "core"
+
+# Groups timeout exceptions in rollbar by exception class, http method, and url.
+# Usage: after requiring rollbar, call:
+#   require "rack/timeout/rollbar"
+#
+# This is somewhat experimental and very lightly tested.
+
+module Rack::Timeout::Rollbar
+  def build_payload(level, message, exception, extra)
+    payload = super(level, message, exception, extra)
+
+    return payload unless exception.is_a? ::Rack::Timeout::ExceptionWithEnv
+    return payload unless payload.respond_to? :[]
+
+    data = payload["data"]
+    return data unless data.respond_to? :[]=
+
+    request = ::Rack::Request.new(exception.env)
+
+    data["fingerprint"] = [
+      exception.class.name,
+      request.request_method,
+      request.fullpath
+      ].join(" ")
+
+    return payload
+  end
+end
+
+::Rollbar::Notifier.prepend ::Rack::Timeout::Rollbar

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-timeout
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0.pre.beta.1
 platform: ruby
 authors:
 - Caio Chassot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-31 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies: []
 description: Rack middleware which aborts requests that have been running for longer
   than a specified timeout.
@@ -17,11 +17,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG
 - MIT-LICENSE
 - README.markdown
 - lib/rack-timeout.rb
-- lib/rack/timeout.rb
+- lib/rack/timeout/base.rb
+- lib/rack/timeout/core.rb
 - lib/rack/timeout/logger.rb
+- lib/rack/timeout/logging-observer.rb
+- lib/rack/timeout/rails.rb
+- lib/rack/timeout/rollbar.rb
 homepage: http://github.com/heroku/rack-timeout
 licenses:
 - MIT
@@ -37,9 +42,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5