magick-feature-flags 0.9.18 → 0.9.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7df3e59dc8f0736e18fb93603f53038f48b5302769c42cc37ab87f2afcba0307
-  data.tar.gz: e0235e0c7518860061b7b67a27aee9c1be88346c8292733aae0a2c794c2288d7
+  metadata.gz: e4f9379b630e9db00b28614f347d523edb33d63c842d6b5c9fd747be02f1d75d
+  data.tar.gz: ffa32ee13faa08781c68870813c15ea7b3dcc15fe65f8c1f2618952251fe870c
 SHA512:
-  metadata.gz: 0a76c637a3cd96cebd6fa91be4f10df8e1174713fabb82c4cdb8df1cecd2d4c6c6ea46e00949cc485e6c0a3d46a9180c718204361a2630c8a71a069a0c6f6bbd
-  data.tar.gz: f0682f004002eab91412ee9d948e69f3f84de41238ab2d5ca3f06abec1abf2616c86063a66198f8a596f32d8dc2cf545c9db0b62961e6dc98a4d97a39b01e5cc
+  metadata.gz: 0f2651c1f8528b4eb385f82a629c7891e0a78ec4a796b574baa8228a2bfcaddf88ee6855af45f9fba9c12b4d7d475e1d8aa6ba6b1002706a1247a8ef81b540e4
+  data.tar.gz: 418cc8c6909969581b147df052c72ffc9635a86b07726f69f0c6085bef3bbb804515d34a3d6ca782f8b4c03d4127722a5547a483ca2d0cddfc56f3bef4e6e864

data/lib/magick/adapters/memory.rb

@@ -11,12 +11,16 @@ module Magick
       end
 
       def get(feature_name, key)
+        # Fast path: avoid mutex if possible (use string keys directly)
+        feature_name_str = feature_name.is_a?(String) ? feature_name : feature_name.to_s
+        key_str = key.is_a?(String) ? key : key.to_s
+
         mutex.synchronize do
           cleanup_expired
-          feature_data = store[feature_name.to_s]
+          feature_data = store[feature_name_str]
           return nil unless feature_data
 
-          value = feature_data[key.to_s]
+          value = feature_data[key_str]
           deserialize_value(value)
         end
       end

data/lib/magick/feature.rb

@@ -22,77 +22,54 @@ module Magick
       @dependencies = options[:dependencies] ? Array(options[:dependencies]) : []
       @stored_value_initialized = false # Track if @stored_value has been explicitly set
 
+      # Performance optimizations: cache expensive checks
+      @_targeting_empty = true # Will be updated after load_from_adapter
+      @_rails_events_enabled = false # Cache Rails events availability (only enable in dev)
+      @_perf_metrics_enabled = false # Cache performance metrics (disabled by default for speed)
+
       validate_type!
       validate_default_value!
       load_from_adapter
+      # 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
       # Save description and display_name to adapter if they were provided and not already in adapter
       save_metadata_if_new
     end
 
     def enabled?(context = {})
-      # Track usage if metrics available
-      start_time = Time.now if Magick.performance_metrics
-
-      result = check_enabled(context)
-
-      if Magick.performance_metrics
-        duration = (Time.now - start_time) * 1000 # milliseconds
-        Magick.performance_metrics.record(name, 'enabled?', duration, success: true)
-      end
-
-      # Rails 8+ events for enabled/disabled
-      if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
-        if result
-          Magick::Rails::Events.feature_enabled(name, context: context)
-        else
-          Magick::Rails::Events.feature_disabled(name, context: context)
-        end
-      end
-
-      # Warn if deprecated
-      if status == :deprecated && result && !context[:allow_deprecated]
-        warn "DEPRECATED: Feature '#{name}' is deprecated and will be removed." if Magick.warn_on_deprecated
-
-        # Rails 8+ event for deprecation warning
-        if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
-          Magick::Rails::Events.deprecated_warning(name)
-        end
-      end
-
-      result
+      # Fastest path: check enabled status directly (no overhead)
+      check_enabled(context)
     rescue StandardError => e
-      if Magick.performance_metrics
-        duration = (Time.now - start_time) * 1000
-        Magick.performance_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
     end
 
     def check_enabled(context = {})
+      # Fast path: check status first
       return false if status == :inactive
       return false if status == :deprecated && !context[:allow_deprecated]
 
-      # NOTE: We don't check dependencies here because:
-      # - Main features can be enabled independently
-      # - Dependencies are only prevented from being enabled if the main feature is disabled
-      # - The dependency check is handled in the enable() method, not in enabled?()
-
-      # Check date/time range targeting
-      return false if targeting[:date_range] && !date_range_active?(targeting[:date_range])
+      # Fast path: skip targeting checks if targeting is empty (most common case)
+      unless @_targeting_empty
+        # Check date/time range targeting
+        return false if targeting[:date_range] && !date_range_active?(targeting[:date_range])
 
-      # Check IP address targeting
-      return false if targeting[:ip_address] && context[:ip_address] && !ip_address_matches?(context[:ip_address])
+        # Check IP address targeting
+        return false if targeting[:ip_address] && context[:ip_address] && !ip_address_matches?(context[:ip_address])
 
-      # Check custom attributes
-      return false if targeting[:custom_attributes] && !custom_attributes_match?(context, targeting[:custom_attributes])
+        # Check custom attributes
+        return false if targeting[:custom_attributes] && !custom_attributes_match?(context,
+                                                                                   targeting[:custom_attributes])
 
-      # Check complex conditions
-      if targeting[:complex_conditions] && !complex_conditions_match?(context, targeting[:complex_conditions])
-        return false
+        # Check complex conditions
+        return false if targeting[:complex_conditions] && !complex_conditions_match?(context,
+                                                                                     targeting[:complex_conditions])
       end
 
+      # Get value and check based on type
       value = get_value(context)
       case type
       when :boolean
@@ -131,19 +108,21 @@ module Magick
     end
 
     def get_value(context = {})
-      # Check targeting rules first
-      targeting_result = check_targeting(context)
-      return targeting_result unless targeting_result.nil?
+      # Fast path: check targeting rules first (only if targeting exists)
+      unless @_targeting_empty
+        targeting_result = check_targeting(context)
+        return targeting_result unless targeting_result.nil?
+      end
 
-      # Use instance variable if it has been set (check using defined? to handle nil vs uninitialized)
-      # We use a special check: if @stored_value was explicitly set (even to false), use it
-      # We track this by checking if @stored_value_initialized flag is set
-      return @stored_value if defined?(@stored_value_initialized) && @stored_value_initialized
+      # Fast path: use cached value if initialized (avoid adapter calls)
+      return @stored_value if @stored_value_initialized
 
       # Load from adapter if instance variable hasn't been initialized
       loaded_value = load_value_from_adapter
       if loaded_value.nil?
-        # Value not found in adapter, use default
+        # Value not found in adapter, use default and cache it
+        @stored_value = default_value
+        @stored_value_initialized = true
         default_value
       else
         # Value found in adapter, use it and mark as initialized
@@ -827,9 +806,14 @@ module Magick
       adapter_registry.set(name, 'targeting', targeting)
 
       # Update the feature in Magick.features if it's registered
-      return unless Magick.features.key?(name)
+      if Magick.features.key?(name)
+        Magick.features[name].instance_variable_set(:@targeting, targeting.dup)
+        # Update targeting empty cache for performance
+        Magick.features[name].instance_variable_set(:@_targeting_empty, targeting.empty?)
+      end
 
-      Magick.features[name].instance_variable_set(:@targeting, targeting.dup)
+      # Update local targeting empty cache for performance
+      @_targeting_empty = targeting.empty?
 
       # Explicitly trigger cache invalidation for targeting updates
       # Targeting changes affect enabled? checks, so we need immediate cache invalidation

data/lib/magick/version.rb

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

data/lib/magick.rb

@@ -103,7 +103,9 @@ module Magick
     end
 
     def enabled?(feature_name, context = {})
-      feature = features[feature_name.to_s] || self[feature_name]
+      # Fast path: use string key directly (avoid repeated to_s conversion)
+      feature_name_str = feature_name.to_s
+      feature = features[feature_name_str] || self[feature_name]
       feature.enabled?(context)
     end
 

metadata

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