star_gates 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9150966ca03ffe47ce938c669d38ab3291e25b6b7aaea9560e89099ec255a65d
-  data.tar.gz: 0454b43be544e3c50026811f5d44ec3a28903c4ff824fcf3b855aaf70a733aba
+  metadata.gz: 58b1b72d0deb4eb946b9c7c799f24ddd621051c2e7d611a570fbce998d33cc8f
+  data.tar.gz: 6e0cdeb3572cd4a939749c2020eb80140ed33e8b9586e5c106bcff5cd65ba47e
 SHA512:
-  metadata.gz: 4d7802feb0b5ebc3aefcd585224cfd5dda9f95e9e8f23ee5653a087f5326d14764ce7e6a06d16ca01cafd60570325c910cb776464b2abce14b2ef05b0a202407
-  data.tar.gz: 3e57ca2506afe07616e9c884f1f74228c2f380601a0ca4779b311a422aa0c215d228835e9160b0689db744ec788252b752f5133703992063a06c6c7db87254d7
+  metadata.gz: 67de3f5d4afb0ed6ea05b889c273aa0d4ea6693bef9d6be51cc8aef84f56f62116fd54cd818fa7de9f8ad2ca09a4cf410ef903ba3d060a5da7da81ebe5c159b5
+  data.tar.gz: 17bcc70a0e898e2d1bb63f6abdca7fc80b5b70e9d03422a2ae552d7d631be1800ad281a0e7a6624df2e5914ef0b8e26a3c8d8a388fba8057f3c80666361bbcac

data/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.3.1"
+}

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## Unreleased
+## [0.3.1](https://github.com/seuros/star_gates/compare/v0.3.0...v0.3.1) (2026-10-30)
+
+
+### Bug Fixes
+
+* **deps:** require breaker_machines 0.22.1 ([34c4f16](https://github.com/seuros/star_gates/commit/34c4f16849e89646e38b73fb846049d1fcffb762))
+
+## [0.3.0](https://github.com/seuros/star_gates/compare/v0.2.0...v0.3.0) (2026-10-30)
+
+
+### Features
+
+* share runtime flags through an ActiveSupport::Cache store ([edb39ba](https://github.com/seuros/star_gates/commit/edb39ba43f03278a6e3d70770a14671ccc4eb539))
 
 ## 0.2.0 (2026-10-28)
 

data/README.md

@@ -46,9 +46,27 @@ StarGates.flags.configuration = -> { Rails.application.config.x.feature_flags }
 
 `StarGates::Flags.new(env: {}, configuration: {})` creates an isolated registry.
 `all`, `enabled_flags`, `summary`, and `flag_status` expose values and their sources.
-Runtime transitions reuse `StarGates::Feature`; changes and metadata are process-local,
-not persisted or synchronized across workers. `reset!` clears both runtime state and
-metadata, not environment/configuration. `StarGates.reset!` resets gates separately.
+By default, runtime transitions reuse `StarGates::Feature`, and changes and metadata are
+process-local. To share them across workers, give the registry an `ActiveSupport::Cache`
+store (Solid Cache, Redis, Memcached):
+
+```ruby
+StarGates.flags.store = Rails.cache
+# or: StarGates::Flags.new(store: Rails.cache, prefix: 'myapp:flags')
+```
+
+Store-backed flags read the store on every check, so a change in one worker is visible
+in the others right away. Each flag's value and metadata are separate keys written
+blindly; `prefix` (default `star_gates:flags`) namespaces them. A failed write raises
+`StarGates::Error`, and a value the store cannot return counts as no runtime override.
+Listing (`all`, `enabled_flags`, `summary`) and `reset!` use a shared name index. Each new
+name takes its own slot from an atomic `increment`, so workers adding flags at the same
+moment never drop each other's names. Stores without `increment` fall back to a
+read-modify-write list, where a concurrent addition can drop a name from listings until
+that flag next changes; lookups by name are unaffected either way. `reset!` and `remove`
+clear runtime state and metadata, not environment/configuration. Switching `store` drops
+process-local runtime state.
+`StarGates.reset!` resets gates separately.
 
 ## Gates and rollouts
 

data/lib/star_gates/flags.rb

@@ -2,17 +2,28 @@
 
 module StarGates
   # Boolean flags with environment > configuration > runtime > false precedence.
-  # Runtime state uses Feature's lifecycle and is local to this process.
+  # Runtime state uses Feature's lifecycle and is local to this process unless
+  # a shared store is configured.
   class Flags
     attr_accessor :configuration
+    attr_reader :store
 
-    def initialize(env: ENV, configuration: {})
+    def initialize(env: ENV, configuration: {}, store: nil, prefix: 'star_gates:flags')
       @env = env
       @configuration = configuration
+      @store = store
+      @prefix = prefix
       @runtime = {}
       @mutex = Mutex.new
     end
 
+    def store=(store)
+      @mutex.synchronize do
+        @runtime.clear
+        @store = store
+      end
+    end
+
     def enabled?(name)
       debug(name)[:enabled]
     end
@@ -34,19 +45,25 @@ module StarGates
     end
 
     def remove(name)
-      @mutex.synchronize { @runtime.delete(normalize(name)) }
+      normalized = normalize(name)
+      if @store
+        store_remove(normalized) if normalized
+      else
+        @mutex.synchronize { @runtime.delete(normalized) }
+      end
       nil
     end
 
     def reset!
-      @mutex.synchronize { @runtime.clear }
+      @store ? store_reset : @mutex.synchronize { @runtime.clear }
       nil
     end
 
     def all
       configured = configuration_flags
-      names = (environment_flags.keys + configured.keys + runtime_names).uniq
-      names.to_h { |name| [name, resolution(name, configured).slice(:enabled, :source)] }
+      runtime = runtime_values
+      names = (environment_flags.keys + configured.keys + runtime.keys).uniq
+      names.to_h { |name| [name, resolution(name, configured, runtime[name]).slice(:enabled, :source)] }
     end
 
     def enabled_flags
@@ -55,7 +72,7 @@ module StarGates
 
     def summary
       {
-        runtime_flags: runtime_names.map(&:to_sym),
+        runtime_flags: runtime_values.keys.map(&:to_sym),
         environment_flags: environment_flags.keys.map(&:to_sym),
         configuration_flags: configuration_flags.keys.map(&:to_sym),
         all_enabled: enabled_flags
@@ -63,14 +80,15 @@ module StarGates
     end
 
     def debug(name)
-      resolution(normalize(name), configuration_flags)
+      normalized = normalize(name)
+      resolution(normalized, configuration_flags, runtime_value(normalized))
     end
 
     def flag_status(name)
       normalized = normalize(name)
       details = debug(normalized)
-      metadata = @mutex.synchronize { @runtime[normalized]&.fetch(:metadata)&.dup || {} }
-      { name: normalized&.to_sym, enabled: details[:enabled], source: details[:source], metadata: metadata }
+      { name: normalized&.to_sym, enabled: details[:enabled], source: details[:source],
+        metadata: runtime_metadata(normalized) }
     end
 
     private
@@ -91,6 +109,8 @@ module StarGates
       raise ArgumentError, 'flag name must be a nonempty string or symbol' unless normalized
 
       enabled = boolean(value)
+      return store_update(normalized, enabled, metadata) if @store
+
       @mutex.synchronize do
         entry = @runtime[normalized] ||= { feature: Feature.new, metadata: {} }
         feature = entry.fetch(:feature)
@@ -101,8 +121,124 @@ module StarGates
       enabled
     end
 
-    def runtime_names
-      @mutex.synchronize { @runtime.keys }
+    def runtime_value(name)
+      return unless name
+      return store_values([name])[name] if @store
+
+      @mutex.synchronize { @runtime[name]&.fetch(:feature)&.enabled_for? }
+    end
+
+    def runtime_values
+      return store_values(store_names) if @store
+
+      @mutex.synchronize { @runtime.transform_values { |entry| entry.fetch(:feature).enabled_for? } }
+    end
+
+    def runtime_metadata(name)
+      return {} unless name
+
+      metadata = if @store
+                   @store.read(metadata_key(name))
+                 else
+                   @mutex.synchronize { @runtime[name]&.fetch(:metadata) }
+                 end
+      metadata.is_a?(Hash) ? metadata.dup : {}
+    end
+
+    def store_update(name, enabled, metadata)
+      index_add(name)
+      store_write(flag_key(name), enabled)
+      store_write(metadata_key(name), metadata.dup) if metadata
+      enabled
+    end
+
+    def store_remove(name)
+      store_delete([flag_key(name), metadata_key(name)])
+    end
+
+    def store_reset
+      slots = index_slot_keys
+      names = slots ? store_read(slots).values.uniq : legacy_index
+      keys = names.flat_map { |name| [flag_key(name), metadata_key(name)] }
+      store_delete(keys + (slots ? slots + [index_sequence_key] : [index_key]))
+    end
+
+    def index_add(name)
+      return unless @store.read(flag_key(name)).nil?
+      return @mutex.synchronize { legacy_index_add(name) } unless @store.respond_to?(:increment)
+
+      slot = @store.increment(index_sequence_key)
+      store_write(index_slot_key(slot), name) if slot
+    end
+
+    def store_names
+      slots = index_slot_keys
+      slots ? store_read(slots).values.uniq : legacy_index
+    end
+
+    def index_slot_keys
+      return unless @store.respond_to?(:increment)
+
+      Array.new(@store.read(index_sequence_key, raw: true).to_i) { |slot| index_slot_key(slot + 1) }
+    end
+
+    def legacy_index_add(name)
+      names = legacy_index
+      store_write(index_key, names + [name]) unless names.include?(name)
+    end
+
+    def legacy_index
+      names = @store.read(index_key)
+      names.is_a?(Array) ? names : []
+    end
+
+    def store_values(names)
+      keys = names.to_h { |name| [flag_key(name), name] }
+      store_read(keys.keys).each_with_object({}) do |(key, value), values|
+        values[keys.fetch(key)] = value if [true, false].include?(value)
+      end
+    end
+
+    def store_read(keys)
+      return {} if keys.empty?
+      return @store.read_multi(*keys) if @store.respond_to?(:read_multi)
+
+      keys.each_with_object({}) do |key, values|
+        value = @store.read(key)
+        values[key] = value unless value.nil?
+      end
+    end
+
+    def store_write(key, value)
+      return if @store.write(key, value)
+
+      raise Error, "#{@store.class} did not persist #{key}"
+    end
+
+    def store_delete(keys)
+      return @store.delete_multi(keys) if @store.respond_to?(:delete_multi)
+
+      keys.each { |key| @store.delete(key) }
+    end
+
+    def flag_key(name)
+      "#{@prefix}:flag:#{name}"
+    end
+
+    def metadata_key(name)
+      "#{@prefix}:metadata:#{name}"
+    end
+
+    def index_key
+      "#{@prefix}:names"
+    end
+
+    def index_sequence_key
+      "#{@prefix}:name_sequence"
+    end
+
+    def index_slot_key(slot)
+      "#{@prefix}:name:#{slot}"
     end
 
     def configuration_flags
@@ -124,10 +260,9 @@ module StarGates
       end
     end
 
-    def resolution(name, configured)
+    def resolution(name, configured, runtime_value)
       env_key = "FEATURE_#{name&.upcase}"
       environment_value = name && @env[env_key]
-      runtime_value = @mutex.synchronize { @runtime[name]&.fetch(:feature)&.enabled_for? }
 
       value, source = if name && !environment_value.to_s.strip.empty?
                         [boolean(environment_value), "environment:#{env_key}"]

data/lib/star_gates/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StarGates
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 end

data/release-please-config.json

@@ -0,0 +1,11 @@
+{
+  "bootstrap-sha": "144ff79fe22abe175830d0c765ddc249c178ddc7",
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "star_gates",
+      "bump-minor-pre-major": true,
+      "include-component-in-tag": false
+    }
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: star_gates
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: 0.22.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: 0.22.1
 - !ruby/object:Gem::Dependency
   name: chrono_machines
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +103,7 @@ extra_rdoc_files: []
 files:
 - ".dictate.toml"
 - ".pre-commit-config.yaml"
+- ".release-please-manifest.json"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
@@ -133,14 +134,14 @@ files:
 - lib/star_gates/telemetry/prometheus_adapter.rb
 - lib/star_gates/telemetry/telemetry_adapter.rb
 - lib/star_gates/version.rb
+- release-please-config.json
 homepage: https://github.com/seuros/star_gates
 licenses:
 - BSD-3-Clause
 metadata:
-  allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/seuros/star_gates
   source_code_uri: https://github.com/seuros/star_gates
-  changelog_uri: https://github.com/seuros/star_gates/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/seuros/star_gates/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: