graphql-anycable 1.3.2 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14133c519749fc9821bc5e9af2c28978b620afe77a7ec03cb26a51f41ef56c66
-  data.tar.gz: c8f8ee0f3c378bc72b80f4df1623e2ab402dc379097af315422b742abe09e17b
+  metadata.gz: 8d1012a281016a5fdd02aa9a1decc2d3935f545fef5899c15505dfeef64c9628
+  data.tar.gz: ae8f4ff4cb25da208b31b8a257f60307bf66fe626362741ea29705c97bcab8e1
 SHA512:
-  metadata.gz: 667c1ecce687b40287dbd930144480cc7a14e4e663ca2ab7cd29538b586d4b2e3d4fdae38a0d3b4f37187ef7d2d25aa7b1f6112d89d79db481efc79f46d49c01
-  data.tar.gz: fc431ad886ce163e17bd1d257491f7964fd1140ebe89365ecdca7c7f5d66c661408c51bea51a3e36bc26c1b380d421b5d7d8ab0814fb6a94bd1a0ead45bad595
+  metadata.gz: 3c37a74df3ffc723b7b2fcf7bbfc009b3d67df79275d1c027b22bec3c9f45d6b3a5896b270582c50fc0deb78e38c1f7bc4f38a03288aa941ac20ed584538a3c8
+  data.tar.gz: 7dff7ea7638ee30a09bbc889648db4e0ebf4a12ba2798f215b013f29bb92e146241b0a9e4cad167c4691fbe15141ef085966f4799d708352ed1729628c97d634

data/.github/workflows/test.yml

@@ -19,13 +19,17 @@ jobs:
       matrix:
         include:
           - ruby: "4.0"
-            graphql: '~> 2.3'
+            graphql: '~> 2.6'
             anycable: '~> 1.6'
             redis_version: latest
+          - ruby: "3.4"
+            graphql: '~> 2.5.0'
+            anycable: '~> 1.6'
+            redis_version: '7.4'
           - ruby: "3.3"
-            graphql: '~> 2.3'
+            graphql: '~> 2.3.0'
             anycable: '~> 1.5'
-            redis_version: latest
+            redis_version: '7.4'
           - ruby: "3.2"
             graphql: '~> 2.2.0'
             anycable: '~> 1.5.0'

data/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## Unreleased
 
+## 1.3.4 - 2026-08-21
+
+### Fixed
+
+- Return `nil` from `read_subscription` if subscription data has gone from Redis, That was resulted in a "No query string was present" errors received on graphql subscription clients receiving a hash with an `nil` `query_string` instead of receiving `nil` directly. [@thlacroix] ([#51](https://github.com/anycable/graphql-anycable/pull/51))
+
+- Subscription events are no longer dropped when another subscription with the same fingerprint expires during execution. [@prog-supdex] ([#53](https://github.com/anycable/graphql-anycable/pull/53))
+
+- Deleting a subscription no longer goes through the deprecated `GraphQL::AnyCable.redis`; this avoids both the deprecation warning and reusing a connection after it has been returned to the pool. [@Envek] ([#53](https://github.com/anycable/graphql-anycable/pull/53))
+
+### Changed
+
+- `GraphQL::Subscriptions::AnyCableSubscriptions#read_subscription` now raises `GraphQL::AnyCable::SubscriptionExpiredError` when the subscription is no longer stored in Redis, instead of returning `nil`. [@Envek] ([#53](https://github.com/anycable/graphql-anycable/pull/53))
+
+## 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
@@ -223,6 +245,7 @@ Technical release to test publishing via GitHub Actions.
 
 Initial version: store subscriptions on redis, re-execute queries in sync. [@Envek]
 
+[@thlacroix]: https://github.com/thlacroix "Thomas Lacroix"
 [@jjb]: https://github.com/jjb "John Bachir"
 [@prog-supdex]: https://github.com/prog-supdex "Igor Platonov"
 [@ilyasgaraev]: https://github.com/ilyasgaraev "Ilyas Garaev"

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/errors.rb

@@ -16,5 +16,9 @@ module GraphQL
         DEFAULT_MESSAGE
       end
     end
+
+    # This error is raised when a subscription is gone from Redis by the time it is read,
+    # so that the caller can tell it from an update GraphQL has deliberately skipped.
+    class SubscriptionExpiredError < ::RuntimeError; end
   end
 end

data/lib/graphql/anycable/version.rb

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

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -95,10 +95,20 @@ module GraphQL
       def execute_grouped(fingerprint, subscription_ids, event, object)
         return if subscription_ids.empty?
 
-        subscription_id = with_redis { |redis| subscription_ids.find { |sid| redis.exists?(redis_key(SUBSCRIPTION_PREFIX) + sid) } }
-        return unless subscription_id # All subscriptions has expired but haven't cleaned up yet
+        result = nil
+
+        subscription_ids.each do |subscription_id|
+          result = execute_update(subscription_id, event, object)
+
+          # Whatever GraphQL has decided here — including a nil result for NO_UPDATE or
+          # for #unsubscribe without a final update — applies to the whole group, as all
+          # of its subscriptions share the same fingerprint. So, ask only one of them.
+          break
+        rescue GraphQL::AnyCable::SubscriptionExpiredError
+          # This one is gone, but the rest of the group is still waiting for the update
+          next
+        end
 
-        result = execute_update(subscription_id, event, object)
         return unless result
 
         # Having calculated the result _once_, send the same payload to all subscribers
@@ -127,8 +137,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,40 +158,48 @@ 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
       end
 
       # Return the query from "storage" (in redis)
+      # @raise [GraphQL::AnyCable::SubscriptionExpiredError] if it is not stored anymore
       def read_subscription(subscription_id)
-        with_redis do |redis|
+        subscription = with_redis do |redis|
           redis.mapped_hmget(
             "#{redis_key(SUBSCRIPTION_PREFIX)}#{subscription_id}",
             :query_string, :variables, :context, :operation_name
-          ).tap do |subscription|
-            next if subscription.values.all?(&:nil?) # Redis returns hash with all nils for missing key
-
-            subscription[:context] = @serializer.load(subscription[:context])
-            subscription[:variables] = JSON.parse(subscription[:variables])
-            subscription[:operation_name] = nil if subscription[:operation_name].strip == ""
-          end
+          )
         end
+
+        # Give the connection back before raising or deserializing: a connector may be
+        # backed by a pool, and neither of these needs Redis anymore.
+        #
+        # Redis returns a hash with nil values for a missing key. A subscription without
+        # a query string is unusable anyway, so treat a half-written one as missing, too.
+        raise GraphQL::AnyCable::SubscriptionExpiredError, subscription_id if subscription[:query_string].nil?
+
+        subscription[:context] = @serializer.load(subscription[:context])
+        subscription[:variables] = JSON.parse(subscription[:variables])
+        subscription[:operation_name] = nil if subscription[:operation_name].to_s.strip == ""
+
+        subscription
       end
 
       # The channel was closed, forget about it and its subscriptions
       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
@@ -190,7 +212,9 @@ module GraphQL
         end
       end
 
-      def delete_subscription(subscription_id, redis: AnyCable.redis)
+      def delete_subscription(subscription_id, redis: nil)
+        return with_redis { |connection| delete_subscription(subscription_id, redis: connection) } unless redis
+
         events = redis.hget(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, :events)
         events = events ? JSON.parse(events) : {}
         fingerprint_subscriptions = {}
@@ -213,7 +237,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 +248,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.4
 platform: ruby
 authors:
 - Andrey Novikov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-05 00:00:00.000000000 Z
+date: 2026-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core