rack-timeout 0.0.4 → 0.1.0beta

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjU4ZjQzOTJjZTcwNDdiZGZiZmU0YWI5NDMyMDRlYzU3Y2M3MTRjNQ==
+    ZmIyM2ZmYTI0MGY2MWM2YjViZDYwNDZjZjEyNGEwODM5OGY5MGUzYw==
   data.tar.gz: !binary |-
-    ZGRlNjU2ZGExNWY2NTYxODU5ZTgyYmMxYWM4MmM2NmYxZDZlNzQ2Ng==
+    YmE0ZjYyZGNjOWE1NTljN2VhYjBjM2E5ZmI3NWIzMjIyY2YzZGJiYQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZWIyMTg0ODVmM2JkMDE0YzUxZjcxZmNiZTYzMjQxZWZmMzc2YTJlMGQ4OTAz
-    NDBlMzczYTY5MDM4YTlkY2JiMTYwOGNjNDNhYTE3YzhiZDQyNjEwOTgxZjVi
-    ZjYxZDQxZWNiZDMxNzM5NzI4ZmUwMDU2NWJlNzJjNWM0YzM5M2Q=
+    NjQxODhjN2JlNjNjM2E2NzI1NDA4NzRhNDFjMmUxYmVmMTFlOGI1NWU3ZWNk
+    NDNkMDYwZjc5YjRiZTE3NGViYTY1YjQyYWJiMjcyZWJhNGMzMjQ0ZTk3M2E1
+    NGI2YTk3YzZjZmRlMmUyNGFkYmQ3OWM2MjdkYTZhZGY1ZWMwZDA=
   data.tar.gz: !binary |-
-    YzQzMzU3MDAxMWY3Y2U4YzY3MjZhYmU4YmRlOGEzOTVjOTNkZWZjNjRiMDlk
-    NWZmMWQ1Zjk4ZjdiNThhOTJiMjQ0N2RhODYwNmQyZTYxM2I0NTM4ZTAzYjQ3
-    M2EwNmEzMzc1OWM4NmY3ZjhkYTgzMGJiYjNlODJmZGEyNWM2MWI=
+    ODg1ODEzZjRhY2FiYmY1NjBmYzkzZDZlZTAxZjRmZWU5MDk3NGY5OWMyN2Q4
+    ZDcyN2QwMzM2NjM5N2RjYzIwYWU3MDE3OWI0NGMyNGRhOTNhYTQxNzMxNTcz
+    YzAwMzE1OTZmMTA5ZmU2OTdmMWNjN2JlYTI3MmVjMjIzMTVjNmM=

data/README.markdown

@@ -1,64 +1,62 @@
 Rack::Timeout
 =============
 
-Abort requests that are taking too long; a Timeout::Error will be raised.
+Abort requests that are taking too long; a `Rack::Timeout::Error` will be raised.
 
 
 Usage
 -----
 
-### Rails 3 app or Rails 2.3 app with Ruby 1.9 and Bundler
+Setup for current versions of Rails, Rack, Ruby, and Bundler. See next section for legacy versions.
 
-    # Gemfile
-    gem "rack-timeout"
-
-### Rails 3 app or Rails 2.3 app with Ruby 1.8 and Bundler
+### Rails apps
 
     # Gemfile
-    gem "SystemTimer", :require => "system_timer", :platforms => :ruby_18
     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:
 
-### Rails 2.3 app without Bundler
-
-    # config/environment.rb
-    config.gem "SystemTimer", :lib => "system_timer" if RUBY_VERSION < "1.9"
-    config.gem "rack-timeout"
-
+    # config/initializers/timeout.rb
+    Rack::Timeout.timeout = 10  # seconds
 
 ### Sinatra and other Rack apps
 
     # config.ru
     require "rack/timeout"
-    use Rack::Timeout           # call as early as possible so rack-timeout runs before other middlewares.
-    Rack::Timeout.timeout = 10  # this line is optional. if omitted, default is 15 seconds.
+    use Rack::Timeout           # Call as early as possible so rack-timeout runs before other middleware.
+    Rack::Timeout.timeout = 10  # This line is optional. If omitted, timeout defaults to 15 seconds.
 
-### Setting a custom timeout for Rails apps
 
-    # config/initializers/timeout.rb
-    Rack::Timeout.timeout = 10  # seconds
+Compatibility
+-------------
 
+This version of Rack::Timeout is compatible with Ruby 1.9.1 and up, and, for Rails apps, Rails 3.x
+and up.
 
-### Here be dragons
+For applications running Ruby 1.8.x and/or Rails 2.x, use [version 0.0.4][v0.0.4].
 
-SystemTimer/timeout rely on threads. If your app or any of the libraries it depends on is not thread-safe,
-you may run into issues using rack-timeout.
+[v0.0.4]: https://github.com/kch/rack-timeout/tree/v0.0.4
 
-Concurrent web servers such as [Unicorn][] and [Puma][] should work fine with rack-timeout.
 
-[Unicorn]: http://unicorn.bogomips.org/
-[Puma]: http://puma.io/
+Here be dragons
+---------------
+
+*   Ruby's Timeout rely on threads. If your app or any of the libraries it depends on is not
+    thread-safe, you may run into issues using Rack::Timeout.
 
-#### A note about testing timeouts in Rails apps
+    Concurrent web servers such as [Unicorn][] and [Puma][] should work fine with Rack::Timeout.
 
-If you're trying to test that a `Timeout::Error` is being raised in your Rails application, please note that
-it's **not possible in functional tests**. You *can*, however, test `assert_raises Rack::Timeout::Error`
-in integration tests.
+*   If you're trying to test that a `Rack::Timeout::Error` 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.
 
-There are more details about general rack middleware testing with Rails in this [@pablobm's answer on Stack Overflow][pablobm].
+    [More details about testing middleware with Rails here][pablobm].
 
+[Unicorn]: http://unicorn.bogomips.org/
+[Puma]:    http://puma.io/
 [pablobm]: http://stackoverflow.com/a/8681208/13989
 
 ---
-Copyright © 2010 Caio Chassot, released under the MIT license  
+Copyright © 2010-2013 Caio Chassot, released under the MIT license  
 <http://github.com/kch/rack-timeout>

data/lib/rack-timeout.rb

@@ -1,11 +1,9 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), 'rack/timeout')
+# encoding: utf-8
+require_relative 'rack/timeout'
 
-if defined? Rails
-  case Rails::VERSION::MAJOR
-  when 2; Rails.configuration.middleware.insert 0, Rack::Timeout
-  when 3
-    class Rack::Timeout::Railtie < Rails::Railtie
-      initializer("rack-timeout.insert-rack-timeout") { |app| app.config.middleware.insert 0, Rack::Timeout }
-    end
+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 }
+    initializer('rack-timeout.timeout-trap') { |app| app.config.middleware.use Rack::Timeout::AbortionReporter }
   end
 end

data/lib/rack/timeout.rb

@@ -1,8 +1,19 @@
-require RUBY_VERSION < '1.9' && RUBY_PLATFORM != 'java' ? 'system_timer' : 'timeout'
-SystemTimer ||= Timeout
+# encoding: utf-8
+require 'timeout'
+require 'securerandom'
 
 module Rack
   class Timeout
+    class Error < RuntimeError;        end
+    class RequestTooOldError  < Error; end
+    class RequestAbortedError < Error; end
+
+    RequestData          = Struct.new(:id, :age, :timeout, :duration, :state)
+    ENV_INFO_KEY         = 'rack-timeout.info'
+    FRAMEWORK_ERROR_KEYS = %w(sinatra.error rack.exception)
+    FINAL_STATES         = [:dropped, :aborted, :completed]
+    MAX_REQUEST_AGE      = 30 # seconds
+
     @timeout = 15
     class << self
       attr_accessor :timeout
@@ -13,7 +24,65 @@ module Rack
     end
 
     def call(env)
-      SystemTimer.timeout(self.class.timeout, ::Timeout::Error) { @app.call(env) }
+      info          = env[ENV_INFO_KEY] ||= RequestData.new
+      info.id     ||= env['HTTP_HEROKU_REQUEST_ID'] || SecureRandom.hex
+      request_start = env['HTTP_X_REQUEST_START'] # unix timestamp in ms
+      request_start = Time.at(request_start.to_i / 1000) if request_start
+      info.age      = Time.now - request_start           if request_start
+      time_left     = MAX_REQUEST_AGE - info.age         if info.age
+      info.timeout  = [self.class.timeout, time_left].compact.select { |n| n >= 0 }.min
+
+      if time_left && time_left <= 0
+        Rack::Timeout.set_state_and_log! info, :dropped
+        raise RequestTooOldError
+      end
+
+      Rack::Timeout.set_state_and_log! info, :ready
+      ::Timeout.timeout(info.timeout, RequestAbortedError) do
+        ready_time    = Time.now
+        response      = Rack::Timeout.perform_reporting_abortion_state_in_env(env) { @app.call(env) }
+        info.duration = Time.now - ready_time
+        Rack::Timeout.set_state_and_log! info, :completed
+        response
+      end
+    end
+
+    def self.perform_reporting_abortion_state_in_env(env)
+      yield
+    rescue RequestAbortedError
+      set_aborted! env
+      raise
+    ensure
+      set_aborted! env if env.values_at(*FRAMEWORK_ERROR_KEYS).any? { |e| e.is_a? RequestAbortedError }
+    end
+
+    def self.set_aborted!(env)
+      set_state_and_log!(env[ENV_INFO_KEY], :aborted)
+    end
+
+    def self.set_state_and_log!(info, state)
+      return if FINAL_STATES.include? info.state
+      info.state = state
+      ms         = ->(s) { '%.fms' % (s * 1000) }
+      s          = 'source=rack-timeout'
+      s << ' id='       << info.id           if info.id
+      s << ' age='      << ms[info.age]      if info.age
+      s << ' timeout='  << ms[info.timeout]  if info.timeout
+      s << ' duration=' << ms[info.duration] if info.duration
+      s << ' state='    << info.state.to_s   if info.state
+      s << "\n"
+
+      $stderr << s
+    end
+
+    class AbortionReporter
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Rack::Timeout.perform_reporting_abortion_state_in_env(env) { @app.call(env) }
+      end
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0beta
 platform: ruby
 authors:
 - Caio Chassot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-25 00:00:00.000000000 Z
+date: 2013-04-26 00:00:00.000000000 Z
 dependencies: []
 description: Rack middleware which aborts requests that have been running for longer
   than a specified timeout.
@@ -36,9 +36,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.0.3