featureflip 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 681f3a17deed31dc5488ce422a58c1bdf6efe2d8af6edcf2fb7551b97552d3db
-  data.tar.gz: 9ea0d5f7091be0e8152a6a58a651053c2e5112486d1398d4c146001aae91c5bc
+  metadata.gz: 74310b5e1a7545b5d289a4f09d32c7e396f3f03bcb5af9265fe970667f2aedfd
+  data.tar.gz: 6f0fd700429f63dbba04b3311c88700e9281113f0b114a6c635797745ca1cddc
 SHA512:
-  metadata.gz: 0ec0ea000a63091c062a807dc5c5c212bc6735ea726278e50f21a9705e2d1860550736e1a8c506732ee4f961922dcba6069721951811de3696180ab703dee601
-  data.tar.gz: d26be8ff065c4efd45566342e8d7f1f39f461e0c0393202ac5e61edb85960f404b957900f2b925ba0eb9ab7ed41f7764486704ef39e5efad66ccc40c96a75510
+  metadata.gz: 6eb646f7ba550b44639e2d294ad8b171d2a9931f5004afcdb7621db46abc18dfa047732da544e74a9167a509da1fd5018e71e49f7126e0753ee87f8ac9e2bccf
+  data.tar.gz: ca59f44a28682ac0fcc5924d4a19e3bb9df8ae76809dfa133f34a57d4bf24243e3cf4b2b7a7f82a54efc0249653a6d54a1fd6ca4c5d0b685fbe2438282e27776

data/lib/featureflip/client.rb

@@ -1,247 +1,86 @@
-require "timeout"
-
 module Featureflip
   class Client
-    attr_reader :initialized
-    alias_method :initialized?, :initialized
+    private_class_method :new
 
-    def initialize(sdk_key: nil, config: nil)
-      @sdk_key = sdk_key || ENV["FEATUREFLIP_SDK_KEY"]
-      raise ConfigurationError, "SDK key is required. Pass sdk_key parameter or set FEATUREFLIP_SDK_KEY env var." unless @sdk_key
+    def self.get(sdk_key = nil, config: nil)
+      sdk_key ||= ENV["FEATUREFLIP_SDK_KEY"]
+      raise ConfigurationError, "SDK key is required. Pass sdk_key parameter or set FEATUREFLIP_SDK_KEY env var." unless sdk_key
 
-      @config = config || Config.new
-      @store = Store::FlagStore.new
-      @evaluator = Evaluation::Evaluator.new
-      @initialized = false
-      @closed = false
-      @test_mode = false
-      @test_values = {}
-      @http_client = nil
-      @streaming_handler = nil
-      @polling_handler = nil
-      @event_processor = nil
-
-      initialize!
+      config ||= Config.new
+      core = SharedCore._get_or_create(sdk_key, config)
+      new(core)
+    end
+
+    def self.for_testing(flags)
+      core = SharedCore._create_for_testing(flags)
+      new(core)
+    end
+
+    def initialized?
+      @core.initialized?
     end
 
     def bool_variation(key, context, default_value)
-      evaluate_flag(key, context, default_value)
+      return default_value if @closed
+      @core.bool_variation(key, context, default_value)
     end
 
     def string_variation(key, context, default_value)
-      evaluate_flag(key, context, default_value)
+      return default_value if @closed
+      @core.string_variation(key, context, default_value)
     end
 
     def number_variation(key, context, default_value)
-      evaluate_flag(key, context, default_value)
+      return default_value if @closed
+      @core.number_variation(key, context, default_value)
     end
 
     def json_variation(key, context, default_value)
-      evaluate_flag(key, context, default_value)
+      return default_value if @closed
+      @core.json_variation(key, context, default_value)
     end
 
     def variation_detail(key, context, default_value)
-      context = normalize_context(context)
-
-      if @test_mode
-        value = @test_values.fetch(key, default_value)
-        reason = @test_values.key?(key) ? "Fallthrough" : "FlagNotFound"
-        return Models::EvaluationDetail.new(value: value, reason: reason)
-      end
-
-      flag = @store.get_flag(key)
-      unless flag
-        record_evaluation(key, context, nil)
-        return Models::EvaluationDetail.new(value: default_value, reason: "FlagNotFound")
+      if @closed
+        return Models::EvaluationDetail.new(value: default_value, reason: "Error")
       end
-
-      result = @evaluator.evaluate(flag, context, get_segment: method(:get_segment))
-      value = result.value.nil? ? default_value : result.value
-      record_evaluation(key, context, result.variation_key)
-
-      Models::EvaluationDetail.new(
-        value: value,
-        reason: result.reason,
-        rule_id: result.rule_id,
-        variation_key: result.variation_key
-      )
-    rescue StandardError
-      Models::EvaluationDetail.new(value: default_value, reason: "Error")
+      @core.variation_detail(key, context, default_value)
     end
 
     def track(event_key, context, metadata = nil)
-      return unless @event_processor
-
-      context = normalize_context(context)
-      @event_processor.queue_event({
-        type: "Custom",
-        flagKey: event_key,
-        userId: context["user_id"]&.to_s,
-        metadata: metadata || {},
-        timestamp: Time.now.utc.iso8601
-      })
+      return if @closed
+      @core.track(event_key, context, metadata)
     end
 
     def identify(context)
-      return unless @event_processor
-
-      context = normalize_context(context)
-      @event_processor.queue_event({
-        type: "Identify",
-        flagKey: "$identify",
-        userId: context["user_id"]&.to_s,
-        timestamp: Time.now.utc.iso8601
-      })
+      return if @closed
+      @core.identify(context)
     end
 
     def flush
-      @event_processor&.flush
+      return if @closed
+      @core.flush
     end
 
     def close
-      @closed = true
-      @streaming_handler&.stop
-      @streaming_handler = nil
-      @polling_handler&.stop
-      @polling_handler = nil
-      @event_processor&.stop
-      @event_processor = nil
+      @close_mutex.synchronize do
+        return if @closed
+        @closed = true
+      end
+      @core._release
     end
 
     def restart
       return if @closed
-
-      @streaming_handler&.stop
-      @polling_handler&.stop
-      @event_processor&.stop
-
-      if @config.streaming
-        start_streaming
-      else
-        start_polling
-      end
-      start_event_processor if @config.send_events
-    end
-
-    def self.for_testing(flags)
-      instance = allocate
-      instance.instance_variable_set(:@sdk_key, "test-key")
-      instance.instance_variable_set(:@config, Config.new)
-      instance.instance_variable_set(:@store, Store::FlagStore.new)
-      instance.instance_variable_set(:@evaluator, Evaluation::Evaluator.new)
-      instance.instance_variable_set(:@initialized, true)
-      instance.instance_variable_set(:@closed, false)
-      instance.instance_variable_set(:@test_mode, true)
-      instance.instance_variable_set(:@test_values, flags.dup)
-      instance.instance_variable_set(:@http_client, nil)
-      instance.instance_variable_set(:@streaming_handler, nil)
-      instance.instance_variable_set(:@polling_handler, nil)
-      instance.instance_variable_set(:@event_processor, nil)
-      instance
+      @core.restart
     end
 
     private
 
-    def initialize!
-      @http_client = Http::Client.new(@sdk_key, @config)
-      fetch_initial_flags
-      start_data_source
-      start_event_processor if @config.send_events
-    end
-
-    def fetch_initial_flags
-      Timeout.timeout(@config.init_timeout) do
-        flags, segments = @http_client.get_flags
-        @store.init(flags, segments)
-        @initialized = true
-      end
-    rescue Timeout::Error
-      raise InitializationError, "Initialization timed out after #{@config.init_timeout}s"
-    rescue InitializationError
-      raise
-    rescue StandardError => e
-      raise InitializationError, "Failed to initialize: #{e.message}"
-    end
-
-    def start_data_source
-      return if @closed
-
-      if @config.streaming
-        start_streaming
-      else
-        start_polling
-      end
-    end
-
-    def start_streaming
-      @streaming_handler = DataSource::StreamingHandler.new(
-        sdk_key: @sdk_key,
-        config: @config,
-        http_client: @http_client,
-        on_flag_updated: ->(flag) { @store.upsert(flag) },
-        on_flag_deleted: ->(key) { @store.remove_flag(key) },
-        on_segment_updated: ->(flags, segments) { @store.init(flags, segments) },
-        on_error: ->(_err) { },
-        on_give_up: -> { fallback_to_polling }
-      )
-      @streaming_handler.start
-    end
-
-    def fallback_to_polling
-      @config.logger&.warn("Featureflip: streaming retries exhausted, falling back to polling")
-      @streaming_handler = nil
-      start_polling
-    end
-
-    def start_polling
-      @polling_handler = DataSource::PollingHandler.new(
-        http_client: @http_client,
-        config: @config,
-        on_update: ->(flags, segments) { @store.init(flags, segments) },
-        on_error: ->(_err) { }
-      )
-      @polling_handler.start
-    end
-
-    def start_event_processor
-      @event_processor = Events::EventProcessor.new(
-        @http_client,
-        flush_interval: @config.flush_interval,
-        flush_batch_size: @config.flush_batch_size
-      )
-      @event_processor.start
-    end
-
-    def evaluate_flag(key, context, default_value)
-      if @test_mode
-        return @test_values.fetch(key, default_value)
-      end
-
-      detail = variation_detail(key, context, default_value)
-      detail.value
-    rescue StandardError
-      default_value
-    end
-
-    def get_segment(key)
-      @store.get_segment(key)
-    end
-
-    def normalize_context(context)
-      return {} if context.nil?
-      context.transform_keys(&:to_s)
-    end
-
-    def record_evaluation(key, context, variation_key)
-      return unless @event_processor
-
-      @event_processor.queue_event({
-        type: "Evaluation",
-        flagKey: key,
-        userId: context["user_id"]&.to_s,
-        variation: variation_key,
-        timestamp: Time.now.utc.iso8601
-      })
+    def initialize(core)
+      @core = core
+      @closed = false
+      @close_mutex = Mutex.new
     end
   end
 end

data/lib/featureflip/evaluation/evaluator.rb

@@ -4,20 +4,37 @@ require_relative "bucketing"
 module Featureflip
   module Evaluation
     class Evaluator
+      # Mirrors packages/js-sdk/src/core/evaluator.ts. The guard uses `>` (not `>=`)
+      # so a chain of MAX_PREREQUISITE_DEPTH + 1 nested flags trips the cap — matches
+      # the JS reference implementation; see prerequisite_spec.rb depth test.
+      MAX_PREREQUISITE_DEPTH = 10
+
       def initialize
         @condition_evaluator = ConditionEvaluator.new
       end
 
-      def evaluate(flag, context, get_segment: nil)
+      def evaluate(flag, context, get_segment: nil, all_flags: {})
+        evaluate_with_shared_memo(flag, context, get_segment: get_segment, all_flags: all_flags, memo: {})
+      end
+
+      def evaluate_with_shared_memo(flag, context, all_flags:, memo:, get_segment: nil)
+        evaluate_internal(flag, context, get_segment, all_flags, 0, memo)
+      end
+
+      private
+
+      def evaluate_internal(flag, context, get_segment, all_flags, depth, memo)
+        if depth > MAX_PREREQUISITE_DEPTH
+          return off_result(flag, reason: "Error")
+        end
+
         unless flag.enabled
-          variation = flag.get_variation(flag.off_variation)
-          return Models::EvaluationDetail.new(
-            value: variation&.value,
-            reason: "FlagDisabled",
-            variation_key: flag.off_variation
-          )
+          return off_result(flag, reason: "FlagDisabled")
         end
 
+        prereq_failure = resolve_prerequisites(flag, context, get_segment, all_flags, depth, memo)
+        return prereq_failure if prereq_failure
+
         sorted_rules = flag.rules.sort_by(&:priority)
         sorted_rules.each do |rule|
           conditions_match = if rule.segment_key && get_segment
@@ -38,25 +55,72 @@ module Featureflip
           if conditions_match
             variation_key = resolve_serve(rule.serve, context)
             variation = flag.get_variation(variation_key)
-            return Models::EvaluationDetail.new(
+            result = Models::EvaluationDetail.new(
               value: variation&.value,
               reason: "RuleMatch",
               rule_id: rule.id,
               variation_key: variation_key
             )
+            memo[flag.key] = result
+            return result
           end
         end
 
         variation_key = resolve_serve(flag.fallthrough, context)
         variation = flag.get_variation(variation_key)
-        Models::EvaluationDetail.new(
+        result = Models::EvaluationDetail.new(
           value: variation&.value,
           reason: "Fallthrough",
           variation_key: variation_key
         )
+        memo[flag.key] = result
+        result
       end
 
-      private
+      # Returns nil when all prerequisites pass; otherwise returns the off-variation
+      # result for the flag and memoises it under flag.key. Mirrors the per-branch
+      # memo writes in the JS SDK evaluator.
+      def resolve_prerequisites(flag, context, get_segment, all_flags, depth, memo)
+        prerequisites = flag.prerequisites || []
+        prerequisites.each do |prereq|
+          key = prereq.prerequisite_flag_key
+          prereq_result = memo[key]
+
+          unless prereq_result
+            prereq_flag = all_flags[key]
+            unless prereq_flag
+              return memoise(memo, flag.key, off_result(flag, reason: "PrerequisiteFailed", prerequisite_key: key))
+            end
+
+            prereq_result = evaluate_internal(prereq_flag, context, get_segment, all_flags, depth + 1, memo)
+            memo[key] = prereq_result
+          end
+
+          if prereq_result.reason == "Error"
+            return memoise(memo, flag.key, off_result(flag, reason: "Error"))
+          end
+
+          if prereq_result.variation_key != prereq.expected_variation_key
+            return memoise(memo, flag.key, off_result(flag, reason: "PrerequisiteFailed", prerequisite_key: key))
+          end
+        end
+        nil
+      end
+
+      def memoise(memo, key, result)
+        memo[key] = result
+        result
+      end
+
+      def off_result(flag, reason:, prerequisite_key: nil)
+        variation = flag.get_variation(flag.off_variation)
+        Models::EvaluationDetail.new(
+          value: variation&.value,
+          reason: reason,
+          variation_key: flag.off_variation,
+          prerequisite_key: prerequisite_key
+        )
+      end
 
       def resolve_serve(serve, context)
         if serve.type == "Fixed"

data/lib/featureflip/http/client.rb

@@ -82,7 +82,15 @@ module Featureflip
           variations: (data["variations"] || []).map { |v| Models::Variation.new(key: v["key"], value: v["value"]) },
           rules: (data["rules"] || []).map { |r| parse_rule(r) },
           fallthrough: parse_serve(data["fallthrough"]),
-          off_variation: data["offVariation"]
+          off_variation: data["offVariation"],
+          prerequisites: (data["prerequisites"] || []).map { |p| parse_prerequisite(p) }
+        )
+      end
+
+      def parse_prerequisite(data)
+        Models::Prerequisite.new(
+          prerequisite_flag_key: data["prerequisiteFlagKey"],
+          expected_variation_key: data["expectedVariationKey"]
         )
       end
 

data/lib/featureflip/models/evaluation_detail.rb

@@ -1,7 +1,7 @@
 module Featureflip
   module Models
-    EvaluationDetail = Struct.new(:value, :reason, :rule_id, :variation_key, keyword_init: true) do
-      def initialize(value:, reason:, rule_id: nil, variation_key: nil)
+    EvaluationDetail = Struct.new(:value, :reason, :rule_id, :variation_key, :prerequisite_key, keyword_init: true) do
+      def initialize(value:, reason:, rule_id: nil, variation_key: nil, prerequisite_key: nil)
         super
       end
     end

data/lib/featureflip/models/flag.rb

@@ -28,7 +28,16 @@ module Featureflip
       end
     end
 
-    FlagConfiguration = Struct.new(:key, :version, :type, :enabled, :variations, :rules, :fallthrough, :off_variation, keyword_init: true) do
+    Prerequisite = Struct.new(:prerequisite_flag_key, :expected_variation_key, keyword_init: true)
+
+    FlagConfiguration = Struct.new(
+      :key, :version, :type, :enabled, :variations, :rules, :fallthrough, :off_variation, :prerequisites,
+      keyword_init: true
+    ) do
+      def initialize(key:, version:, type:, enabled:, variations:, rules:, fallthrough:, off_variation:, prerequisites: [])
+        super
+      end
+
       def get_variation(key)
         @variations_by_key ||= variations.each_with_object({}) { |v, h| h[v.key] = v }
         @variations_by_key[key]

data/lib/featureflip/shared_core.rb

@@ -0,0 +1,376 @@
+require "timeout"
+
+module Featureflip
+  class SharedCore
+    LIVE_CORES = {}
+    LIVE_CORES_MUTEX = Mutex.new
+
+    # --- Class-level factory methods ---
+
+    def self._get_or_create(sdk_key, config)
+      LIVE_CORES_MUTEX.synchronize do
+        existing = LIVE_CORES[sdk_key]
+
+        if existing
+          if existing._acquire
+            unless _configs_equal(existing._config, config)
+              config.logger&.warn(
+                "Featureflip: Client.get called with different config for same SDK key. " \
+                "Using existing configuration. Close all handles first to apply new config."
+              )
+            end
+            return existing
+          else
+            # Stale entry — remove and replace
+            LIVE_CORES.delete(sdk_key)
+          end
+        end
+
+        core = new(sdk_key: sdk_key, config: config)
+        LIVE_CORES[sdk_key] = core
+        core
+      end
+    end
+
+    def self._create_for_testing(flags)
+      core = allocate
+      core.send(:init_test_mode, flags)
+      core
+    end
+
+    def self._reset_for_testing
+      cores_to_release = LIVE_CORES_MUTEX.synchronize do
+        snapshot = LIVE_CORES.values.dup
+        LIVE_CORES.clear
+        snapshot
+      end
+      cores_to_release.each { |c| c._release }
+    end
+
+    # --- Instance methods ---
+
+    def initialize(sdk_key:, config:)
+      @sdk_key = sdk_key
+      @config = config
+      @store = Store::FlagStore.new
+      @evaluator = Evaluation::Evaluator.new
+      @initialized = false
+      @closed = false
+      @test_mode = false
+      @test_values = {}
+      @http_client = nil
+      @streaming_handler = nil
+      @polling_handler = nil
+      @event_processor = nil
+      @ref_count = 1
+      @ref_mutex = Mutex.new
+      @shut_down = false
+
+      bootstrap!
+    end
+
+    def _acquire
+      @ref_mutex.synchronize do
+        return false if @ref_count <= 0
+        @ref_count += 1
+        true
+      end
+    end
+
+    def _release
+      run_shutdown = false
+      @ref_mutex.synchronize do
+        return if @ref_count <= 0
+        @ref_count -= 1
+        if @ref_count == 0 && !@shut_down
+          @shut_down = true
+          run_shutdown = true
+        end
+      end
+      _shutdown if run_shutdown
+    end
+
+    def _config
+      @config
+    end
+
+    def _ref_count
+      @ref_mutex.synchronize { @ref_count }
+    end
+
+    def initialized?
+      @initialized
+    end
+
+    # --- Evaluation methods ---
+
+    def bool_variation(key, context, default_value)
+      evaluate_flag(key, context, default_value)
+    end
+
+    def string_variation(key, context, default_value)
+      evaluate_flag(key, context, default_value)
+    end
+
+    def number_variation(key, context, default_value)
+      evaluate_flag(key, context, default_value)
+    end
+
+    def json_variation(key, context, default_value)
+      evaluate_flag(key, context, default_value)
+    end
+
+    def variation_detail(key, context, default_value)
+      context = normalize_context(context)
+
+      if @test_mode
+        value = @test_values.fetch(key, default_value)
+        reason = @test_values.key?(key) ? "Fallthrough" : "FlagNotFound"
+        return Models::EvaluationDetail.new(value: value, reason: reason)
+      end
+
+      flag = @store.get_flag(key)
+      unless flag
+        record_evaluation(key, context, nil)
+        return Models::EvaluationDetail.new(value: default_value, reason: "FlagNotFound")
+      end
+
+      result = @evaluator.evaluate(
+        flag,
+        context,
+        get_segment: method(:get_segment),
+        all_flags: @store.all_flags_map
+      )
+      value = result.value.nil? ? default_value : result.value
+      record_evaluation(key, context, result.variation_key)
+
+      Models::EvaluationDetail.new(
+        value: value,
+        reason: result.reason,
+        rule_id: result.rule_id,
+        variation_key: result.variation_key,
+        prerequisite_key: result.prerequisite_key
+      )
+    rescue StandardError
+      # Prerequisite-resolution failures return PrerequisiteFailed cleanly through
+      # the evaluator; this rescue only fires on unexpected exceptions (malformed
+      # config, programming errors), so prerequisite_key has no defined value.
+      Models::EvaluationDetail.new(value: default_value, reason: "Error", prerequisite_key: nil)
+    end
+
+    # --- Event methods ---
+
+    def track(event_key, context, metadata = nil)
+      return unless @event_processor
+
+      context = normalize_context(context)
+      @event_processor.queue_event({
+        type: "Custom",
+        flagKey: event_key,
+        userId: context["user_id"]&.to_s,
+        metadata: metadata || {},
+        timestamp: Time.now.utc.iso8601
+      })
+    end
+
+    def identify(context)
+      return unless @event_processor
+
+      context = normalize_context(context)
+      @event_processor.queue_event({
+        type: "Identify",
+        flagKey: "$identify",
+        userId: context["user_id"]&.to_s,
+        timestamp: Time.now.utc.iso8601
+      })
+    end
+
+    def flush
+      @event_processor&.flush
+    end
+
+    def restart
+      return if @shut_down
+
+      @streaming_handler&.stop
+      @polling_handler&.stop
+      @event_processor&.stop
+
+      if @config.streaming
+        start_streaming
+      else
+        start_polling
+      end
+      start_event_processor if @config.send_events
+    end
+
+    private
+
+    def _shutdown
+      LIVE_CORES_MUTEX.synchronize do
+        LIVE_CORES.delete(@sdk_key) if LIVE_CORES[@sdk_key].equal?(self)
+      end
+      _shutdown_internal
+    end
+
+    def _shutdown_internal
+      @closed = true
+      begin
+        @streaming_handler&.stop
+      rescue StandardError
+        # ignore
+      end
+      @streaming_handler = nil
+
+      begin
+        @polling_handler&.stop
+      rescue StandardError
+        # ignore
+      end
+      @polling_handler = nil
+
+      begin
+        @event_processor&.stop
+      rescue StandardError
+        # ignore
+      end
+      @event_processor = nil
+
+      @config.logger&.info("Featureflip: core shut down for SDK key #{@sdk_key}")
+    end
+
+    def bootstrap!
+      @http_client = Http::Client.new(@sdk_key, @config)
+      fetch_initial_flags
+      start_data_source
+      start_event_processor if @config.send_events
+    end
+
+    def fetch_initial_flags
+      Timeout.timeout(@config.init_timeout) do
+        flags, segments = @http_client.get_flags
+        @store.init(flags, segments)
+        @initialized = true
+      end
+    rescue Timeout::Error
+      raise InitializationError, "Initialization timed out after #{@config.init_timeout}s"
+    rescue InitializationError
+      raise
+    rescue StandardError => e
+      raise InitializationError, "Failed to initialize: #{e.message}"
+    end
+
+    def start_data_source
+      return if @closed
+
+      if @config.streaming
+        start_streaming
+      else
+        start_polling
+      end
+    end
+
+    def start_streaming
+      @streaming_handler = DataSource::StreamingHandler.new(
+        sdk_key: @sdk_key,
+        config: @config,
+        http_client: @http_client,
+        on_flag_updated: ->(flag) { @store.upsert(flag) },
+        on_flag_deleted: ->(key) { @store.remove_flag(key) },
+        on_segment_updated: ->(flags, segments) { @store.init(flags, segments) },
+        on_error: ->(_err) { },
+        on_give_up: -> { fallback_to_polling }
+      )
+      @streaming_handler.start
+    end
+
+    def fallback_to_polling
+      @config.logger&.warn("Featureflip: streaming retries exhausted, falling back to polling")
+      @streaming_handler = nil
+      start_polling
+    end
+
+    def start_polling
+      @polling_handler = DataSource::PollingHandler.new(
+        http_client: @http_client,
+        config: @config,
+        on_update: ->(flags, segments) { @store.init(flags, segments) },
+        on_error: ->(_err) { }
+      )
+      @polling_handler.start
+    end
+
+    def start_event_processor
+      @event_processor = Events::EventProcessor.new(
+        @http_client,
+        flush_interval: @config.flush_interval,
+        flush_batch_size: @config.flush_batch_size
+      )
+      @event_processor.start
+    end
+
+    def evaluate_flag(key, context, default_value)
+      if @test_mode
+        return @test_values.fetch(key, default_value)
+      end
+
+      detail = variation_detail(key, context, default_value)
+      detail.value
+    rescue StandardError
+      default_value
+    end
+
+    def get_segment(key)
+      @store.get_segment(key)
+    end
+
+    def normalize_context(context)
+      return {} if context.nil?
+      context.transform_keys(&:to_s)
+    end
+
+    def record_evaluation(key, context, variation_key)
+      return unless @event_processor
+
+      @event_processor.queue_event({
+        type: "Evaluation",
+        flagKey: key,
+        userId: context["user_id"]&.to_s,
+        variation: variation_key,
+        timestamp: Time.now.utc.iso8601
+      })
+    end
+
+    def init_test_mode(flags)
+      @sdk_key = "test-key"
+      @config = Config.new
+      @store = Store::FlagStore.new
+      @evaluator = Evaluation::Evaluator.new
+      @initialized = true
+      @closed = false
+      @test_mode = true
+      @test_values = flags.dup
+      @http_client = nil
+      @streaming_handler = nil
+      @polling_handler = nil
+      @event_processor = nil
+      @ref_count = 1
+      @ref_mutex = Mutex.new
+      @shut_down = false
+    end
+
+    def self._configs_equal(a, b)
+      a.base_url == b.base_url &&
+        a.streaming == b.streaming &&
+        a.poll_interval == b.poll_interval &&
+        a.flush_interval == b.flush_interval &&
+        a.flush_batch_size == b.flush_batch_size &&
+        a.init_timeout == b.init_timeout &&
+        a.connect_timeout == b.connect_timeout &&
+        a.read_timeout == b.read_timeout &&
+        a.send_events == b.send_events
+    end
+
+    private_class_method :_configs_equal
+  end
+end

data/lib/featureflip/store/flag_store.rb

@@ -28,6 +28,10 @@ module Featureflip
         @mutex.synchronize { @flags.values }
       end
 
+      def all_flags_map
+        @mutex.synchronize { @flags.dup }
+      end
+
       def upsert(flag)
         @mutex.synchronize do
           existing = @flags[flag.key]

data/lib/featureflip/version.rb

@@ -1,3 +1,3 @@
 module Featureflip
-  VERSION = "1.0.1"
+  VERSION = "2.1.0"
 end

data/lib/featureflip.rb

@@ -13,6 +13,7 @@ require_relative "featureflip/events/event"
 require_relative "featureflip/events/event_processor"
 require_relative "featureflip/data_source/streaming"
 require_relative "featureflip/data_source/polling"
+require_relative "featureflip/shared_core"
 require_relative "featureflip/client"
 
 module Featureflip
@@ -26,7 +27,7 @@ module Featureflip
         @config = Config.new
         yield @config if block_given?
         @config.validate!
-        @default_client = Client.new(sdk_key: @config.sdk_key, config: @config)
+        @default_client = Client.get(@config.sdk_key, config: @config)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featureflip
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Featureflip
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-03 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -73,6 +73,7 @@ files:
 - lib/featureflip/models/evaluation_detail.rb
 - lib/featureflip/models/flag.rb
 - lib/featureflip/models/segment.rb
+- lib/featureflip/shared_core.rb
 - lib/featureflip/store/flag_store.rb
 - lib/featureflip/version.rb
 homepage: https://featureflip.io