feature_flagger 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33983c979f6382f528796cbab4e51e80000c6855f50702602f451e2fb9cad666
-  data.tar.gz: 766cc624063a0a2516a2509c70f6bf6b397cc4ffcda6ee2333f36ac45d74f99a
+  metadata.gz: 6767ef346f481a29e5ba7d2d6bb9127e1604d52b57ffe51f967e22ab92160639
+  data.tar.gz: a02fca28c7d16ac89332e2d482c1305b460d1d74e5de4bca0bda7062bb027d3d
 SHA512:
-  metadata.gz: 3ea819eac2381595cab508f5d8e83a2e20c3b2516ad413819875ce12392cf61d67b7a1876ffe9a5345e2dc174205b6cf3b72eba8c12fd007baa7045fffefdfc4
-  data.tar.gz: fadce1676c47be30ed5a4fe8845b198448395b75a4a575276fea62eb5f6565318ea9dc27770b21d43418552372c0ec19757f460fefd77a9a15cd017aa386a468
+  metadata.gz: b840991512859a8b26ede79c28e30ffa13e2d298f9bedce5abc3c56dba973d425b6c062bb931f6e1cf49be9e927c3ada304894815e9d202e2c29e0fa9fdf8526
+  data.tar.gz: 120dc250044c525d7e365468e2f32bf8cb55882b83b9d678c5fc07cdffa959f7f725a1e41dc86c464d6d98231df1551c974c8763046cf56a9f4a441268ca456c

data/README.md

@@ -28,7 +28,6 @@ Or install it yourself as:
 
     $ gem install feature_flagger
 
-
 ## Configuration
 
 By default, feature_flagger uses the REDIS_URL env var to setup it's storage.
@@ -44,6 +43,15 @@ FeatureFlagger.configure do |config|
 end
 ```
 
+It's also possible to configure an additional cache layer by using ActiveSupport::Cache APIs. You can configure it the same way you would setup cache_store for Rails Apps. Caching is not enabled by default.
+
+
+```ruby
+configuration.cache_store = :memory_store, { expires_in: 100 }
+
+```
+
+
 1. Create a `rollout.yml` in _config_ path and declare a rollout:
 ```yml
 account: # model name
@@ -60,6 +68,29 @@ class Account < ActiveRecord::Base
   # ....
 end
 ```
+#### Notifier
+The notifier_callback property in config, enables the dispatch of events when a release operation happens.
+```ruby
+config.notifier_callback = -> {|event| do something with event }
+```
+
+
+It accepts a lambda function that will receive a hash with the operation triggered like:
+```ruby
+{
+  type: 'release',
+  model: 'account',
+  key: 'somefeature:somerolloutkey'
+  id: 'account_id' #In realease_to_all and unrelease_to_all operations id will be nil 
+}
+```
+
+The supported operations are:
+* release
+* unrelease
+* release_to_all
+* unrelease_to_all 
+
 
 ## Usage
 
@@ -74,9 +105,9 @@ account.release(:email_marketing, :new_email_flow)
 account.released?(:email_marketing, :new_email_flow)
 #=> true
 
-# Get an array with all features for a specific account id
-account.releases
-=> ['email_marketing:new_email_flow']
+# In order to bypass the cache if cache_store is configured
+account.released?(:email_marketing, :new_email_flow, skip_cache: true)
+#=> true
 
 # Remove feature for given account
 account.unrelease(:email_marketing, :new_email_flow)
@@ -90,6 +121,10 @@ FeatureFlagger::KeyNotFoundError: ["account", "email_marketing", "new_email_flo"
 Account.released_id?(42, :email_marketing, :new_email_flow)
 #=> true
 
+# In order to bypass the cache if cache_store is configured
+Account.released_id?(42, :email_marketing, :new_email_flow, skip_cache: true)
+#=> true
+
 # Release a feature for a specific account id
 Account.release_id(42, :email_marketing, :new_email_flow)
 #=> true
@@ -105,6 +140,10 @@ Account.unrelease_to_all(:email_marketing, :new_email_flow)
 
 # Return an array with all features released for all
 Account.released_features_to_all
+
+# In order to bypass the cache if cache_store is configured
+Account.released_features_to_all(skip_cache: true)
+
 ```
 
 ## Clean up action
@@ -115,6 +154,42 @@ To clean it up, execute or schedule the rake:
 
     $ bundle exec rake feature_flagger:cleanup_removed_rollouts
 
+## Upgrading
+
+When upgrading from `1.1.x` to `1.2.x` the following command must be executed
+to ensure the data stored in Redis storage is right. Check [#67](https://github.com/ResultadosDigitais/feature_flagger/pull/67) and [#68](https://github.com/ResultadosDigitais/feature_flagger/pull/68) for more info.
+
+    $ bundle exec rake feature_flagger:migrate_to_resource_keys
+
+## Extra options
+
+There are a few options to store/retrieve your rollout manifest (a.k.a rollout.yml):
+
+If you have a rollout.yml file and want to use Redis to keep a backup, add the follow code to the configuration block:
+
+```ruby
+require 'feature_flagger/manifest_sources/yaml_with_backup_to_storage'
+FeatureFlagger.configure do |config|
+  ...
+  config.manifest_source = FeatureFlagger::ManifestSources::YAMLWithBackupToStorage.new(config.storage)
+  ...
+end
+```
+
+If you already have your manifest on Redis and prefer not to keep a copy in your application, add the following code to the configuration block:
+
+```ruby
+require 'feature_flagger/manifest_sources/storage_only'
+
+FeatureFlagger.configure do |config|
+  ...
+  config.manifest_source = FeatureFlagger::ManifestSources::StorageOnly.new(config.storage)
+  ...
+end
+```
+
+If you have the YAML file and don't need a backup, it is unnecessary to do any different configuration.
+
 ## Contributing
 
 Bug reports and pull requests are welcome!

data/lib/feature_flagger/configuration.rb

@@ -1,18 +1,23 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
   class Configuration
-    attr_accessor :storage, :yaml_filepath
+    attr_accessor :storage, :cache_store, :manifest_source, :notifier_callback
 
     def initialize
       @storage       ||= Storage::Redis.default_client
-      @yaml_filepath ||= default_yaml_filepath
+      @manifest_source ||= FeatureFlagger::ManifestSources::WithYamlFile.new
+      @notifier_callback = nil
+      @cache_store = nil
     end
 
-    def info
-      raise 'Missing configuration file.' unless yaml_filepath
+    def cache_store=(cache_store)
+      raise ArgumentError, "Cache is only support when used with ActiveSupport" unless defined?(ActiveSupport)
 
-      @info ||= YAML.load_file(yaml_filepath)
+      cache_store = :null_store if cache_store.nil?
+      @cache_store = ActiveSupport::Cache.lookup_store(*cache_store)
+    end
+
+    def info
+      @manifest_source.resolved_info
     end
 
     def mapped_feature_keys(resource_name = nil)
@@ -24,10 +29,6 @@ module FeatureFlagger
 
     private
 
-    def default_yaml_filepath
-      "#{Rails.root}/config/rollout.yml" if defined?(Rails)
-    end
-
     def make_keys_recursively(hash, keys = [], composed_key = [])
       unless hash.values[0].is_a?(Hash)
         keys.push(composed_key)
@@ -44,7 +45,7 @@ module FeatureFlagger
 
     def join_key(resource_name, key)
       key.unshift resource_name if resource_name
-      key.join(':')
+      key.join(":")
     end
   end
 end

data/lib/feature_flagger/control.rb

@@ -1,54 +1,91 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
   class Control
     attr_reader :storage
 
     RELEASED_FEATURES = 'released_features'
 
-    def initialize(storage)
+    def initialize(storage, notifier, cache_store = nil)
       @storage = storage
+      @notifier = notifier
+      @cache_store = cache_store
     end
 
-    def released?(feature_key, resource_name, resource_id)
-      @storage.has_value?(feature_key, resource_name, RELEASED_FEATURES) ||
-        @storage.has_value?(feature_key, resource_name, resource_id)
+    def released?(feature_key, resource_id, options = {})
+      cache "released/#{feature_key}/#{resource_id}", options do
+        @storage.has_value?(RELEASED_FEATURES, feature_key) || @storage.has_value?(feature_key, resource_id)
+      end
     end
 
-    def release(feature_key, resource_name, resource_id)
+    def release(feature_key, resource_id)
+      resource_name = Storage::Keys.extract_resource_name_from_feature_key(
+        feature_key
+      )
+
+      @notifier.send(FeatureFlagger::Notifier::RELEASE, feature_key, resource_id)
       @storage.add(feature_key, resource_name, resource_id)
     end
 
-    def release_to_all(feature_key, resource_name)
-      @storage.add_all(RELEASED_FEATURES, feature_key, resource_name)
+    def releases(resource_name, resource_id, options = {})
+      cache "releases/#{resource_name}/#{resource_id}", options do
+        @storage.fetch_releases(resource_name, resource_id, RELEASED_FEATURES)
+      end
     end
 
-    def all_feature_keys(resource_name, resource_id)
-      @storage.all_feature_keys(RELEASED_FEATURES, resource_name, resource_id)
+    def release_to_all(feature_key)
+      @notifier.send(FeatureFlagger::Notifier::RELEASE_TO_ALL, feature_key)
+      @storage.add_all(RELEASED_FEATURES, feature_key)
     end
 
-    def unrelease(feature_key, resource_name, resource_id)
+    def unrelease(feature_key, resource_id)
+      resource_name = Storage::Keys.extract_resource_name_from_feature_key(
+        feature_key
+      )
+      @notifier.send(FeatureFlagger::Notifier::UNRELEASE, feature_key, resource_id)
       @storage.remove(feature_key, resource_name, resource_id)
     end
 
-    def unrelease_to_all(feature_key, resource_name)
-      @storage.remove_all(feature_key, resource_name)
+    def unrelease_to_all(feature_key)
+      @notifier.send(FeatureFlagger::Notifier::UNRELEASE_TO_ALL, feature_key)
+      @storage.remove_all(RELEASED_FEATURES, feature_key)
     end
 
-    def resource_ids(feature_key, resource_name)
-      @storage.all_values(feature_key, resource_name)
+    def resource_ids(feature_key, options = {})
+      cache "all_values/#{feature_key}", options do
+        @storage.all_values(feature_key)
+      end
     end
 
-    def released_features_to_all(resource_name)
-      @storage.all_feature_keys(RELEASED_FEATURES, resource_name)
+    def released_features_to_all(options = {})
+      cache "released_features_to_all/#{RELEASED_FEATURES}", options do
+        @storage.all_values(RELEASED_FEATURES)
+      end
     end
 
-    def released_to_all?(feature_key, resource_name)
-      @storage.has_value?(feature_key, resource_name, RELEASED_FEATURES)
+    def released_to_all?(feature_key, options = {})
+      cache "has_value/#{RELEASED_FEATURES}/#{feature_key}", options do
+        @storage.has_value?(RELEASED_FEATURES, feature_key)
+      end
     end
 
+    # DEPRECATED: this method will be removed from public api on v2.0 version.
+    # use instead the feature_keys method.
     def search_keys(query)
       @storage.search_keys(query)
     end
+
+    def feature_keys
+      @storage.feature_keys - [FeatureFlagger::Control::RELEASED_FEATURES]
+    end
+
+    def cache(name, options, &block)
+      if @cache_store
+        @cache_store.fetch(name, force: options[:skip_cache]) do
+          block.call
+        end
+      else
+        block.call
+      end
+    end
+
   end
 end

data/lib/feature_flagger/core_ext.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 begin
   require 'active_support/core_ext/string/inflections'
 rescue LoadError

data/lib/feature_flagger/feature.rb

@@ -1,12 +1,8 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
-  class KeyNotFoundError < StandardError; end
-
   class Feature
-    def initialize(feature_key, resource_name)
-      @key_resolver = KeyResolver.new(feature_key, resource_name.to_s)
-
+    def initialize(feature_key, resource_name = nil)
+      @feature_key = resolve_key(feature_key, resource_name)
+      @doc = FeatureFlagger.config.info
       fetch_data
     end
 
@@ -15,35 +11,33 @@ module FeatureFlagger
     end
 
     def key
-      @key_resolver.normalized_key.join(':')
+      @feature_key.join(':')
     end
 
     private
 
-    def config_info
-      FeatureFlagger.config.info
+    def resolve_key(feature_key, resource_name)
+      key = Array(feature_key).flatten
+      key.insert(0, resource_name) if resource_name
+      key.map(&:to_s)
     end
 
     def fetch_data
-      @data ||= find_value(config_info, *@key_resolver.normalized_key_with_name)
-
-      if @data.nil? || @data["description"].nil?
-        raise FeatureFlagger::KeyNotFoundError, @feature_key
-      end
-
+      @data ||= find_value(@doc, *@feature_key)
+      raise FeatureFlagger::KeyNotFoundError.new(@feature_key) if @data.nil?
       @data
     end
 
     def find_value(hash, key, *tail)
-      return nil if hash.nil?
-
       value = hash[key]
 
-      if tail.any?
-        return find_value(value, *tail)
+      if value.nil? || tail.empty?
+        value
+      else
+        find_value(value, *tail)
       end
-
-      value
     end
   end
 end
+
+class FeatureFlagger::KeyNotFoundError < StandardError ; end

data/lib/feature_flagger/manager.rb

@@ -1,28 +1,19 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
   class Manager
-    def self.detached_feature_keys(resource_name)
-      keys = FeatureFlagger.control.search_keys("#{resource_name}:*")
-
-      persisted_features = keys.flat_map do |key|
-        FeatureFlagger.control.all_feature_keys(resource_name, key.sub("#{resource_name}:", ''))
-      end.sort.uniq
 
-      mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys(resource_name).map do |feature|
-        feature.sub("#{resource_name}:", '')
-      end
+    def self.detached_feature_keys
+      persisted_features = FeatureFlagger.control.feature_keys
+      mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys
 
       persisted_features - mapped_feature_keys
     end
 
     def self.cleanup_detached(resource_name, *feature_key)
-      feature = Feature.new(feature_key, resource_name)
-      raise 'key is still mapped'
-    rescue FeatureFlagger::KeyNotFoundError => _e
-      # This means the keys is not present in config file anymore
-      key_resolver = KeyResolver.new(feature_key, resource_name)
-      FeatureFlagger.control.unrelease_to_all(key_resolver.normalized_key, resource_name)
+      complete_feature_key = feature_key.map(&:to_s).insert(0, resource_name.to_s)
+      key_value = FeatureFlagger.config.info.dig(*complete_feature_key)
+      raise "key is still mapped" if key_value
+      FeatureFlagger.control.unrelease_to_all(complete_feature_key.join(':'))
     end
+
   end
 end

data/lib/feature_flagger/manifest_sources/storage_only.rb

@@ -0,0 +1,13 @@
+module FeatureFlagger
+  module ManifestSources
+    class StorageOnly
+      def initialize(storage)
+        @storage = storage
+      end
+
+      def resolved_info
+        YAML.load(@storage.read_manifest_backup)
+      end
+    end
+  end
+end

data/lib/feature_flagger/manifest_sources/with_yaml_file.rb

@@ -0,0 +1,14 @@
+module FeatureFlagger
+  module ManifestSources
+    class WithYamlFile
+      def initialize(yaml_path = nil)
+        @yaml_path = yaml_path
+        @yaml_path ||= "#{Rails.root}/config/rollout.yml" if defined?(Rails)
+      end
+
+      def resolved_info
+        @resolved_info ||= ::YAML.load_file(@yaml_path) if @yaml_path
+      end
+    end
+  end
+end

data/lib/feature_flagger/manifest_sources/yaml_with_backup_to_storage.rb

@@ -0,0 +1,18 @@
+module FeatureFlagger
+  module ManifestSources
+    class YAMLWithBackupToStorage
+      def initialize(storage, yaml_path = nil)
+        @yaml_path = yaml_path || ("#{Rails.root}/config/rollout.yml" if defined?(Rails))
+        @storage   = storage
+      end
+
+      def resolved_info
+        @resolved_info ||= begin
+          yaml_data = YAML.load_file(@yaml_path) if @yaml_path
+          @storage.write_manifest_backup(YAML.dump(yaml_data))
+          yaml_data
+        end
+      end
+    end
+  end
+end

data/lib/feature_flagger/model.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
   # Model provides convinient methods for Rails Models
   # class Account
@@ -14,21 +12,23 @@ module FeatureFlagger
       base.extend ClassMethods
     end
 
-    def released?(*feature_key)
-      self.class.released_id?(feature_flagger_identifier, feature_key)
+    def released?(*feature_key, **options)
+      self.class.released_id?(feature_flagger_identifier, *feature_key, **options)
     end
 
     def release(*feature_key)
       self.class.release_id(feature_flagger_identifier, *feature_key)
     end
 
-    def releases
-      self.class.release_keys(feature_flagger_identifier)
+    def unrelease(*feature_key)
+      resource_name = self.class.feature_flagger_model_settings.entity_name
+      feature = Feature.new(feature_key, resource_name)
+      FeatureFlagger.control.unrelease(feature.key, id)
     end
 
-    def unrelease(*feature_key)
-      feature = Feature.new(feature_key, feature_flagger_name)
-      FeatureFlagger.control.unrelease(feature.key, feature_flagger_name, id)
+    def releases(options = {})
+      resource_name = self.class.feature_flagger_model_settings.entity_name
+      FeatureFlagger.control.releases(resource_name, id, options)
     end
 
     private
@@ -37,66 +37,74 @@ module FeatureFlagger
       public_send(self.class.feature_flagger_model_settings.identifier_field)
     end
 
-    def feature_flagger_name
-      self.class.feature_flagger_model_settings.entity_name
-    end
-
     module ClassMethods
       def feature_flagger
         raise ArgumentError unless block_given?
-
         yield feature_flagger_model_settings
       end
 
-      def released_id?(resource_id, *feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.released?(feature.key, feature_flagger_name, resource_id)
+      def released_id?(resource_id, *feature_key, **options)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.released?(feature.key, resource_id, options)
       end
 
       def release_id(resource_id, *feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.release(feature.key, feature_flagger_name, resource_id)
-      end
-
-      def release_keys(resource_id)
-        FeatureFlagger.control.all_feature_keys(feature_flagger_name, resource_id)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.release(feature.key, resource_id)
       end
 
       def unrelease_id(resource_id, *feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.unrelease(feature.key, feature_flagger_name, resource_id)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.unrelease(feature.key, resource_id)
       end
 
-      def all_released_ids_for(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.resource_ids(feature.key, feature_flagger_name)
+      def all_released_ids_for(*feature_key, **options)
+        feature_key.flatten!
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.resource_ids(feature.key, options)
       end
 
       def release_to_all(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.release_to_all(feature.key, feature_flagger_name)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.release_to_all(feature.key)
       end
 
       def unrelease_to_all(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.unrelease_to_all(feature.key, feature_flagger_name)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.unrelease_to_all(feature.key)
       end
 
-      def released_features_to_all
-        FeatureFlagger.control.released_features_to_all(feature_flagger_name)
+      def released_features_to_all(options = {})
+        FeatureFlagger.control.released_features_to_all(options)
       end
 
-      def released_to_all?(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_name)
-        FeatureFlagger.control.released_to_all?(feature.key, feature_flagger_name)
+      def released_to_all?(*feature_key, **options)
+        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
+        FeatureFlagger.control.released_to_all?(feature.key, options)
       end
 
       def detached_feature_keys
-        Manager.detached_feature_keys(feature_flagger_name)
+        rollout_resource_name = feature_flagger_model_settings.entity_name
+        persisted_features = FeatureFlagger.control.search_keys("#{rollout_resource_name}:*").to_a
+        mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys(rollout_resource_name)
+        (persisted_features - mapped_feature_keys).map { |key| key.sub("#{rollout_resource_name}:",'') }
       end
 
       def cleanup_detached(*feature_key)
-        Manager.cleanup_detached(feature_flagger_name, feature_key)
+        complete_feature_key = feature_key.map(&:to_s).insert(0, feature_flagger_model_settings.entity_name)
+        key_value = FeatureFlagger.config.info.dig(*complete_feature_key)
+        raise "key is still mapped" if key_value
+        FeatureFlagger.control.unrelease_to_all(complete_feature_key.join(':'))
+      end
+
+      def rollout_resource_name
+        klass_name = self.to_s
+        klass_name.gsub!(/::/, '_')
+        klass_name.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        klass_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        klass_name.tr!("-", "_")
+        klass_name.downcase!
+        klass_name
       end
 
       def feature_flagger_model_settings
@@ -106,20 +114,8 @@ module FeatureFlagger
         )
       end
 
-      private
-
-      def rollout_resource_name
-        klass_name = to_s
-        klass_name.gsub!(/::/, '_')
-        klass_name.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-        klass_name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        klass_name.tr!('-', '_')
-        klass_name.downcase!
-        klass_name
-      end
-
-      def feature_flagger_name
-        feature_flagger_model_settings.entity_name
+      def feature_flagger_identifier
+        public_send(feature_flagger_model_settings.identifier_field)
       end
     end
   end

data/lib/feature_flagger/model_settings.rb

@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
   class ModelSettings
     def initialize(arguments)
       arguments.each do |field, value|
-        public_send("#{field}=", value)
+        self.public_send("#{field}=", value)
       end
     end
 
@@ -14,7 +12,7 @@ module FeatureFlagger
 
     # Public: entity_name to which entity the model is targeting.
     # Take this yaml file as example:
-    #
+    # 
     # account:
     #   email_marketing:
     #       whitelabel:
@@ -35,4 +33,4 @@ module FeatureFlagger
     #   end
     attr_accessor :entity_name
   end
-end
+end

data/lib/feature_flagger/notifier.rb

@@ -0,0 +1,45 @@
+module FeatureFlagger
+  class Notifier
+    attr_reader :notify
+
+    RELEASE = 'release'.freeze
+    UNRELEASE = 'unrelease'.freeze
+    RELEASE_TO_ALL = 'release_to_all'.freeze
+    UNRELEASE_TO_ALL = 'unrelease_to_all'.freeze
+
+    def initialize(notify = nil)
+      @notify = valid_notify?(notify) ? notify : nullNotify
+    end
+
+    def send(operation, feature_key, resource_id = nil)
+      @notify.call(build_event(operation, extract_resource_from_key(feature_key), feature_key, resource_id))
+    end
+
+    private
+
+    def nullNotify
+      lambda {|e| }
+    end
+
+    def valid_notify?(notify)
+      !notify.nil? && notify.is_a?(Proc)
+    end
+
+    def extract_resource_from_key(key)
+      Storage::Keys.extract_resource_name_from_feature_key(
+        key
+      )
+    rescue FeatureFlagger::Storage::Keys::InvalidResourceNameError
+      "legacy key"
+    end
+
+    def build_event(operation, resource_name, feature_key, resource_id)
+      {
+        type: operation,
+        model: resource_name,
+        feature: feature_key,
+        id: resource_id
+      }
+    end
+  end
+end

data/lib/feature_flagger/railtie.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 if defined?(Rails)
   module FeatureFlagger
     class Railtie < Rails::Railtie

data/lib/feature_flagger/storage/feature_keys_migration.rb

@@ -1,54 +1,57 @@
 # frozen_string_literal: true
 
 module FeatureFlagger
-  module Storage
-    class FeatureKeysMigration
-      def initialize(from_redis, to_control)
-        @from_redis = from_redis
-        @to_control = to_control
-      end
-
-      def call
-        @from_redis.keys('*').map { |key| migrate_key(key) }.flatten
-      end
+    module Storage
+      class FeatureKeysMigration
 
-      private
-
-      def migrate_key(key)
-        return migrate_release_to_all(key) if feature_released_to_all?(key)
+        def initialize(from_redis, to_control)
+          @from_redis = from_redis
+          @to_control = to_control
+        end
 
-        migrate_release(key)
-      end
+        # call migrates features key from the old fashioned to the new
+        # format.
+        #
+        # It must replicate feature keys with changes:
+        #
+        # from "avenue:traffic_lights" => 42
+        # to   "avenue:42" => traffic_lights
+        def call
+          @from_redis.scan_each(match: "*", count: FeatureFlagger::Storage::Redis::SCAN_EACH_BATCH_SIZE) do |redis_key|
+            # filter out resource_keys
+            next if redis_key.start_with?("#{FeatureFlagger::Storage::Redis::RESOURCE_PREFIX}:")
+
+            migrate_key(redis_key)
+          end
+        end
 
-      def migrate_release_to_all(key)
-        features = @from_redis.smembers(key)
+        private
 
-        features.map do |feature|
-          resource_name, feature_key = KeyDecomposer.decompose(feature)
-          feature = Feature.new(feature_key, resource_name)
+        def migrate_key(key)
+          return migrate_release_to_all(key) if feature_released_to_all?(key)
 
-          @to_control.release_to_all(feature.key, resource_name)
-        rescue KeyNotFoundError => _e
-          next
+          migrate_release(key)
         end
-      end
 
-      def feature_released_to_all?(key)
-        FeatureFlagger::Control::RELEASED_FEATURES == key
-      end
+        def migrate_release_to_all(key)
+          features = @from_redis.smembers(key)
 
-      def migrate_release(key)
-        return false if key =~ /(\d+).*/
+          features.each do |feature_key|
+            @to_control.release_to_all(feature_key)
+          end
+        end
 
-        resource_ids = @from_redis.smembers(key)
+        def feature_released_to_all?(key)
+          FeatureFlagger::Control::RELEASED_FEATURES == key
+        end
 
-        resource_name, feature_key = KeyDecomposer.decompose(key)
-        feature = Feature.new(feature_key, resource_name)
+        def migrate_release(key)
+          resource_ids = @from_redis.smembers(key)
 
-        @to_control.release(feature.key, resource_name, resource_ids)
-      rescue KeyNotFoundError => _e
-        return
+          resource_ids.each do |id|
+            @to_control.release(key, id)
+          end
+        end
       end
     end
   end
-end

data/lib/feature_flagger/storage/keys.rb

@@ -0,0 +1,20 @@
+module FeatureFlagger
+  module Storage
+    module Keys
+      MINIMUM_VALID_FEATURE_PATH = 2.freeze
+
+      def self.resource_key(prefix, resource_name, resource_id)
+        "#{prefix}:#{resource_name}:#{resource_id}"
+      end
+
+      def self.extract_resource_name_from_feature_key(feature_key)
+        feature_paths = feature_key.split(':')
+        raise InvalidResourceNameError if feature_paths.size < MINIMUM_VALID_FEATURE_PATH
+
+        feature_paths.first
+      end
+
+      class InvalidResourceNameError < StandardError; end
+    end
+  end
+end

data/lib/feature_flagger/storage/redis.rb

@@ -1,12 +1,15 @@
-# frozen_string_literal: true
-
 require 'redis'
 require 'redis-namespace'
+require_relative './keys'
 
 module FeatureFlagger
   module Storage
     class Redis
-      DEFAULT_NAMESPACE = :feature_flagger
+      DEFAULT_NAMESPACE    = :feature_flagger
+      RESOURCE_PREFIX      = "_r".freeze
+      MANIFEST_PREFIX      = "_m".freeze
+      MANIFEST_KEY         = "manifest_file".freeze
+      SCAN_EACH_BATCH_SIZE = 1000.freeze
 
       def initialize(redis)
         @redis = redis
@@ -14,81 +17,116 @@ module FeatureFlagger
 
       def self.default_client
         redis = ::Redis.new(url: ENV['REDIS_URL'])
-        ns = ::Redis::Namespace.new(DEFAULT_NAMESPACE, redis: redis)
+        ns = ::Redis::Namespace.new(DEFAULT_NAMESPACE, :redis => redis)
         new(ns)
       end
 
-      def has_value?(feature_key, resource_name, resource_id)
-        @redis.sismember("#{resource_name}:#{resource_id}", feature_key)
+      def fetch_releases(resource_name, resource_id, global_key)
+        resource_key = resource_key(resource_name, resource_id)
+        releases = @redis.sunion(resource_key, global_key)
+
+        releases.select{ |release| release.start_with?(resource_name) }
+      end
+
+      def has_value?(key, value)
+        @redis.sismember(key, value)
       end
 
-      def add(feature_key, resource_name, resource_ids)
+      def add(feature_key, resource_name, resource_id)
+        resource_key = resource_key(resource_name, resource_id)
+
         @redis.multi do |redis|
-          Array(resource_ids).each do |resource_id|
-            redis.sadd("#{resource_name}:#{resource_id}", feature_key)
-          end
+          redis.sadd(feature_key, resource_id)
+          redis.sadd(resource_key, feature_key)
         end
       end
 
-      def remove(feature_key, resource_name, resource_ids)
+      def remove(feature_key, resource_name, resource_id)
+        resource_key = resource_key(resource_name, resource_id)
+
         @redis.multi do |redis|
-          Array(resource_ids).each do |resource_id|
-            redis.srem("#{resource_name}:#{resource_id}", feature_key)
-          end
+          redis.srem(feature_key, resource_id)
+          redis.srem(resource_key, feature_key)
         end
       end
 
-      def all_feature_keys(global_features_key, resource_name, resource_id = nil)
-        if resource_id
-          return @redis.sunion(
-            "#{resource_name}:#{global_features_key}",
-            "#{resource_name}:#{resource_id}"
-          )
-        end
+      def remove_all(global_key, feature_key)
+        @redis.srem(global_key, feature_key)
+        remove_feature_key_from_resources(feature_key)
+      end
 
-        @redis.smembers("#{resource_name}:#{global_features_key}")
+      def add_all(global_key, key)
+        @redis.sadd(global_key, key)
+        remove_feature_key_from_resources(key)
       end
 
-      def remove_all(feature_key, resource_name)
-        keys = search_keys("#{resource_name}:*")
+      def all_values(key)
+        @redis.smembers(key)
+      end
 
-        @redis.multi do |redis|
-          keys.map do |key|
-            redis.srem(key, feature_key)
-          end
-        end
+      # DEPRECATED: this method will be removed from public api on v2.0 version.
+      # use instead the feature_keys method.
+      def search_keys(query)
+        @redis.scan_each(match: query)
       end
 
-      def add_all(global_features_key, feature_key, resource_name)
-        keys = search_keys("#{resource_name}:*") - ["#{resource_name}:#{global_features_key}"]
+      def feature_keys
+        feature_keys = []
 
-        add(feature_key, resource_name, global_features_key)
+        @redis.scan_each(match: "*") do |key|
+          # Reject keys related to feature responsible for return
+          # released features for a given account.
+          next if key.start_with?("#{RESOURCE_PREFIX}:")
+          next if key.start_with?("#{MANIFEST_PREFIX}:")
 
-        @redis.multi do |redis|
-          keys.map do |key|
-            redis.srem(key.to_s, feature_key)
-          end
+          feature_keys << key
         end
+
+        feature_keys
       end
 
-      def all_values(feature_key, resource_name)
-        keys = search_keys("#{resource_name}:*")
-        query = {}
-        @redis.pipelined do |redis|
-          keys.map do |key|
-            query[key] = redis.sismember(key, feature_key)
-          end
-        end
+      def synchronize_feature_and_resource
+        FeatureFlagger::Storage::FeatureKeysMigration.new(
+          @redis,
+          FeatureFlagger.control,
+        ).call
+      end
+
+      def read_manifest_backup
+        @redis.get("#{MANIFEST_PREFIX}:#{MANIFEST_KEY}")
+      end
 
-        query.map do |key, in_redis|
-          next unless in_redis.value == true
+      def write_manifest_backup(yaml_as_string)
+        @redis.set("#{MANIFEST_PREFIX}:#{MANIFEST_KEY}", yaml_as_string)
+      end
+
+      private
 
-          key.gsub("#{resource_name}:", '')
-        end.compact
+      def resource_key(resource_name, resource_id)
+        FeatureFlagger::Storage::Keys.resource_key(
+          RESOURCE_PREFIX,
+          resource_name,
+          resource_id,
+        )
       end
 
-      def search_keys(pattern)
-        @redis.keys(pattern)
+      def remove_feature_key_from_resources(feature_key)
+        cursor = 0
+        resource_name = feature_key.split(":").first
+
+        loop do
+          cursor, resource_ids = @redis.sscan(feature_key, cursor, count: SCAN_EACH_BATCH_SIZE)
+
+          @redis.multi do |redis|
+            resource_ids.each do |resource_id|
+              key = resource_key(resource_name, resource_id)
+              redis.srem(key, feature_key)
+              redis.srem(feature_key, resource_id)
+            end
+          end
+
+          break if cursor == "0"
+        end
       end
     end
   end

data/lib/feature_flagger/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module FeatureFlagger
-  VERSION = '2.0.0'
+  VERSION = "2.2.0"
 end

data/lib/feature_flagger.rb

@@ -1,25 +1,24 @@
-# frozen_string_literal: true
-
 require 'yaml'
 
 require 'feature_flagger/version'
 require 'feature_flagger/storage/redis'
+require 'feature_flagger/storage/feature_keys_migration'
 require 'feature_flagger/control'
 require 'feature_flagger/model'
 require 'feature_flagger/model_settings'
 require 'feature_flagger/feature'
-require 'feature_flagger/key_resolver'
-require 'feature_flagger/key_decomposer'
 require 'feature_flagger/configuration'
 require 'feature_flagger/manager'
-require 'feature_flagger/storage/feature_keys_migration'
 require 'feature_flagger/railtie'
+require 'feature_flagger/notifier'
+require 'feature_flagger/manifest_sources/with_yaml_file'
 
 module FeatureFlagger
   class << self
     def configure
       @@configuration = nil
       @@control = nil
+      @@notifier = nil
       yield config if block_given?
     end
 
@@ -27,8 +26,12 @@ module FeatureFlagger
       @@configuration ||= Configuration.new
     end
 
+    def notifier
+      @@notifier ||= Notifier.new(config.notifier_callback)
+    end
+
     def control
-      @@control ||= Control.new(config.storage)
+      @@control ||= Control.new(config.storage, notifier, config.cache_store)
     end
   end
 end

data/lib/tasks/feature_flagger.rake

@@ -1,55 +1,40 @@
-# frozen_string_literal: true
-
 namespace :feature_flagger do
-  desc "cleaning up keys from storage that are no longer in the rollout.yml file, Usage: `$ bundle exec rake feature_flagger:cleanup_removed_rollouts\[Account\] `"
-  task :cleanup_removed_rollouts, %i[entity_name] => :environment do
-    resource_name = args.entity_name.constantize
-    feature_keys = FeatureFlagger::Manager.detached_feature_keys(resource_name)
-    puts "Found keys to remove: #{feature_keys}"
-    feature_keys.each do |feature_key|
-      FeatureFlagger::Manager.cleanup_detached(resource_name, feature_key)
-    rescue RuntimeError, 'key is still mapped'
-      next
+  desc "cleaning up keys from storage that are no longer in the rollout.yml file"
+  task :cleanup_removed_rollouts => :environment do
+    keys = FeatureFlagger::Manager.detached_feature_keys
+    puts "Found keys to remove: #{keys}"
+    keys.each do |key|
+      FeatureFlagger::Manager.cleanup_detached key
     end
   end
 
-  namespace :storage do
-    namespace :redis do
-      desc 'Migrate the old key format to the new one, Usage: `$ bundle exec rake feature_flagger:storage:redis:migrate`'
-      task :migrate => :environment do |_, _args|
-        redis = ::Redis::Namespace.new(
-          FeatureFlagger::Storage::Redis::DEFAULT_NAMESPACE,
-          redis: ::Redis.new(url: ENV['REDIS_URL'])
-        )
-        control = FeatureFlagger.control
-
-        FeatureFlagger::Storage::FeatureKeysMigration.new(redis, control).call
-      end
-    end
+  desc "Synchronizes resource_keys with feature_keys, recommended to apps that installed feature flagger before v.1.2.0"
+  task :migrate_to_resource_keys => :environment do
+    storage = FeatureFlagger.config.storage
+    storage.synchronize_feature_and_resource
   end
 
   desc "Release feature to given identifiers, Usage: `$ bundle exec rake feature_flagger:release\[Account,email_marketing:whitelabel,1,2,3,4\]`"
-  task :release, %i[entity_name feature_key] => :environment do |_, args|
+  task :release, [:entity_name, :feature_key] => :environment do |_, args|
     entity = args.entity_name.constantize
     entity_ids = args.extras
     entity.release_id(entity_ids, *args.feature_key.split(':'))
   end
 
   desc "Unrelease feature to given identifiers, Usage: `$ bundle exec rake feature_flagger:unrelease\[Account,email_marketing:whitelabel,1,2,3,4\]`"
-  task :unrelease, %i[entity_name feature_key] => :environment do |_, args|
-    entity = args.entity_name.constantize
-    entity_ids = args.extras
+  task :unrelease, [:entity_name, :feature_key] => :environment do |_, args|
+    entity, entity_ids = args.entity_name.constantize, args.extras
     entity.unrelease_id(entity_ids, *args.feature_key.split(':'))
   end
 
   desc "Release one feature to all entity ids, Usage: `$ bundle exec rake feature_flagger:release_to_all\[Account,email_marketing:whitelabel\]`"
-  task :release_to_all, %i[entity_name feature_key] => :environment do |_, args|
+  task :release_to_all, [:entity_name, :feature_key] => :environment do |_, args|
     entity = args.entity_name.constantize
     entity.release_to_all(*args.feature_key.split(':'))
   end
 
   desc "Unrelease one feature to all entity ids, Usage: `$ bundle exec rake feature_flagger:unrelease_to_all\[Account,email_marketing:whitelabel\]`"
-  task :unrelease_to_all, %i[entity_name feature_key] => :environment do |_, args|
+  task :unrelease_to_all, [:entity_name, :feature_key] => :environment do |_, args|
     entity = args.entity_name.constantize
     entity.unrelease_to_all(*args.feature_key.split(':'))
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feature_flagger
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Nando Sousa
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-15 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -40,33 +40,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: fakeredis
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -101,14 +101,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: 0.21.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: 0.21.2
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 description: Management tool to make it easier rollouting features to customers.
 email:
 - nandosousafr@gmail.com
@@ -124,13 +138,16 @@ files:
 - lib/feature_flagger/control.rb
 - lib/feature_flagger/core_ext.rb
 - lib/feature_flagger/feature.rb
-- lib/feature_flagger/key_decomposer.rb
-- lib/feature_flagger/key_resolver.rb
 - lib/feature_flagger/manager.rb
+- lib/feature_flagger/manifest_sources/storage_only.rb
+- lib/feature_flagger/manifest_sources/with_yaml_file.rb
+- lib/feature_flagger/manifest_sources/yaml_with_backup_to_storage.rb
 - lib/feature_flagger/model.rb
 - lib/feature_flagger/model_settings.rb
+- lib/feature_flagger/notifier.rb
 - lib/feature_flagger/railtie.rb
 - lib/feature_flagger/storage/feature_keys_migration.rb
+- lib/feature_flagger/storage/keys.rb
 - lib/feature_flagger/storage/redis.rb
 - lib/feature_flagger/version.rb
 - lib/tasks/feature_flagger.rake
@@ -153,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Partial release your features.

data/lib/feature_flagger/key_decomposer.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module FeatureFlagger
-  class KeyDecomposer
-    def self.decompose(complete_feature_key)
-      decomposed_key = complete_feature_key.split(':')
-      resource_name = decomposed_key.shift
-
-      [resource_name, decomposed_key]
-    end
-  end
-end

data/lib/feature_flagger/key_resolver.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module FeatureFlagger
-  class KeyResolver
-    def initialize(feature_key, resource_name)
-      @feature_key = feature_key
-      @resource_name = resource_name
-    end
-
-    def normalized_key
-      @normalized_key ||= Array(@feature_key).flatten
-                                             .map(&:to_s)
-    end
-
-    def normalized_key_with_name
-      @normalized_key_with_name ||= [@resource_name] + normalized_key
-    end
-  end
-end