prefab-cloud-ruby 0.11.0 → 0.12.0

data/lib/prefab/feature_flag_client.rb

@@ -30,7 +30,7 @@ module Prefab
     end
 
     def evaluate(feature_name, lookup_key, attributes, feature_obj, variants)
-      value_of(get_variant(feature_name, lookup_key, attributes, feature_obj, variants))
+      value_of_variant(get_variant(feature_name, lookup_key, attributes, feature_obj, variants))
     end
 
     private
@@ -50,19 +50,12 @@ module Prefab
         return get_variant_obj(variants, feature_obj.inactive_variant_idx)
       end
 
-      # if user_targets.match
-      feature_obj.user_targets.each do |target|
-        if (target.identifiers.include? lookup_key)
-          return get_variant_obj(variants, target.variant_idx)
-        end
-      end
-
       #default to inactive
       variant_weights = [Prefab::VariantWeight.new(variant_idx: feature_obj.inactive_variant_idx, weight: 1)]
 
       # if rules.match
       feature_obj.rules.each do |rule|
-        if criteria_match?(rule, lookup_key, attributes)
+        if criteria_match?(rule.criteria, lookup_key, attributes)
           variant_weights = rule.variant_weights
           break
         end
@@ -107,22 +100,25 @@ module Prefab
       int_value / MAX_32_FLOAT
     end
 
-    def criteria_match?(rule, lookup_key, attributes)
+    # def criteria_match?(rule, lookup_key, attributes)
+    #
+    # end
+    def criteria_match?(criteria, lookup_key, attributes)
 
-      if rule.criteria.operator == :ALWAYS_TRUE
+      if criteria.operator == :ALWAYS_TRUE
         return true
-      elsif rule.criteria.operator == :LOOKUP_KEY_IN
-        return rule.criteria.values.include?(lookup_key)
-      elsif rule.criteria.operator == :LOOKUP_KEY_NOT_IN
-        return !rule.criteria.values.include?(lookup_key)
-      elsif rule.criteria.operator == :IN_SEG
-        return segment_matches(rule.criteria.values, lookup_key, attributes).any?
-      elsif rule.criteria.operator == :NOT_IN_SEG
-        return segment_matches(rule.criteria.values, lookup_key, attributes).none?
-      elsif rule.criteria.operator == :PROP_IS_ONE_OF
-        return rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym])
-      elsif rule.criteria.operator == :PROP_IS_NOT_ONE_OF
-        return !(rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym]))
+      elsif criteria.operator == :LOOKUP_KEY_IN
+        return criteria.values.include?(lookup_key)
+      elsif criteria.operator == :LOOKUP_KEY_NOT_IN
+        return !criteria.values.include?(lookup_key)
+      elsif criteria.operator == :IN_SEG
+        return segment_matches(criteria.values, lookup_key, attributes).any?
+      elsif criteria.operator == :NOT_IN_SEG
+        return segment_matches(criteria.values, lookup_key, attributes).none?
+      elsif criteria.operator == :PROP_IS_ONE_OF
+        return criteria.values.include?(attributes[criteria.property]) || criteria.values.include?(attributes[criteria.property.to_sym])
+      elsif criteria.operator == :PROP_IS_NOT_ONE_OF
+        return !(criteria.values.include?(attributes[criteria.property]) || criteria.values.include?(attributes[criteria.property.to_sym]))
       end
       @base_client.log.info("Unknown Operator")
       false
@@ -142,10 +138,11 @@ module Prefab
       end
     end
 
+    # does a given segment match?
     def segment_match?(segment, lookup_key, attributes)
-      includes = segment.includes.include?(lookup_key)
-      excludes = segment.excludes.include?(lookup_key)
-      includes && !excludes
+      segment.criterion.map do |criteria|
+        criteria_match?(criteria, lookup_key, attributes)
+      end.any?
     end
   end
 end

data/lib/prefab/internal_logger.rb

@@ -0,0 +1,28 @@
+module Prefab
+  class InternalLogger < Logger
+    def initialize(path, logger)
+      @path = path
+      @logger = logger
+    end
+
+    def debug(progname = nil, &block)
+      @logger.log_internal yield, @path, progname, DEBUG
+    end
+
+    def info(progname = nil, &block)
+      @logger.log_internal yield, @path, progname, INFO
+    end
+
+    def warn(progname = nil, &block)
+      @logger.log_internal yield, @path, progname, WARN
+    end
+
+    def error(progname = nil, &block)
+      @logger.log_internal yield, @path, progname, ERROR
+    end
+
+    def fatal(progname = nil, &block)
+      @logger.log_internal yield, @path, progname, FATAL
+    end
+  end
+end

data/lib/prefab/logger_client.rb

@@ -122,7 +122,7 @@ module Prefab
     # sanitize & clean the path of the caller so the key
     # looks like log_level.app.models.user
     def get_path(absolute_path, base_label)
-      path = absolute_path + ""
+      path = (absolute_path || "unknown") + ""
       path.slice! Dir.pwd
 
       path.gsub!(/.*?(?=\/lib\/)/im, "")

data/lib/prefab/options.rb

@@ -0,0 +1,81 @@
+module Prefab
+  class Options
+    attr_reader :api_key
+    attr_reader :logdev
+    attr_reader :log_formatter
+    attr_reader :stats
+    attr_reader :shared_cache
+    attr_reader :namespace
+    attr_reader :prefab_api_url
+    attr_reader :prefab_grpc_url
+    attr_reader :on_no_default
+    attr_reader :initialization_timeout_sec
+    attr_reader :on_init_failure
+    attr_reader :prefab_config_override_dir
+    attr_reader :prefab_config_classpath_dir
+    attr_reader :defaults_env
+
+    DEFAULT_LOG_FORMATTER = proc { |severity, datetime, progname, msg|
+      "#{severity.ljust(5)} #{datetime}: #{progname} #{msg}\n"
+    }
+
+    module ON_INITIALIZATION_FAILURE
+      RAISE = 1
+      RETURN = 2
+    end
+    module ON_NO_DEFAULT
+      RAISE = 1
+      RETURN = 2
+    end
+    module DATASOURCES
+      ALL = 1
+      LOCAL_ONLY = 2
+    end
+
+    def initialize(
+      api_key: ENV['PREFAB_API_KEY'],
+      logdev: $stdout,
+      stats: NoopStats.new, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
+      shared_cache: NoopCache.new, # Something that quacks like Rails.cache ideally memcached
+      namespace: "",
+      log_formatter: DEFAULT_LOG_FORMATTER,
+      prefab_api_url: ENV["PREFAB_API_URL"] || 'https://api.prefab.cloud',
+      prefab_grpc_url: ENV["PREFAB_GRPC_URL"] || 'grpc.prefab.cloud:443',
+      on_no_default: ON_NO_DEFAULT::RAISE, # options :raise, :warn_and_return_nil,
+      initialization_timeout_sec: 10, # how long to wait before on_init_failure
+      on_init_failure: ON_INITIALIZATION_FAILURE::RAISE, #options :unlock_and_continue, :lock_and_keep_trying, :raise
+      # new_config_callback: nil, #callback method
+      # live_override_url: nil,
+      prefab_datasources: ENV['PREFAB_DATASOURCES'] == "LOCAL_ONLY" ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
+      prefab_config_override_dir: Dir.home,
+      prefab_config_classpath_dir: ".",
+      defaults_env: ""
+    )
+      # debugger
+      @api_key = api_key
+      @logdev = logdev
+      @stats = stats
+      @shared_cache = shared_cache
+      @namespace = namespace
+      @log_formatter = log_formatter
+      @prefab_api_url = prefab_api_url
+      @prefab_grpc_url = prefab_grpc_url
+      @on_no_default = on_no_default
+      @initialization_timeout_sec = initialization_timeout_sec
+      @on_init_failure = on_init_failure
+      @prefab_datasources = prefab_datasources
+      @prefab_config_classpath_dir = prefab_config_classpath_dir
+      @prefab_config_override_dir = prefab_config_override_dir
+      @defaults_env = defaults_env
+    end
+
+    def local_only?
+      @prefab_datasources == DATASOURCES::LOCAL_ONLY
+    end
+
+    # https://api.prefab.cloud -> https://api-prefab-cloud.global.ssl.fastly.net
+    def url_for_api_cdn
+      ENV['PREFAB_CDN_URL'] || "#{@prefab_api_url.gsub(/\./, "-")}.global.ssl.fastly.net"
+    end
+  end
+end

data/lib/prefab/prefab.rb

@@ -0,0 +1,32 @@
+module Prefab
+
+  @@singleton__mutex__ = Mutex.new
+
+  public
+
+  def self.initialize(options = nil)
+    @@singleton__mutex__.synchronize do
+      unless @singleton.nil?
+        puts 'Prefab Double Initialization'
+        return @singleton
+      end
+      @singleton = Prefab::Client.new(options)
+    end
+  end
+
+  def self.get(key)
+    require_initialization
+    @singleton.config_client.get(key)
+  end
+
+  private
+
+  def self.require_initialization
+    if @singleton.nil?
+      puts "Prefab initializing for you. You probably want to call Prefab.initialize(Prefab::Options.new())"
+      self.initialize
+    end
+  end
+  module_function initialize
+  module_function get
+end

data/lib/prefab-cloud-ruby.rb

@@ -6,6 +6,8 @@ require 'openssl'
 require 'ld-eventsource'
 require 'prefab_pb'
 require 'prefab_services_pb'
+require 'prefab/options'
+require 'prefab/internal_logger'
 require 'prefab/config_helper'
 require 'prefab/config_loader'
 require 'prefab/config_resolver'

data/lib/prefab_pb.rb

@@ -75,14 +75,12 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       value :MAXIMUM, 2
     end
     add_message "prefab.FeatureFlagVariant" do
+      proto3_optional :int, :int64, 1
+      proto3_optional :string, :string, 2
+      proto3_optional :double, :double, 3
+      proto3_optional :bool, :bool, 4
       optional :name, :string, 5
       optional :description, :string, 6
-      oneof :type do
-        optional :int, :int64, 1
-        optional :string, :string, 2
-        optional :double, :double, 3
-        optional :bool, :bool, 4
-      end
     end
     add_message "prefab.Criteria" do
       optional :property, :string, 1
@@ -106,15 +104,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       repeated :variant_weights, :message, 2, "prefab.VariantWeight"
     end
     add_message "prefab.Segment" do
-      optional :name, :string, 1
-      optional :description, :string, 2
-      repeated :includes, :string, 3
-      repeated :excludes, :string, 4
-      repeated :criterion, :message, 5, "prefab.Criteria"
-    end
-    add_message "prefab.UserTarget" do
-      optional :variant_idx, :int32, 1
-      repeated :identifiers, :string, 2
+      repeated :criterion, :message, 1, "prefab.Criteria"
     end
     add_message "prefab.VariantWeight" do
       optional :weight, :int32, 1
@@ -123,9 +113,21 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "prefab.FeatureFlag" do
       optional :active, :bool, 1
       optional :inactive_variant_idx, :int32, 2
-      repeated :user_targets, :message, 4, "prefab.UserTarget"
       repeated :rules, :message, 5, "prefab.Rule"
     end
+    add_message "prefab.Identity" do
+      proto3_optional :lookup, :string, 1
+      map :attributes, :string, :string, 2
+    end
+    add_message "prefab.ClientConfigValue" do
+      proto3_optional :int, :int64, 1
+      proto3_optional :string, :string, 2
+      proto3_optional :double, :double, 3
+      proto3_optional :bool, :bool, 4
+    end
+    add_message "prefab.ConfigEvaluations" do
+      map :values, :string, :message, 1, "prefab.ClientConfigValue"
+    end
     add_message "prefab.LimitDefinition" do
       optional :policy_name, :enum, 2, "prefab.LimitResponse.LimitPolicyNames"
       optional :limit, :int32, 3
@@ -205,9 +207,11 @@ module Prefab
   Criteria::CriteriaOperator = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Criteria.CriteriaOperator").enummodule
   Rule = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Rule").msgclass
   Segment = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Segment").msgclass
-  UserTarget = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.UserTarget").msgclass
   VariantWeight = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.VariantWeight").msgclass
   FeatureFlag = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.FeatureFlag").msgclass
+  Identity = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Identity").msgclass
+  ClientConfigValue = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ClientConfigValue").msgclass
+  ConfigEvaluations = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigEvaluations").msgclass
   LimitDefinition = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitDefinition").msgclass
   LimitDefinition::SafetyLevel = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitDefinition.SafetyLevel").enummodule
   LimitDefinitions = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitDefinitions").msgclass

data/lib/prefab_services_pb.rb

@@ -47,6 +47,20 @@ module Prefab
       rpc :GetBlock, ::Prefab::IdBlockRequest, ::Prefab::IdBlock
     end
 
+    Stub = Service.rpc_stub_class
+  end
+  module ClientService
+    class Service
+
+      include ::GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'prefab.ClientService'
+
+      rpc :GetAll, ::Prefab::Identity, ::Prefab::ConfigEvaluations
+    end
+
     Stub = Service.rpc_stub_class
   end
 end

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 0.11.0 ruby lib
+# stub: prefab-cloud-ruby 0.12.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.11.0"
+  s.version = "0.12.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2022-05-05"
+  s.date = "2022-07-21"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -38,10 +38,13 @@ Gem::Specification.new do |s|
     "lib/prefab/config_loader.rb",
     "lib/prefab/config_resolver.rb",
     "lib/prefab/feature_flag_client.rb",
+    "lib/prefab/internal_logger.rb",
     "lib/prefab/logger_client.rb",
     "lib/prefab/murmer3.rb",
     "lib/prefab/noop_cache.rb",
     "lib/prefab/noop_stats.rb",
+    "lib/prefab/options.rb",
+    "lib/prefab/prefab.rb",
     "lib/prefab/ratelimit_client.rb",
     "lib/prefab_pb.rb",
     "lib/prefab_services_pb.rb",
@@ -49,6 +52,7 @@ Gem::Specification.new do |s|
     "run_test_harness_server.sh",
     "test/.prefab.test.config.yaml",
     "test/harness_server.rb",
+    "test/test_config_client.rb",
     "test/test_config_loader.rb",
     "test/test_config_resolver.rb",
     "test/test_feature_flag_client.rb",

data/test/.prefab.test.config.yaml

@@ -1,6 +1,10 @@
-sample: OneTwoThree
+sample: default sample value
 sample_int: 123
 sample_double: 12.12
 sample_bool: true
 sample_to_override: Foo
 prefab.log_level: debug
+unit_tests:
+  sample: test sample value
+ignored_env:
+  sample: ignored value

data/test/harness_server.rb

@@ -18,6 +18,7 @@ class RackApp
     api_key = props["api_key"]
     user_key = props["user_key"]
     is_feature_flag = !props["feature_flag"].nil?
+    attributes = props["attributes"]
     puts props
     client = Prefab::Client.new(
       api_key: api_key,
@@ -35,7 +36,7 @@ class RackApp
 
     if is_feature_flag
       puts "EVALFF #{key} #{user_key}"
-      rtn = client.feature_flag_client.get(key, user_key, []).to_s
+      rtn = client.feature_flag_client.get(key, user_key, attributes).to_s
     else
       rtn = client.config_client.get(key).to_s
     end

data/test/test_config_client.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TestConfigClient < Minitest::Test
+  def setup
+    options = Prefab::Options.new(
+      prefab_config_override_dir: "none",
+      prefab_config_classpath_dir: "test",
+      defaults_env: "unit_tests",
+      local_only: true
+    )
+    @config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
+  end
+
+  def test_load
+    assert_equal "test sample value", @config_client.get("sample")
+    assert_equal 123, @config_client.get("sample_int")
+  end
+
+end

data/test/test_config_loader.rb

@@ -2,40 +2,54 @@ require 'test_helper'
 
 class TestConfigLoader < Minitest::Test
   def setup
-    ENV['PREFAB_CONFIG_OVERRIDE_DIR'] = "none"
-    ENV['PREFAB_CONFIG_CLASSPATH_DIR'] = "test"
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new)
+    options = Prefab::Options.new(
+      prefab_config_override_dir: "none",
+      prefab_config_classpath_dir: "test",
+      defaults_env: "unit_tests"
+    )
+    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
   end
 
   def test_load
     should_be :int, 123, "sample_int"
-    should_be :string, "OneTwoThree", "sample"
+    should_be :string, "test sample value", "sample"
     should_be :bool, true, "sample_bool"
     should_be :double, 12.12, "sample_double"
   end
 
+  def test_load_in_no_default_env
+    options = Prefab::Options.new(
+      prefab_config_override_dir: "none",
+      prefab_config_classpath_dir: "test",
+    # no defaults_env
+    )
+    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
+    should_be :string, "default sample value", "sample"
+    should_be :bool, true, "sample_bool"
+  end
+
   def test_highwater
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
     assert_equal 1, @loader.highwater_mark
 
-    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
+    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
     assert_equal 5, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
     assert_equal 5, @loader.highwater_mark
   end
 
   def test_keeps_most_recent
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]),"test")
     assert_equal 1, @loader.highwater_mark
     should_be :int, 1, "sample_int"
 
-    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]))
+    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]),"test")
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
 
-    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]),"test")
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,14 +57,14 @@ class TestConfigLoader < Minitest::Test
   def test_api_precedence
     should_be :int, 123, "sample_int"
 
-    @loader.set(Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
+    @loader.set(Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]), "test")
     should_be :int, 456, "sample_int"
   end
 
   def test_api_deltas
     val = Prefab::ConfigValue.new(int: 456)
     config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
-    @loader.set(config)
+    @loader.set(config, "test")
 
     configs = Prefab::Configs.new
     configs.configs << config
@@ -59,11 +73,11 @@ class TestConfigLoader < Minitest::Test
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
-    @loader.set(config)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)], id: 2)
+    @loader.set(config, "test")
 
-    config = Prefab::Config.new(key: "sample_int", rows: [])
-    @loader.set(config)
+    config = Prefab::Config.new(key: "sample_int", rows: [], id: 3)
+    @loader.set(config, "test")
 
     configs = Prefab::Configs.new
     assert_equal configs, @loader.get_api_deltas
@@ -72,8 +86,8 @@ class TestConfigLoader < Minitest::Test
   private
 
   def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key].rows[0].value.type
-    assert_equal value, @loader.calc_config[key].rows[0].value.send(type)
+    assert_equal type, @loader.calc_config[key][:config].rows[0].value.type
+    assert_equal value, @loader.calc_config[key][:config].rows[0].value.send(type)
   end
 
 end

data/test/test_config_resolver.rb

@@ -10,7 +10,7 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "key" => Prefab::Config.new(
+      "key" => { config: Prefab::Config.new(
         key: "key",
         rows: [
           Prefab::ConfigRow.new(
@@ -42,13 +42,14 @@ class TestConfigResolver < Minitest::Test
           ),
 
         ]
-      ),
-      "key2" => Prefab::Config.new(
+      ) },
+      "key2" => { config: Prefab::Config.new(
         key: "key2",
         rows: [
           value: Prefab::ConfigValue.new(string: "valueB2"),
         ]
-      )
+      ) }
+
     }
 
     @loader.stub :calc_config, loaded_values do
@@ -107,25 +108,27 @@ class TestConfigResolver < Minitest::Test
 
     @loader = MockConfigLoader.new
     loaded_values = {
-      "ff" => Prefab::Config.new(
-        key: "ff",
-        variants: [
-          Prefab::FeatureFlagVariant.new(string: "inactive"),
-          Prefab::FeatureFlagVariant.new(string: "default"),
-          Prefab::FeatureFlagVariant.new(string: "env"),
-        ],
-        rows: [
-          { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-            inactive_variant_idx: 0,
-            rules: default_ff_rule(1),
-          )) },
-          { project_env_id: TEST_ENV_ID,
-            value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-              inactive_variant_idx: 0,
-              rules: default_ff_rule(2),
-            )) }
-        ]
-      )
+      "ff" => { source: 'test',
+                config: Prefab::Config.new(
+                  key: "ff",
+                  variants: [
+                    Prefab::FeatureFlagVariant.new(string: "inactive"),
+                    Prefab::FeatureFlagVariant.new(string: "default"),
+                    Prefab::FeatureFlagVariant.new(string: "env"),
+                  ],
+                  rows: [
+                    { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+                      inactive_variant_idx: 0,
+                      rules: default_ff_rule(1),
+                    )) },
+                    { project_env_id: TEST_ENV_ID,
+                      value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+                        inactive_variant_idx: 0,
+                        rules: default_ff_rule(2),
+                      )) }
+                  ]
+                )
+      }
     }
     @loader.stub :calc_config, loaded_values do
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
@@ -140,18 +143,18 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "Key:With:Colons" => Prefab::Config.new(
+      "Key:With:Colons" => { config: Prefab::Config.new(
         key: "Key:With:Colons",
         rows: [Prefab::ConfigRow.new(
           value: Prefab::ConfigValue.new(string: "value")
         )]
-      ),
-      "proj:apikey" => Prefab::Config.new(
+      ) },
+      "proj:apikey" => { config: Prefab::Config.new(
         key: "proj:apikey",
         rows: [Prefab::ConfigRow.new(
           value: Prefab::ConfigValue.new(string: "v2")
         )]
-      )
+      ) }
     }
 
     @loader.stub :calc_config, loaded_values do
@@ -189,7 +192,10 @@ class TestConfigResolver < Minitest::Test
   end
 
   def resolver_for_namespace(namespace, loader, project_env_id: TEST_ENV_ID)
-    resolver = Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace), loader)
+    options = Prefab::Options.new(
+      namespace: namespace
+    )
+    resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
     resolver.project_env_id = project_env_id
     resolver.update
     resolver