threaded 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db08fff84d920a28793a4f9d73340879fdcbb03c
-  data.tar.gz: 884731a111fbf0c32bcbc3b5ee4e5f105e290566
+  metadata.gz: eb7c53b0ad0fb2545af7eb99e905600f84571e5b
+  data.tar.gz: d2f05cd3e73110409d4b72fd963f843930c31c58
 SHA512:
-  metadata.gz: bdb4e659e9eab461a2eaf0939b6951f269f42d41d812da326cb4de43336d6633afeb8b6287a82bcf989a31bc4d98c29fea35073bb2ff8da36ba486be9c68435d
-  data.tar.gz: 86e6fc98fbd9245ae59642ffd1832ffdba70abdcbeeb128cf25c7a6b153ec02a296bdf143cf8fbe55cc2e376ee3e7c0f62cd3fe794b4b1d6f5009b48c0543132
+  metadata.gz: 2ffb7a3eb19a8a8b21ec6ff6a7bb21e2fb192aebce6c9b23b525cfde92b09749237585efb46651d19fe33063995c073c4a33d3e9033c9a074b818ad9cce3d866
+  data.tar.gz: f253a4bacd86226d36dd188c17c4b418191bb27c18a16b55cbeb94fa418a8f9aacfae66aa739902e1db1180876310a1e0ab770175d49bb4391ac2b1761138b6e

data/.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
 *.gem
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.0.3
+
+- Remove Gemfile.lock
+
+## 0.0.2
+
+- Allow syncing stdout in promises and turn functionality on by default.

data/README.md

@@ -4,9 +4,9 @@
 
 Simpler than actors, easier than threads. Get threaded!
 
-## Why
+## What
 
-Projects like [Resque](https://github.com/resque/resque), [delayed job](https://github.com/collectiveidea/delayed_job), [queue classic](https://github.com/ryandotsmith/queue_classic), and [sidekiq](https://github.com/mperham/sidekiq) are great. They use data stores like postgres and redis to store information to be processed later. If you're prototyping a system or don't have access to a data store, you might still want to push off some work to a background process. If that's the case an in-memory threaded queue might be a good fit.
+Why wait? If you're doing IO in MRI, or really anything in JRuby you can speed up your programs dramatically by using threads. Threads however are a low level primitive in Ruby that can be difficult to use. The `Threaded` library implements a few common thread patterns into an easy to use interface. This lets you focus on writing your code and `Threaded` will worry about running that code as fast as possible.
 
 ## Install
 
@@ -18,7 +18,130 @@ gem 'threaded'
 
 Then run `$ bundle install`
 
-## Use it
+
+# Simple Promises
+
+Throw tasks you want to get worked on in the background into a `Threaded.later` block:
+
+```ruby
+promise = Threaded.later do
+  require "YAML"
+  YAML.load `curl https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/ruby_versions.yml 2>/dev/null`
+end
+```
+
+Then when you need the value use the `value` method:
+
+```ruby
+promise.value # => ["ruby-2.0.0", "ruby-1.9.3", # ...
+```
+
+It's secretly doing all of that work in the background letting your main Ruby thread focus on the work you care about most.
+
+## Keep your Promises
+
+Promises will block when executed inside of one another, this means you can put promises in your promises and they'll always be executed in the correct order.
+
+```ruby
+curl = Threaded.later do
+  `curl https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/ruby_versions.yml 2>/dev/null`
+end
+
+yaml = Threaded.later do
+  require "YAML"
+  YAML.load curl.value
+end
+```
+
+This code guarantees that the block in `curl` gets executed before the `YAML.load`. Of course, the outcome is the same:
+
+```ruby
+yaml.value # => ["ruby-2.0.0", "ruby-1.9.3", # ...
+```
+
+While a contrived example, you can use this type of promise chaining to parallelize complex tasks.
+
+By the way, if you call `Threaded.later` and never call `value` on the returned object it may run but is not guaranteed to. So if you `value` your "promises" then you'll always keep them.
+
+## Promise STDOUT behavior
+
+A Threaded `later` block is supposed to look and feel like regular code. The biggest difference is that as soon as you define a `Threaded.later {}` block it begins to run in the background. Nothing throws off the illusion of "normal" code than sporadic random lines in your STDOUT. So by default Threaded captures all promise stdout and only outputs it when `value` is called.
+
+```ruby
+task = Threaded.later do
+  puts "HEY YOU GUYS!!!!"
+  10 * 10
+end
+```
+
+At this point the task has already run, but `"HEY YOU GUYS!!!"` is nowhere to be seen in STDOUT. It will show up as soon as you request the value
+
+
+```ruby
+puts task.value
+HEY YOU GUYS!!!!
+# => 100
+```
+
+If you don't like this voodoo and want to see really jumbled up STDIO, it's okay. You can set `Threaded.sync_promise_io = false`
+
+```ruby
+task = Threaded.later do
+  puts "HEY YOU GUYS!!!!"
+  10 * 10
+end
+# => "HEY YOU GUYS!!!"
+task.value
+# => 100
+```
+
+You can also set this value in a `config` block.
+
+## Noisey Shell Sessions
+
+Output from other shell sessions will still show up as soon as they execute.
+
+```
+Threaded.later do
+  `git clone git@github.com:schneems/threaded.git`
+end
+=> #<Threaded::Promise:0x007fd51c0a9b98 @mutex=#<Mutex:0x007fd51c0a9b20>, @has_run=false, @running=true, @result=nil, @error=nil, @job=#<Proc:0x007fd51c0a9bc0@/Users/schneems/Documents/projects/threaded/lib/threaded.rb:71>>
+remote: Counting objects: 221, done.
+remote: Compressing objects: 100% (130/130), done.
+remote: Total 221 (delta 115), reused 188 (delta 83)
+Receiving objects: 100% (221/221), 29.62 KiB | 0 bytes/s, done.
+Resolving deltas: 100% (115/115), done.
+```
+
+You can get around this by redirecting the IO:
+
+```
+out = `git clone git@github.com:schneems/threaded.git 2>/dev/null`
+puts out
+```
+In bash `1` is stdout, `2` is stderror. You can redirect a stream to another, for example to merge stderr into stdout you could run a command with `2>&1` at the end. To completely disregard output you can send it to `/dev/null` on unix systems.
+
+Note: git does some weird things when you try to redirect stderr to stdio `2>&1` (http://stackoverflow.com/a/18006967/147390).
+
+By using a library to direct the sub shell stdin, stdout, stderr like `Open3`:
+
+```
+require 'open3'
+Open3.popen3("git clone git@github.com:schneems/threaded.git") do |stdin, stdout, stderr, wait_thr|
+  puts stdout.read.chomp
+  puts stderr.read.chomp
+end
+```
+
+Or by running the command in a `--quiet` option if it has one:
+
+```
+`git clone git@github.com:schneems/threaded.git --quiet`
+```
+
+## Background Queue
+
+The engine that powers the `Threaded` promise is also a publicly available background queue! You may be familiar with `Resque` or `sidekiq` that allow you to enqueue jobs to be run later, threaded has something like that. The main difference is that threaded does not persist values to a permanent store (like Resque or PostgreSQL). Here's how you use it.
 
 Define your task to be processed:
 
@@ -31,7 +154,7 @@ class Archive
 end
 ```
 
-It can be any object that responds to `call` but we recommend a class or module which makes switching to a durable queue later easier.
+It can be any object that responds to `call` but we recommend a class or module which makes switching to a durable queue system (like Resque) easier.
 
 Then to enqueue a task to be run in the background use `Threaded.enqueue`:
 
@@ -43,7 +166,6 @@ Threaded.enqueue(Archive, repo.id, 'staging')
 The first argument is a class that defines the task to be processed and the rest of the arguments are passed to the task when it is run.
 
 
-
 # Configure
 
 The default number of worker threads is 16, you can configure that when you start your queue:
@@ -54,14 +176,6 @@ Threaded.config do |config|
 end
 ```
 
-By default jobs have a timeout value of 60 seconds. Since this is an in-memory queue (goes away when your process terminates) it is in your best interests to keep jobs small and quick, and not overload the queue. You can configure a different timeout on start:
-
-```ruby
-Threaded.config do |config|
-  config.timeout = 90 # timeout is in seconds
-end
-```
-
 Want a different logger? Specify a different Logger:
 
 ```ruby
@@ -70,10 +184,10 @@ Threaded.config do |config|
 end
 ```
 
-As soon as you call `enqueue` a new thread will be started, if you wish to explicitly start all threads you can call `Threaded.start`. You can also inline your config if you want when you start the queue:
+As soon as you call `enqueue` a new thread will be added to your thread pool if it is needed. If you wish to explicitly start all threads you can call `Threaded.start`. You can also inline your config if you want when you start the queue:
 
 ```ruby
-Threaded.start(size: 5, timeout: 90, logger: Logger.new(STDOUT))
+Threaded.start(size: 5, logger: Logger.new(STDOUT))
 ```
 
 For testing or guaranteed code execution use the `inline` option:
@@ -88,19 +202,11 @@ This option bypasses the queue and executes code as it comes.
 
 This worker operates in the same process as your app, that means if your app is CPU bound, it will not be very useful. This worker uses threads which means that to be useful your app needs to either use IO (database calls, file writes/reads, shelling out, etc.) or run on JRuby or Rubinius.
 
-To make sure all items in your queue are processed you can add a condition `at_exit` to your program:
+All other threading concerns remain true so be careful for using things like `Dir.chdir` inside of threaded as it changes the directory for all threads. Also don't modify shared data (unless you've got a mutex around it and know what you're doing).
 
-```ruby
-at_exit do
-  Threaded.stop
-end
-```
-
-This call takes an optional timeout value (in seconds).
+It is possible for you to enqueue more things in your queue than can be processed before your program exits (you hit CTRL+C, or get an exception). When your program exits all jobs promises and enqueued jobs go away as they are not persisted to disk. If you care about your data getting run always call `value` on promises. When `value` is called on promises if it has not already started running it will be run immediately. This functionality allows for the chaining of promises.
 
-```ruby
-Threaded.stop(42)
-```
+To truly preserve data you've `enqueued` into Threaded's background queue you need to switch to a durable queue backend like Resque. Alternatively use a promise and call `value` on the `Threaded.later` promise object.
 
 ## License
 

data/lib/threaded.rb

@@ -1,56 +1,81 @@
 require 'thread'
 require 'timeout'
 require 'logger'
+require 'stringio'
 
 require 'threaded/version'
-require 'threaded/timeout'
 
 module Threaded
   STOP_TIMEOUT = 10 # seconds
   extend self
-  attr_accessor :inline, :logger, :size, :timeout
-  alias :inline? :inline
 
   @mutex = Mutex.new
 
+  attr_reader :logger, :size, :inline, :sync_promise_io
+  alias :sync_promise_io? :sync_promise_io
+  alias :inline? :inline
+
+  def inline=(inline)
+    @mutex.synchronize { @inline = inline }
+  end
+
+  def logger=(logger)
+    @mutex.synchronize { @logger = logger }
+  end
+
+  def size=(size)
+    @mutex.synchronize { @size = size }
+  end
+
+  def sync_promise_io=(sync_promise_io)
+    @mutex.synchronize { @sync_promise_io = sync_promise_io }
+  end
+  @sync_promise_io = true
+
   def start(options = {})
-    self.master = options
+    raise "Queue is already started, must configure queue before starting" if options.any? && started?
+    options.each do |k, v|
+      self.send(k, v)
+    end
     self.master.start
     return self
   end
 
-  def configure(&block)
-    raise "Queue is already started, must configure queue before starting" if started?
+  def master
     @mutex.synchronize do
-      yield self
+      return @master if @master
+      @master = Master.new(logger: self.logger,
+                           size:   self.size)
     end
+    @master
+  end
+  alias :master= :master
+
+
+  def configure(&block)
+    raise "Queue is already started, must configure queue before starting" if started?
+    yield self
   end
   alias :config  :configure
 
   def started?
-    return false unless master
-    master.alive?
+    !stopped?
   end
 
   def stopped?
-    !started?
-  end
-
-  def master(options = {})
-    @mutex.synchronize do
-      return @master if @master
-      self.logger  = options[:logger]  if options[:logger]
-      self.size    = options[:size]    if options[:size]
-      self.timeout = options[:timeout] if options[:timeout]
-      @master = Master.new(logger:  self.logger,
-                           size:    self.size,
-                           timeout: self.timeout)
-    end
+    master.stopping?
   end
-  alias :master= :master
 
   def later(&block)
-    Threaded::Promise.new(&block).later
+    job = if sync_promise_io?
+      Proc.new {
+        Thread.current[:stdout] = StringIO.new
+        block.call
+      }
+    else
+      block
+    end
+    Threaded::Promise.new(&job).later
   end
 
   def enqueue(job, *args)
@@ -74,6 +99,7 @@ Threaded.logger.level = Logger::INFO
 
 
 require 'threaded/errors'
+require 'threaded/ext/stdout'
 require 'threaded/worker'
 require 'threaded/master'
 require 'threaded/promise'

data/lib/threaded/ext/stdout.rb

@@ -0,0 +1,12 @@
+# Redirects STDOUT to `Thread.current[:stdout]` if present
+$stdout.instance_eval do
+  alias :original_write :write
+end
+
+$stdout.define_singleton_method(:write) do |value|
+  if Thread.current[:stdout]
+    Thread.current[:stdout].write value
+  else
+    original_write value
+  end
+end

data/lib/threaded/master.rb

@@ -1,17 +1,14 @@
 module Threaded
   class Master
-    include Threaded::Timeout
-    attr_reader :workers, :logger
-
-    DEFAULT_TIMEOUT = 60 # seconds, 1 minute
+    DEFAULT_TIMEOUT = 10 # seconds
     DEFAULT_SIZE    = 16
+    attr_reader :workers, :logger
 
     def initialize(options = {})
       @queue    = Queue.new
       @mutex    = Mutex.new
       @stopping = false
       @max      = options[:size]     || DEFAULT_SIZE
-      @timeout  = options[:timeout]  || DEFAULT_TIMEOUT
       @logger   = options[:logger]   || Threaded.logger
       @workers  = []
     end
@@ -20,28 +17,24 @@ module Threaded
       @queue.enq([job, json])
 
       new_worker if needs_workers? && @queue.size > 0
-      raise NoWorkersError unless alive?
+      raise NoWorkersError unless workers.detect {|w| w.alive? }
       return true
     end
 
-    def alive?
-      return false if workers.empty?
-      workers.detect {|w| w.alive? }
-    end
-
     def start
-      return self if alive?
-      @max.times { new_worker }
+      new_workers(@max, true)
       return self
     end
 
-    def stop(timeout = 10)
-      poison
-      timeout(timeout, "waiting for workers to stop") do
-        while self.alive?
-          sleep 0.1
+    def stop(timeout = DEFAULT_TIMEOUT)
+      @mutex.synchronize do
+        @stopping = true
+        workers.each {|w| w.poison }
+        timeout(timeout, "waiting for workers to stop") do
+          while workers.any?
+            workers.reject! {|w| w.join if w.dead? }
+          end
         end
-        join
       end
       return self
     end
@@ -50,31 +43,38 @@ module Threaded
       @workers.size
     end
 
+    def stopping?
+      @stopping
+    end
+
     private
 
-    def needs_workers?
-      size < @max
+    def timeout(timeout, message = "", &block)
+      ::Timeout.timeout(timeout) do
+        yield
+      end
+    rescue ::Timeout::Error
+      logger.error("Took longer than #{timeout} to #{message.inspect}")
     end
 
-    def new_worker
-      @mutex.synchronize do
-        return false unless needs_workers?
-        return false if @stopping
-        @workers << Worker.new(@queue, timeout: @timeout)
-      end
+    def needs_workers?
+      size < @max
     end
 
-    def join
-      workers.each {|w| w.join }
-      return self
+    def max_workers?
+      !needs_workers?
     end
 
-    def poison
+    def new_worker(num = 1, force_start = false)
       @mutex.synchronize do
-        @stopping = true
+        @stopping = false if force_start
+        return false      if stopping?
+        num.times do
+          next if max_workers?
+          @workers << Worker.new(@queue)
+        end
       end
-      workers.each {|w| w.poison }
-      return self
     end
+    alias :new_workers :new_worker
   end
 end

data/lib/threaded/promise.rb

@@ -29,15 +29,14 @@ module Threaded
       @mutex.synchronize do
         return true if running? || has_run?
         begin
-          if @job
-            @running = true
-            @result  = @job.call
-          else
-            raise NoJobError
-          end
+          raise NoJobError unless @job
+          @running = true
+          @result  = @job.call
         rescue Exception => error
           @error   = error
         ensure
+          @stdout = Thread.current[:stdout].dup if Thread.current[:stdout]
+          Thread.current[:stdout] = nil
           @has_run = true
         end
       end
@@ -46,12 +45,14 @@ module Threaded
     def now
       wait_for_it!
       raise error, error.message, error.backtrace if error
+      puts @stdout.string if @stdout
       @result
     end
     alias :join  :now
     alias :value :now
 
     private
+
     def wait_for_it!
       return true if has_run?
 
@@ -63,18 +64,3 @@ module Threaded
     end
   end
 end
-
-# job = Threaded.later do
-
-
-# end
-
-# job.now
-
-# job = Threaded::Promise.new
-# job.enqueue do
-
-
-# end
-
-# job.now

data/lib/threaded/version.rb

@@ -1,3 +1,3 @@
 module Threaded
-  VERSION = "0.0.1"
+  VERSION = "0.0.4"
 end

data/lib/threaded/worker.rb

@@ -1,13 +1,10 @@
 module Threaded
   class Worker
-    DEFAULT_TIMEOUT = 60 # seconds, 1 minute
-    POISON          = "poison"
-    include Threaded::Timeout
+    POISON = "poison"
     attr_reader :queue, :logger, :thread
 
     def initialize(queue, options = {})
       @queue   = queue
-      @timeout = options[:timeout] || DEFAULT_TIMEOUT
       @logger  = options[:logger]  || Threaded.logger
       @thread  = create_thread
     end
@@ -20,6 +17,10 @@ module Threaded
       puts "start is deprecated, thread is started when worker created"
     end
 
+    def dead?
+      !alive?
+    end
+
     def alive?
       thread.alive?
     end
@@ -36,13 +37,11 @@ module Threaded
           payload   = queue.pop
           job, json = *payload
           break if payload == POISON
-
-          self.timeout(@timeout, "job: #{job.to_s}") do
-            job.call(*json)
-          end
+          job.call(*json)
         end
         logger.debug("Threaded In Memory Queue Worker '#{object_id}' stopped")
       }
     end
   end
 end
+

data/test/threaded/config_test.rb

@@ -3,26 +3,27 @@ require 'stringio'
 
 class ConfigTest < Test::Unit::TestCase
 
-  def teardown
+  def setup
     Threaded.stop
   end
 
+  def teardown
+    Threaded.start
+  end
+
   def test_config_works
     fake_out = StringIO.new
     logger   = Logger.new(fake_out)
     size     = rand(1..99)
-    timeout  = rand(1..99)
 
     Threaded.configure do |config|
       config.size    = size
       config.logger  = logger
-      config.timeout = timeout
     end
 
     Threaded.start
 
     assert_equal size,    Threaded.size
-    assert_equal timeout, Threaded.timeout
     assert_equal logger,  Threaded.logger
   end
 
@@ -32,9 +33,7 @@ class ConfigTest < Test::Unit::TestCase
       Threaded.configure do |config|
         config.size    = size
         config.logger  = logger
-        config.timeout = timeout
       end
     end
   end
-
 end

data/test/threaded/promise_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class PromiseTest < Test::Unit::TestCase
+
+  def test_promise_interface
+    Dummy.expects(:process).with(1).once
+    Dummy.expects(:process).with(2).once
+
+    promise1 = Threaded.later do
+      Dummy.process(1)
+    end
+
+    promise2 = Threaded.later do
+      Dummy.process(2)
+    end
+
+    promise1.value
+    promise2.value
+  end
+
+
+  def test_stdout_stdio
+    value = "foo"
+    promise = Threaded.later do
+      puts value
+    end
+    promise.join
+    assert_match value, promise.instance_variable_get("@stdout").string
+  end
+
+  def test_no_sync_stdio
+    Threaded.sync_promise_io = false
+
+    value = "foo"
+    promise = Threaded.later do
+      puts value
+    end
+    promise.join
+    assert_equal nil, promise.instance_variable_get("@stdout")
+  ensure
+    Threaded.sync_promise_io = true
+  end
+
+  class Dummy
+    def later(num)
+      Threaded.later do
+        process(num)
+      end
+    end
+
+    def process(num)
+      Dummy.process(num)
+    end
+  end
+
+  def test_scope
+    Dummy.expects(:process).with(1).once
+    Dummy.new.later(1).value
+  end
+end

data/test/{threaded.rb → threaded_test.rb}

@@ -3,12 +3,16 @@ require 'test_helper'
 class ThreadedTest < Test::Unit::TestCase
 
   def test_started?
-    Threaded.start
     assert Threaded.started?
     Threaded.stop
     sleep 1
     assert Threaded.stopped?
     refute Threaded.started?
+
+    Threaded.start
+
+    refute Threaded.stopped?
+    assert Threaded.started?
   end
 
   def test_inline
@@ -18,7 +22,6 @@ class ThreadedTest < Test::Unit::TestCase
     Threaded.inline = true
     Threaded.enqueue(job, 1)
     assert Threaded.inline
-    assert Threaded.stopped?
   ensure
     Threaded.inline = false
   end
@@ -27,14 +30,12 @@ class ThreadedTest < Test::Unit::TestCase
     Dummy.expects(:process).with(1).once
     Dummy.expects(:process).with(2).once
 
-    Threaded.start
-
     job = Proc.new {|x| Dummy.process(x) }
 
     Threaded.enqueue(job, 1)
     Threaded.enqueue(job, 2)
   ensure
-    Threaded.stop
+    Threaded.stop # gives time to process to finish
+    Threaded.start
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: threaded
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -47,23 +47,23 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - lib/threaded.rb
 - lib/threaded/errors.rb
+- lib/threaded/ext/stdout.rb
 - lib/threaded/master.rb
 - lib/threaded/promise.rb
-- lib/threaded/timeout.rb
 - lib/threaded/version.rb
 - lib/threaded/worker.rb
 - test/test_helper.rb
-- test/threaded.rb
 - test/threaded/config_test.rb
 - test/threaded/master_test.rb
 - test/threaded/promise_test.rb
 - test/threaded/worker_test.rb
+- test/threaded_test.rb
 - threaded.gemspec
 homepage: https://github.com/schneems/threaded
 licenses:
@@ -91,9 +91,9 @@ specification_version: 4
 summary: Memory, Enqueue stuff you will
 test_files:
 - test/test_helper.rb
-- test/threaded.rb
 - test/threaded/config_test.rb
 - test/threaded/master_test.rb
 - test/threaded/promise_test.rb
 - test/threaded/worker_test.rb
+- test/threaded_test.rb
 has_rdoc: 

data/Gemfile.lock

@@ -1,20 +0,0 @@
-PATH
-  remote: .
-  specs:
-    threaded (0.0.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    metaclass (0.0.2)
-    mocha (1.0.0)
-      metaclass (~> 0.0.1)
-    rake (10.1.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  mocha
-  rake
-  threaded!

data/lib/threaded/timeout.rb

@@ -1,11 +0,0 @@
-module Threaded
-  module Timeout
-    def timeout(timeout, message = "", &block)
-      ::Timeout.timeout(timeout) do
-        yield
-      end
-    rescue ::Timeout::Error
-      logger.error("Took longer than #{timeout} to #{message.inspect}")
-    end
-  end
-end