rack-timeout 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a270fccd2075f0f8333041b5bfbbc5c3fdf2c4c
-  data.tar.gz: 41588cd9b9e1fbfce990852177cb5ec7b284de0d
+  metadata.gz: 3011645170de523349a1928ac09ee55825019f0b
+  data.tar.gz: 17fcae3abe9f9cf37391a6381a795c142791cde5
 SHA512:
-  metadata.gz: 0768903ea52e7c2eeabd4140e1bebebe5d24f608e9c03ad1482c65f14d468d2cabd59bc2165502d3255005b420bc91c2797151fabb5483004d04d448569161e6
-  data.tar.gz: d6fb9a424a79dcbdc745b2d1b7be2718ef9baee6b9c22e4ba59e91e3446c64243a99c41424da91929668d2583c21c3284cb2d3e30ebd5a569ad84e61e03730fe
+  metadata.gz: 6eac121daa70934e450db7320a92544840bcc0adba0a38539af380394ac239b546fb428daefa0544a372bff20627f704dfe1ae4415ee99085de1b987b7af35c8
+  data.tar.gz: 7db38b0f4e1b4d9e2678de2efc867efd2b3381cb615dccf1d365f766576b08107a4d8bc7c2e1fdaf18846a912e88c8ba07862999a86002d7aa1046121b3e886b

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.3.1
+=====
+- Rollbar module improvements
+
 0.3.0
 =====
 - use a single scheduler thread to manage timeouts, instead of one timeout thread per request

data/lib/rack/timeout/core.rb

@@ -106,29 +106,29 @@ module Rack
       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
 
-      RT._set_state! env, :ready
+      RT._set_state! env, :ready                            # we're good to go, but have done nothing yet
 
-      heartbeat_event = nil
-      update_service = ->(status = :active) {
-        heartbeat_event.cancel! if status != :active
-        info.service = Time.now - time_started_service
-        RT._set_state! env, status
+      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
+        RT._set_state! env, status                          # update status
       }
-      heartbeat_event = RT::Scheduler.run_every(1) { update_service.call :active }
+      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
 
-      timeout = RT::Scheduler::Timeout.new do |app_thread|
-        update_service.call :timed_out
+      timeout = RT::Scheduler::Timeout.new do |app_thread|  # creates a timeout instance responsible for timing out the request. the given block runs if timed out
+        register_state_change.call :timed_out
         app_thread.raise(RequestTimeoutException.new(env), "Request #{"waited #{info.ms(:wait)}, then " if info.wait}ran for longer than #{info.ms(:timeout)}")
       end
 
-      response = timeout.timeout(info.timeout) do
-        begin  @app.call(env)
-        rescue RequestTimeoutException => e
-          raise RequestTimeoutError.new(env), e.message, e.backtrace
+      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
         end
       end
 
-      update_service.call :completed
+      register_state_change.call :completed
       response
     end
 

data/lib/rack/timeout/rollbar.rb

@@ -5,6 +5,8 @@ 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
 
 module Rack::Timeout::Rollbar
   def build_payload(level, message, exception, extra)
@@ -14,9 +16,12 @@ module Rack::Timeout::Rollbar
     return payload unless payload.respond_to? :[]
 
     data = payload["data"]
-    return data unless data.respond_to? :[]=
+    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,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-timeout
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Caio Chassot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-02 00:00:00.000000000 Z
+date: 2015-09-03 00:00:00.000000000 Z
 dependencies: []
 description: Rack middleware which aborts requests that have been running for longer
   than a specified timeout.