graphql-anycable 1.3.1 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eebb61e4181214e0f86bdf0cc33e7153e0a02c6c8de5e37996ca9457e6231385
-  data.tar.gz: 6fa0f37c132f8c22454bcdf9d995ac9b0c3f40c3913b0047f7be3b91eb68d07f
+  metadata.gz: ba22f385767198acc338809a6b60237248dfc15ecdd2f279a31628e6dad013e8
+  data.tar.gz: 6e59e6c8119969ee8358219b080abecb05df38d6ffe5549adbc58869f214872d
 SHA512:
-  metadata.gz: 06b6b55507a369100a71e9a30b93cf0fccef1d82c948b71693e43a4629116749453577aa0919d5de12c3bad8f6703d9652b0378c6ad90c4775ab355fe9b4ce7d
-  data.tar.gz: d0ed4156e37e936fad396659517245b1f4540451e4b4012ec8d1478cc4c1b1d244c254b690b168f4d8d2d36a3aadf1c22643c5cde639b08c119c8ec801d97152
+  metadata.gz: 3479edd8cf0548d649ca3a0aaaeea728a8030c22342b50cb41beacca14b2ab7391bc9fc1cd2783ca861a07c8049b4ef1256e735fc97468469372213a822c9201
+  data.tar.gz: f6595e5f63dd71d375ec8d90816ae102839a8fda29bfc3f3400af10dedbcbf0cd4fb587d1462233b1a1b733801dfa5af8f172fc1f0906c4b4ba4db6e5250eebf

data/.github/workflows/lint.yml

@@ -24,10 +24,10 @@ jobs:
     env:
       BUNDLE_GEMFILE: "gemfiles/rubocop.gemfile"
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.1
+        ruby-version: 3.4
         bundler-cache: true
     - name: Lint Ruby code with RuboCop
       run: |

data/.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
       id-token: write
       packages: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0 # Fetch current tag as annotated. See https://github.com/actions/checkout/issues/290
       - uses: ruby/setup-ruby@v1

data/.github/workflows/test.yml

@@ -18,6 +18,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - ruby: "4.0"
+            graphql: '~> 2.3'
+            anycable: '~> 1.6'
+            redis_version: latest
           - ruby: "3.3"
             graphql: '~> 2.3'
             anycable: '~> 1.5'
@@ -52,7 +56,7 @@ jobs:
         ports:
           - 6379:6379
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}

data/.rubocop/rspec.yml

@@ -1,4 +1,4 @@
-require:
+plugins:
   - rubocop-rspec
 
 # Disable all cops by default,

data/.rubocop.yml

@@ -2,8 +2,7 @@ inherit_mode:
   merge:
     - Exclude
 
-require:
-  - standard
+plugins:
   - standard-custom
   - standard-performance
   - rubocop-performance

data/CHANGELOG.md

@@ -7,6 +7,26 @@ 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
+
+- Cleanup tasks are much faster and use bounded memory: `SCAN`/`SSCAN`/`ZSCAN` are called with a configurable `COUNT` (new `redis_scan_count` setting, default `1000`) instead of Redis' default of 10, members are read incrementally with `SSCAN`/`ZSCAN` instead of `SMEMBERS`/`ZRANGE` (which materialized entire sets in the rake process), and the per-member `EXISTS`, `OBJECT IDLETIME`, `SREM`, `ZREM` and `DEL` calls are pipelined in batches instead of being issued one round trip at a time. [@jjb] ([#56](https://github.com/anycable/graphql-anycable/pull/56))
+
+## 1.3.1 - 2025-03-29
+
+### Fixed
+
+- Remove `clean:events` from `clean_expired_subscriptions.rake`. [@Geesu] ([#46](https://github.com/anycable/graphql-anycable/pull/46))
+
 ## 1.3.0 - 2024-08-13
 
 ### Changed
@@ -211,6 +231,7 @@ Technical release to test publishing via GitHub Actions.
 
 Initial version: store subscriptions on redis, re-execute queries in sync. [@Envek]
 
+[@jjb]: https://github.com/jjb "John Bachir"
 [@prog-supdex]: https://github.com/prog-supdex "Igor Platonov"
 [@ilyasgaraev]: https://github.com/ilyasgaraev "Ilyas Garaev"
 [@smasry]: https://github.com/smasry "Samer Masry"

data/README.md

@@ -5,9 +5,9 @@ A (mostly) drop-in replacement for default ActionCable subscriptions adapter shi
 [![Gem Version](https://badge.fury.io/rb/graphql-anycable.svg)](https://badge.fury.io/rb/graphql-anycable)
 [![Tests](https://github.com/anycable/graphql-anycable/actions/workflows/test.yml/badge.svg)](https://github.com/anycable/graphql-anycable/actions/workflows/test.yml)
 
-<a href="https://evilmartians.com/?utm_source=graphql-anycable&utm_campaign=project_page">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
-</a>
+<br/>
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="Evil Martians logo" width="22" height="16" /> <b>GraphQL-AnyCable</b> is built by <b><a href="https://evilmartians.com/">Evil Martians</a></b>, an American design and engineering consultancy for <b>developer tools, AI, and cybersecurity startups</b>.
 
 ## Why?
 
@@ -134,6 +134,10 @@ To avoid filling Redis storage with stale subscription data:
 
     Heroku users should set up `use_redis_object_on_cleanup` setting to `false` due to [limitations in Heroku Redis](https://devcenter.heroku.com/articles/heroku-redis#connection-permissions).
 
+    The task is also available as granular sub-tasks, so you can run only some of them, or run them on different schedules: `rake graphql:anycable:clean:channels`, `rake graphql:anycable:clean:subscriptions`, `rake graphql:anycable:clean:fingerprint_subscriptions`, `rake graphql:anycable:clean:topic_fingerprints`.
+
+    Cleanup iterates over Redis with the `SCAN` family of commands and pipelines the checks it performs on each batch. Use the `redis_scan_count` setting to tune the batch size: larger values mean fewer round trips (so faster cleanup), at the cost of doing more work per Redis call.
+
 ## Configuration
 
 GraphQL-AnyCable uses [anyway_config] to configure itself. There are several possibilities to configure this gem:
@@ -144,6 +148,7 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     GRAPHQL_ANYCABLE_SUBSCRIPTION_EXPIRATION_SECONDS=604800
     GRAPHQL_ANYCABLE_USE_REDIS_OBJECT_ON_CLEANUP=true
     GRAPHQL_ANYCABLE_REDIS_PREFIX=graphql
+    GRAPHQL_ANYCABLE_REDIS_SCAN_COUNT=1000
     ```
 
  2. YAML configuration files (note that this is `config/graphql_anycable.yml`, *not* `config/anycable.yml`):
@@ -154,6 +159,7 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
       subscription_expiration_seconds: 300 # 5 minutes
       use_redis_object_on_cleanup: false # For restricted redis installations
       redis_prefix: graphql # You can configure redis_prefix for anycable-graphql subscription prefixes. Default value "graphql"
+      redis_scan_count: 1000 # Batch size used by the cleanup rake tasks. Default value 1000
     ```
 
  3. Configuration from your application code:
@@ -240,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/gemfiles/rubocop.gemfile

@@ -1,5 +1,4 @@
-source "https://rubygems.org" do
-  gem "standard", "~> 1.28"
+source "https://rubygems.org"
 
-  gem "rubocop-rspec"
-end
+gem "standard"
+gem "rubocop-rspec"

data/graphql-anycable.gemspec

@@ -17,6 +17,10 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/Envek/graphql-anycable"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "rubygems_mfa_required" => "true"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
@@ -34,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "redis", ">= 4.2.0"
 
   spec.add_development_dependency "anycable-rails"
-  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "bundler", ">= 2.0"
   spec.add_development_dependency "rack"
   spec.add_development_dependency "railties"
   spec.add_development_dependency "rake", ">= 12.3.3"

data/lib/graphql/anycable/cleaner.rb

@@ -16,37 +16,30 @@ module GraphQL
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        AnyCable.with_redis do |redis|
-          redis.scan_each(match: "#{redis_key(adapter::CHANNEL_PREFIX)}*") do |key|
-            idle = redis.object("IDLETIME", key)
-            next if idle&.<= config.subscription_expiration_seconds
-
-            redis.del(key)
-          end
-        end
+        clean_idle_keys(adapter::CHANNEL_PREFIX)
       end
 
       def clean_subscriptions
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        AnyCable.with_redis do |redis|
-          redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTION_PREFIX)}*") do |key|
-            idle = redis.object("IDLETIME", key)
-            next if idle&.<= config.subscription_expiration_seconds
-
-            redis.del(key)
-          end
-        end
+        clean_idle_keys(adapter::SUBSCRIPTION_PREFIX)
       end
 
       def clean_fingerprint_subscriptions
         AnyCable.with_redis do |redis|
-          redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTIONS_PREFIX)}*") do |key|
-            redis.smembers(key).each do |subscription_id|
-              next if redis.exists?(redis_key(adapter::SUBSCRIPTION_PREFIX) + subscription_id)
+          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
 
-              redis.srem(key, subscription_id)
+            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
@@ -54,12 +47,20 @@ module GraphQL
 
       def clean_topic_fingerprints
         AnyCable.with_redis do |redis|
-          redis.scan_each(match: "#{redis_key(adapter::FINGERPRINTS_PREFIX)}*") do |key|
-            redis.zremrangebyscore(key, "-inf", "0")
-            redis.zrange(key, 0, -1).each do |fingerprint|
-              next if redis.exists?(redis_key(adapter::SUBSCRIPTIONS_PREFIX) + fingerprint)
+          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
 
-              redis.zrem(key, fingerprint)
+            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
@@ -67,6 +68,88 @@ module GraphQL
 
       private
 
+      def clean_idle_keys(prefix)
+        AnyCable.with_redis do |redis|
+          each_key_batch(redis, prefix) do |keys|
+            idle_times = redis.pipelined do |pipeline|
+              keys.each { |key| pipeline.object("IDLETIME", key) }
+            end
+
+            expired = keys.reject.with_index { |_key, index| idle_times[index]&.<= config.subscription_expiration_seconds }
+            redis.del(*expired) unless expired.empty?
+          end
+        end
+      end
+
+      # 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.
+      def each_batch(enumerator, &block)
+        enumerator.each_slice(redis_scan_count, &block)
+      end
+
+      # 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|
+          pairs.each { |_key, member| pipeline.exists?(redis_key(prefix) + member) }
+        end
+
+        # 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
         GraphQL::Subscriptions::AnyCableSubscriptions
       end
@@ -75,6 +158,10 @@ module GraphQL
         GraphQL::AnyCable.config
       end
 
+      def redis_scan_count
+        config.redis_scan_count.to_i
+      end
+
       def redis_key(prefix)
         "#{config.redis_prefix}-#{prefix}"
       end

data/lib/graphql/anycable/config.rb

@@ -11,6 +11,7 @@ module GraphQL
       attr_config subscription_expiration_seconds: nil
       attr_config use_redis_object_on_cleanup: true
       attr_config redis_prefix: "graphql" # Here, we set clear redis_prefix without any hyphen. The hyphen is added at the end of this value on our side.
+      attr_config redis_scan_count: 1_000 # COUNT for SCAN commands and batch size for pipelined commands during cleanup.
     end
   end
 end

data/lib/graphql/anycable/version.rb

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

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -4,8 +4,6 @@ require "anycable"
 require "graphql/subscriptions"
 require "graphql/anycable/errors"
 
-# rubocop: disable Metrics/AbcSize, Metrics/LineLength, Metrics/MethodLength
-
 # A subscriptions implementation that sends data as AnyCable broadcastings.
 #
 # Since AnyCable is aimed to be compatible with ActionCable, this adapter
@@ -129,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)
@@ -146,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
@@ -179,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
@@ -215,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)
@@ -225,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
@@ -249,4 +252,3 @@ module GraphQL
     end
   end
 end
-# rubocop: enable Metrics/AbcSize, Metrics/LineLength, Metrics/MethodLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-anycable
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.3
 platform: ruby
 authors:
 - Andrey Novikov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 2026-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core
@@ -96,14 +96,14 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
@@ -202,7 +202,8 @@ files:
 homepage: https://github.com/Envek/graphql-anycable
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: