message_bus 3.3.6 → 4.0.0

data/README.md

@@ -12,7 +12,7 @@ Read the generated docs: <https://www.rubydoc.info/gems/message_bus>
 
 ## Ruby version support
 
-MessageBus only support officially supported versions of Ruby; as of [2018-06-20](https://www.ruby-lang.org/en/news/2018/06/20/support-of-ruby-2-2-has-ended/) this means we only support Ruby version 2.3 and up.
+MessageBus only support officially supported versions of Ruby; as of [2021-03-31](https://www.ruby-lang.org/en/downloads/branches/) this means we only support Ruby version 2.6 and up.
 
 ## Can you handle concurrent requests?
 
@@ -26,15 +26,21 @@ MessageBus only support officially supported versions of Ruby; as of [2018-06-20
 
 Add this line to your application's Gemfile:
 
-    gem 'message_bus'
+```ruby
+gem 'message_bus'
+```
 
 And then execute:
 
-    $ bundle
+```shell
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install message_bus
+```shell
+$ gem install message_bus
+```
 
 ## Usage
 
@@ -68,19 +74,19 @@ id = MessageBus.last_id("/channel")
 MessageBus.backlog "/channel", id
 ```
 
-### Targetted messages
+### Targeted messages
 
-Messages can be targetted to particular clients by supplying the `client_ids` option when publishing a message.
+Messages can be targeted to particular clients by supplying the `client_ids` option when publishing a message.
 
 ```ruby
 MessageBus.publish "/channel", "hello", client_ids: ["XXX", "YYY"] # (using MessageBus.clientId)
 ```
 
-By configuring the `user_id_lookup` and `group_ids_lookup` options with a Proc or Lambda which will be called with a [Rack specification environment](https://github.com/rack/rack/blob/master/SPEC.rdoc#the-environment-), messages can be targetted to particular clients users or groups by supplying either the `user_ids` or `group_ids` options when publishing a message.
+By configuring the `user_id_lookup` and `group_ids_lookup` options with a Proc or Lambda which will be called with a [Rack specification environment](https://github.com/rack/rack/blob/master/SPEC.rdoc#the-environment-), messages can be targeted to particular clients users or groups by supplying either the `user_ids` or `group_ids` options when publishing a message.
 
 ```ruby
 MessageBus.configure(user_id_lookup: proc do |env|
-  # this lookup occurs on JS-client poolings, so that server can retrieve backlog
+  # this lookup occurs on JS-client polling, so that server can retrieve backlog
   # for the client considering/matching/filtering user_ids set on published messages
   # if user_id is not set on publish time, any user_id returned here will receive the message
   # return the user id here
@@ -98,7 +104,7 @@ end)
 MessageBus.publish "/channel", "hello", group_ids: [1, 2, 3]
 
 # example of MessageBus to set user_ids from an initializer in Rails and Devise:
-# config/inializers/message_bus.rb
+# config/initializers/message_bus.rb
 MessageBus.user_id_lookup do |env|
   req = Rack::Request.new(env)
 
@@ -109,13 +115,13 @@ MessageBus.user_id_lookup do |env|
 end
 ```
 
-If both `user_ids` and `group_ids` options are supplied when publishing a message, the message will be targetted at clients with lookup return values that  matches on either the `user_ids` **or** the `group_ids` options.
+If both `user_ids` and `group_ids` options are supplied when publishing a message, the message will be targeted at clients with lookup return values that matches on either the `user_ids` **or** the `group_ids` options.
 
 ```ruby
 MessageBus.publish "/channel", "hello", user_ids: [1, 2, 3], group_ids: [1, 2, 3]
 ```
 
-If the `client_ids` option is supplied with either the `user_ids` or `group_ids` options when publising a message, the `client_ids` option will be applied unconditionally and messages will be filtered further using `user_id` or `group_id` clauses.
+If the `client_ids` option is supplied with either the `user_ids` or `group_ids` options when publishing a message, the `client_ids` option will be applied unconditionally and messages will be filtered further using `user_id` or `group_id` clauses.
 
 ```ruby
 MessageBus.publish "/channel", "hello", client_ids: ["XXX", "YYY"], user_ids: [1, 2, 3], group_ids: [1, 2, 3]
@@ -129,7 +135,7 @@ Custom client message filters can be registered via `MessageBus#register_client_
 
 For example, ensuring that only messages seen by the server in the last 20 seconds are published to the client:
 
-```
+```ruby
 MessageBus.register_client_message_filter('/test') do |message|
   (Time.now.to_i - message.data[:published_at]) <= 20
 end
@@ -163,32 +169,6 @@ curl -H "Content-Type: application/x-www-form-urlencoded" -X POST --data "/messa
 
 You should see a reply with the messages of that channel you requested (in this case `/message`) starting at the message ID you requested (`0`). The URL parameter `dlp=t` disables long-polling: we do not want this request to stay open.
 
-### Diagnostics
-
-MessageBus comes with a diagnostics interface, which you can access at `/message-bus/_diagnostics`. This interface allows you visibility into the runtime behaviour of message_bus.
-
-In order to use the diagnostics UI in your application, it is necessary to:
-
-* Enable it
-* Define a user ID for requests
-* Define a check for admin role
-
-as an example, you can do something like this:
-
-```ruby
-MessageBus.enable_diagnostics # Must be called after `MessageBus.after_fork` if using a forking webserver
-
-MessageBus.user_id_lookup do |_env|
-  1
-end
-
-MessageBus.is_admin_lookup do |_env|
-  true
-end
-```
-
-Of course, in your real-world application, you would define these values according to your authentication/authorization logic.
-
 ### Transport
 
 MessageBus ships with 3 transport mechanisms.
@@ -245,7 +225,7 @@ end)
 MessageBus.publish "/channel", "some message"
 
 # you can also choose to pass the `:site_id`.
-# This takes precendence over whatever `site_id_lookup`
+# This takes precedence over whatever `site_id_lookup`
 # returns
 MessageBus.publish "/channel", "some message", site_id: "site-id"
 
@@ -280,7 +260,7 @@ MessageBus.start(); // call once at startup
 MessageBus.callbackInterval = 500;
 
 // you will get all new messages sent to channel
-MessageBus.subscribe("/channel", function(data){
+MessageBus.subscribe("/channel", function (data) {
   // data shipped from server
 });
 
@@ -386,6 +366,16 @@ headers|{}|Extra headers to be include with requests. Properties and values of o
 
 message_bus can be configured to use one of several available storage backends, and each has its own configuration options.
 
+### Keepalive
+
+To ensure correct operation of message_bus, every 60 seconds a message is broadcast to itself. If for any reason the message is not consumed by the same process within 3 keepalive intervals a warning log message is raised.
+
+To control keepalive interval use
+
+```ruby
+MessageBus.configure(keepalive_interval: 60)
+```
+
 ### Redis
 
 message_bus supports using Redis as a storage backend, and you can configure message_bus to use redis in `config/initializers/message_bus.rb`, like so:
@@ -400,17 +390,17 @@ The redis client message_bus uses is [redis-rb](https://github.com/redis/redis-r
 
 Out of the box Redis keeps track of 2000 messages in the global backlog and 1000 messages in a per-channel backlog. Per-channel backlogs get cleared automatically after 7 days of inactivity.
 
-This is configurable via accessors on the ReliablePubSub instance.
+This is configurable via accessors on the Backend instance.
 
 ```ruby
 # only store 100 messages per channel
-MessageBus.reliable_pub_sub.max_backlog_size = 100
+MessageBus.backend_instance.max_backlog_size = 100
 
 # only store 100 global messages
-MessageBus.reliable_pub_sub.max_global_backlog_size = 100
+MessageBus.backend_instance.max_global_backlog_size = 100
 
 # flush per-channel backlog after 100 seconds of inactivity
-MessageBus.reliable_pub_sub.max_backlog_age = 100
+MessageBus.backend_instance.max_backlog_age = 100
 ```
 
 ### PostgreSQL
@@ -435,7 +425,6 @@ MessageBus.configure(backend: :memory)
 
 The `:clear_every` option supported by the PostgreSQL backend is also supported by the in-memory backend.
 
-
 ### Transport codecs
 
 By default MessageBus serializes messages to the backend using JSON. Under most situation this performs extremely well.
@@ -454,9 +443,9 @@ using a packed string encoder.
 
 Keep in mind, much of MessageBus internals and supporting tools expect data to be converted to JSON and back, if you use a naive (and fast) `Marshal` based codec you may need to limit the features you use. Specifically the Postgresql backend expects the codec never to return a string with `\u0000`, additionally some classes like DistributedCache expect keys to be converted to Strings.
 
-Another example may be very large and complicated messages where Oj in compatability mode outperforms JSON. To opt for the Oj codec use:
+Another example may be very large and complicated messages where Oj in compatibility mode outperforms JSON. To opt for the Oj codec use:
 
-```
+```ruby
 MessageBus.configure(transport_codec: MessageBus::Codec::Oj.new)
 ```
 
@@ -503,7 +492,6 @@ For more information see the [Passenger documentation](https://www.phusionpassen
 
 ```ruby
 # path/to/your/config/puma.rb
-require 'message_bus' # omit this line for Rails 5
 on_worker_boot do
   MessageBus.after_fork
 end
@@ -513,7 +501,6 @@ end
 
 ```ruby
 # path/to/your/config/unicorn.rb
-require 'message_bus'
 after_fork do |server, worker|
   MessageBus.after_fork
 end
@@ -554,26 +541,21 @@ MessageBus ships with an optional `DistributedCache` API which provides a simple
 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
 ```
@@ -631,7 +613,7 @@ In e.g. `config/initializers/message_bus.rb`:
 ```ruby
 MessageBus.extra_response_headers_lookup do |env|
   [
-      ["Access-Control-Allow-Origin", "http://example.com:3000"],
+    ["Access-Control-Allow-Origin", "http://example.com:3000"],
   ]
 end
 ```
@@ -692,8 +674,8 @@ In certain conditions, a status message will be delivered and look like this:
   "message_id": -1,
   "channel": "/__status",
   "data": {
-    "/some/channel":5,
-    "/other/channel":9
+    "/some/channel": 5,
+    "/other/channel": 9
   }
 }
 ```
@@ -727,7 +709,7 @@ When submitting a PR, please be sure to include notes on it in the `Unreleased`
 
 To run tests you need both Postgres and Redis installed. By default on Redis the tests connect to `localhost:6379` and on Postgres connect the database `localhost:5432/message_bus_test` with the system username; if you wish to override this, you can set alternative values:
 
-```
+```shell
 PGUSER=some_user PGDATABASE=some_db bundle exec rake
 ```
 
@@ -742,7 +724,3 @@ While working on documentation, it is useful to automatically re-build it as you
 ### Benchmarks
 
 Some simple benchmarks are implemented in `spec/performance` and can be executed using `rake performance` (or `docker-compose run tests rake performance`). You should run these before and after your changes to avoid introducing performance regressions.
-
-### Diagnostics Interface
-
-It is possible to manually test the diagnostics interface by executing `docker-compose up example` and then `open http://localhost:9292`.

data/Rakefile

@@ -4,23 +4,17 @@ require 'rake/testtask'
 require 'bundler'
 require 'bundler/gem_tasks'
 require 'bundler/setup'
-require 'jasmine'
+require 'rubocop/rake_task'
+require 'yard'
 
-ENV['JASMINE_CONFIG_PATH'] ||= File.join(Dir.pwd, 'spec', 'assets', 'support', 'jasmine.yml')
-load 'jasmine/tasks/jasmine.rake'
+Bundler.require(:default, :test)
 
-require 'rubocop/rake_task'
 RuboCop::RakeTask.new
-
-require 'yard'
 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
@@ -35,20 +29,30 @@ module Bundler
   end
 end
 
-task spec_client_js: 'jasmine:ci'
+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
 
-backends = Dir["lib/message_bus/backends/*.rb"].map { |file| file.match(%r{backends/(?<backend>.*).rb})[:backend] } - ["base"]
+namespace :jasmine do
+  desc "Run Jasmine tests in headless mode"
+  task 'ci' do
+    if !system("npx jasmine-browser-runner runSpecs")
+      exit 1
+    end
+  end
+end
 
 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
@@ -57,6 +61,8 @@ namespace :spec do
 
   desc "Run integration tests"
   task :integration do
+    require "socket"
+
     def port_available?(port)
       server = TCPServer.open("0.0.0.0", port)
       server.close
@@ -69,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
@@ -78,12 +87,12 @@ namespace :spec do
 end
 
 desc "Run tests on all backends, plus client JS tests"
-task spec: backends.map { |backend| "spec:#{backend}" } + [:spec_client_js, "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')
@@ -92,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/assets/message-bus-ajax.js

@@ -2,7 +2,7 @@
 // as a fallback if jQuery is not present
 //
 // Only implements methods & options used by MessageBus
-(function(global, undefined) {
+(function(global) {
   'use strict';
   if (!global.MessageBus){
       throw new Error("MessageBus must be loaded before the ajax adapter");
@@ -16,7 +16,7 @@
     for (var name in options.headers){
       xhr.setRequestHeader(name, options.headers[name]);
     }
-    xhr.setRequestHeader('Content-Type', 'application/json');
+    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
     if (options.messageBus.chunked){
       options.messageBus.onProgressListener(xhr);
     }
@@ -31,7 +31,7 @@
         options.complete();
       }
     }
-    xhr.send(JSON.stringify(options.data));
+    xhr.send(new URLSearchParams(options.data).toString());
     return xhr;
   };
 

data/bench/codecs/marshal.rb

@@ -6,6 +6,6 @@ class MarshalCodec
   end
 
   def decode(payload)
-    ::Marshal.load(payload)
+    ::Marshal.load(payload) # rubocop:disable Security/MarshalLoad
   end
 end

data/bench/codecs/packed_string.rb

@@ -55,7 +55,7 @@ class PackedString
   end
 
   def decode(payload)
-    result = Marshal.load(payload)
+    result = Marshal.load(payload) # rubocop:disable Security/MarshalLoad
     result["data"] = ::Oj.load(result["data"], @oj_options)
 
     if str = result["user_ids"]

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/examples/bench/bench.lua

@@ -1,9 +1,9 @@
 -- wrk returns lots of read errors, this is unavoidable cause
 --
--- 1. There is no internal implmentation of chunked encoding in wrk (which would be ideal)
+-- 1. There is no internal implementation of chunked encoding in wrk (which would be ideal)
 --
 -- 2. MessageBus gem does not provide http keepalive (by design), and can not provide content length
---   if MessageBus provided keepalive it would have to be able to redispatch the reqs to rack, something
+--   if MessageBus provided keepalive it would have to be able to re-dispatch requests to rack, something
 --   that is not supported by the underlying rack hijack protocol, once a req is hijacked it can not be
 --   returned
 --

data/lib/message_bus/backends/base.rb

@@ -62,7 +62,7 @@ module MessageBus
       attr_accessor :max_backlog_size
       # @return [Integer] the largest permitted size (number of messages) for the global backlog; beyond this capacity, old messages will be dropped.
       attr_accessor :max_global_backlog_size
-      # @return [Integer] the longest amount of time a message may live in a backlog before beging removed, in seconds.
+      # @return [Integer] the longest amount of time a message may live in a backlog before being removed, in seconds.
       attr_accessor :max_backlog_age
       # Typically, backlogs are trimmed whenever we publish to them. This setting allows some tolerance in order to improve performance.
       # @return [Integer] the interval of publications between which the backlog will not be cleared.
@@ -74,7 +74,7 @@ module MessageBus
       # @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(config = {}, max_backlog_size = 1000); end
 
-      # Performs routines specific to the backend that are necessary after a process fork, typically triggerd by a forking webserver. Typically this re-opens sockets to the backend.
+      # Performs routines specific to the backend that are necessary after a process fork, typically triggered by a forking webserver. Typically this re-opens sockets to the backend.
       def after_fork
         raise ConcreteClassMustImplementError
       end
@@ -84,6 +84,11 @@ module MessageBus
         raise ConcreteClassMustImplementError
       end
 
+      # Closes all open connections to the storage.
+      def destroy
+        raise ConcreteClassMustImplementError
+      end
+
       # Deletes all backlogs and their data. Does not delete non-backlog data that message_bus may persist, depending on the concrete backend implementation. Use with extreme caution.
       # @abstract
       def expire_all_backlogs!
@@ -96,7 +101,7 @@ module MessageBus
       # @param [JSON] data some data to publish to the channel. Must be an object that can be encoded as JSON
       # @param [Hash] opts
       # @option opts [Boolean] :queue_in_memory (true) whether or not to hold the message in an in-memory buffer if publication fails, to be re-tried later
-      # @option opts [Integer] :max_backlog_age (`self.max_backlog_age`) the longest amount of time a message may live in a backlog before beging removed, in seconds
+      # @option opts [Integer] :max_backlog_age (`self.max_backlog_age`) the longest amount of time a message may live in a backlog before being removed, in seconds
       # @option opts [Integer] :max_backlog_size (`self.max_backlog_size`) the largest permitted size (number of messages) for the channel backlog; beyond this capacity, old messages will be dropped
       #
       # @return [Integer] the channel-specific ID the message was given

data/lib/message_bus/backends/memory.rb

@@ -212,6 +212,12 @@ module MessageBus
         client.reset!
       end
 
+      # No-op; this backend doesn't maintain any storage connections.
+      # (see Base#destroy)
+      def destroy
+        nil
+      end
+
       # (see Base#expire_all_backlogs!)
       def expire_all_backlogs!
         client.expire_all_backlogs!

data/lib/message_bus/backends/postgres.rb

@@ -44,6 +44,8 @@ module MessageBus
           @listening_on = {}
           @available = []
           @allocated = {}
+          @subscribe_connection = nil
+          @subscribed = false
           @mutex = Mutex.new
           @pid = Process.pid
         end
@@ -85,10 +87,12 @@ module MessageBus
           hold { |conn| exec_prepared(conn, 'get_message', [channel, id]) { |r| r.getvalue(0, 0) } }
         end
 
-        def reconnect
+        def after_fork
           sync do
-            @listening_on.clear
+            @pid = Process.pid
+            INHERITED_CONNECTIONS.concat(@available)
             @available.clear
+            @listening_on.clear
           end
         end
 
@@ -100,6 +104,13 @@ module MessageBus
           end
         end
 
+        def destroy
+          sync do
+            @available.each(&:close)
+            @available.clear
+          end
+        end
+
         # use with extreme care, will nuke all of the data
         def expire_all_backlogs!
           reset!
@@ -131,7 +142,7 @@ module MessageBus
           listener = Listener.new
           yield listener
 
-          conn = raw_pg_connection
+          conn = @subscribe_connection = raw_pg_connection
           conn.exec "LISTEN #{channel}"
           listener.do_sub.call
           while listening_on?(channel, obj)
@@ -145,6 +156,9 @@ module MessageBus
 
           conn.exec "UNLISTEN #{channel}"
           nil
+        ensure
+          @subscribe_connection&.close
+          @subscribe_connection = nil
         end
 
         def unsubscribe
@@ -170,11 +184,7 @@ module MessageBus
         def hold
           current_pid = Process.pid
           if current_pid != @pid
-            @pid = current_pid
-            sync do
-              INHERITED_CONNECTIONS.concat(@available)
-              @available.clear
-            end
+            after_fork
           end
 
           if conn = sync { @allocated[Thread.current] }
@@ -249,12 +259,14 @@ module MessageBus
         # after 7 days inactive backlogs will be removed
         @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 triggerd by a forking webserver
+      # Reconnects to Postgres; used after a process fork, typically triggered by a forking webserver
       # @see Base#after_fork
       def after_fork
-        client.reconnect
+        client.after_fork
       end
 
       # (see Base#reset!)
@@ -262,6 +274,11 @@ module MessageBus
         client.reset!
       end
 
+      # (see Base#destroy)
+      def destroy
+        client.destroy
+      end
+
       # (see Base#expire_all_backlogs!)
       def expire_all_backlogs!
         client.expire_all_backlogs!
@@ -277,7 +294,7 @@ module MessageBus
         msg = MessageBus::Message.new backlog_id, backlog_id, channel, data
         payload = msg.encode
         c.publish postgresql_channel_name, payload
-        if backlog_id % clear_every == 0
+        if backlog_id && backlog_id % clear_every == 0
           max_backlog_size = (opts && opts[:max_backlog_size]) || self.max_backlog_size
           max_backlog_age = (opts && opts[:max_backlog_age]) || self.max_backlog_age
           c.clear_global_backlog(backlog_id, @max_global_backlog_size)
@@ -397,11 +414,7 @@ module MessageBus
       private
 
       def client
-        @client ||= new_connection
-      end
-
-      def new_connection
-        Client.new(@config)
+        @client || @mutex.synchronize { @client ||= Client.new(@config) }
       end
 
       def postgresql_channel_name

data/lib/message_bus/backends/redis.rb

@@ -58,14 +58,16 @@ 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
 
-      # Reconnects to Redis; used after a process fork, typically triggerd by a forking webserver
+      # Reconnects to Redis; used after a process fork, typically triggered by a forking webserver
       # @see Base#after_fork
       def after_fork
-        pub_redis.disconnect!
+        @pub_redis&.disconnect!
       end
 
       # (see Base#reset!)
@@ -75,6 +77,11 @@ module MessageBus
         end
       end
 
+      # (see Base#destroy)
+      def destroy
+        @pub_redis&.disconnect!
+      end
+
       # Deletes all backlogs and their data. Does not delete ID pointers, so new publications will get IDs that continue from the last publication before the expiry. Use with extreme caution.
       # @see Base#expire_all_backlogs!
       def expire_all_backlogs!
@@ -254,6 +261,7 @@ LUA
           new_redis.publish(redis_channel_name, UNSUB_MESSAGE)
         ensure
           new_redis&.disconnect!
+          @subscribed = false
         end
       end
 
@@ -296,6 +304,7 @@ LUA
 
             on.message do |_c, m|
               if m == UNSUB_MESSAGE
+                @subscribed = false
                 global_redis.unsubscribe
                 return
               end