solid_cable 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f06792b582165dee33117bc0433cf27e61d3d9e932765bced3d8cdb4891d0ba9
-  data.tar.gz: 81d50418ae04e5f99b82d57d13ec52fc293ec12a2bbd34f7d0b1f6cfcbaa0a9f
+  metadata.gz: 1aef7361e9ee2d03dbcd1d8bc89009cd4f3af500b1834e7fab52663850fde410
+  data.tar.gz: 63185c05065aa3ad657189fa7c2bbd8bf2a049eee2596e4e5d441c7c881ad258
 SHA512:
-  metadata.gz: f79b6a5e853f86aba526fc5963039d4888659315d08604b72e202b167912e0b26ba8120c53a6b0f4cf9c41cbdc30f53c96f3714597e0b1e4c00363fd69d9bba9
-  data.tar.gz: 5106fd2c0d1f12c3cfd854bb55a1ec239eb85bd51282c2fe9905f973f041ead14798da8466a9abd19385e09f478a1ca596db639f1a2d77e8836bcad35e603d30
+  metadata.gz: 7b8da2e04fd45d8dea8098ad3d453d06d3df53881369480157f03fff63f1d1fa615fdfcc6a162aa2b85976c3767afc25ecae725663b375edc89568470176bda3
+  data.tar.gz: ba1fb17d9ac2c916e815db54d4495f6cd0f53f72d63f276932fcb935958b3e7853e7bd2685c5e677b5972f98a306910b2598405bf7ead4dfabb25aa2ba74b59e

data/README.md

@@ -3,11 +3,12 @@
 Solid Cable is a database-backed Action Cable adapter that keeps messages in a table and continously polls for updates. This makes it possible to drop the common dependency on Redis, if it isn't needed for any other purpose. Despite polling, the performance of Solid Cable is comparable to Redis in most situations. And in all circumstances, it makes it easier to deploy Rails when Redis is no longer a required dependency for Action Cable functionality.
 
 > [!NOTE]
-> Solid Cable is primarily targeted at MySQL and SQLite but is tested to work
-> with PostgreSQL. PostgreSQL has its own Action Cable adapter which utilizes
-> the NOTIFY command for better performance. However, the PostgreSQL adapter
-> does have an 8kb limit on its payload, so if you find yourself broadcasting
-> large payloads, Solid Cable will work without a hitch.
+> Solid Cable is tested to work with MySQL, SQLite, and PostgreSQL.
+>
+> Action Cable already has a [dedicated PostgreSQL adapter](https://guides.rubyonrails.org/action_cable_overview.html#postgresql-adapter),
+> which utilizes the builtin `NOTIFY` command for better performance. However, that
+> adapter has an 8kb limit on its payload. Solid Cable is a great alternative if you find yourself
+> broadcasting large payloads, or prefer not to use the `NOTIFY` command.
 
 ## Installation
 
@@ -51,6 +52,16 @@ production:
 
 Then run `db:prepare` in production to ensure the database is created and the schema is loaded.
 
+### Single database configuration
+
+Running Solid Cable in a separate database is recommended, but it's also possible to use a single database for both the app and Action Cable.
+
+1. Copy the contents of `db/cable_schema.rb` into a normal migration and delete `db/cable_schema.rb`
+2. Remove `connects_to` from `config/cable.yml`
+3. `bin/rails db:migrate`
+
+You won't have multiple databases, so `database.yml` doesn't need to have primary and cable database.
+
 ## Configuration
 
 All configuration is managed via the `config/cable.yml` file. By default, it'll be configured like this:
@@ -207,6 +218,42 @@ rtt..................: avg=822.08ms min=51ms     med=732ms    max=5.05s  p(90)=1
 ws_connecting........: avg=278.08ms min=146.66ms med=236.35ms max=2.37s  p(90)=318.17ms p(95)=374.98ms
 ```
 
+
+##### PostgreSQL with Solid Cable
+
+With a polling interval of 0.1 seconds and autotrimming enabled. This instance
+was also hosted on the same machine.
+
+100 VUs
+```
+rtt..................: avg=137.45ms min=48ms     med=139ms    max=439ms    p(90)=179.1ms  p(95)=204ms
+ws_connecting........: avg=207.13ms min=150.29ms med=197.76ms max=443.67ms p(90)=254.44ms p(95)=263.29ms
+```
+250 VUs
+```
+rtt..................: avg=151.63ms min=49ms     med=146ms    max=538ms p(90)=222ms    p(95)=248.04ms
+ws_connecting........: avg=245.89ms min=147.18ms med=205.57ms max=30s   p(90)=265.08ms p(95)=281.15ms
+```
+500 VUs
+```
+rtt..................: avg=362.79ms min=50ms     med=249ms    max=1.21s p(90)=757ms    p(95)=844ms
+ws_connecting........: avg=257.02ms min=146.13ms med=227.65ms max=2.39s p(90)=303.22ms p(95)=344.39ms
+```
+
+
+##### PostgreSQL with dedicated adapter
+
+100 VUs
+```
+rtt..................: avg=69.76ms  min=41ms     med=57ms     max=622ms p(90)=116ms    p(95)=133ms
+ws_connecting........: avg=210.97ms min=149.68ms med=196.06ms max=1.27s p(90)=259.67ms p(95)=273.17ms
+```
+250 VUs
+```
+rtt..................: avg=73.43ms  min=40ms     med=58ms     max=698ms p(90)=126ms    p(95)=141ms
+ws_connecting........: avg=210.83ms min=143.01ms med=195.22ms max=1.27s p(90)=259.27ms p(95)=272.6ms
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/jobs/solid_cable/trim_job.rb

@@ -13,15 +13,14 @@ module SolidCable
     end
 
     private
+      def trim_batch_size
+        ::SolidCable.trim_batch_size
+      end
 
-    def trim_batch_size
-      ::SolidCable.trim_batch_size
-    end
-
-    def trim?
-      expires_per_write = (1 / trim_batch_size.to_f) * ::SolidCable.trim_chance
+      def trim?
+        expires_per_write = (1 / trim_batch_size.to_f) * ::SolidCable.trim_chance
 
-      rand < (expires_per_write - expires_per_write.floor)
-    end
+        rand < (expires_per_write - expires_per_write.floor)
+      end
   end
 end

data/app/models/solid_cable/message.rb

@@ -3,7 +3,7 @@
 module SolidCable
   class Message < SolidCable::Record
     scope :trimmable, lambda {
-      where(created_at: ..::SolidCable.message_retention.ago)
+      where(created_at: ...::SolidCable.message_retention.ago)
     }
     scope :broadcastable, lambda { |channels, last_id|
       where(channel_hash: channel_hashes_for(channels)).
@@ -12,7 +12,8 @@ module SolidCable
 
     class << self
       def broadcast(channel, payload)
-        insert({ channel:, payload:, channel_hash: channel_hash_for(channel) })
+        insert({ created_at: Time.current, channel:, payload:,
+          channel_hash: channel_hash_for(channel) })
       end
 
       def channel_hashes_for(channels)

data/lib/action_cable/subscription_adapter/solid_cable.rb

@@ -31,88 +31,86 @@ module ActionCable
       delegate :shutdown, to: :listener
 
       private
-
-      def listener
-        @listener || @server.mutex.synchronize do
-          @listener ||= Listener.new(@server.event_loop)
+        def listener
+          @listener || @server.mutex.synchronize do
+            @listener ||= Listener.new(@server.event_loop)
+          end
         end
-      end
 
-      class Listener < ::ActionCable::SubscriptionAdapter::SubscriberMap
-        def initialize(event_loop)
-          super()
+        class Listener < ::ActionCable::SubscriptionAdapter::SubscriberMap
+          def initialize(event_loop)
+            super()
 
-          @event_loop = event_loop
+            @event_loop = event_loop
 
-          @thread = Thread.new do
-            Thread.current.abort_on_exception = true
-            listen
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = true
+              listen
+            end
           end
-        end
 
-        def listen
-          while running?
-            with_polling_volume { broadcast_messages }
+          def listen
+            while running?
+              with_polling_volume { broadcast_messages }
 
-            sleep ::SolidCable.polling_interval
+              sleep ::SolidCable.polling_interval
+            end
           end
-        end
 
-        def shutdown
-          self.running = false
-          Thread.pass while thread.alive?
-        end
-
-        def add_channel(channel, on_success)
-          channels.add(channel)
-          event_loop.post(&on_success) if on_success
-        end
+          def shutdown
+            self.running = false
+            Thread.pass while thread.alive?
+          end
 
-        def remove_channel(channel)
-          channels.delete(channel)
-        end
+          def add_channel(channel, on_success)
+            channels.add(channel)
+            event_loop.post(&on_success) if on_success
+          end
 
-        def invoke_callback(*)
-          event_loop.post { super }
-        end
+          def remove_channel(channel)
+            channels.delete(channel)
+          end
 
-        private
+          def invoke_callback(*)
+            event_loop.post { super }
+          end
 
-        attr_reader :event_loop, :thread
-        attr_writer :running, :last_id
+          private
+            attr_reader :event_loop, :thread
+            attr_writer :running, :last_id
 
-        def running?
-          if defined?(@running)
-            @running
-          else
-            self.running = true
-          end
-        end
+            def running?
+              if defined?(@running)
+                @running
+              else
+                self.running = true
+              end
+            end
 
-        def last_id
-          @last_id ||= ::SolidCable::Message.maximum(:id) || 0
-        end
+            def last_id
+              @last_id ||= ::SolidCable::Message.maximum(:id) || 0
+            end
 
-        def channels
-          @channels ||= Set.new
-        end
+            def channels
+              @channels ||= Set.new
+            end
 
-        def broadcast_messages
-          ::SolidCable::Message.broadcastable(channels, last_id).
-            each do |message|
-              broadcast(message.channel, message.payload)
-              self.last_id = message.id
+            def broadcast_messages
+              ::SolidCable::Message.broadcastable(channels, last_id).
+                each do |message|
+                  broadcast(message.channel, message.payload)
+                  self.last_id = message.id
+                end
             end
-        end
 
-        def with_polling_volume
-          if ::SolidCable.silence_polling?
-            ActiveRecord::Base.logger.silence { yield }
-          else
-            yield
-          end
+            def with_polling_volume
+              if ::SolidCable.silence_polling?
+                ActiveRecord::Base.logger.silence { yield }
+              else
+                yield
+              end
+            end
         end
-      end
     end
   end
 end

data/lib/generators/solid_cable/install/templates/config/cable.yml

@@ -1,6 +1,6 @@
 # Async adapter only works within the same process, so for manually triggering cable updates from a console,
 # and seeing results in the browser, you must do so from the web console (running inside the dev process),
-# not a terminal started via bin/rails console! Add "console" to any action or "<%= console %>" in any view
+# not a terminal started via bin/rails console! Add "console" to any action or any ERB template view
 # to make the web console appear.
 development:
   adapter: async

data/lib/generators/solid_cable/install/templates/db/cable_schema.rb

@@ -1,11 +1,8 @@
-# frozen_string_literal: true
-
 ActiveRecord::Schema[7.1].define(version: 1) do
   create_table "solid_cable_messages", force: :cascade do |t|
     t.binary "channel", limit: 1024, null: false
     t.binary "payload", limit: 536870912, null: false
     t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
     t.integer "channel_hash", limit: 8, null: false
     t.index ["channel"], name: "index_solid_cable_messages_on_channel"
     t.index ["channel_hash"], name: "index_solid_cable_messages_on_channel_hash"

data/lib/solid_cable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidCable
-  VERSION = "3.0.0"
+  VERSION = "3.0.1"
 end

data/lib/solid_cable.rb

@@ -27,7 +27,7 @@ module SolidCable
     end
 
     def trim_batch_size
-      if (size = cable_config.trim_batch_size.to_i) < 1
+      if (size = cable_config.trim_batch_size.to_i) < 2
         100
       else
         size
@@ -42,24 +42,24 @@ module SolidCable
     # many records. This ensures there is downward pressure on the cache size
     # while there is valid data to delete. Read this as 'every time the trim job
     # runs theres a trim_multiplier chance this trims'. Adjust number to make it
-    # more or less likely to trim.
+    # more or less likely to trim. Only works like this if trim_batch_size is
+    # 100
     def trim_chance
-      10
+      2
     end
 
     private
+      def cable_config
+        Rails.application.config_for("cable")
+      end
 
-    def cable_config
-      Rails.application.config_for("cable")
-    end
-
-    def parse_duration(duration, default:)
-      if duration.present?
-        *amount, units = duration.to_s.split(".")
-        amount.join(".").to_f.public_send(units)
-      else
-        default
+      def parse_duration(duration, default:)
+        if duration.present?
+          *amount, units = duration.to_s.split(".")
+          amount.join(".").to_f.public_send(units)
+        else
+          default
+        end
       end
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_cable
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Nick Pezza
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2024-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord