magick-feature-flags 1.4.3 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e6f3b4ee81b2521e7f6975c0bd3c7a0a886ea2e23b5792b37e48cd28b08cb8d
-  data.tar.gz: 3aeb62560e637d844af0ea4e320a08a48eb72a33ebfd0653482899f42e8e2079
+  metadata.gz: be6153e50823e724cefb980f60d0272c878ed9fd3619cfa98eaaa8917ab621d1
+  data.tar.gz: a6e50cabc9eb5730f819ff038ce23b9869e56140244d2b6b48a4c6efa46c1667
 SHA512:
-  metadata.gz: 1135ba02b878e0d772259545231aa89f950e11199a0ee8d982440b9040f9c575a077567f3cd404727b27eb6eb962d811c6b301f92ad2227817289851392cf6c9
-  data.tar.gz: fb95eca4f8aa3b013298c087209818c91338ef4f9fe2a843951777df4c17fbe9bf83fdc5b1b45447503d5e718c6059d8a57b888746a36f463c929d8965526b3a
+  metadata.gz: d392122de52073465642db7d78302e4bd7aecb9d9507b9d2189f02c3bc9332b47c9facc02a5c1f7771d8bc355e25fe7607bd0c56a655536031bac6257b9a6cd0
+  data.tar.gz: 5feae702d0c3f67142b70ea65b1b396ea34c352430db81749eecdcb636481cbb87aff026dad4012c89e8875f4a6395edca61ca0669859039e6d7912ebd65375e

data/README.md

@@ -195,6 +195,40 @@ feature.enable_for_ip_addresses('192.168.1.0/24', '10.0.0.1')
 feature.enable_for_custom_attribute(:subscription_tier, ['premium', 'enterprise'])
 ```
 
+### Wire Targeting Payload (control-plane APIs)
+
+For building flag-management endpoints on top of the gem (an internal panel,
+a sync job, any JSON API), two primitives implement the wire contract — the
+gem ships no routes, your app owns paths and auth:
+
+```ruby
+# GET side — full flag payload, string keys. The "targeting" key is ALWAYS
+# present ({} = no targeting); list rules are arrays of strings, percentages
+# floats. Rails-idiomatic: works with render json: directly.
+render json: Magick.features.values          # [{... "targeting" => {"user" => ["3"], "percentage_users" => 50.0}}, ...]
+
+# PATCH side — wholesale, declarative write: the payload IS the new targeting
+# state. Keys absent from the payload are removed; {} clears everything.
+feature.replace_targeting(payload['targeting'])
+```
+
+`replace_targeting` is lenient about input spellings (string or symbol keys,
+plural aliases like `users:`, scalars for lists, numeric strings) but strict
+about content: unknown keys or invalid values (percentage outside `(0, 100]`,
+malformed date ranges, junk IPs) raise `Magick::InvalidTargetingError`
+*before anything is applied* — map it to a 422:
+
+```ruby
+rescue Magick::InvalidTargetingError => e
+  render json: { error: e.message }, status: :unprocessable_entity
+```
+
+Each call records one audit entry and one version snapshot
+(`replace_targeting`). A/B variants are not part of the targeting payload —
+they never appear inside the wire `targeting` object and survive a replace
+untouched (manage them via `set_variants`). `enable`/`disable` still clear
+all targeting wholesale, so their wire representation is `"targeting": {}`.
+
 ### Feature Exclusions
 
 Exclusions let you block specific users, groups, roles, tags, or IP addresses from a feature — even if they match an inclusion rule. **Exclusions always take priority over inclusions.**
@@ -531,12 +565,58 @@ Magick.import(File.read('features.json'))
 
 #### Versioning and Rollback
 
+Every state-changing operation (value, status, group, targeting, exclusions,
+variants, dependencies, delete) automatically records a version snapshot and
+an audit entry — one per logical operation, under its real action name
+(`enable`, `exclude_user`, `set_status`, …). Nested internals never
+double-record.
+
 ```ruby
-# Save current state as version
+# History accumulates automatically:
+Magick[:my_feature].enable            # => version 1 (action: "enable")
+Magick[:my_feature].enable_for_user(42) # => version 2 (action: "enable_for_user")
+
+# Inspect history (hot window: last 50 versions by default)
+Magick.versioning.get_versions(:my_feature)
+
+# Include the unlimited ActiveRecord archive (when AR adapter is configured)
+Magick.versioning.get_versions(:my_feature, all: true)
+
+# Rollback fully restores a snapshot: value (including false/empty), status,
+# group, and the entire targeting hash — and records the rollback itself as a
+# new version, so history only ever rolls forward.
+Magick.versioning.rollback(:my_feature, 2)
+
+# Manual snapshots still work (action: "manual")
 Magick.versioning.save_version(:my_feature, created_by: current_user.id)
+```
 
-# Rollback to previous version
-Magick.versioning.rollback(:my_feature, version: 2)
+**Retention is tiered:** memory/Redis keep the last `max_versions` snapshots
+(default 50) for fast access; the ActiveRecord adapter keeps an unlimited
+archive that also survives feature deletion.
+
+```ruby
+Magick.configure do
+  versioning enabled: true, max_versions: 50
+end
+```
+
+**Attribution:** wrap changes in `Magick.with_actor` to stamp audit entries
+(`user_id`) and versions (`created_by`):
+
+```ruby
+Magick.with_actor(current_user.id) do
+  Magick[:my_feature].enable_for_user(42)
+end
+```
+
+**Boot replay is not recorded:** the Rails railtie loads `config/features.rb`
+inside `Magick.definition_mode`, so re-applying declarative definitions on
+every process boot does not flood history. Non-Rails apps should wrap their
+own definition file load the same way:
+
+```ruby
+Magick.definition_mode { load 'config/features.rb' }
 ```
 
 #### Performance Metrics
@@ -595,6 +675,11 @@ end
 
 #### Audit Logging
 
+Every mutation is logged under its real action name (`enable`, `disable`,
+`set_value`, `enable_for_user`, `exclude_role`, `set_status`, `set_group`,
+`delete`, `rollback`, …). One logical operation produces exactly one entry:
+`enable` no longer surfaces as a bare `set_value`.
+
 ```ruby
 # View audit log entries
 entries = Magick.audit_log.entries(feature_name: :my_feature, limit: 100)
@@ -603,6 +688,15 @@ entries.each do |entry|
 end
 ```
 
+In the Admin UI, configure a `current_actor` hook so every change made
+through the UI is attributed:
+
+```ruby
+Magick::AdminUI.configure do |config|
+  config.current_actor = ->(controller) { controller.session[:admin_id] }
+end
+```
+
 ## Architecture
 
 ### Adapters

data/app/controllers/magick/adminui/features_controller.rb

@@ -15,6 +15,9 @@ module Magick
       layout 'application'
       before_action :authenticate_admin!
       before_action :set_feature, only: %i[show edit update enable disable enable_for_user enable_for_role disable_for_role update_targeting update_variants]
+      # Attribute every change made during the request to the configured
+      # actor, so audit entries and version snapshots record who did it.
+      around_action :with_magick_actor
       # Render the TRUE current state, not this process's local cache. In a
       # multi-process / multi-container deployment the enable/disable POST and
       # the redirected GET are load-balanced to different processes, so the
@@ -39,8 +42,7 @@ module Magick
       end
 
       def partially_enabled?(feature)
-        targeting = feature.instance_variable_get(:@targeting) || {}
-        targeting.any? && !targeting.empty?
+        (feature.targeting || {}).any?
       end
 
       def index
@@ -129,7 +131,6 @@ module Magick
       end
 
       def update_targeting
-        # Handle targeting updates from form
         targeting_params = params[:targeting] || {}
         unless hash_like?(targeting_params)
           redirect_to magick_admin_ui.feature_path(@feature.name), alert: 'Invalid targeting payload.'
@@ -140,146 +141,13 @@ module Magick
         feature_name = @feature.name.to_s
         @feature = Magick.features[feature_name] if Magick.features.key?(feature_name)
 
-        current_targeting = @feature.instance_variable_get(:@targeting) || {}
-
-        # Handle roles - always clear existing and set new ones
-        # Rails checkboxes don't send unchecked values, so we need to check what was sent
-        current_roles = current_targeting[:role].is_a?(Array) ? current_targeting[:role] : (current_targeting[:role] ? [current_targeting[:role]] : [])
-        selected_roles = Array(targeting_params[:roles]).reject(&:blank?)
-
-        # Disable roles that are no longer selected
-        (current_roles - selected_roles).each do |role|
-          @feature.disable_for_role(role) if role.present?
-        end
-
-        # Enable newly selected roles
-        (selected_roles - current_roles).each do |role|
-          @feature.enable_for_role(role) if role.present?
-        end
-
-        # Handle tags - always clear existing and set new ones
-        # Rails checkboxes don't send unchecked values, so we need to check what was sent
-        current_tags = current_targeting[:tag].is_a?(Array) ? current_targeting[:tag] : (current_targeting[:tag] ? [current_targeting[:tag]] : [])
-        selected_tags = Array(targeting_params[:tags]).reject(&:blank?)
-
-        # Disable tags that are no longer selected
-        (current_tags - selected_tags).each do |tag|
-          @feature.disable_for_tag(tag) if tag.present?
-        end
-
-        # Enable newly selected tags
-        (selected_tags - current_tags).each do |tag|
-          @feature.enable_for_tag(tag) if tag.present?
-        end
-
-        # Handle user IDs - replace existing user targeting
-        if targeting_params[:user_ids].present?
-          user_ids = targeting_params[:user_ids].split(',').map(&:strip).reject(&:blank?)
-          current_user_ids = current_targeting[:user].is_a?(Array) ? current_targeting[:user] : (current_targeting[:user] ? [current_targeting[:user]] : [])
-
-          # Disable users that are no longer in the list
-          (current_user_ids - user_ids).each do |user_id|
-            @feature.disable_for_user(user_id) if user_id.present?
-          end
-
-          # Enable new users
-          (user_ids - current_user_ids).each do |user_id|
-            @feature.enable_for_user(user_id) if user_id.present?
-          end
-        elsif targeting_params.key?(:user_ids) && targeting_params[:user_ids].blank?
-          # Clear all user targeting if field was cleared
-          current_user_ids = current_targeting[:user].is_a?(Array) ? current_targeting[:user] : (current_targeting[:user] ? [current_targeting[:user]] : [])
-          current_user_ids.each do |user_id|
-            @feature.disable_for_user(user_id) if user_id.present?
-          end
-        end
-
-        # Handle percentage of users
-        percentage_users_value = targeting_params[:percentage_users]
-        if percentage_users_value.present? && percentage_users_value.to_s.strip != ''
-          percentage = percentage_users_value.to_f
-          if percentage > 0 && percentage <= 100
-            result = @feature.enable_percentage_of_users(percentage)
-            Rails.logger.debug "Magick: Enabled percentage_users #{percentage} for #{@feature.name}: #{result}" if defined?(Rails)
-          else
-            # Value is 0 or invalid - disable
-            @feature.disable_percentage_of_users
-          end
-        else
-          # Field is empty - disable if it was previously set
-          @feature.disable_percentage_of_users if current_targeting[:percentage_users]
-        end
-
-        # Handle percentage of requests
-        percentage_requests_value = targeting_params[:percentage_requests]
-        if percentage_requests_value.present? && percentage_requests_value.to_s.strip != ''
-          percentage = percentage_requests_value.to_f
-          if percentage > 0 && percentage <= 100
-            result = @feature.enable_percentage_of_requests(percentage)
-            Rails.logger.debug "Magick: Enabled percentage_requests #{percentage} for #{@feature.name}: #{result}" if defined?(Rails)
-          else
-            # Value is 0 or invalid - disable
-            @feature.disable_percentage_of_requests
-          end
-        else
-          # Field is empty - disable if it was previously set
-          @feature.disable_percentage_of_requests if current_targeting[:percentage_requests]
-        end
-
-        # Handle excluded user IDs
-        if targeting_params[:excluded_user_ids].present?
-          excluded_user_ids = targeting_params[:excluded_user_ids].split(',').map(&:strip).reject(&:blank?)
-          current_excluded_users = current_targeting[:excluded_users].is_a?(Array) ? current_targeting[:excluded_users] : (current_targeting[:excluded_users] ? [current_targeting[:excluded_users]] : [])
-
-          (current_excluded_users - excluded_user_ids).each do |user_id|
-            @feature.remove_user_exclusion(user_id) if user_id.present?
-          end
-
-          (excluded_user_ids - current_excluded_users).each do |user_id|
-            @feature.exclude_user(user_id) if user_id.present?
-          end
-        elsif targeting_params.key?(:excluded_user_ids) && targeting_params[:excluded_user_ids].blank?
-          current_excluded_users = current_targeting[:excluded_users].is_a?(Array) ? current_targeting[:excluded_users] : (current_targeting[:excluded_users] ? [current_targeting[:excluded_users]] : [])
-          current_excluded_users.each do |user_id|
-            @feature.remove_user_exclusion(user_id) if user_id.present?
-          end
-        end
-
-        # Handle excluded roles
-        current_excluded_roles = current_targeting[:excluded_roles].is_a?(Array) ? current_targeting[:excluded_roles] : (current_targeting[:excluded_roles] ? [current_targeting[:excluded_roles]] : [])
-        selected_excluded_roles = Array(targeting_params[:excluded_roles]).reject(&:blank?)
-
-        (current_excluded_roles - selected_excluded_roles).each do |role|
-          @feature.remove_role_exclusion(role) if role.present?
-        end
-
-        (selected_excluded_roles - current_excluded_roles).each do |role|
-          @feature.exclude_role(role) if role.present?
-        end
-
-        # Handle excluded tags
-        current_excluded_tags = current_targeting[:excluded_tags].is_a?(Array) ? current_targeting[:excluded_tags] : (current_targeting[:excluded_tags] ? [current_targeting[:excluded_tags]] : [])
-        selected_excluded_tags = Array(targeting_params[:excluded_tags]).reject(&:blank?)
-
-        (current_excluded_tags - selected_excluded_tags).each do |tag|
-          @feature.remove_tag_exclusion(tag) if tag.present?
-        end
-
-        (selected_excluded_tags - current_excluded_tags).each do |tag|
-          @feature.exclude_tag(tag) if tag.present?
-        end
-
-        # After all targeting updates, ensure we're using the registered feature instance
-        # and reload it to get the latest state from adapter
-        feature_name = @feature.name.to_s
-        if Magick.features.key?(feature_name)
-          @feature = Magick.features[feature_name]
-          @feature.reload
-        else
-          @feature.reload
-        end
+        # One declarative write: one audit entry + one version per submit.
+        @feature.replace_targeting(desired_targeting_from_form(targeting_params))
+        @feature.reload
 
         redirect_to magick_admin_ui.feature_path(@feature.name), notice: 'Targeting updated successfully'
+      rescue Magick::InvalidTargetingError => e
+        redirect_to magick_admin_ui.feature_path(@feature.name), alert: "Invalid targeting: #{e.message}"
       rescue StandardError => e
         Rails.logger.error "Magick: Error updating targeting for #{@feature.name}: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}" if defined?(Rails)
         redirect_to magick_admin_ui.feature_path(@feature.name), alert: 'Could not update targeting — see server logs for details.'
@@ -319,8 +187,72 @@ module Magick
         redirect_to magick_admin_ui.feature_path(@feature.name), alert: 'Could not update variants — see server logs for details.'
       end
 
+      # Targeting rules the edit form has no fields for. They are carried over
+      # from the current state on every submit so a form save can never
+      # silently destroy them. (:variants is preserved by replace_targeting
+      # itself.)
+      FORM_UNMANAGED_TARGETING_KEYS = %i[
+        group excluded_groups ip_address excluded_ip_addresses
+        date_range custom_attributes complex_conditions
+      ].freeze
+
       private
 
+      # Build the full desired targeting state from the edit form. Checkbox
+      # groups (roles/tags and their exclusions) and the percentage fields are
+      # authoritative on every submit — unchecked/blank means "remove the
+      # rule". The comma-separated user lists are only authoritative when
+      # their field was actually sent. Percentages stay lenient here (blank
+      # or out-of-range clears the rule, as the form always behaved) —
+      # strict validation is for API callers of replace_targeting.
+      def desired_targeting_from_form(targeting_params)
+        current = @feature.targeting || {}
+        desired = {}
+        FORM_UNMANAGED_TARGETING_KEYS.each { |key| desired[key] = current[key] if current.key?(key) }
+
+        desired[:role] = Array(targeting_params[:roles]).reject(&:blank?)
+        desired[:tag] = Array(targeting_params[:tags]).reject(&:blank?)
+        desired[:excluded_roles] = Array(targeting_params[:excluded_roles]).reject(&:blank?)
+        desired[:excluded_tags] = Array(targeting_params[:excluded_tags]).reject(&:blank?)
+
+        desired[:user] = csv_ids(targeting_params, :user_ids, current[:user])
+        desired[:excluded_users] = csv_ids(targeting_params, :excluded_user_ids, current[:excluded_users])
+
+        desired[:percentage_users] = form_percentage(targeting_params[:percentage_users])
+        desired[:percentage_requests] = form_percentage(targeting_params[:percentage_requests])
+
+        desired.compact
+      end
+
+      def csv_ids(targeting_params, field, current_value)
+        return Array(current_value) unless targeting_params.key?(field)
+
+        targeting_params[field].to_s.split(',').map(&:strip).reject(&:blank?)
+      end
+
+      def form_percentage(raw)
+        return nil if raw.blank?
+
+        percentage = raw.to_f
+        percentage.positive? && percentage <= 100 ? percentage : nil
+      end
+
+      # Resolve the acting admin via the configurable AdminUI hook and run the
+      # action inside Magick.with_actor. A failing resolver only costs
+      # attribution — it must never 500 the admin UI, and it is rescued
+      # separately so an action error is never swallowed or re-run.
+      def with_magick_actor(&block)
+        actor = begin
+          resolver = Magick::AdminUI.config.current_actor
+          resolver.respond_to?(:call) ? resolver.call(self) : nil
+        rescue StandardError => e
+          Rails.logger.warn "Magick: current_actor hook failed: #{e.class}: #{e.message}" if defined?(Rails)
+          nil
+        end
+
+        actor ? Magick.with_actor(actor, &block) : yield
+      end
+
       def authenticate_admin!
         return unless Magick::AdminUI.config.require_role
 

data/config/magick.rb.example

@@ -20,11 +20,13 @@ Magick.configure do
   # Enable performance metrics tracking
   performance_metrics enabled: true
 
-  # Enable audit logging
+  # Enable audit logging (every mutation is logged under its real action name)
   audit_log enabled: true
 
-  # Enable versioning support
-  versioning enabled: true
+  # Enable versioning (every save creates a version snapshot; allows rollback)
+  # max_versions caps the hot window kept in memory/Redis; the ActiveRecord
+  # adapter keeps an unlimited archive.
+  versioning enabled: true, max_versions: 50
 
   # Enable deprecation warnings
   warn_on_deprecated true

data/lib/generators/magick/install/templates/magick.rb

@@ -23,11 +23,13 @@ Magick.configure do
   # Enable performance metrics tracking
   performance_metrics enabled: true
 
-  # Enable audit logging (tracks who changed what, when)
+  # Enable audit logging (every mutation is logged under its real action name)
   audit_log enabled: true
 
-  # Enable versioning support (allows rollback)
-  versioning enabled: true
+  # Enable versioning (every save creates a version snapshot; allows rollback)
+  # max_versions caps the hot window kept in memory/Redis; the ActiveRecord
+  # adapter keeps an unlimited archive.
+  versioning enabled: true, max_versions: 50
 
   # Enable deprecation warnings in logs
   warn_on_deprecated enabled: true

data/lib/magick/adapters/registry.rb

@@ -176,7 +176,9 @@ module Magick
         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
+        # Version history is stored under a reserved pseudo-feature namespace;
+        # it is bookkeeping, not a feature.
+        features.uniq.reject { |f| f.to_s.start_with?(Versioning::STORE_PREFIX) }
       end
 
       # Load all keys for a single feature in one call instead of N separate get() calls
@@ -357,9 +359,13 @@ module Magick
         end
       end
 
+      # Public so Versioning can apply tiered retention: hot window written to
+      # memory/Redis, unlimited archive written to ActiveRecord only.
+      attr_reader :memory_adapter, :redis_adapter, :active_record_adapter
+
       private
 
-      attr_reader :memory_adapter, :redis_adapter, :active_record_adapter, :circuit_breaker
+      attr_reader :circuit_breaker
 
       # Signal the subscribe loop to return, then close the connection so any
       # retry/reconnect attempt fails fast instead of sleeping for 5s.

data/lib/magick/admin_ui.rb

@@ -17,7 +17,7 @@ module Magick
       end
 
       class Configuration
-        attr_accessor :theme, :brand_name, :require_role, :available_roles, :available_tags
+        attr_accessor :theme, :brand_name, :require_role, :available_roles, :available_tags, :current_actor
 
         def initialize
           @theme = :light
@@ -25,6 +25,10 @@ module Magick
           @require_role = nil
           @available_roles = [] # Can be populated via DSL: admin_ui { roles ['admin', 'user', 'manager'] }
           @available_tags = nil # Can be array or lambda: -> { Tag.all }
+          # Lambda receiving the controller, returning who is making the
+          # change; stamped onto audit entries (user_id) and versions
+          # (created_by): -> (controller) { controller.current_user&.id }
+          @current_actor = nil
         end
 
         # Get available tags, calling lambda if needed

data/lib/magick/config.rb

@@ -135,8 +135,11 @@ module Magick
                    end
     end
 
-    def versioning(enabled: true)
-      @versioning = (Versioning.new(adapter_registry || default_adapter_registry) if enabled)
+    def versioning(enabled: true, max_versions: Versioning::DEFAULT_MAX_VERSIONS)
+      @versioning_enabled = enabled
+      @versioning = if enabled
+                      Versioning.new(adapter_registry || default_adapter_registry, max_versions: max_versions)
+                    end
     end
 
     def circuit_breaker(threshold: nil, timeout: nil)
@@ -186,8 +189,11 @@ module Magick
         end
       end
 
-      Magick.audit_log = audit_log if audit_log
-      Magick.versioning = versioning if versioning
+      # Read the ivars directly: calling the DSL methods here would re-run
+      # them with their defaults and stomp explicit `enabled: false` settings.
+      Magick.audit_log = @audit_log if @audit_log
+      Magick.versioning = @versioning if @versioning
+      Magick.versioning_enabled = @versioning_enabled unless @versioning_enabled.nil?
       Magick.warn_on_deprecated = warn_on_deprecated
     end
 

data/lib/magick/errors.rb

@@ -5,5 +5,9 @@ module Magick
   class FeatureNotFoundError < Error; end
   class InvalidFeatureTypeError < Error; end
   class InvalidFeatureValueError < Error; end
+  # Raised by Feature#replace_targeting when a wire targeting payload
+  # contains unknown keys or invalid values. Nothing is applied on failure,
+  # so API callers can map it straight to a 422.
+  class InvalidTargetingError < Error; end
   class AdapterError < Error; end
 end

data/lib/magick/export_import.rb

@@ -103,55 +103,18 @@ module Magick
       feature.set_value(value) if !value.nil? && !(value.is_a?(String) && value.empty?)
     end
 
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/CyclomaticComplexity
     def self.apply_targeting(feature, targeting)
-      targeting.each do |type, values|
-        case type.to_sym
-        when :user, :users
-          Array(values).each { |v| feature.enable_for_user(v) }
-        when :excluded_users
-          Array(values).each { |v| feature.exclude_user(v) }
-        when :group, :groups
-          Array(values).each { |v| feature.enable_for_group(v) }
-        when :excluded_groups
-          Array(values).each { |v| feature.exclude_group(v) }
-        when :role, :roles
-          Array(values).each { |v| feature.enable_for_role(v) }
-        when :excluded_roles
-          Array(values).each { |v| feature.exclude_role(v) }
-        when :tag, :tags
-          Array(values).each { |v| feature.enable_for_tag(v) }
-        when :excluded_tags
-          Array(values).each { |v| feature.exclude_tag(v) }
-        when :ip_address, :ip_addresses
-          feature.enable_for_ip_addresses(Array(values))
-        when :excluded_ip_addresses
-          feature.exclude_ip_addresses(Array(values))
-        when :percentage_users
-          feature.enable_percentage_of_users(values)
-        when :percentage_requests
-          feature.enable_percentage_of_requests(values)
-        when :date_range
-          range = values.is_a?(Hash) ? values.transform_keys(&:to_sym) : values
-          feature.enable_for_date_range(range[:start], range[:end]) if range.is_a?(Hash) && range[:start] && range[:end]
-        when :custom_attributes
-          apply_custom_attributes(feature, values)
-        end
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/CyclomaticComplexity
+      return unless targeting.is_a?(Hash)
 
-    def self.apply_custom_attributes(feature, values)
-      return unless values.is_a?(Hash)
+      # Exports from gem versions where variants leaked into the targeting
+      # hash must stay importable; variants are applied separately from the
+      # top-level key.
+      payload = targeting.reject { |key, _| key.to_s == 'variants' }
+      return if payload.empty?
 
-      values.each do |attr, rule|
-        rule_h = rule.is_a?(Hash) ? rule.transform_keys(&:to_sym) : {}
-        next unless rule_h[:values]
-
-        feature.enable_for_custom_attribute(attr, rule_h[:values], operator: (rule_h[:operator] || :equals).to_sym)
-      end
+      feature.replace_targeting(payload)
+    rescue Magick::InvalidTargetingError => e
+      raise ImportError, "Magick.import: invalid targeting for '#{feature.name}': #{e.message}"
     end
 
     def self.apply_variants(feature, variants)