magick-feature-flags 0.7.0

data/lib/magick/performance_metrics.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Magick
+  class PerformanceMetrics
+    class Metric
+      attr_reader :feature_name, :operation, :duration, :timestamp, :success
+
+      def initialize(feature_name, operation, duration, success: true)
+        @feature_name = feature_name.to_s
+        @operation = operation.to_s
+        @duration = duration
+        @timestamp = Time.now
+        @success = success
+      end
+
+      def to_h
+        {
+          feature_name: feature_name,
+          operation: operation,
+          duration: duration,
+          timestamp: timestamp.iso8601,
+          success: success
+        }
+      end
+    end
+
+    def initialize
+      @metrics = []
+      @mutex = Mutex.new
+      @usage_count = Hash.new(0)
+    end
+
+    def record(feature_name, operation, duration, success: true)
+      metric = Metric.new(feature_name, operation, duration, success: success)
+      @mutex.synchronize do
+        @metrics << metric
+        @usage_count[feature_name.to_s] += 1
+        # Keep only last 1000 metrics
+        @metrics.shift if @metrics.length > 1000
+      end
+
+      # Rails 8+ event for usage tracking
+      if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
+        Magick::Rails::Events.usage_tracked(feature_name, operation: operation, duration: duration, success: success)
+      end
+
+      metric
+    end
+
+    def average_duration(feature_name: nil, operation: nil)
+      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
+    end
+
+    def usage_count(feature_name)
+      @usage_count[feature_name.to_s] || 0
+    end
+
+    def most_used_features(limit: 10)
+      @usage_count.sort_by { |_name, count| -count }.first(limit).to_h
+    end
+
+    def clear!
+      @mutex.synchronize do
+        @metrics.clear
+        @usage_count.clear
+      end
+    end
+  end
+end

data/lib/magick/rails/event_subscriber.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Magick
+  module Rails
+    # Example event subscriber for Rails 8.1+ structured events
+    # Users can create custom subscribers to handle Magick events
+    class EventSubscriber
+      def initialize
+        @subscribed = false
+      end
+
+      # Subscribe to all Magick events
+      def subscribe_to_all
+        return unless Events.rails81?
+
+        Events::EVENTS.each_value do |event_name|
+          subscribe_to(event_name)
+        end
+        @subscribed = true
+      end
+
+      # Subscribe to a specific event
+      def subscribe_to(event_name, &block)
+        return unless Events.rails81?
+
+        full_event_name = Events::EVENTS[event_name] || event_name.to_s
+        Rails.event.subscribe(full_event_name, self)
+      end
+
+      # Implement the emit method required by Rails 8.1 event system
+      def emit(event)
+        # event is a hash with :name, :payload, :source_location, :tags, :context
+        handle_event(event)
+      end
+
+      private
+
+      def handle_event(event)
+        # Default handler - users can override
+        Rails.logger&.info "Magick Event: #{event[:name]} - #{event[:payload].inspect}"
+      end
+    end
+
+    # Default log subscriber for Magick events
+    class LogSubscriber
+      def emit(event)
+        payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(" ")
+        source_location = event[:source_location]
+        log = "[#{event[:name]}] #{payload}"
+        log += " at #{source_location[:filepath]}:#{source_location[:lineno]}" if source_location
+        Rails.logger&.info(log)
+      end
+    end
+  end
+end

data/lib/magick/rails/events.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Magick
+  module Rails
+    module Events
+      # Check if Rails 8.1+ structured events are available
+      def self.rails81?
+        defined?(Rails) && Rails.respond_to?(:event) && Rails.event.respond_to?(:notify)
+      end
+
+      # Event names (using Rails 8.1 structured event format)
+      EVENT_PREFIX = 'magick.feature_flag'
+
+      EVENTS = {
+        changed: "#{EVENT_PREFIX}.changed",
+        enabled: "#{EVENT_PREFIX}.enabled",
+        disabled: "#{EVENT_PREFIX}.disabled",
+        enabled_globally: "#{EVENT_PREFIX}.enabled_globally",
+        disabled_globally: "#{EVENT_PREFIX}.disabled_globally",
+        dependency_added: "#{EVENT_PREFIX}.dependency_added",
+        dependency_removed: "#{EVENT_PREFIX}.dependency_removed",
+        variant_set: "#{EVENT_PREFIX}.variant_set",
+        variant_selected: "#{EVENT_PREFIX}.variant_selected",
+        targeting_added: "#{EVENT_PREFIX}.targeting_added",
+        targeting_removed: "#{EVENT_PREFIX}.targeting_removed",
+        version_saved: "#{EVENT_PREFIX}.version_saved",
+        rollback: "#{EVENT_PREFIX}.rollback",
+        exported: "#{EVENT_PREFIX}.exported",
+        imported: "#{EVENT_PREFIX}.imported",
+        audit_logged: "#{EVENT_PREFIX}.audit_logged",
+        usage_tracked: "#{EVENT_PREFIX}.usage_tracked",
+        deprecated_warning: "#{EVENT_PREFIX}.deprecated_warning"
+      }.freeze
+
+      def self.notify(event_name, payload = {})
+        return unless rails81?
+
+        event_name_str = EVENTS[event_name] || event_name.to_s
+        Rails.event.notify(event_name_str, payload)
+      end
+
+      # Backward compatibility alias
+      def self.rails8?
+        rails81?
+      end
+
+      # Feature flag changed (value, status, etc.)
+      def self.feature_changed(feature_name, changes:, user_id: nil, **metadata)
+        notify(:changed, {
+                 feature_name: feature_name.to_s,
+                 changes: changes,
+                 user_id: user_id,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Feature enabled
+      def self.feature_enabled(feature_name, context: {}, **metadata)
+        notify(:enabled, {
+                 feature_name: feature_name.to_s,
+                 context: context,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Feature disabled
+      def self.feature_disabled(feature_name, context: {}, **metadata)
+        notify(:disabled, {
+                 feature_name: feature_name.to_s,
+                 context: context,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Feature enabled globally (no targeting)
+      def self.feature_enabled_globally(feature_name, user_id: nil, **metadata)
+        notify(:enabled_globally, {
+                 feature_name: feature_name.to_s,
+                 user_id: user_id,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Feature disabled globally (no targeting)
+      def self.feature_disabled_globally(feature_name, user_id: nil, **metadata)
+        notify(:disabled_globally, {
+                 feature_name: feature_name.to_s,
+                 user_id: user_id,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Dependency added
+      def self.dependency_added(feature_name, dependency_name, **metadata)
+        notify(:dependency_added, {
+                 feature_name: feature_name.to_s,
+                 dependency_name: dependency_name.to_s,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Dependency removed
+      def self.dependency_removed(feature_name, dependency_name, **metadata)
+        notify(:dependency_removed, {
+                 feature_name: feature_name.to_s,
+                 dependency_name: dependency_name.to_s,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Variants set
+      def self.variant_set(feature_name, variants:, **metadata)
+        notify(:variant_set, {
+                 feature_name: feature_name.to_s,
+                 variants: variants.is_a?(Array) ? variants.map(&:to_h) : variants,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Variant selected
+      def self.variant_selected(feature_name, variant_name:, context: {}, **metadata)
+        notify(:variant_selected, {
+                 feature_name: feature_name.to_s,
+                 variant_name: variant_name.to_s,
+                 context: context,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Targeting added
+      def self.targeting_added(feature_name, targeting_type:, targeting_value:, **metadata)
+        notify(:targeting_added, {
+                 feature_name: feature_name.to_s,
+                 targeting_type: targeting_type.to_s,
+                 targeting_value: targeting_value,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Targeting removed
+      def self.targeting_removed(feature_name, targeting_type:, targeting_value: nil, **metadata)
+        notify(:targeting_removed, {
+                 feature_name: feature_name.to_s,
+                 targeting_type: targeting_type.to_s,
+                 targeting_value: targeting_value,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Version saved
+      def self.version_saved(feature_name, version:, created_by: nil, **metadata)
+        notify(:version_saved, {
+                 feature_name: feature_name.to_s,
+                 version: version,
+                 created_by: created_by,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Rollback performed
+      def self.rollback(feature_name, version:, **metadata)
+        notify(:rollback, {
+                 feature_name: feature_name.to_s,
+                 version: version,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Export performed
+      def self.exported(format:, feature_count:, **metadata)
+        notify(:exported, {
+                 format: format.to_s,
+                 feature_count: feature_count,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Import performed
+      def self.imported(format:, feature_count:, **metadata)
+        notify(:imported, {
+                 format: format.to_s,
+                 feature_count: feature_count,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Audit log entry created
+      def self.audit_logged(feature_name, action:, user_id: nil, changes: {}, **metadata)
+        notify(:audit_logged, {
+                 feature_name: feature_name.to_s,
+                 action: action.to_s,
+                 user_id: user_id,
+                 changes: changes,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Usage tracked
+      def self.usage_tracked(feature_name, operation:, duration:, success: true, **metadata)
+        notify(:usage_tracked, {
+                 feature_name: feature_name.to_s,
+                 operation: operation.to_s,
+                 duration: duration,
+                 success: success,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+
+      # Deprecation warning
+      def self.deprecated_warning(feature_name, **metadata)
+        notify(:deprecated_warning, {
+                 feature_name: feature_name.to_s,
+                 timestamp: Time.now.iso8601,
+                 **metadata
+               })
+      end
+    end
+  end
+end

data/lib/magick/rails/railtie.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+if defined?(Rails)
+  require 'magick'
+  require 'magick/dsl'
+  require_relative 'events'
+
+  module Magick
+    module Rails
+      class Railtie < ::Rails::Railtie
+        # Make DSL available early so it works in config/initializers/features.rb
+        initializer 'magick.dsl', before: :load_config_initializers do
+          # Ensure DSL is available globally for initializers
+          Object.class_eval { include Magick::DSL } unless Object.included_modules.include?(Magick::DSL)
+        end
+
+        initializer 'magick.configure' do |app|
+          # Configure Magick with Rails-specific settings
+          Magick.configure do |config|
+            # Use Redis if available, otherwise fall back to memory
+            if defined?(Redis)
+              begin
+                redis_url = app.config.respond_to?(:redis_url) ? app.config.redis_url : nil
+                redis_client = redis_url ? ::Redis.new(url: redis_url) : ::Redis.new
+                memory_adapter = Adapters::Memory.new
+                redis_adapter = Adapters::Redis.new(redis_client)
+                config.adapter_registry = Adapters::Registry.new(memory_adapter, redis_adapter)
+              rescue StandardError => e
+                Rails.logger&.warn "Magick: Failed to initialize Redis adapter: #{e.message}. Using memory-only adapter."
+              end
+            end
+          end
+
+          # Load features from DSL file if it exists
+          # Supports both config/features.rb and config/initializers/features.rb
+          config.after_initialize do
+            # Try config/features.rb first (recommended location)
+            features_file = Rails.root.join('config', 'features.rb')
+            if File.exist?(features_file)
+              load features_file
+            else
+              # Fallback to config/initializers/features.rb (already loaded by Rails, but check anyway)
+              initializer_file = Rails.root.join('config', 'initializers', 'features.rb')
+              if File.exist?(initializer_file)
+                # Only load if not already loaded (Rails may have already loaded it)
+                load initializer_file unless defined?(Magick::Rails::FeaturesLoaded)
+              end
+            end
+            Magick::Rails.const_set(:FeaturesLoaded, true) rescue nil
+          end
+        end
+
+        # Preload features in request store
+        config.to_prepare do
+          if defined?(RequestStore)
+            RequestStore.store[:magick_features] ||= {}
+          end
+        end
+      end
+    end
+
+    # Request store integration
+    module RequestStoreIntegration
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def enabled?(feature_name, context = {})
+          # Check request store cache first
+          if defined?(RequestStore)
+            cache_key = "#{feature_name}:#{context.hash}"
+            cached = RequestStore.store[:magick_features]&.[](cache_key)
+            return cached unless cached.nil?
+          end
+
+          # Check feature
+          result = super(feature_name, context)
+
+          # Cache in request store
+          if defined?(RequestStore)
+            RequestStore.store[:magick_features] ||= {}
+            RequestStore.store[:magick_features][cache_key] = result
+          end
+
+          result
+        end
+      end
+    end
+  end
+
+  # Extend Magick module with request store integration
+  Magick.extend(Magick::Rails::RequestStoreIntegration)
+end

data/lib/magick/rails.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Rails integration is now in lib/magick/rails/railtie.rb
+# This file is kept for backward compatibility
+if defined?(Rails)
+  require_relative 'rails/railtie'
+end

data/lib/magick/targeting/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class Base
+      def matches?(context)
+        raise NotImplementedError, "#{self.class} must implement #matches?"
+      end
+    end
+  end
+end

data/lib/magick/targeting/complex.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class Complex < Base
+      def initialize(conditions, operator: :and)
+        @conditions = Array(conditions)
+        @operator = operator.to_sym
+      end
+
+      def matches?(context)
+        return false if @conditions.empty?
+
+        results = @conditions.map { |condition| condition.matches?(context) }
+
+        case @operator
+        when :and, :all
+          results.all?
+        when :or, :any
+          results.any?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/magick/targeting/custom_attribute.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class CustomAttribute < Base
+      def initialize(attribute_name, values, operator: :equals)
+        @attribute_name = attribute_name.to_sym
+        @values = Array(values)
+        @operator = operator.to_sym
+      end
+
+      def matches?(context)
+        context_value = context[@attribute_name] || context[@attribute_name.to_s]
+        return false if context_value.nil?
+
+        case @operator
+        when :equals, :eq
+          @values.include?(context_value.to_s)
+        when :not_equals, :ne
+          !@values.include?(context_value.to_s)
+        when :in
+          @values.include?(context_value.to_s)
+        when :not_in
+          !@values.include?(context_value.to_s)
+        when :greater_than, :gt
+          context_value.to_f > @values.first.to_f
+        when :less_than, :lt
+          context_value.to_f < @values.first.to_f
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/magick/targeting/date_range.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class DateRange < Base
+      def initialize(start_date, end_date)
+        @start_date = start_date.is_a?(String) ? Time.parse(start_date) : start_date
+        @end_date = end_date.is_a?(String) ? Time.parse(end_date) : end_date
+      end
+
+      def matches?(_context)
+        now = Time.now
+        now >= @start_date && now <= @end_date
+      end
+    end
+  end
+end

data/lib/magick/targeting/group.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class Group < Base
+      def initialize(group_name)
+        @group_name = group_name.to_s
+      end
+
+      def matches?(context)
+        context[:group]&.to_s == @group_name
+      end
+    end
+  end
+end

data/lib/magick/targeting/ip_address.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Magick
+  module Targeting
+    class IpAddress < Base
+      def initialize(ip_addresses)
+        @ip_addresses = Array(ip_addresses).map { |ip| IPAddr.new(ip) }
+      end
+
+      def matches?(context)
+        return false unless context[:ip_address]
+
+        client_ip = IPAddr.new(context[:ip_address])
+        @ip_addresses.any? { |ip| ip.include?(client_ip) }
+      rescue IPAddr::InvalidAddressError
+        false
+      end
+    end
+  end
+end

data/lib/magick/targeting/percentage.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Magick
+  module Targeting
+    class Percentage < Base
+      def initialize(percentage, feature_name, user_id = nil)
+        @percentage = percentage.to_f
+        @feature_name = feature_name.to_s
+        @user_id = user_id&.to_s
+      end
+
+      def matches?(context)
+        user_id = (@user_id || context[:user_id])&.to_s
+        return false unless user_id
+
+        hash = Digest::MD5.hexdigest("#{@feature_name}:#{user_id}")
+        hash_value = hash[0..7].to_i(16)
+        (hash_value % 100) < @percentage
+      end
+    end
+  end
+end

data/lib/magick/targeting/request_percentage.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class RequestPercentage < Base
+      def initialize(percentage)
+        @percentage = percentage.to_f
+      end
+
+      def matches?(_context)
+        rand(100) < @percentage
+      end
+    end
+  end
+end

data/lib/magick/targeting/role.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class Role < Base
+      def initialize(role_name)
+        @role_name = role_name.to_s
+      end
+
+      def matches?(context)
+        context[:role]&.to_s == @role_name
+      end
+    end
+  end
+end

data/lib/magick/targeting/user.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Magick
+  module Targeting
+    class User < Base
+      def initialize(user_id)
+        @user_id = user_id.to_s
+      end
+
+      def matches?(context)
+        context[:user_id]&.to_s == @user_id
+      end
+    end
+  end
+end