prefab-cloud-ruby 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22d564bcc76424b3308623b4d2e27a4acaf4217c285bcca02542291d8cc15827
-  data.tar.gz: c097169d379d9f477a66d20fc378f693173de044baecad08059263fd239257e5
+  metadata.gz: 2525930a7f8c2e2924db43504b7dfb6d32e60647bbc359b8a85af8ae3c9f2db0
+  data.tar.gz: 583f5dc901866eaf206f7f693a95bec47b7ea04c54f3d56275a04bbf0a7bb75f
 SHA512:
-  metadata.gz: cdf6ca3b1b28bf83caa629193b21e2d26e4d22d64ee4cd30b7a88fdce623adc7f3feb3605df7107cdca00e7823709f9eeac2a68176db1d10b6616196d2bcb580
-  data.tar.gz: c61b171a2be217c016fad1cc0a1ce9faed159c6f894065db4202ec200ec1f8ac22caabb880fae0f358fcced0930ce49d4e273f800a0fb72c39c6d6f19cc59d07
+  metadata.gz: 6c4ff539c75a2d2cfc5e5d6c3ac7bbab494489386d9a1c66ec97af47ab11d46e723a86df862ab8f86a06b09e6ce93d93425f991656cc473395ccf7e2e5fa4da5
+  data.tar.gz: 1fe296a9c44484d2d8cc4a185929aaef80358fdee8f3bd83d47152933aa6f684fcf995c3f18bae6feb0389370620e9557d2d37f00d657cc72ef43fdd3b55e37e

data/Gemfile.lock

@@ -6,7 +6,7 @@ GEM
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    addressable (2.7.0)
+    addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     builder (3.2.4)
     concurrent-ruby (1.1.8)
@@ -26,7 +26,7 @@ GEM
     ffi-compiler (1.0.1)
       ffi (>= 1.0.0)
       rake
-    git (1.8.1)
+    git (1.11.0)
       rchardet (~> 1.8)
     github_api (0.19.0)
       addressable (~> 2.4)
@@ -75,13 +75,13 @@ GEM
     llhttp-ffi (0.3.1)
       ffi-compiler (~> 1.0)
       rake (~> 13.0)
-    mini_portile2 (2.7.1)
+    mini_portile2 (2.8.0)
     minitest (5.14.4)
     multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.13.1)
-      mini_portile2 (~> 2.7.0)
+    nokogiri (1.13.6)
+      mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
     oauth2 (1.4.7)
       faraday (>= 0.8, < 2.0)

data/README.md

@@ -43,6 +43,15 @@ on_worker_boot do
 end
 ```
 
+## Logging & Debugging
+In classpath or ~/.prefab.overrides.config.yaml set
+```log_level.prefab: debug```
+
+To debug issues before this config file has been read, set env var
+```
+PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL = debug
+```
+
 ## Contributing to prefab-cloud-ruby
  
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.

data/VERSION

@@ -1 +1 @@
-0.11.0
+0.12.0

data/lib/prefab/client.rb

@@ -1,46 +1,38 @@
 module Prefab
-  class Client
 
+  class Client
     MAX_SLEEP_SEC = 10
     BASE_SLEEP_SEC = 0.5
-    DEFAULT_LOG_FORMATTER = proc {|severity, datetime, progname, msg|
-      "#{severity.ljust(5)} #{datetime}: #{progname} #{msg}\n"
-    }
-
-
-    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url
-
-    def initialize(api_key: ENV['PREFAB_API_KEY'],
-                   logdev: nil,
-                   stats: nil, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
-                   shared_cache: nil, # Something that quacks like Rails.cache ideally memcached
-                   local: false,
-                   namespace: "",
-                   log_formatter: DEFAULT_LOG_FORMATTER
-    )
-      raise "No API key. Set PREFAB_API_KEY env var" if api_key.nil? || api_key.empty?
-      raise "PREFAB_API_KEY format invalid. Expecting 123-development-yourapikey-SDK" unless api_key.count("-") == 3
-      @logdev = (logdev || $stdout)
-      @log_formatter = log_formatter
-      @local = local
-      @stats = (stats || NoopStats.new)
-      @shared_cache = (shared_cache || NoopCache.new)
-      @api_key = api_key
-      @project_id = api_key.split("-")[0].to_i # unvalidated, but that's ok. APIs only listen to the actual passwd
-      @namespace = namespace
-      @interceptor = Prefab::AuthInterceptor.new(api_key)
+
+    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url, :options
+
+    def initialize(options = Prefab::Options.new)
+      @options = options
+      @shared_cache = @options.shared_cache
+      @stats = @options.stats
+      @namespace = @options.namespace
       @stubs = {}
-      @prefab_api_url = ENV["PREFAB_API_URL"] || 'https://api.prefab.cloud'
-      @prefab_grpc_url = ENV["PREFAB_GRPC_URL"] || 'grpc.prefab.cloud:443'
-      log_internal Logger::INFO, "Prefab Connecting to: #{@prefab_api_url} and #{@prefab_grpc_url} Secure: #{http_secure?}"
-      at_exit do
-        channel.destroy
+
+      if @options.local_only?
+        @project_id = 0
+        log_internal Logger::INFO, "Prefab Running in Local Mode"
+      else
+        @api_key = @options.api_key
+        raise "No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY" if @api_key.nil? || @api_key.empty?
+        raise "PREFAB_API_KEY format invalid. Expecting 123-development-yourapikey-SDK" unless @api_key.count("-") == 3
+        @project_id = @api_key.split("-")[0].to_i # unvalidated, but that's ok. APIs only listen to the actual passwd
+        @interceptor = Prefab::AuthInterceptor.new(@api_key)
+        @prefab_api_url = @options.prefab_api_url
+        @prefab_grpc_url = @options.prefab_grpc_url
+        log_internal Logger::INFO, "Prefab Connecting to: #{@prefab_api_url} and #{@prefab_grpc_url} Secure: #{http_secure?}"
+        at_exit do
+          channel.destroy
+        end
       end
     end
 
     def channel
       credentials = http_secure? ? creds : :this_channel_is_insecure
-      log_internal Logger::DEBUG, "GRPC Channel #{@prefab_grpc_url} #{credentials}"
       @_channel ||= GRPC::Core::Channel.new(@prefab_grpc_url, nil, credentials)
     end
 
@@ -57,11 +49,11 @@ module Prefab
     end
 
     def log
-      @logger_client ||= Prefab::LoggerClient.new(@logdev, formatter: @log_formatter)
+      @logger_client ||= Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter)
     end
 
-    def log_internal(level, msg)
-      log.log_internal msg, "prefab", nil, level
+    def log_internal(level, msg, path = "prefab")
+      log.log_internal msg, path, nil, level
     end
 
     def request(service, method, req_options: {}, params: {})
@@ -122,7 +114,7 @@ module Prefab
       Dir["#{OpenSSL::X509::DEFAULT_CERT_DIR}/*.pem"].each do |cert|
         ssl_certs << File.open(cert).read
       end
-      if OpenSSL::X509::DEFAULT_CERT_FILE && File.exists?(OpenSSL::X509::DEFAULT_CERT_FILE)
+      if OpenSSL::X509::DEFAULT_CERT_FILE && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
         ssl_certs << File.open(OpenSSL::X509::DEFAULT_CERT_FILE).read
       end
       ssl_certs

data/lib/prefab/config_client.rb

@@ -1,41 +1,47 @@
 module Prefab
   class ConfigClient
+    include Prefab::ConfigHelper
+
     RECONNECT_WAIT = 5
     DEFAULT_CHECKPOINT_FREQ_SEC = 60
     DEFAULT_S3CF_BUCKET = 'http://d2j4ed6ti5snnd.cloudfront.net'
+    SSE_READ_TIMEOUT = 300
 
     def initialize(base_client, timeout)
       @base_client = base_client
+      @options = base_client.options
       @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient"
       @timeout = timeout
-      @initialization_lock = Concurrent::ReadWriteLock.new
+
+      @stream_lock = Concurrent::ReadWriteLock.new
 
       @checkpoint_freq_secs = DEFAULT_CHECKPOINT_FREQ_SEC
 
       @config_loader = Prefab::ConfigLoader.new(@base_client)
       @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
 
+      @initialization_lock = Concurrent::ReadWriteLock.new
       @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquireWriteLock"
       @initialization_lock.acquire_write_lock
       @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquiredWriteLock"
+      @initialized_future = Concurrent::Future.execute { @initialization_lock.acquire_read_lock }
 
       @cancellable_interceptor = Prefab::CancellableInterceptor.new(@base_client)
 
       @s3_cloud_front = ENV["PREFAB_S3CF_BUCKET"] || DEFAULT_S3CF_BUCKET
 
-      load_checkpoint
-      start_checkpointing_thread
+      if @options.local_only?
+        finish_init!(:local_only)
+      else
+        load_checkpoint
+        start_checkpointing_thread
+        start_streaming
+      end
     end
 
     def start_streaming
-      @streaming = true
-      # start_grpc_streaming_connection_thread(@config_loader.highwater_mark)
-      start_sse_streaming_connection_thread(@config_loader.highwater_mark)
-    end
-
-    def get(key)
-      @initialization_lock.with_read_lock do
-        @config_resolver.get(key)
+      @stream_lock.with_write_lock do
+        start_sse_streaming_connection_thread(@config_loader.highwater_mark) if @streaming_thread.nil?
       end
     end
 
@@ -48,7 +54,7 @@ module Prefab
 
       @base_client.request Prefab::ConfigService, :upsert, req_options: { timeout: @timeout }, params: upsert_req
       @base_client.stats.increment("prefab.config.upsert")
-      @config_loader.set(config_delta)
+      @config_loader.set(config_delta, :upsert)
       @config_loader.rm(previous_key) if previous_key&.present?
       @config_resolver.update
     end
@@ -67,14 +73,32 @@ module Prefab
                          rows: [Prefab::ConfigRow.new(value: config_value)])
     end
 
+    def get(key)
+      config = _get(key)
+      config ? value_of(config[:value]) : nil
+    end
+
     def get_config_obj(key)
-      @initialization_lock.with_read_lock do
-        @config_resolver.get_config(key)
-      end
+      config = _get(key)
+      config ? config[:config] : nil
     end
 
     private
 
+    def _get(key)
+      # wait timeout sec for the initalization to be complete
+      @initialized_future.value(@options.initialization_timeout_sec)
+      if @initialized_future.incomplete?
+        if @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
+          @base_client.log_internal Logger::WARN, "Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have"
+          @initialization_lock.release_write_lock
+        else
+          raise "Prefab Couldn't Initialize In #{@options.initialization_timeout_sec} 2 timeout. Key #{key}. "
+        end
+      end
+      @config_resolver._get(key)
+    end
+
     def stub
       @_stub = Prefab::ConfigService::Stub.new(nil,
                                                nil,
@@ -82,56 +106,93 @@ module Prefab
                                                interceptors: [@base_client.interceptor, @cancellable_interceptor])
     end
 
-    # Bootstrap out of the cache
-    # returns the high-watermark of what was in the cache
+    # try API first, if not, fallback to s3
     def load_checkpoint
-      success = load_checkpoint_from_config
+      success = load_checkpoint_api_cdn
 
-      if !success
-        @base_client.log_internal Logger::INFO, "Fallback to S3"
-        load_checkpoint_from_s3
+      if success
+        return
+      else
+        @base_client.log_internal Logger::INFO, "LoadCheckpoint: Fallback to GRPC API"
       end
 
-    rescue => e
-      @base_client.log_internal Logger::WARN, "Unexpected problem loading checkpoint #{e}"
-    end
+      success = load_checkpoint_from_grpc_api
 
-    def load_checkpoint_from_config
-      @base_client.log_internal Logger::DEBUG, "Load Checkpoint From Config"
+      if success
+        return
+      else
+        @base_client.log_internal Logger::INFO, "LoadCheckpoint: Fallback to S3"
+      end
+
+      success = load_checkpoint_from_s3
 
+      if !success
+        @base_client.log_internal Logger::WARN, "No success loading checkpoints"
+      end
+    end
+
+    def load_checkpoint_from_grpc_api
       config_req = Prefab::ConfigServicePointer.new(start_at_id: @config_loader.highwater_mark)
 
       resp = stub.get_all_config(config_req)
-      @base_client.log_internal Logger::DEBUG, "Got Response #{resp}"
-      load_configs(resp, :api)
-      @config_resolver.update
-      finish_init!(:api)
+      load_configs(resp, :remote_api_grpc)
       true
+    rescue GRPC::Unauthenticated
+      @base_client.log_internal Logger::WARN, "Unauthenticated"
     rescue => e
-      @base_client.log_internal Logger::WARN, "Unexpected problem loading checkpoint #{e}"
+      puts e.class
+      @base_client.log_internal Logger::WARN, "Unexpected grpc_api problem loading checkpoint #{e}"
       false
     end
 
+    def load_checkpoint_api_cdn
+      key_hash = Murmur3.murmur3_32(@base_client.api_key)
+      url = "#{@options.url_for_api_cdn}/api/v1/config/#{@base_client.project_id}/#{key_hash}/0"
+      conn = if Faraday::VERSION[0].to_i >= 2
+               Faraday.new(url) do |conn|
+                 conn.request :authorization, :basic, @base_client.project_id, @base_client.api_key
+               end
+             else
+               Faraday.new(url) do |conn|
+                 conn.request :basic_auth, @base_client.project_id, @base_client.api_key
+               end
+             end
+      load_url(conn, :remote_cdn_api)
+    end
+
     def load_checkpoint_from_s3
       url = "#{@s3_cloud_front}/#{@base_client.api_key.gsub("|", "/")}"
-      resp = Faraday.get url
+      load_url(Faraday.new(url), :remote_s3)
+    end
+
+    def load_url(conn, source)
+      resp = conn.get('')
       if resp.status == 200
         configs = Prefab::Configs.decode(resp.body)
-        load_configs(configs, :s3)
+        load_configs(configs, source)
+        true
       else
-        @base_client.log_internal Logger::INFO, "No S3 checkpoint. Response #{resp.status} Plan may not support this."
+        @base_client.log_internal Logger::INFO, "Checkpoint #{source} failed to load. Response #{resp.status}"
+        false
       end
+    rescue => e
+      @base_client.log_internal Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+      false
     end
 
     def load_configs(configs, source)
       project_env_id = configs.config_service_pointer.project_env_id
       @config_resolver.project_env_id = project_env_id
+      starting_highwater_mark = @config_loader.highwater_mark
 
-      @base_client.log_internal Logger::INFO, "Prefab Initializing in project: #{@base_client.project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
       configs.configs.each do |config|
-        @config_loader.set(config)
+        @config_loader.set(config, source)
+      end
+      if @config_loader.highwater_mark > starting_highwater_mark
+        @base_client.log_internal Logger::INFO, "Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{@base_client.project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
+      else
+        @base_client.log_internal Logger::DEBUG, "Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.", "prefab.config_client.load_configs"
       end
-      @base_client.log_internal Logger::INFO, "Found checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}"
       @base_client.stats.increment("prefab.config.checkpoint.load")
       @config_resolver.update
       finish_init!(source)
@@ -139,6 +200,7 @@ module Prefab
 
     # A thread that checks for a checkpoint
     def start_checkpointing_thread
+
       Thread.new do
         loop do
           begin
@@ -158,72 +220,32 @@ module Prefab
 
     def finish_init!(source)
       if @initialization_lock.write_locked?
-        @base_client.log_internal Logger::DEBUG, "Unlocked Config via #{source}"
+        @base_client.log_internal Logger::INFO, "Unlocked Config via #{source}"
         @initialization_lock.release_write_lock
         @base_client.log.set_config_client(self)
+        @base_client.log_internal Logger::INFO, to_s
       end
     end
 
-
     def start_sse_streaming_connection_thread(start_at_id)
       auth = "#{@base_client.project_id}:#{@base_client.api_key}"
-
       auth_string = Base64.strict_encode64(auth)
       headers = {
         "x-prefab-start-at-id": start_at_id,
         "Authorization": "Basic #{auth_string}",
       }
       url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
-      @base_client.log_internal Logger::INFO, "SSE Streaming Connect to #{url}"
-      SSE::Client.new(url, headers: headers) do |client|
+      @base_client.log_internal Logger::INFO, "SSE Streaming Connect to #{url} start_at #{start_at_id}"
+      @streaming_thread = SSE::Client.new(url,
+                                          headers: headers,
+                                          read_timeout: SSE_READ_TIMEOUT,
+                                          logger: Prefab::InternalLogger.new("prefab.config.sse", @base_client.log)) do |client|
         client.on_event do |event|
           configs = Prefab::Configs.decode(Base64.decode64(event.data))
-          @base_client.log_internal Logger::INFO, "SSE received configs."
-          @base_client.log_internal Logger::DEBUG, "SSE received configs: #{configs}"
-          configs.configs.each do |config|
-            @config_loader.set(config)
-          end
-          @config_resolver.update
-          finish_init!(:streaming)
+          load_configs(configs, :sse)
         end
       end
     end
-
-    # Setup a streaming connection to the API
-    # Save new config values into the loader
-    def start_grpc_streaming_connection_thread(start_at_id)
-      config_req = Prefab::ConfigServicePointer.new(start_at_id: start_at_id)
-      @base_client.log_internal Logger::DEBUG, "start api connection thread #{start_at_id}"
-      @base_client.stats.increment("prefab.config.api.start")
-
-      @api_connection_thread = Thread.new do
-        at_exit do
-          @streaming = false
-          @cancellable_interceptor.cancel
-        end
-
-        while @streaming do
-          begin
-            resp = stub.get_config(config_req)
-            resp.each do |r|
-              r.configs.each do |config|
-                @config_loader.set(config)
-              end
-              @config_resolver.update
-              finish_init!(:streaming)
-            end
-          rescue => e
-            if @streaming
-              level = e.code == 1 ? Logger::DEBUG : Logger::INFO
-              @base_client.log_internal level, ("config client encountered #{e.message} pausing #{RECONNECT_WAIT}")
-              reset
-              sleep(RECONNECT_WAIT)
-            end
-          end
-        end
-      end
-
-    end
   end
 end
 

data/lib/prefab/config_helper.rb

@@ -16,5 +16,13 @@ module Prefab
         config_value.segment
       end
     end
+
+    def value_of_variant(feature_flag_variant)
+      return feature_flag_variant.string if feature_flag_variant.has_string?
+      return feature_flag_variant.int if feature_flag_variant.has_int?
+      return feature_flag_variant.double if feature_flag_variant.has_double?
+      return feature_flag_variant.bool if feature_flag_variant.has_bool?
+      return nil
+    end
   end
 end

data/lib/prefab/config_loader.rb

@@ -5,6 +5,7 @@ module Prefab
 
     def initialize(base_client)
       @base_client = base_client
+      @prefab_options = base_client.options
       @highwater_mark = 0
       @classpath_config = load_classpath_config
       @local_overrides = load_local_overrides
@@ -20,16 +21,19 @@ module Prefab
       rtn
     end
 
-    def set(config)
+    def set(config, source)
       # don't overwrite newer values
-      if @api_config[config.key] && @api_config[config.key].id > config.id
+      if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
         return
       end
 
       if config.rows.empty?
         @api_config.delete(config.key)
       else
-        @api_config[config.key] = config
+        if @api_config[config.key]
+          @base_client.log_internal Logger::DEBUG, "Replace #{config.key} with value from #{source} #{ @api_config[config.key][:config].id} -> #{config.id}"
+        end
+        @api_config[config.key] = { source: source, config: config }
       end
       @highwater_mark = [config.id, @highwater_mark].max
     end
@@ -41,7 +45,7 @@ module Prefab
     def get_api_deltas
       configs = Prefab::Configs.new
       @api_config.each_value do |config_value|
-        configs.configs << config_value
+        configs.configs << config_value[:config]
       end
       configs
     end
@@ -49,12 +53,12 @@ module Prefab
     private
 
     def load_classpath_config
-      classpath_dir = ENV['PREFAB_CONFIG_CLASSPATH_DIR'] || "."
+      classpath_dir = @prefab_options.prefab_config_classpath_dir
       load_glob(File.join(classpath_dir, ".prefab*config.yaml"))
     end
 
     def load_local_overrides
-      override_dir = ENV['PREFAB_CONFIG_OVERRIDE_DIR'] || Dir.home
+      override_dir = @prefab_options.prefab_config_override_dir
       load_glob(File.join(override_dir, ".prefab*config.yaml"))
     end
 
@@ -63,9 +67,26 @@ module Prefab
       Dir.glob(glob).each do |file|
         yaml = load(file)
         yaml.each do |k, v|
-          rtn[k] = Prefab::Config.new(key: k, rows: [
-            Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(v)))
-          ])
+          if v.class == Hash
+            v.each do |env_k, env_v|
+              if k == @prefab_options.defaults_env
+                rtn[env_k] = { source: file,
+                               match: k,
+                               config: Prefab::Config.new(key: env_k, rows: [
+                                 Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(env_v)))
+                               ]) }
+              else
+                next
+              end
+            end
+          else
+            rtn[k] = { source: file,
+                       match: "default",
+                       config: Prefab::Config.new(key: k, rows: [
+                         Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(v)))
+                       ]) }
+
+          end
         end
       end
       rtn

data/lib/prefab/config_resolver.rb

@@ -8,22 +8,27 @@ module Prefab
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @namespace = base_client.namespace
+      @namespace = base_client.options.namespace
       @config_loader = config_loader
       @project_env_id = 0
       make_local
     end
 
     def to_s
-      str = ""
+      str = "\n"
       @lock.with_read_lock do
         @local_store.each do |k, v|
+          elements = [k.slice(0..49).ljust(50)]
           if v.nil?
-            str<< "|#{k}| tombstone\n"
+            elements << "tombstone"
           else
             value = v[:value]
-            str << "|#{k}| from #{v[:match]} |#{value_of(value)}|#{value_of(value).class}\n"
+            elements << value_of(value).to_s.slice(0..34).ljust(35)
+            elements << value_of(value).class.to_s.slice(0..6).ljust(7)
+            elements << "Match: #{v[:match]}".slice(0..29).ljust(30)
+            elements << "Source: #{v[:source]}"
           end
+          str << elements.join(" | ") << "\n"
         end
       end
       str
@@ -39,12 +44,14 @@ module Prefab
       config ? config[:config] : nil
     end
 
-    def update
-      make_local
+    def _get(key)
+      @lock.with_read_lock do
+        @local_store[key]
+      end
     end
 
-    def export_api_deltas
-      @config_loader.get_api_deltas
+    def update
+      make_local
     end
 
     private
@@ -64,23 +71,26 @@ module Prefab
 
     def make_local
       store = {}
-      @config_loader.calc_config.each do |key, config|
+      @config_loader.calc_config.each do |key, config_resolver_obj|
+        config = config_resolver_obj[:config]
         sortable = config.rows.map do |row|
           if row.project_env_id != 0
             if row.project_env_id == @project_env_id
               if !row.namespace.empty?
                 (starts_with, count) = starts_with_ns?(row.namespace, @namespace)
                 # rubocop:disable BlockNesting
-                { sortable: 2 + count, match: row.namespace, value: row.value, config: config} if starts_with
+                { sortable: 2 + count, match: "nm:#{row.namespace}", value: row.value, config: config} if starts_with
               else
-                { sortable: 1, match: row.project_env_id, value: row.value, config: config}
+                { sortable: 1, match: "env:#{row.project_env_id}", value: row.value, config: config}
               end
             end
           else
-            { sortable: 0, match: "default", value: row.value, config: config}
+            match = config_resolver_obj[:match] || "default"
+            { sortable: 0, match: match, value: row.value, config: config}
           end
         end.compact
         to_store = sortable.sort_by { |h| h[:sortable] }.last
+        to_store[:source] = config_resolver_obj[:source]
         store[key] = to_store
       end
 
@@ -88,11 +98,5 @@ module Prefab
         @local_store = store
       end
     end
-
-    def _get(property)
-      @lock.with_read_lock do
-        @local_store[property]
-      end
-    end
   end
 end