magick-feature-flags 0.9.10 → 0.9.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ff57666debab09c055a1709e27902b4ff03780b62ca97382e3f0df191b4b1ce
-  data.tar.gz: 1420d03c05427c4c0ef7f319debb108542b36fa5fccf999ad13e3bd0571c0451
+  metadata.gz: 7df3e59dc8f0736e18fb93603f53038f48b5302769c42cc37ab87f2afcba0307
+  data.tar.gz: e0235e0c7518860061b7b67a27aee9c1be88346c8292733aae0a2c794c2288d7
 SHA512:
-  metadata.gz: 2150805b902ed92fc1f033493e47697541078d21fb7d9d1e827ddf8b22d9e17fd58e8e1ed926aa47fecf1662c491d910ecba528a0d1ce8f306b340c9e0b35a16
-  data.tar.gz: 21144c7b0ad4c6c23eb379f088898757f438058dc9c2278f3fc30a03e188b03a6b58e9cb4aac8d5e37127523b5bcfc562a00c08079de95da035d10b9afa28ad5
+  metadata.gz: 0a76c637a3cd96cebd6fa91be4f10df8e1174713fabb82c4cdb8df1cecd2d4c6c6ea46e00949cc485e6c0a3d46a9180c718204361a2630c8a71a069a0c6f6bbd
+  data.tar.gz: f0682f004002eab91412ee9d948e69f3f84de41238ab2d5ca3f06abec1abf2616c86063a66198f8a596f32d8dc2cf545c9db0b62961e6dc98a4d97a39b01e5cc

data/lib/magick/config.rb

@@ -41,21 +41,50 @@ module Magick
     def redis(url: nil, namespace: nil, **options)
       @redis_url = url if url
       @redis_namespace = namespace if namespace
-      configure_redis_adapter(url: url, namespace: namespace, **options)
+      redis_adapter = configure_redis_adapter(url: url, namespace: namespace, **options)
+
+      # Automatically create Registry adapter if it doesn't exist
+      # This allows users to just call `redis url: ...` without needing to call `adapter :registry`
+      if @adapter_registry
+        # If registry already exists, update it with the new Redis adapter
+        # This allows reconfiguring Redis without recreating the registry
+        if redis_adapter && @adapter_registry.is_a?(Adapters::Registry)
+          # Update the Redis adapter in the existing registry
+          @adapter_registry.instance_variable_set(:@redis_adapter, redis_adapter)
+          # Restart cache invalidation subscriber with new Redis adapter
+          @adapter_registry.send(:start_cache_invalidation_subscriber) if redis_adapter
+        end
+      else
+        memory_adapter = configure_memory_adapter
+        cb = Magick::CircuitBreaker.new(
+          failure_threshold: @circuit_breaker_threshold,
+          timeout: @circuit_breaker_timeout
+        )
+        @adapter_registry = Adapters::Registry.new(
+          memory_adapter,
+          redis_adapter,
+          circuit_breaker: cb,
+          async: @async_updates
+        )
+      end
+
+      redis_adapter
     end
 
     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)
-      # Store redis_tracking preference for later application
+      # Store redis_tracking preference before creating instance
       @performance_metrics_redis_tracking = redis_tracking
-      # Enable Redis tracking if explicitly set to true, otherwise defer to apply! method
-      if redis_tracking == true
-        @performance_metrics.enable_redis_tracking(enable: true)
-      elsif redis_tracking == false
-        @performance_metrics.enable_redis_tracking(enable: false)
-      end
+      # Create instance with redis_enabled set if explicitly provided
+      initial_redis_enabled = redis_tracking == true
+      @performance_metrics = PerformanceMetrics.new(
+        batch_size: batch_size,
+        flush_interval: flush_interval,
+        redis_enabled: initial_redis_enabled
+      )
+      # If explicitly set to false, disable it
+      @performance_metrics.enable_redis_tracking(enable: false) if redis_tracking == false
       # If nil, will be auto-determined in apply! method
       @performance_metrics
     end
@@ -100,10 +129,19 @@ module Magick
         Magick.performance_metrics = performance_metrics
         # Re-apply redis_tracking setting after assignment (in case object was replaced)
         if defined?(@performance_metrics_redis_tracking) && !@performance_metrics_redis_tracking.nil?
+          # Explicitly set value takes precedence
           Magick.performance_metrics.enable_redis_tracking(enable: @performance_metrics_redis_tracking)
         # Otherwise, auto-enable if Redis adapter is configured
         # Check Magick.adapter_registry (after it's been set) instead of local instance variable
         elsif Magick.adapter_registry.is_a?(Adapters::Registry) && Magick.adapter_registry.redis_available?
+          # Always enable if Redis adapter is available (unless explicitly disabled above)
+          Magick.performance_metrics.enable_redis_tracking(enable: true)
+        end
+      elsif Magick.performance_metrics
+        # If no new performance_metrics was configured, but one exists, still try to enable Redis tracking
+        # if Redis adapter is available and redis_tracking wasn't explicitly disabled
+        # Only auto-enable if not explicitly disabled
+        if Magick.adapter_registry.is_a?(Adapters::Registry) && Magick.adapter_registry.redis_available? && !(defined?(@performance_metrics_redis_tracking) && @performance_metrics_redis_tracking == false)
           Magick.performance_metrics.enable_redis_tracking(enable: true)
         end
       end
@@ -150,7 +188,7 @@ module Magick
       memory_adapter = memory || configure_memory_adapter
       redis_adapter = redis || configure_redis_adapter
 
-      cb = circuit_breaker || CircuitBreaker.new(
+      cb = circuit_breaker || Magick::CircuitBreaker.new(
         failure_threshold: @circuit_breaker_threshold,
         timeout: @circuit_breaker_timeout
       )

data/lib/magick/performance_metrics.rb

@@ -24,17 +24,23 @@ module Magick
       end
     end
 
-    def initialize(batch_size: 100, flush_interval: 60)
+    def initialize(batch_size: 100, flush_interval: 60, redis_enabled: nil)
       @metrics = []
       @mutex = Mutex.new
-      @usage_count = Hash.new(0)
-      @pending_updates = Hash.new(0) # For Redis batching
+      @usage_count = Hash.new(0) # Memory-only counts (reset on each process boot)
+      @pending_updates = Hash.new(0) # For Redis batching (reset on each process boot)
+      @flushed_counts = Hash.new(0) # Track counts that have been flushed to Redis (to avoid double-counting)
       @batch_size = batch_size
       @flush_interval = flush_interval
       @last_flush = Time.now
-      @redis_enabled = false
+      # If redis_enabled is explicitly set, use it; otherwise default to false
+      # It will be enabled later via enable_redis_tracking if Redis adapter is available
+      @redis_enabled = redis_enabled.nil? ? false : redis_enabled
     end
 
+    # Public accessor for redis_enabled
+    attr_reader :redis_enabled
+
     def record(feature_name, operation, duration, success: true)
       feature_name_str = feature_name.to_s
       metric = Metric.new(feature_name_str, operation, duration, success: success)
@@ -43,7 +49,8 @@ module Magick
         @metrics << metric
         @usage_count[feature_name_str] += 1
         @pending_updates[feature_name_str] += 1
-        # Keep only last 1000 metrics
+        # Keep only last 1000 metrics (as a safety limit)
+        # Note: Metrics are removed from memory after flushing to Redis to reduce memory usage
         @metrics.shift if @metrics.length > 1000
       end
 
@@ -59,41 +66,98 @@ module Magick
     end
 
     def flush_to_redis_if_needed
-      return unless @redis_enabled
+      # Always try to flush if Redis adapter is available, even if @redis_enabled is false
+      # This ensures stats are collected even if redis_enabled wasn't set correctly
+      adapter = Magick.adapter_registry || Magick.default_adapter_registry
+      return unless adapter # No adapter at all, skip
+
+      redis_available = adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
+
+      return unless redis_available || @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
-        should_flush = true if @pending_updates.size >= @batch_size || (Time.now - @last_flush) >= @flush_interval
+        # Flush if we have enough pending updates (sum of all counts) or enough time has passed
+        # Check total count of pending updates, not just number of keys
+        total_pending_count = @pending_updates.values.sum
+        should_flush = true if total_pending_count >= @batch_size || (Time.now - @last_flush) >= @flush_interval
       end
 
       flush_to_redis if should_flush
     end
 
+    # Force flush pending updates to Redis immediately
+    # Useful when you need up-to-date stats across processes
+    def force_flush_to_redis
+      return if @pending_updates.empty?
+
+      flush_to_redis
+    end
+
     def flush_to_redis
       updates_to_flush = nil
+      duration_stats_to_flush = {}
       @mutex.synchronize do
         return if @pending_updates.empty?
 
         updates_to_flush = @pending_updates.dup
+        flushed_feature_names = updates_to_flush.keys.to_set
         @pending_updates.clear
+        # Track what we're flushing so we don't double-count in usage_count
+        updates_to_flush.each do |feature_name, count|
+          @flushed_counts[feature_name] += count
+        end
+
+        # Collect duration stats for flushed features
+        # Group metrics by feature_name and operation, sum durations and count occurrences
+        @metrics.each do |metric|
+          next unless flushed_feature_names.include?(metric.feature_name) && metric.success
+
+          key = "#{metric.feature_name}:#{metric.operation}"
+          duration_stats_to_flush[key] ||= { sum: 0.0, count: 0, feature_name: metric.feature_name,
+                                             operation: metric.operation }
+          duration_stats_to_flush[key][:sum] += metric.duration
+          duration_stats_to_flush[key][:count] += 1
+        end
+
+        # Remove metrics for flushed features from memory to reduce memory usage
+        # Metrics are already persisted in Redis, so we don't need to keep them in memory
+        @metrics.reject! { |m| flushed_feature_names.include?(m.feature_name) }
+
         @last_flush = Time.now
       end
 
       return if updates_to_flush.nil? || updates_to_flush.empty?
 
       # Update Redis in batch
+      # Always try to flush if Redis adapter is available, regardless of @redis_enabled flag
+      # This ensures stats are collected even if redis_enabled wasn't set correctly
       begin
         adapter = Magick.adapter_registry || Magick.default_adapter_registry
         if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
           redis = adapter.redis_client
           if redis
+            # Flush usage counts
             updates_to_flush.each do |feature_name, count|
               redis_key = "magick:stats:#{feature_name}"
               redis.incrby(redis_key, count)
               redis.expire(redis_key, 86_400 * 7) # Keep stats for 7 days
             end
+
+            # Flush duration stats (sum and count for calculating averages)
+            duration_stats_to_flush.each do |_key, stats|
+              sum_key = "magick:duration:sum:#{stats[:feature_name]}:#{stats[:operation]}"
+              count_key = "magick:duration:count:#{stats[:feature_name]}:#{stats[:operation]}"
+              redis.incrbyfloat(sum_key, stats[:sum])
+              redis.incrby(count_key, stats[:count])
+              redis.expire(sum_key, 86_400 * 7) # Keep stats for 7 days
+              redis.expire(count_key, 86_400 * 7)
+            end
+
+            # Auto-enable redis tracking if we successfully flushed to Redis
+            # This ensures redis_enabled is set correctly even if config didn't work
+            @redis_enabled ||= true
           end
         end
       rescue StandardError => e
@@ -103,67 +167,137 @@ module Magick
     end
 
     def enable_redis_tracking(enable: true)
+      old_value = @redis_enabled
       @redis_enabled = enable
+
       # Flush any pending updates when enabling
-      flush_to_redis if enable && !@pending_updates.empty?
+      if enable && !@pending_updates.empty?
+        begin
+          flush_to_redis
+        rescue StandardError => e
+          # Don't fail if flush fails - the flag is still set
+          if defined?(Rails) && Rails.env.development?
+            warn "Magick: Failed to flush stats when enabling Redis tracking: #{e.message}"
+          end
+        end
+      end
+
+      # Verify the value was set (for debugging)
+      if !(@redis_enabled == enable) && defined?(Rails) && Rails.env.development?
+        warn "Magick: Failed to set redis_enabled to #{enable}, current value: #{@redis_enabled}"
+      end
+
+      true
     end
 
     def average_duration(feature_name: nil, operation: nil)
+      # Calculate from memory metrics (current process, not yet flushed)
       filtered = @metrics.select do |m|
         (feature_name.nil? || m.feature_name == feature_name.to_s) &&
           (operation.nil? || m.operation == operation.to_s) &&
           m.success
       end
-      return 0.0 if filtered.empty?
 
-      filtered.sum(&:duration) / filtered.length.to_f
+      memory_sum = filtered.sum(&:duration)
+      memory_count = filtered.length
+
+      # Also get from Redis if available (persisted across processes)
+      redis_sum = 0.0
+      redis_count = 0
+      begin
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
+          redis = adapter.redis_client
+          if redis
+            if feature_name && operation
+              # Specific feature and operation
+              sum_key = "magick:duration:sum:#{feature_name}:#{operation}"
+              count_key = "magick:duration:count:#{feature_name}:#{operation}"
+              redis_sum = redis.get(sum_key).to_f
+              redis_count = redis.get(count_key).to_i
+            elsif feature_name
+              # All operations for this feature
+              pattern = "magick:duration:sum:#{feature_name}:*"
+              redis.keys(pattern).each do |sum_key|
+                op = sum_key.to_s.sub("magick:duration:sum:#{feature_name}:", '')
+                count_key = "magick:duration:count:#{feature_name}:#{op}"
+                redis_sum += redis.get(sum_key).to_f
+                redis_count += redis.get(count_key).to_i
+              end
+            else
+              # All features and operations (not recommended, but supported)
+              redis.keys('magick:duration:sum:*').each do |sum_key|
+                count_key = sum_key.to_s.sub(':sum:', ':count:')
+                redis_sum += redis.get(sum_key).to_f
+                redis_count += redis.get(count_key).to_i
+              end
+            end
+          end
+        end
+      rescue StandardError
+        # Silently fail
+      end
+
+      total_sum = memory_sum + redis_sum
+      total_count = memory_count + redis_count
+
+      return 0.0 if total_count == 0
+
+      total_sum / total_count.to_f
     end
 
     def usage_count(feature_name)
       feature_name_str = feature_name.to_s
-      memory_count = @usage_count[feature_name_str] || 0
 
-      # Also check Redis if enabled
+      # Force flush any pending updates for this feature before reading to ensure accuracy
+      # This ensures stats are synced across processes immediately
+      force_flush_to_redis if @pending_updates[feature_name_str] && @pending_updates[feature_name_str] > 0
+
+      # Memory count = total counts in current process minus what we've already flushed
+      # This avoids double-counting with Redis
+      memory_count = (@usage_count[feature_name_str] || 0) - (@flushed_counts[feature_name_str] || 0)
+      memory_count = 0 if memory_count < 0 # Safety check
+
+      # Redis count = total counts from all processes (including this process's flushed counts)
       redis_count = 0
-      if @redis_enabled
-        begin
-          adapter = Magick.adapter_registry || Magick.default_adapter_registry
-          if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
-            redis = adapter.redis_client
-            if redis
-              redis_key = "magick:stats:#{feature_name_str}"
-              redis_count = redis.get(redis_key).to_i
-            end
+      begin
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
+          redis = adapter.redis_client
+          if redis
+            redis_key = "magick:stats:#{feature_name_str}"
+            redis_count = redis.get(redis_key).to_i
           end
-        rescue StandardError
-          # Silently fail
         end
+      rescue StandardError
+        # Silently fail
       end
 
-      memory_count + redis_count
+      # Total = Redis (all processes, all time) + memory (current process, not yet flushed)
+      redis_count + memory_count
     end
 
     def most_used_features(limit: 10)
       # 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_available?
-            redis = adapter.redis_client
-            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
+      # Always check Redis if adapter is available (not just if @redis_enabled)
+      # This ensures we get the full count even if redis_enabled flag wasn't set correctly
+      begin
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available?
+          redis = adapter.redis_client
+          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
-        rescue StandardError
-          # Silently fail
         end
+      rescue StandardError
+        # Silently fail
       end
 
       combined_counts.sort_by { |_name, count| -count }.first(limit).to_h
@@ -174,6 +308,7 @@ module Magick
         @metrics.clear
         @usage_count.clear
         @pending_updates.clear
+        @flushed_counts.clear
       end
     end
   end

data/lib/magick/rails/railtie.rb

@@ -29,11 +29,44 @@ if defined?(Rails)
                   memory_adapter = Adapters::Memory.new
                   redis_adapter = Adapters::Redis.new(redis_client)
                   magick.adapter_registry = Adapters::Registry.new(memory_adapter, redis_adapter)
-                  # Re-apply Redis tracking if performance metrics exists
-                  Magick.reapply_redis_tracking! if Magick.performance_metrics
+                  # Enable Redis tracking if performance metrics exists and Redis is available
+                  if Magick.performance_metrics && redis_adapter
+                    Magick.performance_metrics.enable_redis_tracking(enable: true)
+                  end
                 rescue StandardError => e
                   Rails.logger&.warn "Magick: Failed to initialize Redis adapter: #{e.message}. Using memory-only adapter."
+                  # Still set up memory adapter even if Redis fails
+                  memory_adapter = Adapters::Memory.new
+                  magick.adapter_registry = Adapters::Registry.new(memory_adapter, nil)
                 end
+              else
+                # No Redis gem, use memory-only adapter
+                memory_adapter = Adapters::Memory.new
+                magick.adapter_registry = Adapters::Registry.new(memory_adapter, nil)
+              end
+            end
+          end
+
+          # Ensure adapter_registry is always set (fallback to default if not configured)
+          unless Magick.adapter_registry
+            Magick.adapter_registry = Magick.default_adapter_registry
+          end
+
+          # Ensure adapter_registry is set and Redis tracking is enabled after all initializers have run
+          # This ensures user's config/initializers/magick.rb has been loaded
+          config.after_initialize do
+            # Ensure adapter_registry is set (fallback to default if not configured)
+            unless Magick.adapter_registry
+              Magick.adapter_registry = Magick.default_adapter_registry
+            end
+
+            # Force enable Redis tracking if Redis adapter is available
+            # This is a final safety net to ensure stats are collected
+            if Magick.performance_metrics && Magick.adapter_registry.is_a?(Adapters::Registry) && Magick.adapter_registry.redis_available?
+              Magick.performance_metrics.enable_redis_tracking(enable: true)
+              # Double-check it was enabled (for debugging)
+              unless Magick.performance_metrics.redis_enabled
+                Rails.logger&.warn 'Magick: Failed to enable Redis tracking despite Redis adapter being available'
               end
             end
           end
@@ -64,6 +97,12 @@ if defined?(Rails)
         # Preload features in request store
         config.to_prepare do
           RequestStore.store[:magick_features] ||= {} if defined?(RequestStore)
+
+          # Final check: ensure Redis tracking is enabled (runs on every request in development)
+          # This is the absolute last chance to enable it
+          if Magick.performance_metrics && Magick.adapter_registry.is_a?(Adapters::Registry) && Magick.adapter_registry.redis_available? && !Magick.performance_metrics.redis_enabled
+            Magick.performance_metrics.enable_redis_tracking(enable: true)
+          end
         end
       end
     end

data/lib/magick/version.rb

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

data/lib/magick.rb

@@ -28,24 +28,63 @@ require_relative 'magick/dsl'
 
 module Magick
   class << self
-    attr_accessor :adapter_registry, :default_adapter, :performance_metrics, :audit_log, :versioning,
+    attr_accessor :adapter_registry, :default_adapter, :audit_log, :versioning,
                   :warn_on_deprecated
 
+    # Override performance_metrics setter to auto-enable Redis tracking
+    def performance_metrics=(value)
+      @performance_metrics = value
+      # Auto-enable Redis tracking if Redis adapter is available
+      if value && adapter_registry.is_a?(Adapters::Registry) && adapter_registry.redis_available?
+        value.enable_redis_tracking(enable: true)
+      end
+      value
+    end
+
+    # Override adapter_registry setter to auto-enable Redis tracking on existing performance_metrics
+    def adapter_registry=(value)
+      @adapter_registry = value
+      # Auto-enable Redis tracking if performance_metrics exists and Redis adapter is available
+      if performance_metrics && value.is_a?(Adapters::Registry) && value.redis_available?
+        performance_metrics.enable_redis_tracking(enable: true)
+      end
+      value
+    end
+
+    # Getter for performance_metrics
+    def performance_metrics
+      @performance_metrics
+    end
+
     def configure(&block)
       @performance_metrics ||= PerformanceMetrics.new
       @audit_log ||= AuditLog.new
       @warn_on_deprecated ||= false
+      # Ensure adapter_registry is set (fallback to default if not configured)
+      @adapter_registry ||= default_adapter_registry
 
       # Support both old style and new DSL style
       return unless block_given?
 
       if block.arity.zero?
-        # New DSL style
+        # New DSL style - calls apply! automatically
         ConfigDSL.configure(&block)
       else
-        # Old style
+        # Old style - need to manually reapply Redis tracking after configuration
         yield self
+        # Ensure adapter_registry is still set after configuration
+        @adapter_registry ||= default_adapter_registry
+        # Enable Redis tracking if adapter is available and performance_metrics exists
+        # Only enable if not already enabled (to avoid overriding explicit false setting)
+        if @performance_metrics && @adapter_registry.is_a?(Adapters::Registry) && @adapter_registry.redis_available?
+          unless @performance_metrics.instance_variable_get(:@redis_enabled)
+            @performance_metrics.enable_redis_tracking(enable: true)
+          end
+        end
       end
+
+      # Final check: ensure adapter_registry is set
+      @adapter_registry ||= default_adapter_registry
     end
 
     def [](feature_name)

metadata

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