magick-feature-flags 0.9.23 → 0.9.25

data/lib/magick/adapters/registry.rb

@@ -5,11 +5,14 @@ module Magick
     class Registry
       CACHE_INVALIDATION_CHANNEL = 'magick:cache:invalidate'
 
-      def initialize(memory_adapter, redis_adapter = nil, circuit_breaker: nil, async: false)
+      def initialize(memory_adapter, redis_adapter = nil, active_record_adapter: nil, circuit_breaker: nil,
+                     async: false, primary: nil)
         @memory_adapter = memory_adapter
         @redis_adapter = redis_adapter
+        @active_record_adapter = active_record_adapter
         @circuit_breaker = circuit_breaker || Magick::CircuitBreaker.new
         @async = async
+        @primary = primary || :memory # :memory, :redis, or :active_record
         @subscriber_thread = nil
         @subscriber = nil
         # Only start Pub/Sub subscriber if Redis is available
@@ -19,7 +22,7 @@ module Magick
 
       def get(feature_name, key)
         # Try memory first (fastest) - no Redis calls needed thanks to Pub/Sub invalidation
-        value = memory_adapter.get(feature_name, key)
+        value = memory_adapter.get(feature_name, key) if memory_adapter
         return value unless value.nil?
 
         # Fall back to Redis if available
@@ -27,10 +30,25 @@ module Magick
           begin
             value = redis_adapter.get(feature_name, key)
             # Update memory cache if found in Redis
-            memory_adapter.set(feature_name, key, value) if value
+            if value && memory_adapter
+              memory_adapter.set(feature_name, key, value)
+              return value
+            end
+            # If Redis returns nil, continue to next adapter
+          rescue StandardError, AdapterError
+            # Redis failed, continue to next adapter
+          end
+        end
+
+        # Fall back to Active Record if available
+        if active_record_adapter
+          begin
+            value = active_record_adapter.get(feature_name, key)
+            # Update memory cache if found in Active Record
+            memory_adapter.set(feature_name, key, value) if value && memory_adapter
             return value
-          rescue AdapterError
-            # Redis failed, return nil
+          rescue StandardError, AdapterError
+            # Active Record failed, return nil
             nil
           end
         end
@@ -40,55 +58,88 @@ module Magick
 
       def set(feature_name, key, value)
         # Update memory first (always synchronous)
-        memory_adapter.set(feature_name, key, value)
+        memory_adapter&.set(feature_name, key, value)
 
         # Update Redis if available
-        return unless redis_adapter
+        if redis_adapter
+          update_redis = proc do
+            circuit_breaker.call do
+              redis_adapter.set(feature_name, key, value)
+            end
+          rescue AdapterError => e
+            # Log error but don't fail - memory is updated
+            warn "Failed to update Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
+          end
 
-        update_redis = proc do
-          circuit_breaker.call do
-            redis_adapter.set(feature_name, key, value)
+          if @async && defined?(Thread)
+            # For async updates, publish cache invalidation synchronously
+            # This ensures other processes are notified immediately, even if Redis update is delayed
+            publish_cache_invalidation(feature_name)
+            Thread.new { update_redis.call }
+          else
+            update_redis.call
             # Publish cache invalidation message to notify other processes
             publish_cache_invalidation(feature_name)
           end
-        rescue AdapterError => e
-          # Log error but don't fail - memory is updated
-          warn "Failed to update Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
         end
 
-        if @async && defined?(Thread)
-          Thread.new { update_redis.call }
-        else
-          update_redis.call
+        # Always update Active Record if available (as fallback/persistence layer)
+        return unless active_record_adapter
+
+        begin
+          active_record_adapter.set(feature_name, key, value)
+        rescue AdapterError => e
+          # Log error but don't fail
+          warn "Failed to update Active Record: #{e.message}" if defined?(Rails) && Rails.env.development?
         end
       end
 
       def delete(feature_name)
-        memory_adapter.delete(feature_name)
-        return unless redis_adapter
+        memory_adapter&.delete(feature_name)
+
+        if redis_adapter
+          begin
+            redis_adapter.delete(feature_name)
+            # Publish cache invalidation message
+            publish_cache_invalidation(feature_name)
+          rescue AdapterError
+            # Continue even if Redis fails
+          end
+        end
+
+        return unless active_record_adapter
 
         begin
-          redis_adapter.delete(feature_name)
-          # Publish cache invalidation message
-          publish_cache_invalidation(feature_name)
+          active_record_adapter.delete(feature_name)
         rescue AdapterError
-          # Continue even if Redis fails
+          # Continue even if Active Record fails
         end
       end
 
       def exists?(feature_name)
-        memory_adapter.exists?(feature_name) || (redis_adapter&.exists?(feature_name) == true)
+        return true if memory_adapter&.exists?(feature_name)
+        return true if redis_adapter&.exists?(feature_name) == true
+        return true if active_record_adapter&.exists?(feature_name) == true
+
+        false
       end
 
       def all_features
-        memory_features = memory_adapter.all_features
-        redis_features = redis_adapter&.all_features || []
-        (memory_features + redis_features).uniq
+        features = []
+        features += memory_adapter.all_features if memory_adapter
+        features += redis_adapter.all_features if redis_adapter
+        features += active_record_adapter.all_features if active_record_adapter
+        features.uniq
       end
 
       # Explicitly trigger cache invalidation for a feature
       # This is useful for targeting updates that need immediate cache invalidation
+      # Invalidates memory cache in current process AND publishes to Redis for other processes
       def invalidate_cache(feature_name)
+        # Invalidate memory cache in current process immediately
+        memory_adapter&.delete(feature_name)
+
+        # Publish to Redis Pub/Sub to invalidate cache in other processes
         publish_cache_invalidation(feature_name)
       end
 
@@ -104,11 +155,9 @@ module Magick
         redis_adapter.instance_variable_get(:@redis)
       end
 
-      private
-
-      attr_reader :memory_adapter, :redis_adapter, :circuit_breaker
-
-      # Publish cache invalidation message to Redis Pub/Sub
+      # Publish cache invalidation message to Redis Pub/Sub (without deleting local memory cache)
+      # This is useful when you've just updated the cache and want to notify other processes
+      # but keep the local memory cache intact
       def publish_cache_invalidation(feature_name)
         return unless redis_adapter
 
@@ -121,6 +170,10 @@ module Magick
         end
       end
 
+      private
+
+      attr_reader :memory_adapter, :redis_adapter, :active_record_adapter, :circuit_breaker
+
       # Start a background thread to listen for cache invalidation messages
       def start_cache_invalidation_subscriber
         return unless redis_adapter && defined?(Thread)
@@ -132,8 +185,28 @@ module Magick
           @subscriber = redis_client.dup
           @subscriber.subscribe(CACHE_INVALIDATION_CHANNEL) do |on|
             on.message do |_channel, feature_name|
+              feature_name_str = feature_name.to_s
+
               # Invalidate memory cache for this feature
-              memory_adapter.delete(feature_name)
+              memory_adapter.delete(feature_name_str) if memory_adapter
+
+              # Also reload the feature instance in Magick.features if it exists
+              # This ensures the feature instance has the latest targeting and values
+              if defined?(Magick) && Magick.features.key?(feature_name_str)
+                feature = Magick.features[feature_name_str]
+                if feature.respond_to?(:reload)
+                  feature.reload
+                  # Log for debugging (only in development)
+                  if defined?(Rails) && Rails.env.development?
+                    Rails.logger.debug "Magick: Reloaded feature '#{feature_name_str}' after cache invalidation"
+                  end
+                end
+              end
+            rescue StandardError => e
+              # Log error but don't crash the subscriber thread
+              if defined?(Rails) && Rails.env.development?
+                warn "Magick: Error processing cache invalidation for '#{feature_name}': #{e.message}"
+              end
             end
           end
         rescue StandardError => e

data/lib/magick/admin_ui/config/routes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Magick::AdminUI::Engine.routes.draw do
+  root 'features#index'
+  resources :features, only: %i[index show edit update] do
+    member do
+      put :enable
+      put :disable
+      put :enable_for_user
+    end
+  end
+  resources :stats, only: [:show]
+end

data/lib/magick/admin_ui/engine.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Configure inflector immediately when this file loads
+# This ensures AdminUI stays as AdminUI (not AdminUi) before Rails processes routes
+if defined?(ActiveSupport::Inflector)
+  ActiveSupport::Inflector.inflections(:en) do |inflect|
+    inflect.acronym 'AdminUI'
+    inflect.acronym 'UI'
+  end
+end
+
+module Magick
+  module AdminUI
+    class Engine < ::Rails::Engine
+      isolate_namespace Magick::AdminUI
+
+      engine_name 'magick_admin_ui'
+
+      # Rails engines automatically detect app/views and app/controllers directories
+      # With isolate_namespace, views should be at:
+      # app/views/magick/adminui/[controller]/[action].html.erb
+      # Controllers should be at:
+      # app/controllers/magick/adminui/[controller]_controller.rb
+      # Rails handles this automatically, but we explicitly add app/controllers to autoload paths
+      # to ensure controllers are found
+      config.autoload_paths += %W[#{root}/app/controllers] if root.join('app', 'controllers').exist?
+
+      # Explicitly add app/views to view paths
+      # Rails engines should do this automatically, but we ensure it's configured
+      initializer 'magick.admin_ui.append_view_paths', after: :add_view_paths do |app|
+        app.paths['app/views'] << root.join('app', 'views').to_s if root.join('app', 'views').exist?
+      end
+
+      # Also ensure view paths are added when ActionController loads
+      initializer 'magick.admin_ui.append_view_paths_to_controller', after: :add_view_paths do
+        ActiveSupport.on_load(:action_controller) do
+          view_path = Magick::AdminUI::Engine.root.join('app', 'views').to_s
+          append_view_path view_path unless view_paths.include?(view_path)
+        end
+      end
+
+      # Ensure view paths are added in to_prepare (runs before each request in development)
+      config.to_prepare do
+        view_path = Magick::AdminUI::Engine.root.join('app', 'views').to_s
+        if File.directory?(view_path)
+          if defined?(Magick::AdminUI::FeaturesController)
+            Magick::AdminUI::FeaturesController.append_view_path(view_path)
+          end
+          Magick::AdminUI::StatsController.append_view_path(view_path) if defined?(Magick::AdminUI::StatsController)
+        end
+      end
+    end
+  end
+end
+
+# Draw routes directly - Rails engines should auto-load config/routes.rb
+# but for gems we need to ensure routes are drawn at the right time
+# Use both to_prepare (for development reloading) and an initializer (for production)
+if defined?(Rails)
+  # Initializer runs once during app initialization
+  Magick::AdminUI::Engine.initializer 'magick.admin_ui.draw_routes', after: :load_config_initializers do
+    Magick::AdminUI::Engine.routes.draw do
+      root 'features#index'
+      resources :features, only: %i[index show edit update] do
+        member do
+          put :enable
+          put :disable
+          put :enable_for_user
+          put :enable_for_role
+          put :disable_for_role
+          put :update_targeting
+        end
+      end
+      resources :stats, only: [:show]
+    end
+  end
+
+  # to_prepare runs before each request in development (for code reloading)
+  Magick::AdminUI::Engine.config.to_prepare do
+    # Routes are already drawn by initializer, but redraw if needed for development reloading
+    if Magick::AdminUI::Engine.routes.routes.empty?
+      Magick::AdminUI::Engine.routes.draw do
+        root 'features#index'
+        resources :features, only: %i[index show edit update] do
+          member do
+            put :enable
+            put :disable
+            put :enable_for_user
+            put :enable_for_role
+            put :disable_for_role
+            put :update_targeting
+          end
+        end
+        resources :stats, only: [:show]
+      end
+    end
+  end
+end

data/lib/magick/admin_ui/helpers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Magick
+  module AdminUI
+    module Helpers
+      def self.feature_status_badge(status)
+        case status.to_sym
+        when :active
+          '<span class="badge badge-success">Active</span>'
+        when :deprecated
+          '<span class="badge badge-warning">Deprecated</span>'
+        when :inactive
+          '<span class="badge badge-danger">Inactive</span>'
+        else
+          '<span class="badge">Unknown</span>'
+        end
+      end
+
+      def self.feature_type_label(type)
+        case type.to_sym
+        when :boolean
+          'Boolean'
+        when :string
+          'String'
+        when :number
+          'Number'
+        else
+          type.to_s.capitalize
+        end
+      end
+    end
+  end
+end

data/lib/magick/admin_ui/routes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Routes file - users should add this to their Rails app's config/routes.rb:
+# mount Magick::AdminUI::Engine, at: '/magick'
+#
+# Or define routes manually:
+# Magick::AdminUI::Engine.routes.draw do
+#   root 'features#index'
+#   resources :features, only: [:index, :show, :edit, :update] do
+#     member do
+#       put :enable
+#       put :disable
+#       put :enable_for_user
+#     end
+#   end
+#   resources :stats, only: [:show]
+# end

data/lib/magick/admin_ui.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'admin_ui/engine'
+# Controllers are in app/controllers and will be auto-loaded by Rails engine
+# But we explicitly require them to ensure they're available when needed
+if defined?(Rails) && Rails.env
+  # In Rails, controllers are auto-loaded from app/controllers
+  # But we can explicitly require them if needed for console access
+  engine_root = Magick::AdminUI::Engine.root
+  if engine_root.join('app', 'controllers', 'magick', 'adminui', 'features_controller.rb').exist?
+    require engine_root.join('app', 'controllers', 'magick', 'adminui', 'features_controller').to_s
+  end
+  if engine_root.join('app', 'controllers', 'magick', 'adminui', 'stats_controller.rb').exist?
+    require engine_root.join('app', 'controllers', 'magick', 'adminui', 'stats_controller').to_s
+  end
+end
+require_relative 'admin_ui/helpers'
+
+module Magick
+  module AdminUI
+    class << self
+      def configure
+        yield config if block_given?
+      end
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      class Configuration
+        attr_accessor :theme, :brand_name, :require_role, :available_roles
+
+        def initialize
+          @theme = :light
+          @brand_name = 'Magick'
+          @require_role = nil
+          @available_roles = [] # Can be populated via DSL: admin_ui { roles ['admin', 'user', 'manager'] }
+        end
+      end
+    end
+  end
+end

data/lib/magick/config.rb

@@ -3,7 +3,7 @@
 module Magick
   class Config
     attr_accessor :adapter_registry, :performance_metrics, :audit_log, :versioning, :warn_on_deprecated,
-                  :async_updates, :memory_ttl, :circuit_breaker_threshold, :circuit_breaker_timeout, :redis_url, :redis_namespace, :environment
+                  :async_updates, :memory_ttl, :circuit_breaker_threshold, :circuit_breaker_timeout, :redis_url, :redis_namespace, :redis_db, :environment, :active_record_model_class, :enable_admin_ui
 
     def initialize
       @warn_on_deprecated = false
@@ -12,7 +12,9 @@ module Magick
       @circuit_breaker_threshold = 5
       @circuit_breaker_timeout = 60
       @redis_namespace = 'magick:features'
+      @redis_db = nil # Use default database (0) unless specified
       @environment = defined?(Rails) ? Rails.env.to_s : 'development'
+      @enable_admin_ui = false # Admin UI disabled by default
     end
 
     # DSL methods for configuration
@@ -22,6 +24,8 @@ module Magick
         configure_memory_adapter(**options)
       when :redis
         configure_redis_adapter(**options)
+      when :active_record
+        configure_active_record_adapter(**options)
       when :registry
         if block_given?
           instance_eval(&block)
@@ -38,10 +42,11 @@ module Magick
       configure_memory_adapter(**options)
     end
 
-    def redis(url: nil, namespace: nil, **options)
+    def redis(url: nil, namespace: nil, db: nil, **options)
       @redis_url = url if url
       @redis_namespace = namespace if namespace
-      redis_adapter = configure_redis_adapter(url: url, namespace: namespace, **options)
+      @redis_db = db if db
+      redis_adapter = configure_redis_adapter(url: url, namespace: namespace, db: db, **options)
 
       # Automatically create Registry adapter if it doesn't exist
       # This allows users to just call `redis url: ...` without needing to call `adapter :registry`
@@ -56,6 +61,7 @@ module Magick
         end
       else
         memory_adapter = configure_memory_adapter
+        active_record_adapter = configure_active_record_adapter if defined?(::ActiveRecord::Base)
         cb = Magick::CircuitBreaker.new(
           failure_threshold: @circuit_breaker_threshold,
           timeout: @circuit_breaker_timeout
@@ -63,6 +69,7 @@ module Magick
         @adapter_registry = Adapters::Registry.new(
           memory_adapter,
           redis_adapter,
+          active_record_adapter: active_record_adapter,
           circuit_breaker: cb,
           async: @async_updates
         )
@@ -71,6 +78,40 @@ module Magick
       redis_adapter
     end
 
+    def active_record(model_class: nil, primary: false, **options)
+      @active_record_model_class = model_class if model_class
+      @active_record_primary = primary
+      active_record_adapter = configure_active_record_adapter(model_class: model_class, **options)
+
+      # Automatically create Registry adapter if it doesn't exist
+      if @adapter_registry
+        # If registry already exists, update it with the new Active Record adapter
+        if active_record_adapter && @adapter_registry.is_a?(Adapters::Registry)
+          @adapter_registry.instance_variable_set(:@active_record_adapter, active_record_adapter)
+          # Update primary if specified
+          @adapter_registry.instance_variable_set(:@primary, :active_record) if primary
+        end
+      else
+        memory_adapter = configure_memory_adapter
+        redis_adapter = configure_redis_adapter
+        cb = Magick::CircuitBreaker.new(
+          failure_threshold: @circuit_breaker_threshold,
+          timeout: @circuit_breaker_timeout
+        )
+        primary_adapter = primary ? :active_record : :memory
+        @adapter_registry = Adapters::Registry.new(
+          memory_adapter,
+          redis_adapter,
+          active_record_adapter: active_record_adapter,
+          circuit_breaker: cb,
+          async: @async_updates,
+          primary: primary_adapter
+        )
+      end
+
+      active_record_adapter
+    end
+
     def performance_metrics(enabled: true, redis_tracking: nil, batch_size: 100, flush_interval: 60, **_options)
       return unless enabled
 
@@ -120,6 +161,10 @@ module Magick
       @environment = name.to_s
     end
 
+    def admin_ui(enabled: true)
+      @enable_admin_ui = enabled
+    end
+
     def apply!
       # Apply configuration to Magick module
       Magick.adapter_registry = adapter_registry if adapter_registry
@@ -149,6 +194,11 @@ module Magick
       Magick.audit_log = audit_log if audit_log
       Magick.versioning = versioning if versioning
       Magick.warn_on_deprecated = warn_on_deprecated
+
+      # Load optional components if enabled
+      return unless @enable_admin_ui && defined?(Rails)
+
+      require_relative '../magick/admin_ui' unless defined?(Magick::AdminUI)
     end
 
     private
@@ -161,17 +211,37 @@ module Magick
       adapter
     end
 
-    def configure_redis_adapter(url: nil, namespace: nil, client: nil)
+    def configure_redis_adapter(url: nil, namespace: nil, db: nil, client: nil)
       return nil unless defined?(Redis)
 
       url ||= @redis_url
       namespace ||= @redis_namespace
+      db ||= @redis_db
 
       redis_client = client || begin
+        redis_options = {}
+
         if url
-          ::Redis.new(url: url)
+          # Parse URL to extract database number if present
+          parsed_url = begin
+            URI.parse(url)
+          rescue StandardError
+            nil
+          end
+          db_from_url = nil
+          if parsed_url && parsed_url.path && parsed_url.path.length > 1
+            # Redis URL format: redis://host:port/db_number
+            db_from_url = parsed_url.path[1..-1].to_i
+          end
+
+          # Use db parameter if provided, otherwise use db from URL, otherwise nil (default DB 0)
+          final_db = db || db_from_url
+          redis_options[:db] = final_db if final_db
+          redis_options[:url] = url
+          ::Redis.new(redis_options)
         else
-          ::Redis.new
+          redis_options[:db] = db if db
+          ::Redis.new(redis_options)
         end
       rescue StandardError
         nil
@@ -179,14 +249,46 @@ module Magick
 
       return nil unless redis_client
 
+      # If db was specified but not in URL, select it explicitly
+      # This handles cases where URL doesn't include db number
+      if db && url
+        parsed_url = begin
+          URI.parse(url)
+        rescue StandardError
+          nil
+        end
+        url_has_db = parsed_url && parsed_url.path && parsed_url.path.length > 1
+        unless url_has_db
+          begin
+            redis_client.select(db)
+          rescue StandardError
+            # Ignore if SELECT fails (some Redis setups don't support SELECT, e.g., Redis Cluster)
+          end
+        end
+      end
+
       adapter = Adapters::Redis.new(redis_client)
       adapter.instance_variable_set(:@namespace, namespace) if namespace
       adapter
     end
 
-    def configure_registry_adapter(memory: nil, redis: nil, async: nil, circuit_breaker: nil)
+    def configure_active_record_adapter(model_class: nil, **_options)
+      return nil unless defined?(::ActiveRecord::Base)
+
+      model_class ||= @active_record_model_class
+      Adapters::ActiveRecord.new(model_class: model_class)
+    rescue StandardError => e
+      if defined?(Rails) && Rails.env.development?
+        warn "Magick: Failed to initialize ActiveRecord adapter: #{e.message}"
+      end
+      nil
+    end
+
+    def configure_registry_adapter(memory: nil, redis: nil, active_record: nil, async: nil, circuit_breaker: nil,
+                                   primary: nil)
       memory_adapter = memory || configure_memory_adapter
       redis_adapter = redis || configure_redis_adapter
+      active_record_adapter = active_record || configure_active_record_adapter
 
       cb = circuit_breaker || Magick::CircuitBreaker.new(
         failure_threshold: @circuit_breaker_threshold,
@@ -194,12 +296,15 @@ module Magick
       )
 
       async_enabled = async.nil? ? @async_updates : async
+      primary_adapter = primary || (@active_record_primary ? :active_record : :memory)
 
       @adapter_registry = Adapters::Registry.new(
         memory_adapter,
         redis_adapter,
+        active_record_adapter: active_record_adapter,
         circuit_breaker: cb,
-        async: async_enabled
+        async: async_enabled,
+        primary: primary_adapter
       )
     end
 
@@ -207,7 +312,8 @@ module Magick
       @default_adapter_registry ||= begin
         memory_adapter = Adapters::Memory.new
         redis_adapter = configure_redis_adapter
-        Adapters::Registry.new(memory_adapter, redis_adapter)
+        active_record_adapter = configure_active_record_adapter if defined?(::ActiveRecord::Base)
+        Adapters::Registry.new(memory_adapter, redis_adapter, active_record_adapter: active_record_adapter)
       end
     end
   end