graphql-anycable 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14133c519749fc9821bc5e9af2c28978b620afe77a7ec03cb26a51f41ef56c66
-  data.tar.gz: c8f8ee0f3c378bc72b80f4df1623e2ab402dc379097af315422b742abe09e17b
+  metadata.gz: ba22f385767198acc338809a6b60237248dfc15ecdd2f279a31628e6dad013e8
+  data.tar.gz: 6e59e6c8119969ee8358219b080abecb05df38d6ffe5549adbc58869f214872d
 SHA512:
-  metadata.gz: 667c1ecce687b40287dbd930144480cc7a14e4e663ca2ab7cd29538b586d4b2e3d4fdae38a0d3b4f37187ef7d2d25aa7b1f6112d89d79db481efc79f46d49c01
-  data.tar.gz: fc431ad886ce163e17bd1d257491f7964fd1140ebe89365ecdca7c7f5d66c661408c51bea51a3e36bc26c1b380d421b5d7d8ab0814fb6a94bd1a0ead45bad595
+  metadata.gz: 3479edd8cf0548d649ca3a0aaaeea728a8030c22342b50cb41beacca14b2ab7391bc9fc1cd2783ca861a07c8049b4ef1256e735fc97468469372213a822c9201
+  data.tar.gz: f6595e5f63dd71d375ec8d90816ae102839a8fda29bfc3f3400af10dedbcbf0cd4fb587d1462233b1a1b733801dfa5af8f172fc1f0906c4b4ba4db6e5250eebf

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## Unreleased
 
+## 1.3.3 - 2026-08-10
+
+### Fixed
+
+- Subscriptions are no longer leaked when a channel carries more than one of them. The first subscription's id now names the channel and later subscriptions are added to that same set. On disconnect, the channel's set is read and all subscriptions in it are deleted instead of only the most recent one as before. [@jjb] ([#58](https://github.com/anycable/graphql-anycable/pull/58))
+
+- Further optimize cleanup tasks with pipelining their reads and removals across keys. [@jjb] ([#57](https://github.com/anycable/graphql-anycable/pull/57))
+
 ## 1.3.2 - 2026-08-05
 
 ### Fixed

data/README.md

@@ -246,11 +246,12 @@ As in AnyCable there is no place to store subscription data in-memory, it should
     }
     ```
 
- 4. Channel subscriptions: `graphql-channel:#{subscription_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
+ 4. Channel subscriptions: `graphql-channel:#{channel_id}` set containing identifiers for all subscriptions created on one ActionCable channel, used to delete them on client disconnect. The channel is named after its first subscription's id (stored in the channel's AnyCable state); every later subscription on the same channel is added to that same set.
 
     ```sh
-    SMEMBERS graphql-channel:17420c6ed9e
+    SMEMBERS graphql-channel:52ee8d65-275e-4d22-94af-313129116388
     => 52ee8d65-275e-4d22-94af-313129116388
+       a1b2c3d4-5678-90ab-cdef-111213141516
     ```
 
 ## Stats

data/lib/graphql/anycable/cleaner.rb

@@ -28,10 +28,18 @@ module GraphQL
 
       def clean_fingerprint_subscriptions
         AnyCable.with_redis do |redis|
-          each_key(redis, adapter::SUBSCRIPTIONS_PREFIX) do |key|
-            each_batch(redis.sscan_each(key, count: redis_scan_count)) do |subscription_ids|
-              stale = missing_key_ids(redis, adapter::SUBSCRIPTION_PREFIX, subscription_ids)
-              redis.srem(key, stale) unless stale.empty?
+          each_key_batch(redis, adapter::SUBSCRIPTIONS_PREFIX) do |keys|
+            bulk_readable, oversized = partition_by_size(redis, keys, :scard)
+
+            each_capped_chunk(bulk_readable) do |chunk|
+              members = redis.pipelined { |pipeline| chunk.each { |key| pipeline.smembers(key) } }
+              remove_stale(redis, adapter::SUBSCRIPTION_PREFIX, chunk.zip(members), :srem)
+            end
+
+            oversized.each do |key|
+              each_batch(redis.sscan_each(key, count: redis_scan_count)) do |subscription_ids|
+                remove_stale(redis, adapter::SUBSCRIPTION_PREFIX, [[key, subscription_ids]], :srem)
+              end
             end
           end
         end
@@ -39,13 +47,20 @@ module GraphQL
 
       def clean_topic_fingerprints
         AnyCable.with_redis do |redis|
-          each_key(redis, adapter::FINGERPRINTS_PREFIX) do |key|
-            redis.zremrangebyscore(key, "-inf", "0")
+          each_key_batch(redis, adapter::FINGERPRINTS_PREFIX) do |keys|
+            redis.pipelined { |pipeline| keys.each { |key| pipeline.zremrangebyscore(key, "-inf", "0") } }
+
+            bulk_readable, oversized = partition_by_size(redis, keys, :zcard)
+
+            each_capped_chunk(bulk_readable) do |chunk|
+              fingerprints = redis.pipelined { |pipeline| chunk.each { |key| pipeline.zrange(key, 0, -1) } }
+              remove_stale(redis, adapter::SUBSCRIPTIONS_PREFIX, chunk.zip(fingerprints), :zrem)
+            end
 
-            each_batch(redis.zscan_each(key, count: redis_scan_count)) do |members|
-              fingerprints = members.map(&:first)
-              stale = missing_key_ids(redis, adapter::SUBSCRIPTIONS_PREFIX, fingerprints)
-              redis.zrem(key, stale) unless stale.empty?
+            oversized.each do |key|
+              each_batch(redis.zscan_each(key, count: redis_scan_count)) do |members|
+                remove_stale(redis, adapter::SUBSCRIPTIONS_PREFIX, [[key, members.map(&:first)]], :zrem)
+              end
             end
           end
         end
@@ -55,7 +70,7 @@ module GraphQL
 
       def clean_idle_keys(prefix)
         AnyCable.with_redis do |redis|
-          each_batch(redis.scan_each(match: "#{redis_key(prefix)}*", count: redis_scan_count)) do |keys|
+          each_key_batch(redis, prefix) do |keys|
             idle_times = redis.pipelined do |pipeline|
               keys.each { |key| pipeline.object("IDLETIME", key) }
             end
@@ -66,9 +81,56 @@ module GraphQL
         end
       end
 
-      # Iterates over the keys matching the given prefix, one key at a time.
-      def each_key(redis, prefix, &block)
-        redis.scan_each(match: "#{redis_key(prefix)}*", count: redis_scan_count, &block)
+      # Splits keys into those small enough to read in one go and those that have to be iterated
+      # with a cursor. Most collections hold only a handful of members, and reading many of them
+      # per round trip is what keeps cleanup bearable when there are a lot of keys; the rare huge
+      # ones still have to be iterated, or they would blow up memory in the process.
+      def partition_by_size(redis, keys, size_command)
+        sizes = redis.pipelined do |pipeline|
+          keys.each { |key| pipeline.public_send(size_command, key) }
+        end
+
+        bulk_readable, oversized = keys.zip(sizes).partition { |_key, size| size <= redis_scan_count }
+        [bulk_readable, oversized.map(&:first)]
+      end
+
+      # Yields key chunks whose combined size stays within redis_scan_count.
+      def each_capped_chunk(sized_keys)
+        chunk, total = [], 0
+
+        sized_keys.each do |key, size|
+          if chunk.any? && total + size > redis_scan_count
+            yield chunk
+            chunk, total = [], 0
+          end
+
+          chunk << key
+          total += size
+        end
+
+        yield chunk if chunk.any?
+      end
+
+      # Removes the members which no longer have a corresponding key in redis, given `[key, members]`
+      # pairs for one or more collections. Takes two round trips for the whole lot, however many
+      # collections and members it is handed: one for the existence checks and one for the removals.
+      def remove_stale(redis, prefix, members_by_key, remove_command)
+        pairs = members_by_key.flat_map { |key, members| members.map { |member| [key, member] } }
+        return if pairs.empty?
+
+        stale = missing_key_pairs(redis, prefix, pairs)
+        return if stale.empty?
+
+        redis.pipelined do |pipeline|
+          stale.group_by(&:first).each do |key, key_pairs|
+            pipeline.public_send(remove_command, key, key_pairs.map(&:last))
+          end
+        end
+      end
+
+      # Iterates over the keys matching the given prefix in batches, to allow pipelining.
+      def each_key_batch(redis, prefix, &block)
+        each_batch(redis.scan_each(match: "#{redis_key(prefix)}*", count: redis_scan_count), &block)
       end
 
       # Consumes a lazy enumerator (SCAN family) in batches to keep memory usage bounded.
@@ -76,14 +138,16 @@ module GraphQL
         enumerator.each_slice(redis_scan_count, &block)
       end
 
-      # Returns the ids which have no corresponding key in redis anymore, checking them in a single round trip.
-      def missing_key_ids(redis, prefix, ids)
+      # Returns the `[key, member]` pairs whose member has no corresponding key in redis anymore,
+      # checking all of them in a single round trip. The member cannot be looked up on its own,
+      # since the same member may well appear in more than one collection.
+      def missing_key_pairs(redis, prefix, pairs)
         exists = redis.pipelined do |pipeline|
-          ids.each { |id| pipeline.exists?(redis_key(prefix) + id) }
+          pairs.each { |_key, member| pipeline.exists?(redis_key(prefix) + member) }
         end
 
-        # Reject ids that has corresponding key in Redis in `exists` array of pipelined responses.
-        ids.reject.with_index { |_id, index| exists[index] }
+        # Reject pairs whose member has a corresponding key in Redis in `exists` array of pipelined responses.
+        pairs.reject.with_index { |_pair, index| exists[index] }
       end
 
       def adapter

data/lib/graphql/anycable/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module AnyCable
-    VERSION = "1.3.2"
+    VERSION = "1.3.3"
   end
 end

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -127,8 +127,12 @@ module GraphQL
 
         raise GraphQL::AnyCable::ChannelConfigurationError unless channel
 
-        # Store subscription_id in the channel state to cleanup on disconnect
-        write_subscription_id(channel, subscription_id)
+        # Store the channel's id in its state to cleanup on disconnect. A channel may carry more
+        # than one subscription, so the first subscription's id names the channel and every later
+        # subscription is added to that same set: otherwise each new subscription would overwrite
+        # the stored id, and #delete_channel_subscriptions could only ever find the last one.
+        channel_id = read_channel_id(channel) || subscription_id
+        write_channel_id(channel, channel_id)
 
         events.each do |event|
           channel.stream_from(redis_key(SUBSCRIPTIONS_PREFIX) + event.fingerprint)
@@ -144,14 +148,14 @@ module GraphQL
 
         with_redis do |redis|
           redis.multi do |pipeline|
-            pipeline.sadd(redis_key(CHANNEL_PREFIX) + subscription_id, [subscription_id])
+            pipeline.sadd(redis_key(CHANNEL_PREFIX) + channel_id, [subscription_id])
             pipeline.mapped_hmset(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, data)
             events.each do |event|
               pipeline.zincrby(redis_key(FINGERPRINTS_PREFIX) + event.topic, 1, event.fingerprint)
               pipeline.sadd(redis_key(SUBSCRIPTIONS_PREFIX) + event.fingerprint, [subscription_id])
             end
             next unless config.subscription_expiration_seconds
-            pipeline.expire(redis_key(CHANNEL_PREFIX) + subscription_id, config.subscription_expiration_seconds)
+            pipeline.expire(redis_key(CHANNEL_PREFIX) + channel_id, config.subscription_expiration_seconds)
             pipeline.expire(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, config.subscription_expiration_seconds)
           end
         end
@@ -177,7 +181,7 @@ module GraphQL
       def delete_channel_subscriptions(channel)
         raise(ArgumentError, "Please pass channel instance to #{__method__} in your #unsubscribed method") if channel.is_a?(String)
 
-        channel_id = read_subscription_id(channel)
+        channel_id = read_channel_id(channel)
 
         # Missing in case disconnect happens before #execute
         return unless channel_id
@@ -213,7 +217,8 @@ module GraphQL
 
       private
 
-      def read_subscription_id(channel)
+      # Channel cleanup key kept in AnyCable istate as "sid"
+      def read_channel_id(channel)
         return channel.instance_variable_get(:@__sid__) if channel.instance_variable_defined?(:@__sid__)
 
         istate = fetch_channel_istate(channel)
@@ -223,7 +228,7 @@ module GraphQL
         channel.instance_variable_set(:@__sid__, istate["sid"])
       end
 
-      def write_subscription_id(channel, val)
+      def write_channel_id(channel, val)
         channel.connection.anycable_socket.istate["sid"] = val
         channel.instance_variable_set(:@__sid__, val)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-anycable
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Andrey Novikov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-05 00:00:00.000000000 Z
+date: 2026-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core