message_bus 3.3.8 → 4.2.0

data/Rakefile

@@ -5,18 +5,16 @@ require 'bundler'
 require 'bundler/gem_tasks'
 require 'bundler/setup'
 require 'rubocop/rake_task'
+require 'yard'
 
-RuboCop::RakeTask.new
+Bundler.require(:default, :test)
 
-require 'yard'
+RuboCop::RakeTask.new
 YARD::Rake::YardocTask.new
 
-desc "Generate documentation for Yard, and fail if there are any warnings"
-task :test_doc do
-  sh "yard --fail-on-warning #{'--no-progress' if ENV['CI']}"
-end
-
-Bundler.require(:default, :test)
+BACKENDS = Dir["lib/message_bus/backends/*.rb"].map { |file| file.match(%r{backends/(?<backend>.*).rb})[:backend] } - ["base"]
+SPEC_FILES = Dir['spec/**/*_spec.rb']
+INTEGRATION_FILES = Dir['spec/integration/**/*_spec.rb']
 
 module CustomBuild
   def build_gem
@@ -31,6 +29,11 @@ module Bundler
   end
 end
 
+desc "Generate documentation for Yard, and fail if there are any warnings"
+task :test_doc do
+  sh "yard --fail-on-warning #{'--no-progress' if ENV['CI']}"
+end
+
 namespace :jasmine do
   desc "Run Jasmine tests in headless mode"
   task 'ci' do
@@ -40,18 +43,16 @@ namespace :jasmine do
   end
 end
 
-backends = Dir["lib/message_bus/backends/*.rb"].map { |file| file.match(%r{backends/(?<backend>.*).rb})[:backend] } - ["base"]
-
 namespace :spec do
-  spec_files = Dir['spec/**/*_spec.rb']
-  integration_files = Dir['spec/integration/**/*_spec.rb']
-
-  backends.each do |backend|
+  BACKENDS.each do |backend|
     desc "Run tests on the #{backend} backend"
     task backend do
       begin
         ENV['MESSAGE_BUS_BACKEND'] = backend
-        sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| load f}\" #{(spec_files - integration_files).to_a.join(' ')}"
+        Rake::TestTask.new(backend) do |t|
+          t.test_files = SPEC_FILES - INTEGRATION_FILES
+        end
+        Rake::Task[backend].invoke
       ensure
         ENV.delete('MESSAGE_BUS_BACKEND')
       end
@@ -74,7 +75,10 @@ namespace :spec do
       ENV['MESSAGE_BUS_BACKEND'] = 'memory'
       pid = spawn("bundle exec puma -p 9292 spec/fixtures/test/config.ru")
       sleep 1 while port_available?(9292)
-      sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| load f}\" #{integration_files.to_a.join(' ')}"
+      Rake::TestTask.new(:integration) do |t|
+        t.test_files = INTEGRATION_FILES
+      end
+      Rake::Task[:integration].invoke
     ensure
       ENV.delete('MESSAGE_BUS_BACKEND')
       Process.kill('TERM', pid) if pid
@@ -83,12 +87,12 @@ namespace :spec do
 end
 
 desc "Run tests on all backends, plus client JS tests"
-task spec: backends.map { |backend| "spec:#{backend}" } + ["jasmine:ci", "spec:integration"]
+task spec: BACKENDS.map { |backend| "spec:#{backend}" } + ["jasmine:ci", "spec:integration"]
 
 desc "Run performance benchmarks on all backends"
 task :performance do
   begin
-    ENV['MESSAGE_BUS_BACKENDS'] = backends.join(",")
+    ENV['MESSAGE_BUS_BACKENDS'] = BACKENDS.join(",")
     sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| load f}\" #{Dir['spec/performance/*.rb'].to_a.join(' ')}"
   ensure
     ENV.delete('MESSAGE_BUS_BACKENDS')
@@ -97,7 +101,3 @@ end
 
 desc "Run all tests, link checks and confirms documentation compiles without error"
 task default: [:spec, :rubocop, :test_doc]
-
-Rake::Task['release'].enhance do
-  sh "yarn publish"
-end

data/docker-compose.yml

@@ -36,7 +36,7 @@ services:
   example:
     build:
       context: .
-    command: bash -c "cd examples/diagnostics && bundle install && bundle exec rackup --server puma --host 0.0.0.0"
+    command: bash -c "cd examples/chat && bundle install && bundle exec rackup --server puma --host 0.0.0.0"
     environment:
       BUNDLE_TO: /usr/local/bundle
       REDISURL: redis://redis:6379

data/lib/message_bus/backends/base.rb

@@ -118,6 +118,15 @@ module MessageBus
         raise ConcreteClassMustImplementError
       end
 
+      # Get the ID of the last message published on multiple channels
+      #
+      # @param [Array<String>] channels - array of channels to fetch
+      #
+      # @return [Array<Integer>] the channel-specific IDs of the last message published to each requested channel
+      def last_ids(*channels)
+        raise ConcreteClassMustImplementError
+      end
+
       # Get messages from a channel backlog
       #
       # @param [String] channel the name of the channel in question

data/lib/message_bus/backends/memory.rb

@@ -244,6 +244,13 @@ module MessageBus
         client.max_id(channel)
       end
 
+      # (see Base#last_ids)
+      def last_ids(*channels)
+        channels.map do |c|
+          last_id(c)
+        end
+      end
+
       # (see Base#backlog)
       def backlog(channel, last_id = 0)
         items = client.backlog channel, last_id.to_i

data/lib/message_bus/backends/postgres.rb

@@ -45,6 +45,7 @@ module MessageBus
           @available = []
           @allocated = {}
           @subscribe_connection = nil
+          @subscribed = false
           @mutex = Mutex.new
           @pid = Process.pid
         end
@@ -131,6 +132,21 @@ module MessageBus
           end
         end
 
+        def max_ids(*channels)
+          block = proc do |pg_result|
+            ids = Array.new(channels.size, 0)
+            pg_result.ntuples.times do |i|
+              channel = pg_result.getvalue(i, 0)
+              max_id = pg_result.getvalue(i, 1)
+              channel_index = channels.index(channel)
+              ids[channel_index] = max_id.to_i
+            end
+            ids
+          end
+
+          hold { |conn| exec_prepared(conn, 'max_channel_ids', [PG::TextEncoder::Array.new.encode(channels)], &block) }
+        end
+
         def publish(channel, data)
           hold { |conn| exec_prepared(conn, 'publish', [channel, data]) }
         end
@@ -174,9 +190,16 @@ module MessageBus
         end
 
         def create_table(conn)
-          conn.exec 'CREATE TABLE message_bus (id bigserial PRIMARY KEY, channel text NOT NULL, value text NOT NULL CHECK (octet_length(value) >= 2), added_at timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL)'
-          conn.exec 'CREATE INDEX table_channel_id_index ON message_bus (channel, id)'
-          conn.exec 'CREATE INDEX table_added_at_index ON message_bus (added_at)'
+          sync do
+            begin
+              conn.exec("SELECT 'message_bus'::regclass")
+            rescue PG::UndefinedTable
+              conn.exec 'CREATE TABLE message_bus (id bigserial PRIMARY KEY, channel text NOT NULL, value text NOT NULL CHECK (octet_length(value) >= 2), added_at timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL)'
+              conn.exec 'CREATE INDEX table_channel_id_index ON message_bus (channel, id)'
+              conn.exec 'CREATE INDEX table_added_at_index ON message_bus (added_at)'
+            end
+          end
+
           nil
         end
 
@@ -213,11 +236,7 @@ module MessageBus
         def new_pg_connection
           conn = raw_pg_connection
 
-          begin
-            conn.exec("SELECT 'message_bus'::regclass")
-          rescue PG::UndefinedTable
-            create_table(conn)
-          end
+          create_table(conn)
 
           conn.exec 'PREPARE insert_message AS INSERT INTO message_bus (channel, value) VALUES ($1, $2) RETURNING id'
           conn.exec 'PREPARE clear_global_backlog AS DELETE FROM message_bus WHERE (id <= $1)'
@@ -227,6 +246,7 @@ module MessageBus
           conn.exec "PREPARE expire AS DELETE FROM message_bus WHERE added_at < CURRENT_TIMESTAMP - ($1::text || ' seconds')::interval"
           conn.exec 'PREPARE get_message AS SELECT value FROM message_bus WHERE ((channel = $1) AND (id = $2))'
           conn.exec 'PREPARE max_channel_id AS SELECT max(id) FROM message_bus WHERE (channel = $1)'
+          conn.exec 'PREPARE max_channel_ids AS SELECT channel, max(id) FROM message_bus WHERE (channel = ANY($1)) GROUP BY channel'
           conn.exec 'PREPARE max_id AS SELECT max(id) FROM message_bus'
           conn.exec 'PREPARE publish AS SELECT pg_notify($1, $2)'
 
@@ -259,6 +279,7 @@ module MessageBus
         @max_backlog_age = 604800
         @clear_every = config[:clear_every] || 1
         @mutex = Mutex.new
+        @client = nil
       end
 
       # Reconnects to Postgres; used after a process fork, typically triggered by a forking webserver
@@ -308,7 +329,12 @@ module MessageBus
         client.max_id(channel)
       end
 
-      # (see Base#last_id)
+      # (see Base#last_ids)
+      def last_ids(*channels)
+        client.max_ids(*channels)
+      end
+
+      # (see Base#backlog)
       def backlog(channel, last_id = 0)
         items = client.backlog channel, last_id.to_i
 

data/lib/message_bus/backends/redis.rb

@@ -30,8 +30,6 @@ module MessageBus
     #     messages are removed (when no publication happens during this
     #     time-frame).
     #
-    #   * `clear_every` is not a supported option for this backend.
-    #
     # @see Base general information about message_bus backends
     class Redis < Base
       class BackLogOutOfOrder < StandardError
@@ -45,9 +43,11 @@ module MessageBus
       # @param [Hash] redis_config in addition to the options listed, see https://github.com/redis/redis-rb for other available options
       # @option redis_config [Logger] :logger a logger to which logs will be output
       # @option redis_config [Boolean] :enable_redis_logger (false) whether or not to enable logging by the underlying Redis library
+      # @option redis_config [Integer] :clear_every (1) the interval of publications between which the backlog will not be cleared
       # @param [Integer] max_backlog_size the largest permitted size (number of messages) for per-channel backlogs; beyond this capacity, old messages will be dropped.
       def initialize(redis_config = {}, max_backlog_size = 1000)
         @redis_config = redis_config.dup
+        @clear_every = redis_config.delete(:clear_every) || 1
         @logger = @redis_config[:logger]
         unless @redis_config[:enable_redis_logger]
           @redis_config[:logger] = nil
@@ -58,6 +58,8 @@ module MessageBus
         @in_memory_backlog = []
         @lock = Mutex.new
         @flush_backlog_thread = nil
+        @pub_redis = nil
+        @subscribed = false
         # after 7 days inactive backlogs will be removed
         @max_backlog_age = 604800
       end
@@ -98,6 +100,7 @@ module MessageBus
       local max_backlog_size = tonumber(ARGV[3])
       local max_global_backlog_size = tonumber(ARGV[4])
       local channel = ARGV[5]
+      local clear_every = ARGV[6]
 
       local global_id_key = KEYS[1]
       local backlog_id_key = KEYS[2]
@@ -118,11 +121,11 @@ module MessageBus
 
       redis.call("EXPIRE", backlog_id_key, max_backlog_age)
 
-      if backlog_id > max_backlog_size then
+      if backlog_id > max_backlog_size and backlog_id % clear_every == 0 then
         redis.call("ZREMRANGEBYSCORE", backlog_key, 1, backlog_id - max_backlog_size)
       end
 
-      if global_id > max_global_backlog_size then
+      if global_id > max_global_backlog_size and global_id % clear_every == 0 then
         redis.call("ZREMRANGEBYSCORE", global_backlog_key, 1, global_id - max_global_backlog_size)
       end
 
@@ -153,7 +156,8 @@ LUA
             max_backlog_age,
             max_backlog_size,
             max_global_backlog_size,
-            channel
+            channel,
+            clear_every
           ],
           keys: [
             global_id_key,
@@ -192,6 +196,13 @@ LUA
         pub_redis.get(backlog_id_key).to_i
       end
 
+      # (see Base#last_ids)
+      def last_ids(*channels)
+        return [] if channels.size == 0
+        backlog_id_keys = channels.map { |c| backlog_id_key(c) }
+        pub_redis.mget(*backlog_id_keys).map(&:to_i)
+      end
+
       # (see Base#backlog)
       def backlog(channel, last_id = 0)
         redis = pub_redis
@@ -259,6 +270,7 @@ LUA
           new_redis.publish(redis_channel_name, UNSUB_MESSAGE)
         ensure
           new_redis&.disconnect!
+          @subscribed = false
         end
       end
 
@@ -301,6 +313,7 @@ LUA
 
             on.message do |_c, m|
               if m == UNSUB_MESSAGE
+                @subscribed = false
                 global_redis.unsubscribe
                 return
               end

data/lib/message_bus/client.rb

@@ -178,31 +178,32 @@ class MessageBus::Client
     r = []
     new_message_ids = nil
 
-    @subscriptions.each do |k, v|
-      id = v.to_i
+    last_bus_ids = @bus.last_ids(*@subscriptions.keys, site_id: site_id)
 
-      if id < -1
-        last_id = @bus.last_id(k, site_id)
-        id = last_id + id + 1
-        id = 0 if id < 0
+    @subscriptions.each do |k, v|
+      last_client_id = v.to_i
+      last_bus_id = last_bus_ids[k]
+
+      if last_client_id < -1 # Client requesting backlog relative to bus position
+        last_client_id = last_bus_id + last_client_id + 1
+        last_client_id = 0 if last_client_id < 0
+      elsif last_client_id == -1 # Client not requesting backlog
+        next
+      elsif last_client_id == last_bus_id # Client already up-to-date
+        next
+      elsif last_client_id > last_bus_id # Client ahead of the bus
+        @subscriptions[k] = -1
+        next
       end
 
-      next if id < 0
-
-      messages = @bus.backlog(k, id, site_id)
+      messages = @bus.backlog(k, last_client_id, site_id)
 
-      if messages.length == 0
-        if id > @bus.last_id(k, site_id)
-          @subscriptions[k] = -1
-        end
-      else
-        messages.each do |msg|
-          if allowed?(msg)
-            r << msg
-          else
-            new_message_ids ||= {}
-            new_message_ids[k] = msg.message_id
-          end
+      messages.each do |msg|
+        if allowed?(msg)
+          r << msg
+        else
+          new_message_ids ||= {}
+          new_message_ids[k] = msg.message_id
         end
       end
     end
@@ -212,7 +213,7 @@ class MessageBus::Client
     @subscriptions.each do |k, v|
       if v.to_i == -1 || (new_message_ids && new_message_ids[k])
         status_message ||= {}
-        @subscriptions[k] = status_message[k] = @bus.last_id(k, site_id)
+        @subscriptions[k] = status_message[k] = last_bus_ids[k]
       end
     end
 

data/lib/message_bus/rack/middleware.rb

@@ -41,7 +41,6 @@ class MessageBus::Rack::Middleware
     @started_listener = false
     @base_route = "#{@bus.base_route}message-bus/"
     @base_route_length = @base_route.length
-    @diagnostics_route = "#{@base_route}_diagnostics"
     @broadcast_route = "#{@base_route}broadcast"
     start_listener unless @bus.off?
   end
@@ -79,11 +78,6 @@ class MessageBus::Rack::Middleware
       return [200, { "Content-Type" => "text/html" }, ["sent"]]
     end
 
-    if env['PATH_INFO'].start_with? @diagnostics_route
-      diags = MessageBus::Rack::Diagnostics.new(@app, message_bus: @bus)
-      return diags.call(env)
-    end
-
     client_id = env['PATH_INFO'][@base_route_length..-1].split("/")[0]
     return [404, {}, ["not found"]] unless client_id
 

data/lib/message_bus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MessageBus
-  VERSION = "3.3.8"
+  VERSION = "4.2.0"
 end

data/lib/message_bus.rb

@@ -7,9 +7,7 @@ require_relative "message_bus/version"
 require_relative "message_bus/message"
 require_relative "message_bus/client"
 require_relative "message_bus/connection_manager"
-require_relative "message_bus/diagnostics"
 require_relative "message_bus/rack/middleware"
-require_relative "message_bus/rack/diagnostics"
 require_relative "message_bus/timer_thread"
 require_relative "message_bus/codec/base"
 require_relative "message_bus/backends"
@@ -47,21 +45,6 @@ module MessageBus::Implementation
     @subscriber_thread = nil
   end
 
-  # @param [Boolean] val whether or not to cache static assets for the diagnostics pages
-  # @return [void]
-  def cache_assets=(val)
-    configure(cache_assets: val)
-  end
-
-  # @return [Boolean] whether or not to cache static assets for the diagnostics pages
-  def cache_assets
-    if defined? @config[:cache_assets]
-      @config[:cache_assets]
-    else
-      true
-    end
-  end
-
   # @param [Logger] logger a logger object to be used by the bus
   # @return [void]
   def logger=(logger)
@@ -297,15 +280,20 @@ module MessageBus::Implementation
     @config[:transport_codec] ||= MessageBus::Codec::Json.new
   end
 
-  # @param [MessageBus::Backend::Base] pub_sub a configured backend
+  # @param [MessageBus::Backend::Base] backend_instance A configured backend
   # @return [void]
+  def backend_instance=(backend_instance)
+    configure(backend_instance: backend_instance)
+  end
+
   def reliable_pub_sub=(pub_sub)
-    configure(reliable_pub_sub: pub_sub)
+    logger.warn "MessageBus.reliable_pub_sub= is deprecated, use MessageBus.backend_instance= instead."
+    self.backend_instance = pub_sub
   end
 
   # @return [MessageBus::Backend::Base] the configured backend. If not
   #   explicitly set, will be loaded based on the configuration provided.
-  def reliable_pub_sub
+  def backend_instance
     @mutex.synchronize do
       return nil if @destroyed
 
@@ -313,7 +301,7 @@ module MessageBus::Implementation
       # passed to backend.
       logger
 
-      @config[:reliable_pub_sub] ||= begin
+      @config[:backend_instance] ||= begin
         @config[:backend_options] ||= {}
         require "message_bus/backends/#{backend}"
         MessageBus::BACKENDS[backend].new @config
@@ -321,17 +309,16 @@ module MessageBus::Implementation
     end
   end
 
+  def reliable_pub_sub
+    logger.warn "MessageBus.reliable_pub_sub is deprecated, use MessageBus.backend_instance instead."
+    backend_instance
+  end
+
   # @return [Symbol] the name of the backend implementation configured
   def backend
     @config[:backend] || :redis
   end
 
-  # Enables diagnostics tracking
-  # @return [void]
-  def enable_diagnostics
-    MessageBus::Diagnostics.enable(self)
-  end
-
   # Publishes a message to a channel
   #
   # @param [String] channel the name of the channel to which the message should be published
@@ -398,7 +385,7 @@ module MessageBus::Implementation
     end
 
     encoded_channel_name = encode_channel_name(channel, site_id)
-    reliable_pub_sub.publish(encoded_channel_name, encoded_data, channel_opts)
+    backend_instance.publish(encoded_channel_name, encoded_data, channel_opts)
   end
 
   # Subscribe to messages. Each message will be delivered by yielding to the
@@ -414,9 +401,9 @@ module MessageBus::Implementation
   # @return [void]
   def blocking_subscribe(channel = nil, &blk)
     if channel
-      reliable_pub_sub.subscribe(encode_channel_name(channel), &blk)
+      backend_instance.subscribe(encode_channel_name(channel), &blk)
     else
-      reliable_pub_sub.global_subscribe(&blk)
+      backend_instance.global_subscribe(&blk)
     end
   end
 
@@ -495,9 +482,9 @@ module MessageBus::Implementation
   def backlog(channel = nil, last_id = nil, site_id = nil)
     old =
       if channel
-        reliable_pub_sub.backlog(encode_channel_name(channel, site_id), last_id)
+        backend_instance.backlog(encode_channel_name(channel, site_id), last_id)
       else
-        reliable_pub_sub.global_backlog(last_id)
+        backend_instance.global_backlog(last_id)
       end
 
     old.each do |m|
@@ -513,7 +500,19 @@ module MessageBus::Implementation
   #
   # @return [Integer] the channel-specific ID of the last message published to the given channel
   def last_id(channel, site_id = nil)
-    reliable_pub_sub.last_id(encode_channel_name(channel, site_id))
+    backend_instance.last_id(encode_channel_name(channel, site_id))
+  end
+
+  # Get the ID of the last message published on multiple channels
+  #
+  # @param [Array<String>] channels - array of channels to fetch
+  # @param [String] site_id - the ID of the site by which to filter
+  #
+  # @return [Hash] the channel-specific IDs of the last message published to each requested channel
+  def last_ids(*channels, site_id: nil)
+    encoded_channel_names = channels.map { |c| encode_channel_name(c, site_id) }
+    ids = backend_instance.last_ids(*encoded_channel_names)
+    channels.zip(ids).to_h
   end
 
   # Get the last message published on a channel
@@ -536,8 +535,8 @@ module MessageBus::Implementation
   def destroy
     return if @destroyed
 
-    reliable_pub_sub.global_unsubscribe
-    reliable_pub_sub.destroy
+    backend_instance.global_unsubscribe
+    backend_instance.destroy
 
     @mutex.synchronize do
       return if @destroyed
@@ -555,7 +554,7 @@ module MessageBus::Implementation
   #   scheduled tasks.
   # @return [void]
   def after_fork
-    reliable_pub_sub.after_fork
+    backend_instance.after_fork
     ensure_subscriber_thread
     # will ensure timer is running
     timer.queue {}
@@ -564,12 +563,12 @@ module MessageBus::Implementation
   # @return [Boolean] whether or not the server is actively listening for
   #   publications on the bus
   def listening?
-    @subscriber_thread && @subscriber_thread.alive?
+    @subscriber_thread&.alive?
   end
 
   # (see MessageBus::Backend::Base#reset!)
   def reset!
-    reliable_pub_sub.reset! if reliable_pub_sub
+    backend_instance.reset! if backend_instance
   end
 
   # @return [MessageBus::TimerThread] the timer thread used for triggering
@@ -697,12 +696,6 @@ module MessageBus::Implementation
     @subscriptions[site_id][channel] << blk
     ensure_subscriber_thread
 
-    attempts = 100
-    while attempts > 0 && !reliable_pub_sub.subscribed
-      sleep 0.001
-      attempts -= 1
-    end
-
     raise MessageBus::BusDestroyed if @destroyed
 
     blk
@@ -720,10 +713,17 @@ module MessageBus::Implementation
 
   def ensure_subscriber_thread
     @mutex.synchronize do
-      return if (@subscriber_thread && @subscriber_thread.alive?) || @destroyed
+      return if @destroyed
+      next if @subscriber_thread&.alive?
 
       @subscriber_thread = new_subscriber_thread
     end
+
+    attempts = 100
+    while attempts > 0 && !backend_instance.subscribed
+      sleep 0.001
+      attempts -= 1
+    end
   end
 
   MIN_KEEPALIVE = 20
@@ -744,34 +744,11 @@ module MessageBus::Implementation
       if !@destroyed && thread.alive? && keepalive_interval > MIN_KEEPALIVE
 
         publish("/__mb_keepalive__/", Process.pid, user_ids: [-1])
-        # going for x3 keepalives missed for a restart, need to ensure this only very rarely happens
-        # note: after_fork will sort out a bad @last_message date, but thread will be dead anyway
         if (Time.now - (@last_message || Time.now)) > keepalive_interval * 3
-          logger.warn "Global messages on #{Process.pid} timed out, restarting process"
-          # No other clean way to remove this thread, its listening on a socket
-          #   no data is arriving
-          #
-          # In production we see this kind of situation ... sometimes ... when there is
-          # a VRRP failover, or weird networking condition
-          pid = Process.pid
-
-          # do the best we can to terminate self cleanly
-          fork do
-            Process.kill('TERM', pid)
-            sleep 10
-            begin
-              Process.kill('KILL', pid)
-            rescue Errno::ESRCH
-              logger.warn "#{Process.pid} successfully terminated by `TERM` signal."
-            end
-          end
-
-          sleep 10
-          Process.kill('KILL', pid)
-
-        else
-          timer.queue(keepalive_interval, &blk) if keepalive_interval > MIN_KEEPALIVE
+          logger.warn "Global messages on #{Process.pid} timed out, message bus is no longer functioning correctly"
         end
+
+        timer.queue(keepalive_interval, &blk) if keepalive_interval > MIN_KEEPALIVE
       end
     end
 
@@ -783,7 +760,7 @@ module MessageBus::Implementation
   def global_subscribe_thread
     # pretend we just got a message
     @last_message = Time.now
-    reliable_pub_sub.global_subscribe do |msg|
+    backend_instance.global_subscribe do |msg|
       begin
         @last_message = Time.now
         decode_message!(msg)

data/message_bus.gemspec

@@ -11,8 +11,6 @@ Gem::Specification.new do |gem|
   gem.license       = "MIT"
   gem.files         = `git ls-files`.split($\) +
                       ["vendor/assets/javascripts/message-bus.js", "vendor/assets/javascripts/message-bus-ajax.js"]
-  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "message_bus"
   gem.require_paths = ["lib"]
   gem.version       = MessageBus::VERSION