magick-feature-flags 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5124df88b7d429811d4b0f131d01aeeef2dedabc25b598da96fa5f01eb07163
-  data.tar.gz: 72c12e81d29990d6990f0f749effb978c7f9a4d7a316d3455e8ceb508269889d
+  metadata.gz: a53f3c93e974822f126ed2148d9fb61adf7de3a374ba26acbd834a2a916545a0
+  data.tar.gz: 31dbbacc15565a496e65113364d3eaf5a6a5385251f3654a28ea1c5eb9e9b014
 SHA512:
-  metadata.gz: 880f57facbd900c562aa10d21708afe0100087a6160ac814cc9d3453233d62cb7b41de1bfe18a831f27ecbd14cfb2b59b238a92f91c4a8fa56d0ae30a62ba125
-  data.tar.gz: cd4addd623241b24d2bc3d08cab687233de382d3c1dc260461484e6b750c637f19dc51368c552694c021f503a30c85e1425016f1af4a7056b8f3cf19f816a299
+  metadata.gz: 9b39439b771eb158d39496758362675db1134ea160311b8af9d51b59e1b40c7440ee425ee7d8f6e28bd02dc3da6498ec24d79744cd5cb7b63f54e13e86fa8cf4
+  data.tar.gz: 0bc2519decc3164d6b3dddd6080bf79c00b9a1ee2473d95b25550edbea8ca8c433912b8655d72c86b993762526781377df27219f1957585990b59942e3597bb8

data/README.md

@@ -221,8 +221,15 @@ Create `config/features.rb`:
 
 ```ruby
 # Boolean features
-boolean_feature :new_dashboard, default: false, description: "New dashboard UI"
-boolean_feature :dark_mode, default: false, description: "Dark mode theme"
+boolean_feature :new_dashboard,
+  default: false,
+  name: "New Dashboard",
+  description: "New dashboard UI"
+
+boolean_feature :dark_mode,
+  default: false,
+  name: "Dark Mode",
+  description: "Dark mode theme"
 
 # String features
 string_feature :api_version, default: "v1", description: "API version"

data/lib/magick/config.rb

@@ -44,8 +44,16 @@ module Magick
       configure_redis_adapter(url: url, namespace: namespace, **options)
     end
 
-    def performance_metrics(enabled: true, **_options)
-      @performance_metrics = (PerformanceMetrics.new if enabled)
+    def performance_metrics(enabled: true, redis_tracking: nil, batch_size: 100, flush_interval: 60, **_options)
+      return unless enabled
+
+      @performance_metrics = PerformanceMetrics.new(batch_size: batch_size, flush_interval: flush_interval)
+      # Enable Redis tracking if Redis adapter is configured (or explicitly set)
+      if redis_tracking.nil?
+        # Auto-enable if Redis adapter exists
+        redis_tracking = !@redis_url.nil? || configure_redis_adapter != nil
+      end
+      @performance_metrics.enable_redis_tracking(enable: redis_tracking) if @performance_metrics
     end
 
     def audit_log(enabled: true, adapter: nil)
@@ -86,6 +94,11 @@ module Magick
       Magick.audit_log = audit_log if audit_log
       Magick.versioning = versioning if versioning
       Magick.warn_on_deprecated = warn_on_deprecated
+
+      # Enable Redis tracking for performance metrics if Redis adapter is configured
+      if Magick.performance_metrics && adapter_registry.is_a?(Adapters::Registry) && adapter_registry.redis_adapter
+        Magick.performance_metrics.enable_redis_tracking(enable: true)
+      end
     end
 
     private

data/lib/magick/feature.rb

@@ -8,7 +8,7 @@ module Magick
     VALID_TYPES = %i[boolean string number].freeze
     VALID_STATUSES = %i[active inactive deprecated].freeze
 
-    attr_reader :name, :type, :status, :default_value, :description, :adapter_registry
+    attr_reader :name, :type, :status, :default_value, :description, :display_name, :adapter_registry
 
     def initialize(name, adapter_registry, **options)
       @name = name.to_s
@@ -17,6 +17,7 @@ module Magick
       @status = (options[:status] || :active).to_sym
       @default_value = options.fetch(:default_value, default_for_type)
       @description = options[:description]
+      @display_name = options[:name] || options[:display_name]
       @targeting = {}
       @dependencies = options[:dependencies] ? Array(options[:dependencies]) : []
 
@@ -318,6 +319,7 @@ module Magick
       adapter_registry.set(name, 'status', status)
       adapter_registry.set(name, 'default_value', default_value)
       adapter_registry.set(name, 'description', description) if description
+      adapter_registry.set(name, 'display_name', display_name) if display_name
       @stored_value = value
 
       # Update registered feature instance if it exists
@@ -382,6 +384,9 @@ module Magick
         raise InvalidFeatureValueError, "Cannot disable feature of type #{type}"
       end
 
+      # Cascade disable: disable all features that depend on this one
+      disable_dependent_features(user_id: user_id)
+
       # Rails 8+ event
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.feature_disabled_globally(name, user_id: user_id)
@@ -410,6 +415,7 @@ module Magick
     def to_h
       {
         name: name,
+        display_name: display_name,
         type: type,
         status: status,
         value: stored_value,
@@ -437,6 +443,7 @@ module Magick
         registered = Magick.features[name]
         registered.instance_variable_set(:@stored_value, @stored_value)
         registered.instance_variable_set(:@status, @status)
+        registered.instance_variable_set(:@display_name, @display_name)
         registered.instance_variable_set(:@targeting, @targeting.dup)
       end
       self
@@ -448,6 +455,8 @@ module Magick
       @stored_value = load_value_from_adapter
       status_value = adapter_registry.get(name, 'status')
       @status = status_value ? status_value.to_sym : status
+      display_name_value = adapter_registry.get(name, 'display_name')
+      @display_name = display_name_value if display_name_value
       targeting_value = adapter_registry.get(name, 'targeting')
       if targeting_value.is_a?(Hash)
         # Normalize keys to symbols and handle nested structures
@@ -655,6 +664,34 @@ module Magick
       context
     end
 
+    def disable_dependent_features(user_id: nil)
+      # Find all features that depend on this feature
+      dependent_features = find_dependent_features
+
+      # Disable each dependent feature
+      dependent_features.each do |dep_feature_name|
+        dep_feature = Magick.features[dep_feature_name.to_s] || Magick[dep_feature_name]
+        next unless dep_feature
+
+        # Only disable if it's currently enabled (to avoid unnecessary operations)
+        if dep_feature.enabled?
+          dep_feature.disable(user_id: user_id)
+        end
+      end
+    end
+
+    def find_dependent_features
+      # Find all features that have this feature in their dependencies
+      dependent_features = []
+      Magick.features.each do |_name, feature|
+        feature_deps = feature.instance_variable_get(:@dependencies) || []
+        if feature_deps.include?(name.to_s) || feature_deps.include?(name.to_sym)
+          dependent_features << feature.name
+        end
+      end
+      dependent_features
+    end
+
     def enable_targeting(type, value)
       @targeting[type] ||= []
       @targeting[type] << value.to_s unless @targeting[type].include?(value.to_s)

data/lib/magick/performance_metrics.rb

@@ -24,17 +24,25 @@ module Magick
       end
     end
 
-    def initialize
+    def initialize(batch_size: 100, flush_interval: 60)
       @metrics = []
       @mutex = Mutex.new
       @usage_count = Hash.new(0)
+      @pending_updates = Hash.new(0) # For Redis batching
+      @batch_size = batch_size
+      @flush_interval = flush_interval
+      @last_flush = Time.now
+      @redis_enabled = false
     end
 
     def record(feature_name, operation, duration, success: true)
-      metric = Metric.new(feature_name, operation, duration, success: success)
+      feature_name_str = feature_name.to_s
+      metric = Metric.new(feature_name_str, operation, duration, success: success)
+
       @mutex.synchronize do
         @metrics << metric
-        @usage_count[feature_name.to_s] += 1
+        @usage_count[feature_name_str] += 1
+        @pending_updates[feature_name_str] += 1
         # Keep only last 1000 metrics
         @metrics.shift if @metrics.length > 1000
       end
@@ -44,9 +52,64 @@ module Magick
         Magick::Rails::Events.usage_tracked(feature_name, operation: operation, duration: duration, success: success)
       end
 
+      # Batch flush to Redis if needed
+      flush_to_redis_if_needed
+
       metric
     end
 
+    def flush_to_redis_if_needed
+      return unless @redis_enabled
+      return if @pending_updates.empty?
+
+      should_flush = false
+      @mutex.synchronize do
+        # Flush if we have enough pending updates or enough time has passed
+        if @pending_updates.size >= @batch_size || (Time.now - @last_flush) >= @flush_interval
+          should_flush = true
+        end
+      end
+
+      flush_to_redis if should_flush
+    end
+
+    def flush_to_redis
+      updates_to_flush = nil
+      @mutex.synchronize do
+        return if @pending_updates.empty?
+
+        updates_to_flush = @pending_updates.dup
+        @pending_updates.clear
+        @last_flush = Time.now
+      end
+
+      return if updates_to_flush.nil? || updates_to_flush.empty?
+
+      # Update Redis in batch
+      begin
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+          redis = adapter.redis_adapter.instance_variable_get(:@redis)
+          if redis
+            updates_to_flush.each do |feature_name, count|
+              redis_key = "magick:stats:#{feature_name}"
+              redis.incrby(redis_key, count)
+              redis.expire(redis_key, 86400 * 7) # Keep stats for 7 days
+            end
+          end
+        end
+      rescue StandardError => e
+        # Silently fail - don't break feature checks if stats fail
+        warn "Magick: Failed to flush stats to Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
+      end
+    end
+
+    def enable_redis_tracking(enable: true)
+      @redis_enabled = enable
+      # Flush any pending updates when enabling
+      flush_to_redis if enable && !@pending_updates.empty?
+    end
+
     def average_duration(feature_name: nil, operation: nil)
       filtered = @metrics.select do |m|
         (feature_name.nil? || m.feature_name == feature_name.to_s) &&
@@ -59,17 +122,60 @@ module Magick
     end
 
     def usage_count(feature_name)
-      @usage_count[feature_name.to_s] || 0
+      feature_name_str = feature_name.to_s
+      memory_count = @usage_count[feature_name_str] || 0
+
+      # Also check Redis if enabled
+      redis_count = 0
+      if @redis_enabled
+        begin
+          adapter = Magick.adapter_registry || Magick.default_adapter_registry
+          if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+            redis = adapter.redis_adapter.instance_variable_get(:@redis)
+            if redis
+              redis_key = "magick:stats:#{feature_name_str}"
+              redis_count = redis.get(redis_key).to_i
+            end
+          end
+        rescue StandardError
+          # Silently fail
+        end
+      end
+
+      memory_count + redis_count
     end
 
     def most_used_features(limit: 10)
-      @usage_count.sort_by { |_name, count| -count }.first(limit).to_h
+      # Combine memory and Redis counts
+      combined_counts = @usage_count.dup
+
+      if @redis_enabled
+        begin
+          adapter = Magick.adapter_registry || Magick.default_adapter_registry
+          if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+            redis = adapter.redis_adapter.instance_variable_get(:@redis)
+            if redis
+              # Get all stats keys
+              redis.keys("magick:stats:*").each do |key|
+                feature_name = key.to_s.sub('magick:stats:', '')
+                redis_count = redis.get(key).to_i
+                combined_counts[feature_name] = (combined_counts[feature_name] || 0) + redis_count
+              end
+            end
+          end
+        rescue StandardError
+          # Silently fail
+        end
+      end
+
+      combined_counts.sort_by { |_name, count| -count }.first(limit).to_h
     end
 
     def clear!
       @mutex.synchronize do
         @metrics.clear
         @usage_count.clear
+        @pending_updates.clear
       end
     end
   end

data/lib/magick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Magick
-  VERSION = '0.8.0'
+  VERSION = '0.8.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magick-feature-flags
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Andrew Lobanov