graphql-anycable 1.1.7 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d792c5cf2b52398bfe6c09e768a1c3af484209aca0bbfa810eccb25480d791d2
-  data.tar.gz: 29eb4a0c90b0cef15040ce6c67493e832c7efe191ee90f98e1e1de4eb2c89eb0
+  metadata.gz: bafa1a80487eeb78627ed0752751eb488dd33ca9709d38b205d61d310f97d7ae
+  data.tar.gz: 821cba31fd376a471c9db5757a2da3e51d936f618f372a624fab1515dea5d4e6
 SHA512:
-  metadata.gz: 276d5e8243fd288480ec7420eb7151e4dcb6802df9255fb2bb581d45f6f9b5d6eb582cc789d0bde4f1541bdbf17b5bab6e5c9244adb264ce24c0bafce4a57266
-  data.tar.gz: a7237e211c05268f1a74da0a32946b97f1f737046c1c7920b5b786f5755026f8c1529c41a3783e3ec8d41a42d37d5b52ea8672523c095bc9e42138c04f309ab3
+  metadata.gz: fdad5b3cfcc372ec326ebfa9641ecdc81d5f586aca7fc54edb5bc1985d4e0e8fabd3ba93eb25cf8e9f55556a7d5410a2971596ab52936706199cdb6c6f3faa10
+  data.tar.gz: f71265d7dc1f0afdb4162e2d6a00d87c92bd53aa484429a5dff138e7f53db754b75a55137d999314f6c600eee3d88d661b6ab91a87b1bdd9f52a0317a7d9e43a

data/.github/workflows/test.yml

@@ -10,35 +10,33 @@ on:
 
 jobs:
   test:
-    name: "GraphQL-Ruby ${{ matrix.graphql }} on Ruby ${{ matrix.ruby }} (use_client_id: ${{ matrix.client_id }}) Redis v${{ matrix.redis_version }}"
+    name: "GraphQL-Ruby ${{ matrix.graphql }} AnyCable ${{ matrix.anycable }} on Ruby ${{ matrix.ruby }} Redis ${{ matrix.redis_version }}"
+    # Skip running tests for local pull requests (use push event instead), run only for foreign ones
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.owner.login != github.event.pull_request.base.repo.owner.login
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         include:
+          - ruby: "3.3"
+            graphql: '~> 2.3'
+            anycable: '~> 1.5'
+            redis_version: latest
+          - ruby: "3.2"
+            graphql: '~> 2.2.0'
+            anycable: '~> 1.4.0'
+            redis_version: '7.2'
           - ruby: "3.1"
             graphql: '~> 2.0.0'
-            client_id: 'false'
-            anycable_rails: '~> 1.3'
-            redis_version: latest
-          - ruby: "3.0"
-            graphql: '~> 1.13.0'
-            client_id: 'false'
-            anycable_rails: '~> 1.2.0'
-            redis_version: 5.0.4
-          - ruby: 2.7
-            graphql: '~> 1.12.0'
-            client_id: 'true'
-            anycable_rails: '~> 1.1.0'
-            redis_version: 4.0.14
-    container:
-      image: ruby:${{ matrix.ruby }}
-      env:
-        CI: true
-        GRAPHQL_RUBY_VERSION: ${{ matrix.graphql }}
-        ANYCABLE_RAILS_VERSION: ${{ matrix.anycable_rails }}
-        GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID: ${{ matrix.client_id }}
-        REDIS_URL: redis://redis:6379
+            anycable: '~> 1.3.0'
+            redis_version: '6.2'
+    env:
+      CI: true
+      GRAPHQL_RUBY_VERSION: ${{ matrix.graphql }}
+      ANYCABLE_VERSION: ${{ matrix.anycable }}
+      ANYCABLE_RAILS_VERSION: ${{ matrix.anycable }}
+      GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID: ${{ matrix.client_id }}
+      REDIS_URL: redis://localhost:6379
     services:
       redis:
         image: redis:${{ matrix.redis_version }}
@@ -47,21 +45,13 @@ jobs:
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
+        ports:
+          - 6379:6379
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
         with:
-          path: vendor/bundle
-          key: bundle-${{ matrix.ruby }}-${{ matrix.graphql }}-${{ matrix.anycable }}-${{ hashFiles('**/*.gemspec') }}-${{ hashFiles('**/Gemfile') }}
-          restore-keys: |
-            bundle-${{ matrix.ruby }}-${{ matrix.graphql }}-${{ matrix.anycable }}-
-            bundle-${{ matrix.ruby }}-
-      - name: Upgrade Bundler to 2.0 (for older Rubies)
-        run: gem install bundler -v '~> 2.0'
-      - name: Bundle install
-        run: |
-          bundle config path vendor/bundle
-          bundle install
-          bundle update
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
       - name: Run RSpec
         run: bundle exec rspec

data/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## Unreleased
 
-## 1.1.7 - 2024-05-08
+## 1.2.0 - 2024-05-07
 
 ### Changed
 
@@ -17,6 +17,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
   See https://github.com/anycable/graphql-anycable/issues/43 for details.
 
+### Removed
+
+- Handling of client-provided channel identifiers. **BREAKING CHANGE**
+
+  Please make sure that you have changed your channel `disconnected` method to pass channel instance to GraphQL-AnyCable's `delete_channel_subscriptions` method.
+  See [release notes for version 1.1.0](https://github.com/anycable/graphql-anycable/releases/tag/v1.1.0) for details.
+
+- Handling of pre-1.0 subscriptions data.
+
+  If you're still using version 0.5 or below, please upgrade to 1.0 or 1.1 first with `handle_legacy_subscriptions` setting enabled.
+  See [release notes for version 1.0.0](https://github.com/anycable/graphql-anycable/releases/tag/v1.0.0) for details.
+
 ## 1.1.6 - 2023-08-03
 
 ### Fixed
@@ -185,8 +197,6 @@ Technical release to test publishing via GitHub Actions.
 
 Initial version: store subscriptions on redis, re-execute queries in sync. [@Envek]
 
-[@ilyasgaraev]: https://github.com/ilyasgaraev "Ilyas Garaev"
-[@smasry]: https://github.com/smasry "Samer Masry"
 [@gsamokovarov]: https://github.com/gsamokovarov "Genadi Samokovarov"
 [@bibendi]: https://github.com/bibendi "Misha Merkushin"
 [@FX-HAO]: https://github.com/FX-HAO "Fuxin Hao"

data/Gemfile

@@ -7,9 +7,9 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in graphql-anycable.gemspec
 gemspec
 
-gem "graphql",  ENV.fetch("GRAPHQL_RUBY_VERSION", "~> 1.12")
-gem "anycable", ENV.fetch("ANYCABLE_VERSION", "~> 1.0")
-gem "anycable-rails", ENV.fetch("ANYCABLE_RAILS_VERSION", "~> 1.3")
+gem "graphql",  ENV.fetch("GRAPHQL_RUBY_VERSION", "~> 2.3")
+gem "anycable", ENV.fetch("ANYCABLE_VERSION", "~> 1.5")
+gem "anycable-rails", ENV.fetch("ANYCABLE_RAILS_VERSION", "~> 1.5")
 
 group :development, :test do
   gem "pry"

data/README.md

@@ -140,8 +140,7 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     ```.env
     GRAPHQL_ANYCABLE_SUBSCRIPTION_EXPIRATION_SECONDS=604800
     GRAPHQL_ANYCABLE_USE_REDIS_OBJECT_ON_CLEANUP=true
-    GRAPHQL_ANYCABLE_HANDLE_LEGACY_SUBSCRIPTIONS=false
-    GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID=false
+    GRAPHQL_ANYCABLE_REDIS_PREFIX=graphql
     ```
 
  2. YAML configuration files (note that this is `config/graphql_anycable.yml`, *not* `config/anycable.yml`):
@@ -151,8 +150,7 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     production:
       subscription_expiration_seconds: 300 # 5 minutes
       use_redis_object_on_cleanup: false # For restricted redis installations
-      handle_legacy_subscriptions: false # For seamless upgrade from pre-1.0 versions
-      use_client_provided_uniq_id: false # To avoid problems with non-uniqueness of Apollo channel identifiers
+      redis_prefix: graphql # You can configure redis_prefix for anycable-graphql subscription prefixes. Default value "graphql"
     ```
 
  3. Configuration from your application code:
@@ -160,11 +158,48 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     ```ruby
     GraphQL::AnyCable.configure do |config|
       config.subscription_expiration_seconds = 3600 # 1 hour
+      config.redis_prefix = "graphql" # on our side, we add `-` ourselves after the redis_prefix
     end
     ```
 
 And any other way provided by [anyway_config]. Check its documentation!
 
+## Emergency actions
+In situations when you don't set `subscription_expiration_seconds`, have a lot of inactive subscriptions, and `GraphQL::AnyCable::Cleaner` does`t help in that, 
+you can do the following actions for clearing subscriptions
+
+1. Set `config.subscription_expiration_seconds`. After that, the new subscriptions will have `TTL`
+2. Run the script
+```ruby
+   redis = GraphQL::AnyCable.redis
+   config = GraphQL::AnyCable.config
+   
+   # do it for subscriptions
+   redis.scan_each("graphql-subscription:*") do |key|
+     redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
+     # or you can just remove it immediately
+     # redis.del(key) if redis.ttl(key) < 0
+   end
+
+   # do it for channels
+   redis.scan_each("graphql-channel:*") do |key|
+     redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
+     # or you can just remove it immediately
+     # redis.del(key) if redis.ttl(key) < 0
+   end
+```
+
+Or you can change the `redis_prefix` in the `configuration` and then remove all records with the old_prefix 
+For instance:
+
+1. Change the `redis_prefix`. The default `redis_prefix` is `graphql`
+2. Run the ruby script, which remove all records with `old prefix`
+```ruby
+  redis.scan_each("graphql-*") do |key|
+    redis.del(key)
+  end
+```
+
 ## Data model
 
 As in AnyCable there is no place to store subscription data in-memory, it should be persisted somewhere to be retrieved on `GraphQLSchema.subscriptions.trigger` and sent to subscribed clients. `graphql-anycable` uses the same Redis database as AnyCable itself.
@@ -183,13 +218,6 @@ As in AnyCable there is no place to store subscription data in-memory, it should
     => 52ee8d65-275e-4d22-94af-313129116388
     ```
 
-    > For backward compatibility with pre-1.0 versions of this gem older `graphql-event:#{event.topic}` set containing subscription identifiers is also supported.
-    >
-    > ```
-    > SMEMBERS graphql-event:1:myStats:
-    > => 52ee8d65-275e-4d22-94af-313129116388
-    > ```
-
  3. Subscription data: `graphql-subscription:#{subscription_id}` hash contains everything required to evaluate subscription on trigger and create data for client.
 
     ```
@@ -202,13 +230,112 @@ As in AnyCable there is no place to store subscription data in-memory, it should
     }
     ```
 
- 4. Channel subscriptions: `graphql-channel:#{channel_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
+ 4. Channel subscriptions: `graphql-channel:#{subscription_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
 
     ```
     SMEMBERS graphql-channel:17420c6ed9e
     => 52ee8d65-275e-4d22-94af-313129116388
     ```
 
+## Stats
+
+You can grab Redis subscription statistics by calling
+
+```ruby
+    GraphQL::AnyCable.stats
+```
+
+It will return a total of the amount of the key with the following prefixes
+
+```
+    graphql-subscription
+    graphql-fingerprints
+    graphql-subscriptions
+    graphql-channel
+```
+
+The response will look like this
+
+```json
+  {
+    "total": {
+      "subscription":22646,
+      "fingerprints":3200,
+      "subscriptions":20101,
+      "channel": 4900
+    }
+  }
+```
+
+You can also grab the number of subscribers grouped by subscriptions
+
+```ruby
+    GraphQL::AnyCable.stats(include_subscriptions: true)
+```
+
+It will return the response that contains `subscriptions`
+
+```json
+  {
+    "total": {
+      "subscription":22646,
+      "fingerprints":3200,
+      "subscriptions":20101,
+      "channel": 4900
+    },
+    "subscriptions": {
+      "productCreated": 11323,
+      "productUpdated": 11323
+    }
+  }
+```
+
+Also, you can set another `scan_count`, if needed.
+The default value is 1_000
+
+```ruby
+    GraphQL::AnyCable.stats(scan_count: 100)
+```
+
+We can set statistics data to [Yabeda][] for tracking amount of subscriptions
+
+```ruby
+  # config/initializers/metrics.rb
+  Yabeda.configure do
+    group :graphql_anycable_statistics do
+      gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
+    end
+  end
+```
+
+```ruby
+  # in your app
+  statistics = GraphQL::AnyCable.stats[:total]
+
+  statistics.each do |key , value|
+    Yabeda.graphql_anycable_statistics.subscriptions_count.set({name: key}, value)
+  end
+```
+
+Or you can use `collect`
+```ruby
+  # config/initializers/metrics.rb
+  Yabeda.configure do
+    group :graphql_anycable_statistics do
+      gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
+    end
+    
+    collect do
+      statistics = GraphQL::AnyCable.stats[:total]
+
+      statistics.each do |redis_prefix, value|
+        graphql_anycable_statistics.subscriptions_count.set({name: redis_prefix}, value)
+      end
+    end
+  end
+```
+
+
 ## Testing applications which use `graphql-anycable`
 
 You can pass custom redis-server URL to AnyCable using ENV variable.
@@ -268,3 +395,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [AnyCable]: https://github.com/anycable/anycable "Polyglot replacement for Ruby WebSocket servers with Action Cable protocol"
 [LiteCable]: https://github.com/palkan/litecable "Lightweight Action Cable implementation (Rails-free)"
 [anyway_config]: https://github.com/palkan/anyway_config "Ruby libraries and applications configuration on steroids!"
+[Yabeda]: https://github.com/yabeda-rb/yabeda "Extendable solution for easy setup of monitoring in your Ruby apps"

data/lib/graphql/anycable/cleaner.rb

@@ -8,7 +8,6 @@ module GraphQL
       def clean
         clean_channels
         clean_subscriptions
-        clean_events
         clean_fingerprint_subscriptions
         clean_topic_fingerprints
       end
@@ -17,7 +16,7 @@ module GraphQL
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        redis.scan_each(match: "#{adapter::CHANNEL_PREFIX}*") do |key|
+        redis.scan_each(match: "#{redis_key(adapter::CHANNEL_PREFIX)}*") do |key|
           idle = redis.object("IDLETIME", key)
           next if idle&.<= config.subscription_expiration_seconds
 
@@ -29,7 +28,7 @@ module GraphQL
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        redis.scan_each(match: "#{adapter::SUBSCRIPTION_PREFIX}*") do |key|
+        redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTION_PREFIX)}*") do |key|
           idle = redis.object("IDLETIME", key)
           next if idle&.<= config.subscription_expiration_seconds
 
@@ -37,25 +36,10 @@ module GraphQL
         end
       end
 
-      def clean_events
-        return unless config.handle_legacy_subscriptions
-
-        redis.scan_each(match: "#{adapter::SUBSCRIPTION_EVENTS_PREFIX}*") do |key|
-          subscription_id = key.sub(/\A#{adapter::SUBSCRIPTION_EVENTS_PREFIX}/, "")
-          next if redis.exists?(adapter::SUBSCRIPTION_PREFIX + subscription_id)
-
-          redis.smembers(key).each do |event_topic|
-            redis.srem(adapter::EVENT_PREFIX + event_topic, subscription_id)
-          end
-
-          redis.del(key)
-        end
-      end
-
       def clean_fingerprint_subscriptions
-        redis.scan_each(match: "#{adapter::SUBSCRIPTIONS_PREFIX}*") do |key|
+        redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTIONS_PREFIX)}*") do |key|
           redis.smembers(key).each do |subscription_id|
-            next if redis.exists?(adapter::SUBSCRIPTION_PREFIX + subscription_id)
+            next if redis.exists?(redis_key(adapter::SUBSCRIPTION_PREFIX) + subscription_id)
 
             redis.srem(key, subscription_id)
           end
@@ -63,10 +47,10 @@ module GraphQL
       end
 
       def clean_topic_fingerprints
-        redis.scan_each(match: "#{adapter::FINGERPRINTS_PREFIX}*") do |key|
+        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?(adapter::SUBSCRIPTIONS_PREFIX + fingerprint)
+            next if redis.exists?(redis_key(adapter::SUBSCRIPTIONS_PREFIX) + fingerprint)
 
             redis.zrem(key, fingerprint)
           end
@@ -86,6 +70,10 @@ module GraphQL
       def config
         GraphQL::AnyCable.config
       end
+
+      def redis_key(prefix)
+        "#{config.redis_prefix}-#{prefix}"
+      end
     end
   end
 end

data/lib/graphql/anycable/config.rb

@@ -10,8 +10,7 @@ module GraphQL
 
       attr_config subscription_expiration_seconds: nil
       attr_config use_redis_object_on_cleanup: true
-      attr_config handle_legacy_subscriptions: false
-      attr_config use_client_provided_uniq_id: 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.
     end
   end
 end

data/lib/graphql/anycable/stats.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module AnyCable
+    # Calculates  amount of Graphql Redis keys
+    # (graphql-subscription, graphql-fingerprints, graphql-subscriptions, graphql-channel)
+    # Also, calculate the number of subscribers grouped by subscriptions
+    class Stats
+      SCAN_COUNT_RECORDS_AMOUNT = 1_000
+
+      attr_reader :scan_count, :include_subscriptions
+
+      def initialize(scan_count: SCAN_COUNT_RECORDS_AMOUNT, include_subscriptions: false)
+        @scan_count = scan_count
+        @include_subscriptions = include_subscriptions
+      end
+
+      def collect
+        total_subscriptions_result = {total: {}}
+
+        list_prefixes_keys.each do |name, prefix|
+          total_subscriptions_result[:total][name] = count_by_scan(match: "#{prefix}*")
+        end
+
+        if include_subscriptions
+          total_subscriptions_result[:subscriptions] = group_subscription_stats
+        end
+
+        total_subscriptions_result
+      end
+
+      private
+
+      # Counting all keys, that match the pattern with iterating by count
+      def count_by_scan(match:)
+        sb_amount = 0
+        cursor = '0'
+
+        loop do
+          cursor, result = redis.scan(cursor, match: match, count: scan_count)
+          sb_amount += result.count
+
+          break if cursor == '0'
+        end
+
+        sb_amount
+      end
+
+      # Calculate subscribes, grouped by subscriptions
+      def group_subscription_stats
+        subscription_groups = {}
+
+        redis.scan_each(match: "#{list_prefixes_keys[:fingerprints]}*", count: scan_count) do |fingerprint_key|
+          subscription_name = fingerprint_key.gsub(/#{list_prefixes_keys[:fingerprints]}|:/, "")
+          subscription_groups[subscription_name] = 0
+
+          redis.zscan_each(fingerprint_key) do |data|
+            redis.sscan_each("#{list_prefixes_keys[:subscriptions]}#{data[0]}") do |subscription_key|
+              next unless redis.exists?("#{list_prefixes_keys[:subscription]}#{subscription_key}")
+
+              subscription_groups[subscription_name] += 1
+            end
+          end
+        end
+
+        subscription_groups
+      end
+
+      def list_prefixes_keys
+        {
+          subscription: redis_key(adapter::SUBSCRIPTION_PREFIX),
+          fingerprints: redis_key(adapter::FINGERPRINTS_PREFIX),
+          subscriptions: redis_key(adapter::SUBSCRIPTIONS_PREFIX),
+          channel: redis_key(adapter::CHANNEL_PREFIX)
+        }
+      end
+
+      def adapter
+        GraphQL::Subscriptions::AnyCableSubscriptions
+      end
+
+      def redis
+        GraphQL::AnyCable.redis
+      end
+
+      def config
+        GraphQL::AnyCable.config
+      end
+
+      def redis_key(prefix)
+        "#{config.redis_prefix}-#{prefix}"
+      end
+    end
+  end
+end

data/lib/graphql/anycable/tasks/clean_expired_subscriptions.rake

@@ -18,11 +18,6 @@ namespace :graphql do
         GraphQL::AnyCable::Cleaner.clean_subscriptions
       end
 
-      # Clean up legacy subscription_ids from events for expired subscriptions
-      task :events do
-        GraphQL::AnyCable::Cleaner.clean_events
-      end
-
       # Clean up subscription_ids from event fingerprints for expired subscriptions
       task :fingerprint_subscriptions do
         GraphQL::AnyCable::Cleaner.clean_fingerprint_subscriptions

data/lib/graphql/anycable/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module AnyCable
-    VERSION = "1.1.7"
+    VERSION = "1.2.0"
   end
 end

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -56,13 +56,10 @@ module GraphQL
 
       def_delegators :"GraphQL::AnyCable", :redis, :config
 
-      SUBSCRIPTION_PREFIX  = "graphql-subscription:"  # HASH: Stores subscription data: query, context, …
-      FINGERPRINTS_PREFIX  = "graphql-fingerprints:"  # ZSET: To get fingerprints by topic
-      SUBSCRIPTIONS_PREFIX = "graphql-subscriptions:" # SET:  To get subscriptions by fingerprint
-      CHANNEL_PREFIX       = "graphql-channel:"       # SET:  Auxiliary structure for whole channel's subscriptions cleanup
-      # For backward compatibility:
-      EVENT_PREFIX = "graphql-event:"
-      SUBSCRIPTION_EVENTS_PREFIX = "graphql-subscription-events:"
+      SUBSCRIPTION_PREFIX  = "subscription:"  # HASH: Stores subscription data: query, context, …
+      FINGERPRINTS_PREFIX  = "fingerprints:"  # ZSET: To get fingerprints by topic
+      SUBSCRIPTIONS_PREFIX = "subscriptions:" # SET:  To get subscriptions by fingerprint
+      CHANNEL_PREFIX       = "channel:"       # SET:  Auxiliary structure for whole channel's subscriptions cleanup
 
       # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
       def initialize(serializer: Serialize, **rest)
@@ -73,15 +70,13 @@ module GraphQL
       # An event was triggered.
       # Re-evaluate all subscribed queries and push the data over ActionCable.
       def execute_all(event, object)
-        execute_legacy(event, object) if config.handle_legacy_subscriptions
-
-        fingerprints = redis.zrange(FINGERPRINTS_PREFIX + event.topic, 0, -1)
+        fingerprints = redis.zrange(redis_key(FINGERPRINTS_PREFIX) + event.topic, 0, -1)
         return if fingerprints.empty?
 
         fingerprint_subscription_ids = Hash[fingerprints.zip(
           redis.pipelined do |pipeline|
             fingerprints.map do |fingerprint|
-              pipeline.smembers(SUBSCRIPTIONS_PREFIX + fingerprint)
+              pipeline.smembers(redis_key(SUBSCRIPTIONS_PREFIX) + fingerprint)
             end
           end
         )]
@@ -99,25 +94,14 @@ module GraphQL
       def execute_grouped(fingerprint, subscription_ids, event, object)
         return if subscription_ids.empty?
 
-        subscription_id = subscription_ids.find { |sid| redis.exists?(SUBSCRIPTION_PREFIX + sid) }
+        subscription_id = 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 = execute_update(subscription_id, event, object)
         return unless result
 
         # Having calculated the result _once_, send the same payload to all subscribers
-        deliver(SUBSCRIPTIONS_PREFIX + fingerprint, result)
-      end
-
-      # For migration from pre-1.0 graphql-anycable gem
-      def execute_legacy(event, object)
-        redis.smembers(EVENT_PREFIX + event.topic).each do |subscription_id|
-          next unless redis.exists?(SUBSCRIPTION_PREFIX + subscription_id)
-          result = execute_update(subscription_id, event, object)
-          next unless result
-
-          deliver(SUBSCRIPTION_PREFIX + subscription_id, result)
-        end
+        deliver(redis_key(SUBSCRIPTIONS_PREFIX) + fingerprint, result)
       end
 
       # Disable this method as there is no fingerprint (it can be retrieved from subscription though)
@@ -142,14 +126,11 @@ module GraphQL
 
         raise GraphQL::AnyCable::ChannelConfigurationError unless channel
 
-        channel_uniq_id = config.use_client_provided_uniq_id? ? channel.params["channelId"] : subscription_id
-
         # Store subscription_id in the channel state to cleanup on disconnect
-        write_subscription_id(channel, channel_uniq_id)
-
+        write_subscription_id(channel, subscription_id)
 
         events.each do |event|
-          channel.stream_from(SUBSCRIPTIONS_PREFIX + event.fingerprint)
+          channel.stream_from(redis_key(SUBSCRIPTIONS_PREFIX) + event.fingerprint)
         end
 
         data = {
@@ -161,22 +142,22 @@ module GraphQL
         }
 
         redis.multi do |pipeline|
-          pipeline.sadd(CHANNEL_PREFIX + channel_uniq_id, [subscription_id])
-          pipeline.mapped_hmset(SUBSCRIPTION_PREFIX + subscription_id, data)
+          pipeline.sadd(redis_key(CHANNEL_PREFIX) + subscription_id, [subscription_id])
+          pipeline.mapped_hmset(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, data)
           events.each do |event|
-            pipeline.zincrby(FINGERPRINTS_PREFIX + event.topic, 1, event.fingerprint)
-            pipeline.sadd(SUBSCRIPTIONS_PREFIX + event.fingerprint, [subscription_id])
+            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(CHANNEL_PREFIX + channel_uniq_id, config.subscription_expiration_seconds)
-          pipeline.expire(SUBSCRIPTION_PREFIX + subscription_id, config.subscription_expiration_seconds)
+          pipeline.expire(redis_key(CHANNEL_PREFIX) + subscription_id, config.subscription_expiration_seconds)
+          pipeline.expire(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, config.subscription_expiration_seconds)
         end
       end
 
       # Return the query from "storage" (in redis)
       def read_subscription(subscription_id)
         redis.mapped_hmget(
-          "#{SUBSCRIPTION_PREFIX}#{subscription_id}",
+          "#{redis_key(SUBSCRIPTION_PREFIX)}#{subscription_id}",
           :query_string, :variables, :context, :operation_name
         ).tap do |subscription|
           return if subscription.values.all?(&:nil?) # Redis returns hash with all nils for missing key
@@ -188,17 +169,17 @@ module GraphQL
       end
 
       def delete_subscription(subscription_id)
-        events = redis.hget(SUBSCRIPTION_PREFIX + subscription_id, :events)
+        events = redis.hget(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, :events)
         events = events ? JSON.parse(events) : {}
         fingerprint_subscriptions = {}
         redis.pipelined do |pipeline|
           events.each do |topic, fingerprint|
-            pipeline.srem(SUBSCRIPTIONS_PREFIX + fingerprint, subscription_id)
-            score = pipeline.zincrby(FINGERPRINTS_PREFIX + topic, -1, fingerprint)
-            fingerprint_subscriptions[FINGERPRINTS_PREFIX + topic] = score
+            pipeline.srem(redis_key(SUBSCRIPTIONS_PREFIX) + fingerprint, subscription_id)
+            score = pipeline.zincrby(redis_key(FINGERPRINTS_PREFIX) + topic, -1, fingerprint)
+            fingerprint_subscriptions[redis_key(FINGERPRINTS_PREFIX) + topic] = score
           end
           # Delete subscription itself
-          pipeline.del(SUBSCRIPTION_PREFIX + subscription_id)
+          pipeline.del(redis_key(SUBSCRIPTION_PREFIX) + subscription_id)
         end
         # Clean up fingerprints that doesn't have any subscriptions left
         redis.pipelined do |pipeline|
@@ -206,33 +187,21 @@ module GraphQL
             pipeline.zremrangebyscore(key, '-inf', '0') if score.value.zero?
           end
         end
-        delete_legacy_subscription(subscription_id)
-      end
-
-      def delete_legacy_subscription(subscription_id)
-        return unless config.handle_legacy_subscriptions
-
-        events = redis.smembers(SUBSCRIPTION_EVENTS_PREFIX + subscription_id)
-        redis.pipelined do
-          events.each do |event_topic|
-            redis.srem(EVENT_PREFIX + event_topic, subscription_id)
-          end
-          redis.del(SUBSCRIPTION_EVENTS_PREFIX + subscription_id)
-        end
       end
 
       # The channel was closed, forget about it and its subscriptions
-      def delete_channel_subscriptions(channel_or_id)
-        # For backward compatibility
-        channel_id = channel_or_id.is_a?(String) ? channel_or_id : read_subscription_id(channel_or_id)
+      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)
 
         # Missing in case disconnect happens before #execute
         return unless channel_id
 
-        redis.smembers(CHANNEL_PREFIX + channel_id).each do |subscription_id|
+        redis.smembers(redis_key(CHANNEL_PREFIX) + channel_id).each do |subscription_id|
           delete_subscription(subscription_id)
         end
-        redis.del(CHANNEL_PREFIX + channel_id)
+        redis.del(redis_key(CHANNEL_PREFIX) + channel_id)
       end
 
       private
@@ -268,6 +237,10 @@ module GraphQL
           channel.connection.socket.istate
         end
       end
+
+      def redis_key(prefix)
+        "#{config.redis_prefix}-#{prefix}"
+      end
     end
   end
 end

data/lib/graphql-anycable.rb

@@ -6,20 +6,19 @@ require_relative "graphql/anycable/version"
 require_relative "graphql/anycable/cleaner"
 require_relative "graphql/anycable/config"
 require_relative "graphql/anycable/railtie" if defined?(Rails)
+require_relative "graphql/anycable/stats"
 require_relative "graphql/subscriptions/anycable_subscriptions"
 
 module GraphQL
   module AnyCable
     def self.use(schema, **options)
-      if config.use_client_provided_uniq_id?
-        warn "[Deprecated] Using client provided channel uniq IDs could lead to unexpected behaviour, " \
-             "please, set GraphQL::AnyCable.config.use_client_provided_uniq_id = false or GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID=false, " \
-             "and update the `#unsubscribed` callback code according to the latest docs."
-      end
-
       schema.use GraphQL::Subscriptions::AnyCableSubscriptions, **options
     end
 
+    def self.stats(**options)
+      Stats.new(**options).collect
+    end
+
     module_function
 
     def redis

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-anycable
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrey Novikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-08 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core
@@ -191,6 +191,7 @@ files:
 - lib/graphql/anycable/config.rb
 - lib/graphql/anycable/errors.rb
 - lib/graphql/anycable/railtie.rb
+- lib/graphql/anycable/stats.rb
 - lib/graphql/anycable/tasks/clean_expired_subscriptions.rake
 - lib/graphql/anycable/version.rb
 - lib/graphql/subscriptions/anycable_subscriptions.rb