message_bus 2.1.5 → 2.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc63e91243c887e17566c8e993d8a1974095fb5dbd526f975532a49cc21b53df
-  data.tar.gz: 58721c57100d84323d839c9c6ffbb9dd49a86e4f31e241058bf89c6c88224646
+  metadata.gz: 41c92c01f6f8f8b478877cd97213ceaa9517b28eddb42edc6e421a39d8e6da50
+  data.tar.gz: 00bab454cbce2f3f264eda6470ade5d61bfde42ddbc8709d288da6ee2c204dd8
 SHA512:
-  metadata.gz: 996048cdb5e4f4834ec943fbd9dad61b40e5a1c2977046a426c3ec1ec621ba8990d272ec21f916e2d098f7096489d516bdc56d0bfb0dc1d859c2759f42bf83c6
-  data.tar.gz: da9e30f25a9918d7d2290a508e6d068d93ec18a5f8d69423426c381838c00dcd7b8480d5a1760196ceb66ea7bb30da209b6c7046f8a2c74fc3a8322d40a730dc
+  metadata.gz: e009850b2ecd51ed40978993297b67f70e2cb50939e46f165630ce5aa3c1b42170e7ca70f753888218c00ec7fb33dd6ece38900d263f683e2183a66a7cbf0e7a
+  data.tar.gz: 435044844fc8f8620d3ddbac25c5cae390e4ee2988cca28f37fa41da18f12b57293ef7686ecd412af3be23a5a9787e29c459d7bd52548fd1a7bf5378956d5a80

data/CHANGELOG

@@ -1,3 +1,12 @@
+15-10-2018
+
+- Version 2.1.6
+
+- FEATURE: `MesssageBus.publish` accepts option `site_id` to publish to a site
+- FEATURE: Added MessageBus::DistributedCache for cross process caching
+- PERF: Use monotonic times in timer thread
+- FEATURE: min poll interval is now configurable client side
+
 16-05-2018
 
 - Version 2.1.5

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 
 group :test do
   gem 'minitest'
+  gem 'minitest-hooks'
   gem 'rake'
   gem 'http_parser.rb'
   gem 'thin'
@@ -14,3 +15,4 @@ end
 
 gem 'redis'
 gem 'rack'
+gem 'concurrent-ruby' # for distributed-cache

data/README.md

@@ -14,7 +14,6 @@ Live chat demo per [examples/chat](https://github.com/SamSaffron/message_bus/tre
 
 ### http://chat.samsaffron.com
 
-
 ## Want to help?
 
 If you are looking to contribute to this project here are some ideas
@@ -119,6 +118,18 @@ MessageBus.user_id_lookup do |env|
 end
 ```
 
+### Debugging
+
+When setting up MessageBus, it's good to manually check the channels before integrating the client.
+
+You can `curl` MessageBus. This is helpful when trying to debug what may be doing wrong. This uses https://chat.samsaffron.com.
+
+```
+curl -H "Content-Type: application/x-www-form-urlencoded" -X POST --data "/message=0" https://chat.samsaffron.com/message-bus/client-id/poll\?dlp\=t
+```
+
+You should see a reply with the messages of that channel you requested for (`/message`) starting at the message ID (`0`). `dlp=t` disables long-polling: we do not want this request to stay open.
+
 ### Transport
 
 MessageBus ships with 3 transport mechanisms.
@@ -165,7 +176,8 @@ Polling also requires no special setup, MessageBus will fallback to polling afte
 MessageBus can be used in an environment that hosts multiple sites by multiplexing channels. To use this mode
 
 ```ruby
-# define a site_id lookup method
+# define a site_id lookup method, which is executed
+# when `MessageBus.publish` is called
 MessageBus.configure(site_id_lookup: proc do
   some_method_that_returns_site_id_string
 end)
@@ -173,6 +185,11 @@ end)
 # you may post messages just to this site
 MessageBus.publish "/channel", "some message"
 
+# you can also choose to pass the `site_id`.
+# This takes precendence over whatever `site_id_lookup`
+# returns
+MessageBus.publish "/channel", "some message", site_id: "site-id"
+
 # you may publish messages to ALL sites using the /global/ prefix
 MessageBus.publish "/global/channel", "will go to all sites"
 
@@ -238,6 +255,7 @@ Setting|Default|Info
 enableLongPolling|true|Allow long-polling (provided it is enable by the server)
 callbackInterval|15000|Safeguard to ensure background polling does not exceed this interval (in milliseconds)
 backgroundCallbackInterval|60000|Interval to poll when long polling is disabled (either explicitly or due to browser being in background)
+minPollInterval|100|When polling requests succeed, this is the minimum amount of time to wait before making the next request.
 maxPollInterval|180000|If request to the server start failing, MessageBus will backoff, this is the upper limit of the backoff.
 alwaysLongPoll|false|For debugging you may want to disable the "is browser in background" check and always long-poll
 baseUrl|/|If message bus is mounted in a subdirectory of different domain, you may configure it to perform requests there
@@ -294,13 +312,13 @@ This is configurable via accessors on the ReliablePubSub instance.
 
 ```ruby
 # only store 100 messages per channel
-MessageBus.reliabe_pub_sub.max_backlog_size = 100
+MessageBus.reliable_pub_sub.max_backlog_size = 100
 
 # only store 100 global messages
-MessageBus.reliabe_pub_sub.max_global_backlog_size = 100
+MessageBus.reliable_pub_sub.max_global_backlog_size = 100
 
 # flush per-channel backlog after 100 seconds of inactivity
-MessageBus.reliabe_pub_sub.max_backlog_age = 100
+MessageBus.reliable_pub_sub.max_backlog_age = 100
 
 ```
 
@@ -395,6 +413,52 @@ Rails.application.config do |config|
 end
 ```
 
+### A Distributed Cache
+
+MessageBus ships with an optional DistributedCache object you can use to synchronize a cache between processes.
+It allows you a simple and efficient way of synchronizing a cache between processes.
+
+```ruby
+require 'message_bus/distributed_cache'
+
+# process 1
+
+cache = MessageBus::DistributedCache.new("animals")
+
+# process 2
+
+cache = MessageBus::DistributedCache.new("animals")
+
+# process 1
+
+cache["frogs"] = 5
+
+# process 2
+
+puts cache["frogs"]
+# => 5
+
+cache["frogs"] = nil
+
+# process 1
+
+puts cache["frogs"]
+# => nil
+
+```
+
+Automatically expiring the cache on app update:
+
+```ruby
+cache = MessageBus::DistributedCache.new("cache name", app_version: "12.1.7.ABDEB")
+cache["a"] = 77
+
+cache = MessageBus::DistributedCache.new("cache name", app_version: "12.1.7.ABDEF")
+
+puts cache["a"]
+# => nil
+```
+
 #### Error Handling
 
 The internet is a chaotic environment and clients can drop off for a variety of reasons. If this happens while MessageBus is trying to write a message to the client you may see something like this in your logs:

data/assets/message-bus.js

@@ -6,6 +6,7 @@
   // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
   var callbacks, clientId, failCount, shouldLongPoll, queue, responseCallbacks, uniqueId, baseUrl;
   var me, started, stopped, longPoller, pollTimeout, paused, later, jQuery, interval, chunkedBackoff;
+  var delayPollTimeout;
 
   var ajaxInProgress = false;
 
@@ -277,7 +278,7 @@
         var interval;
         try {
           if (gotData || aborted) {
-            interval = 100;
+            interval = me.minPollInterval;
           } else {
             interval = me.callbackInterval;
             if (failCount > 2) {
@@ -303,11 +304,16 @@
 
         if (pollTimeout) {
           clearTimeout(pollTimeout);
-        }
-        pollTimeout = setTimeout(function(){
           pollTimeout = null;
-          poll();
-        }, interval);
+        }
+
+        if (started) {
+          pollTimeout = setTimeout(function(){
+            pollTimeout = null;
+            poll();
+          }, interval);
+        }
+
         me.longPoll = null;
       }
     });
@@ -322,6 +328,7 @@
     enableLongPolling: true,
     callbackInterval: 15000,
     backgroundCallbackInterval: 60000,
+    minPollInterval: 100,
     maxPollInterval: 3 * 60 * 1000,
     callbacks: callbacks,
     clientId: clientId,
@@ -354,11 +361,18 @@
     stop: function() {
       stopped = true;
       started = false;
+      if (delayPollTimeout) {
+        clearTimeout(delayPollTimeout);
+        delayPollTimeout = null;
+      }
+      if (me.longPoll) {
+        me.longPoll.abort();
+      }
     },
 
     // Start polling
     start: function() {
-      var poll, delayPollTimeout;
+      var poll;
 
       if (started) return;
       started = true;

data/lib/message_bus.rb

@@ -226,10 +226,12 @@ module MessageBus::Implementation
     group_ids = nil
     client_ids = nil
 
+    site_id = nil
     if opts
       user_ids = opts[:user_ids]
       group_ids = opts[:group_ids]
       client_ids = opts[:client_ids]
+      site_id = opts[:site_id]
     end
 
     raise ::MessageBus::InvalidMessage if (user_ids || group_ids) && global?(channel)
@@ -250,7 +252,8 @@ module MessageBus::Implementation
       }
     end
 
-    reliable_pub_sub.publish(encode_channel_name(channel), encoded_data, channel_opts)
+    encoded_channel_name = encode_channel_name(channel, site_id)
+    reliable_pub_sub.publish(encoded_channel_name, encoded_data, channel_opts)
   end
 
   def blocking_subscribe(channel = nil, &blk)

data/lib/message_bus/distributed_cache.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# Like a hash, just does its best to stay in sync across the farm.
+# On boot all instances are blank, but they populate as various processes
+# fill it up.
+
+require 'weakref'
+require 'base64'
+require 'securerandom'
+
+module MessageBus
+  class DistributedCache
+
+    DEFAULT_SITE_ID = 'default'
+
+    class Manager
+      CHANNEL_NAME ||= '/distributed_hash'.freeze
+
+      attr_accessor :app_version
+
+      def initialize(message_bus = nil)
+        @subscribers = []
+        @subscribed = false
+        @lock = Mutex.new
+        @message_bus = message_bus || MessageBus
+      end
+
+      def subscribers
+        @subscribers
+      end
+
+      def process_message(message)
+        i = @subscribers.length - 1
+
+        payload = message.data
+
+        while i >= 0
+          begin
+            current = @subscribers[i]
+
+            next if payload["origin"] == current.identity
+            next if current.key != payload["hash_key"]
+
+            next if @app_version && payload["app_version"] != @app_version
+
+            hash = current.hash(message.site_id || DEFAULT_SITE_ID)
+
+            case payload["op"]
+            when "set" then hash[payload["key"]] = payload["marshalled"] ? Marshal.load(Base64.decode64(payload["value"])) : payload["value"]
+            when "delete" then hash.delete(payload["key"])
+            when "clear"  then hash.clear
+            end
+
+          rescue WeakRef::RefError
+            @subscribers.delete_at(i)
+          ensure
+            i -= 1
+          end
+        end
+      end
+
+      def ensure_subscribe!
+        return if @subscribed
+        @lock.synchronize do
+          return if @subscribed
+          @message_bus.subscribe(CHANNEL_NAME) do |message|
+            @lock.synchronize do
+              process_message(message)
+            end
+          end
+          @subscribed = true
+        end
+      end
+
+      def publish(hash, message)
+        message[:origin] = hash.identity
+        message[:hash_key] = hash.key
+        message[:app_version] = @app_version if @app_version
+        @message_bus.publish(CHANNEL_NAME, message, user_ids: [-1])
+      end
+
+      def set(hash, key, value)
+        # special support for set
+        marshal = (Set === value || Hash === value || Array === value)
+        value = Base64.encode64(Marshal.dump(value)) if marshal
+        publish(hash, op: :set, key: key, value: value, marshalled: marshal)
+      end
+
+      def delete(hash, key)
+        publish(hash, op: :delete, key: key)
+      end
+
+      def clear(hash)
+        publish(hash, op: :clear)
+      end
+
+      def register(hash)
+        @lock.synchronize do
+          @subscribers << WeakRef.new(hash)
+        end
+      end
+    end
+
+    @default_manager = Manager.new
+
+    def self.default_manager
+      @default_manager
+    end
+
+    attr_reader :key
+
+    def initialize(key, manager: nil, namespace: true, app_version: nil)
+      @key = key
+      @data = {}
+      @manager = manager || DistributedCache.default_manager
+      @manager.app_version = app_version if app_version
+      @namespace = namespace
+      @app_version = app_version
+
+      @manager.ensure_subscribe!
+      @manager.register(self)
+    end
+
+    def identity
+      # fork resilient / multi machine identity
+      (@seed_id ||= SecureRandom.hex) + "#{Process.pid}"
+    end
+
+    def []=(k, v)
+      k = k.to_s if Symbol === k
+      @manager.set(self, k, v)
+      hash[k] = v
+    end
+
+    def [](k)
+      k = k.to_s if Symbol === k
+      hash[k]
+    end
+
+    def delete(k, publish: true)
+      k = k.to_s if Symbol === k
+      @manager.delete(self, k) if publish
+      hash.delete(k)
+    end
+
+    def clear
+      @manager.clear(self)
+      hash.clear
+    end
+
+    def hash(site_id_arg = nil)
+      site_id =
+        if @namespace
+          site_id_arg ||
+            (MessageBus.site_id_lookup && MessageBus.site_id_lookup.call) ||
+            DEFAULT_SITE_ID
+        else
+          DEFAULT_SITE_ID
+        end
+
+      @data[site_id] ||= {}
+    end
+
+  end
+end

data/lib/message_bus/timer_thread.rb

@@ -4,7 +4,14 @@ class MessageBus::TimerThread
   attr_reader :jobs
 
   class Cancelable
-    NOOP = proc {}
+    class NoOp
+      def call
+      end
+    end
+
+    # usually you could just use a blank lambda
+    # but an object is ever so slightly faster
+    NOOP = NoOp.new
 
     def initialize(job)
       @job = job
@@ -58,7 +65,7 @@ class MessageBus::TimerThread
 
   # queue a block to run after a certain delay (in seconds)
   def queue(delay = 0, &block)
-    queue_time = Time.new.to_f + delay
+    queue_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay
     job = [queue_time, block]
 
     @mutex.synchronize do
@@ -96,7 +103,7 @@ class MessageBus::TimerThread
 
   def do_work
     while !@stopped
-      if @next && @next <= Time.new.to_f
+      if @next && @next <= Process.clock_gettime(Process::CLOCK_MONOTONIC)
         _, blk = @mutex.synchronize { @jobs.shift }
         begin
           blk.call
@@ -107,10 +114,10 @@ class MessageBus::TimerThread
           @next, _ = @jobs[0]
         end
       end
-      unless @next && @next <= Time.new.to_f
+      unless @next && @next <= Process.clock_gettime(Process::CLOCK_MONOTONIC)
         sleep_time = 1000
         @mutex.synchronize do
-          sleep_time = @next - Time.new.to_f if @next
+          sleep_time = @next - Process.clock_gettime(Process::CLOCK_MONOTONIC) if @next
         end
         sleep [0, sleep_time].max
       end

data/lib/message_bus/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module MessageBus
-  VERSION = "2.1.5"
+  VERSION = "2.1.6"
 end

data/spec/assets/SpecHelper.js

@@ -27,6 +27,7 @@ beforeEach(function () {
   function MockedXMLHttpRequest(){
     this.headers = {};
   };
+
   MockedXMLHttpRequest.prototype.send              = function(){
     this.readyState = 4
     this.responseText = encodeChunks(this, spec.responseChunks);
@@ -35,21 +36,38 @@ beforeEach(function () {
     if (this.onprogress){ this.onprogress(); }
     this.onreadystatechange()
   }
+
   MockedXMLHttpRequest.prototype.open              = function(){ }
-  MockedXMLHttpRequest.prototype.abort             = function(){ }
+
+  MockedXMLHttpRequest.prototype.abort             = function(){
+    this.readyState = 4
+    this.responseText = '';
+    this.statusText = '';
+    this.status = 400;
+    this.onreadystatechange()
+  }
+
   MockedXMLHttpRequest.prototype.setRequestHeader  = function(k,v){
     this.headers[k] = v;
   }
+
   MockedXMLHttpRequest.prototype.getResponseHeader = function(){
     return 'text/plain; charset=utf-8';
   }
+
   MessageBus.xhrImplementation = MockedXMLHttpRequest
   this.MockedXMLHttpRequest = MockedXMLHttpRequest
-  MessageBus.start()
+
   this.responseChunks = [
     {channel: '/test', data: {password: 'MessageBusRocks!'}}
   ];
 
+  MessageBus.start();
+});
+
+afterEach(function(){
+  MessageBus.stop()
+  MessageBus.callbacks.splice(0, MessageBus.callbacks.length)
 });
 
 window.testMB = function(description, testFn, path, data){
@@ -88,10 +106,3 @@ window.testMB = function(description, testFn, path, data){
 
 }
 
-afterEach(function(){
-  MessageBus.stop()
-  if (MessageBus.longPoll){
-    MessageBus.longPoll.abort();
-  }
-  MessageBus.callbacks.splice(0, MessageBus.callbacks.length)
-});

data/spec/assets/message-bus.spec.js

@@ -84,6 +84,12 @@ describe("Messagebus", function() {
     window.MessageBus = mb;
   });
 
+  it('respects minPollInterval setting with defaults', function(){
+    expect(MessageBus.minPollInterval).toEqual(100);
+    MessageBus.minPollInterval = 1000;
+    expect(MessageBus.minPollInterval).toEqual(1000);
+  });
+
   testMB('sends using custom header', function(){
     MessageBus.headers['X-MB-TEST-VALUE'] = '42';
     this.perform(function(message, xhr){

data/spec/lib/message_bus/distributed_cache_spec.rb

@@ -0,0 +1,133 @@
+require_relative '../../spec_helper'
+require 'minitest/hooks/default'
+require 'message_bus'
+require 'message_bus/distributed_cache'
+
+describe MessageBus::DistributedCache do
+
+  before :all do
+    @bus = MessageBus::Instance.new
+    @bus.configure(backend: :memory)
+    @manager = MessageBus::DistributedCache::Manager.new(@bus)
+  end
+
+  after :all do
+    @bus.destroy
+  end
+
+  def cache(name)
+    MessageBus::DistributedCache.new(name, manager: @manager)
+  end
+
+  let :cache_name do
+    SecureRandom.hex
+  end
+
+  before do
+    @cache1 = cache(cache_name)
+    @cache2 = cache(cache_name)
+  end
+
+  it 'supports arrays with hashes' do
+
+    c1 = cache("test1")
+    c2 = cache("test1")
+
+    c1["test"] = [{ test: :test }]
+
+    wait_for do
+      c2["test"] == [{ test: :test }]
+    end
+
+    expect(c2[:test]).must_equal([{ test: :test }])
+  end
+
+  it 'allows us to store Set' do
+    c1 = cache("test1")
+    c2 = cache("test1")
+
+    set = Set.new
+    set << 1
+    set << "b"
+    set << 92803984
+    set << 93739739873973
+
+    c1["cats"] = set
+
+    wait_for do
+      c2["cats"] == set
+    end
+
+    expect(c2["cats"]).must_equal(set)
+
+    set << 5
+
+    c2["cats"] = set
+
+    wait_for do
+      c1["cats"] == set
+    end
+
+    expect(c1["cats"]).must_equal(set)
+  end
+
+  it 'does not leak state across caches' do
+    c2 = cache("test1")
+    c3 = cache("test1")
+    c2["hi"] = "hi"
+    wait_for do
+      c3["hi"] == "hi"
+    end
+
+    Thread.pass
+    assert_nil(@cache1["hi"])
+
+  end
+
+  it 'allows coerces symbol keys to strings' do
+    @cache1[:key] = "test"
+    expect(@cache1["key"]).must_equal("test")
+
+    wait_for do
+      @cache2[:key] == "test"
+    end
+    expect(@cache2["key"]).must_equal("test")
+  end
+
+  it 'sets other caches' do
+    @cache1["test"] = "world"
+    wait_for do
+      @cache2["test"] == "world"
+    end
+  end
+
+  it 'deletes from other caches' do
+    @cache1["foo"] = "bar"
+
+    wait_for do
+      @cache2["foo"] == "bar"
+    end
+
+    @cache1.delete("foo")
+    assert_nil(@cache1["foo"])
+
+    wait_for do
+      @cache2["foo"] == nil
+    end
+  end
+
+  it 'clears cache on request' do
+    @cache1["foo"] = "bar"
+
+    wait_for do
+      @cache2["foo"] == "bar"
+    end
+
+    @cache1.clear
+    assert_nil(@cache1["foo"])
+    wait_for do
+      @cache2["boom"] == nil
+    end
+  end
+
+end

data/spec/lib/message_bus/timer_thread_spec.rb

@@ -13,7 +13,7 @@ describe MessageBus::TimerThread do
   it "allows you to queue every jobs" do
     i = 0
     m = Mutex.new
-    every = @timer.every(0.001){m.synchronize{i += 1 if i < 3}}
+    every = @timer.every(0.001) { m.synchronize { i += 1 if i < 3 } }
     # allow lots of time, cause in test mode stuff can be slow
     wait_for(1000) do
       m.synchronize do
@@ -27,7 +27,7 @@ describe MessageBus::TimerThread do
 
   it "allows you to cancel timers" do
     success = true
-    @timer.queue(0.005){success=false}.cancel
+    @timer.queue(0.005) { success = false }.cancel
     sleep(0.006)
     success.must_equal true
   end
@@ -45,7 +45,7 @@ describe MessageBus::TimerThread do
       4 == results.length
     }
 
-    results.must_equal [0,1,2,3]
+    results.must_equal [0, 1, 2, 3]
   end
 
   it "should call the error callback if something goes wrong" do

data/spec/lib/message_bus_spec.rb

@@ -159,6 +159,26 @@ describe MessageBus do
     assert_nil @bus.last_message("/nothing")
   end
 
+  describe "#publish" do
+    it "allows publishing to a explicit site" do
+      data, site_id, channel = nil
+
+      @bus.subscribe do |msg|
+        data = msg.data
+        site_id = msg.site_id
+        channel = msg.channel
+      end
+
+      @bus.publish("/chuck", "norris", site_id: "law-and-order")
+
+      wait_for(2000) { data }
+
+      data.must_equal 'norris'
+      site_id.must_equal 'law-and-order'
+      channel.must_equal '/chuck'
+    end
+  end
+
   describe "global subscriptions" do
     before do
       seq = 0

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ if backend == :postgres
 end
 puts "Running with backend: #{backend}"
 
-def wait_for(timeout_milliseconds)
+def wait_for(timeout_milliseconds=2000)
   timeout = (timeout_milliseconds + 0.0) / 1000
   finish = Time.now + timeout
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: message_bus
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.6
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-16 00:00:00.000000000 Z
+date: 2018-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -95,6 +95,7 @@ files:
 - lib/message_bus/client.rb
 - lib/message_bus/connection_manager.rb
 - lib/message_bus/diagnostics.rb
+- lib/message_bus/distributed_cache.rb
 - lib/message_bus/em_ext.rb
 - lib/message_bus/message.rb
 - lib/message_bus/rack/diagnostics.rb
@@ -114,6 +115,7 @@ files:
 - spec/lib/message_bus/backends/redis_spec.rb
 - spec/lib/message_bus/client_spec.rb
 - spec/lib/message_bus/connection_manager_spec.rb
+- spec/lib/message_bus/distributed_cache_spec.rb
 - spec/lib/message_bus/multi_process_spec.rb
 - spec/lib/message_bus/rack/middleware_spec.rb
 - spec/lib/message_bus/timer_thread_spec.rb
@@ -157,6 +159,7 @@ test_files:
 - spec/lib/message_bus/backends/redis_spec.rb
 - spec/lib/message_bus/client_spec.rb
 - spec/lib/message_bus/connection_manager_spec.rb
+- spec/lib/message_bus/distributed_cache_spec.rb
 - spec/lib/message_bus/multi_process_spec.rb
 - spec/lib/message_bus/rack/middleware_spec.rb
 - spec/lib/message_bus/timer_thread_spec.rb