magick-feature-flags 0.9.20 → 0.9.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4f9379b630e9db00b28614f347d523edb33d63c842d6b5c9fd747be02f1d75d
-  data.tar.gz: ffa32ee13faa08781c68870813c15ea7b3dcc15fe65f8c1f2618952251fe870c
+  metadata.gz: 42699b3af1d542ac14b10f2b82ea4156da27b68e3e2a07e715cd528f0e3f936b
+  data.tar.gz: 0c5235c6cb220201ed0443d1a4633009325d410620d8d28ecbb836cac01bdc25
 SHA512:
-  metadata.gz: 0f2651c1f8528b4eb385f82a629c7891e0a78ec4a796b574baa8228a2bfcaddf88ee6855af45f9fba9c12b4d7d475e1d8aa6ba6b1002706a1247a8ef81b540e4
-  data.tar.gz: 418cc8c6909969581b147df052c72ffc9635a86b07726f69f0c6085bef3bbb804515d34a3d6ca782f8b4c03d4127722a5547a483ca2d0cddfc56f3bef4e6e864
+  metadata.gz: 10fb678c4aeaf5a17f721341e01ec937bf9a14042e4a90fa0bcc1aba13c5e91272aba144fa05913a020660ffd602ccf7481d216e92364338c7e4a111794e0896
+  data.tar.gz: '079e2d11d6ab0339929f965c1eb05fc934ea88522f26e268df324c366ad28268f87131233fe0f2315a5494328ae5fa18790e8e512fa550372852c3c1d61c3faf'

data/lib/magick/feature.rb

@@ -33,15 +33,55 @@ module Magick
       # Update targeting empty cache after loading
       @_targeting_empty = @targeting.empty?
       # Cache performance metrics availability (check once, not on every call)
-      @_perf_metrics_enabled = Magick.performance_metrics != nil
+      # Only enable if performance_metrics exists AND is actually being used
+      @_perf_metrics_enabled = !Magick.performance_metrics.nil?
       # Save description and display_name to adapter if they were provided and not already in adapter
       save_metadata_if_new
     end
 
     def enabled?(context = {})
-      # Fastest path: check enabled status directly (no overhead)
-      check_enabled(context)
+      # Check performance metrics dynamically (in case enabled after feature creation)
+      # But cache the check result for performance
+      perf_metrics = Magick.performance_metrics
+      perf_metrics_enabled = !perf_metrics.nil?
+
+      # Update cached flag if it changed
+      @_perf_metrics_enabled = perf_metrics_enabled if @_perf_metrics_enabled != perf_metrics_enabled
+
+      # Fast path: if performance metrics disabled, skip all overhead
+      return check_enabled(context) unless perf_metrics_enabled
+
+      # Performance metrics enabled: measure and record
+      # Use inline timing to avoid function call overhead
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = check_enabled(context)
+      duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000 # milliseconds
+
+      # Record metrics (fast path - minimal overhead)
+      perf_metrics.record(name, 'enabled?', duration, success: true)
+
+      # Rails 8+ events (only in development or when explicitly enabled)
+      if @_rails_events_enabled
+        if result
+          Magick::Rails::Events.feature_enabled(name, context: context)
+        else
+          Magick::Rails::Events.feature_disabled(name, context: context)
+        end
+      end
+
+      # Warn if deprecated (only if enabled)
+      if status == :deprecated && result && !context[:allow_deprecated] && Magick.warn_on_deprecated
+        warn "DEPRECATED: Feature '#{name}' is deprecated and will be removed."
+        Magick::Rails::Events.deprecated_warning(name) if @_rails_events_enabled
+      end
+
+      result
     rescue StandardError => e
+      # Record error metrics if enabled
+      if perf_metrics_enabled && perf_metrics
+        duration = defined?(start_time) && start_time ? (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000 : 0.0
+        perf_metrics.record(name, 'enabled?', duration, success: false)
+      end
       # Return false on any error (fail-safe)
       warn "Magick: Error checking feature '#{name}': #{e.message}" if defined?(Rails) && Rails.env.development?
       false
@@ -452,6 +492,10 @@ module Magick
     # Reload feature state from adapter (useful when feature is changed externally)
     def reload
       load_from_adapter
+      # Update targeting empty cache
+      @_targeting_empty = @targeting.empty?
+      # Update performance metrics flag (in case it was enabled after feature creation)
+      @_perf_metrics_enabled = !Magick.performance_metrics.nil?
       # Update registered feature instance if it exists
       if Magick.features.key?(name)
         registered = Magick.features[name]
@@ -461,6 +505,8 @@ module Magick
         registered.instance_variable_set(:@description, @description)
         registered.instance_variable_set(:@display_name, @display_name)
         registered.instance_variable_set(:@targeting, @targeting.dup)
+        registered.instance_variable_set(:@_targeting_empty, @_targeting_empty)
+        registered.instance_variable_set(:@_perf_metrics_enabled, @_perf_metrics_enabled)
       end
       true
     end

data/lib/magick/performance_metrics.rb

@@ -36,44 +36,59 @@ module Magick
       # 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
+      # Cache expensive checks for performance
+      @_rails_events_enabled = defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
+      @_adapter_available = nil # Will be cached on first check
+      @_redis_available = nil # Will be cached on first check
     end
 
     # Public accessor for redis_enabled
     attr_reader :redis_enabled
 
     def record(feature_name, operation, duration, success: true)
+      # Fast path: minimize work in mutex
       feature_name_str = feature_name.to_s
-      metric = Metric.new(feature_name_str, operation, duration, success: success)
 
+      # Minimize mutex lock time - only update counters
+      pending_count = nil
+      total_pending = nil
       @mutex.synchronize do
-        @metrics << metric
+        # Only create Metric object if we're keeping metrics in memory
+        # Most of the time we just need counters, not full metric objects
+        if @metrics.length < 1000
+          metric = Metric.new(feature_name_str, operation, duration, success: success)
+          @metrics << metric
+        end
         @usage_count[feature_name_str] += 1
         @pending_updates[feature_name_str] += 1
+        pending_count = @pending_updates[feature_name_str]
+        total_pending = @pending_updates.values.sum
         # 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
 
-      # Rails 8+ event for usage tracking
-      if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
+      # Rails 8+ event for usage tracking (cached check)
+      if @_rails_events_enabled
         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
+      # Batch flush check - only if we're close to batch size (avoid expensive checks)
+      # Check pending count first before doing expensive adapter checks
+      flush_to_redis_if_needed if pending_count >= @batch_size || total_pending >= @batch_size
 
-      metric
+      nil # Don't return metric object to avoid allocation overhead
     end
 
     def flush_to_redis_if_needed
-      # 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?
+      # Cache adapter availability check (expensive)
+      if @_adapter_available.nil?
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        @_adapter_available = adapter
+        @_redis_available = adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_available? if adapter
+      end
 
-      return unless redis_available || @redis_enabled
+      return unless @_adapter_available
+      return unless @_redis_available || @redis_enabled
       return if @pending_updates.empty?
 
       should_flush = false

data/lib/magick/version.rb

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

data/lib/magick.rb

@@ -38,6 +38,12 @@ module Magick
       if value && adapter_registry.is_a?(Adapters::Registry) && adapter_registry.redis_available?
         value.enable_redis_tracking(enable: true)
       end
+      # Update all existing features to enable performance metrics tracking
+      if value
+        features.each_value do |feature|
+          feature.instance_variable_set(:@_perf_metrics_enabled, true)
+        end
+      end
       value
     end
 

metadata

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