prefab-cloud-ruby 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4207ba2ec83b02534caa1d8f23b75c2120c8d277253312a5bd98898c38baf156
-  data.tar.gz: 8698e869c65017759a56c01f3ff57bc16b9597cc4d1edc219fc282f0ae371e0c
+  metadata.gz: 5bfaef7482dfdd1946bd0b0dee2cd0f366f5661e275bb8b906fb207d9b241d14
+  data.tar.gz: ed36c67d8039d2250fab5c6b1ff08da23cde51f696c256daaa943639205f2d0e
 SHA512:
-  metadata.gz: 31eb4a0e5e132dd3136a48f9afa5f7d7decb73eccb43cc74329e9fc2b3c5a5b7109bc53a3c468e8272ae0d4ad04e3f85fb516eb16b6590325e23046e6f1c9d7b
-  data.tar.gz: 9ea6c49f4ffe05d15654143c98dc7f74d405ac00bd919d3ae43547d9aa3ba4c3adcfa54626a0c393fa766cb420af29231032f07dd4da1c53d71c12da2cfc273a
+  metadata.gz: 209f9cc828ec0eccd3b34162d9513c53695bf36838b60601103fd699748fad78af28cb622c1d057ea63162abd143f4db176395726a52517426885483789c7a3c
+  data.tar.gz: 3d368dc2aab1e941607e437d889dd51c8d5aaf9e65208d81552f930cfa34db0eff02fba1b7f2e7a3a08ab87a23e11fad67a0634861e586649fbc466a4f2d3629

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.2.0 - 2023-10-30
+- Add `Prefab.get('key')` style usage after a `Prefab.init()` call (#151)
+- Add `add_context_keys` and `with_context_keys` method for LoggerClient (#145)
+
+## 1.1.2 - 2023-10-13
+
+- Add `cloud.prefab.client.criteria_evaluator` `debug` logging of evaluations (#150)
+- Add `x_use_local_cache` for local caching (#148)
+- Tests run in RubyMine (#147)
+
 ## 1.1.1 - 2023-10-11
 
 - Migrate happy-path client-initialization logging to `DEBUG` level rather than `INFO` (#144)

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/lib/prefab/client.rb

@@ -6,6 +6,7 @@ module Prefab
   class Client
     MAX_SLEEP_SEC = 10
     BASE_SLEEP_SEC = 0.5
+    LOG = Prefab::InternalLogger.new(Client)
 
     attr_reader :namespace, :interceptor, :api_key, :prefab_api_url, :options, :instance_hash
 
@@ -14,15 +15,19 @@ module Prefab
       @namespace = @options.namespace
       @stubs = {}
       @instance_hash = UUID.new.generate
+      Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter,
+                                prefix: @options.log_prefix,
+                               log_path_aggregator: log_path_aggregator
+      )
 
       if @options.local_only?
-        log_internal ::Logger::DEBUG, 'Prefab Running in Local Mode'
+        LOG.debug 'Prefab Running in Local Mode'
       else
         @api_key = @options.api_key
         raise Prefab::Errors::InvalidApiKeyError, @api_key if @api_key.nil? || @api_key.empty? || api_key.count('-') < 1
 
         @prefab_api_url = @options.prefab_api_url
-        log_internal ::Logger::DEBUG, "Prefab Connecting to: #{@prefab_api_url}"
+        LOG.debug "Prefab Connecting to: #{@prefab_api_url}"
       end
 
       context.clear
@@ -54,9 +59,7 @@ module Prefab
     end
 
     def log
-      @logger_client ||= Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter,
-                                                                   prefix: @options.log_prefix,
-                                                                   log_path_aggregator: log_path_aggregator)
+      Prefab::LoggerClient.instance
     end
 
     def context_shape_aggregator
@@ -99,10 +102,6 @@ module Prefab
       resolver.on_update(&block)
     end
 
-    def log_internal(level, msg, path = nil, **tags)
-      log.log_internal msg, path, nil, level, tags
-    end
-
     def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
       feature_flag_client.feature_is_on_for?(feature_name, jit_context)
     end
@@ -133,7 +132,10 @@ module Prefab
     #   $prefab.set_rails_loggers
     # end
     def fork
-      Prefab::Client.new(@options)
+      log_options = self.log.context_keys.to_a # get keys pre-fork
+      Prefab::Client.new(@options.for_fork).tap do |client|
+        client.log.add_context_keys(*log_options)
+      end
     end
 
     private

data/lib/prefab/config_client.rb

@@ -5,13 +5,15 @@ module Prefab
     RECONNECT_WAIT = 5
     DEFAULT_CHECKPOINT_FREQ_SEC = 60
     SSE_READ_TIMEOUT = 300
+    STALE_CACHE_WARN_HOURS = 5
     AUTH_USER = 'authuser'
     LOGGING_KEY_PREFIX = "#{Prefab::LoggerClient::BASE_KEY}#{Prefab::LoggerClient::SEP}".freeze
+    LOG = Prefab::InternalLogger.new(ConfigClient)
 
     def initialize(base_client, timeout)
       @base_client = base_client
       @options = base_client.options
-      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient'
+      LOG.debug 'Initialize ConfigClient'
       @timeout = timeout
 
       @stream_lock = Concurrent::ReadWriteLock.new
@@ -22,9 +24,9 @@ module Prefab
       @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
 
       @initialization_lock = Concurrent::ReadWriteLock.new
-      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient: AcquireWriteLock'
+      LOG.debug 'Initialize ConfigClient: AcquireWriteLock'
       @initialization_lock.acquire_write_lock
-      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient: AcquiredWriteLock'
+      LOG.debug 'Initialize ConfigClient: AcquiredWriteLock'
       @initialized_future = Concurrent::Future.execute { @initialization_lock.acquire_read_lock }
 
       if @options.local_only?
@@ -95,8 +97,7 @@ module Prefab
           raise Prefab::Errors::InitializationTimeoutError.new(@options.initialization_timeout_sec, key)
         end
 
-        @base_client.log_internal ::Logger::WARN,
-                                  "Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have"
+        LOG.warn("Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have")
         @initialization_lock.release_write_lock
       end
 
@@ -112,7 +113,11 @@ module Prefab
 
       return if success
 
-      @base_client.log_internal ::Logger::WARN, 'No success loading checkpoints'
+      success = load_cache
+
+      return if success
+
+      LOG.warn 'No success loading checkpoints'
     end
 
     def load_checkpoint_api_cdn
@@ -130,13 +135,14 @@ module Prefab
       if resp.status == 200
         configs = PrefabProto::Configs.decode(resp.body)
         load_configs(configs, source)
+        cache_configs(configs)
         true
       else
-        @base_client.log_internal ::Logger::INFO, "Checkpoint #{source} failed to load. Response #{resp.status}"
+        LOG.info "Checkpoint #{source} failed to load. Response #{resp.status}"
         false
       end
     rescue StandardError => e
-      @base_client.log_internal ::Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+      LOG.warn "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
       false
     end
 
@@ -161,27 +167,66 @@ module Prefab
         @config_loader.set(config, source)
       end
       if @config_loader.highwater_mark > starting_highwater_mark
-        @base_client.log_internal ::Logger::DEBUG,
-                                  "Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
+        LOG.debug("Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{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.", 'load_configs'
+        LOG.debug("Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.")
       end
       @config_resolver.update
       finish_init!(source, project_id)
     end
 
+    def cache_path
+      return @cache_path unless @cache_path.nil?
+      @cache_path ||= calc_cache_path
+      FileUtils.mkdir_p(File.dirname(@cache_path))
+      @cache_path
+    end
+
+    def calc_cache_path
+      file_name = "prefab.cache.#{@base_client.options.api_key_id}.json"
+      dir = ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache'))
+      File.join(dir, file_name)
+    end
+
+    def cache_configs(configs)
+      return unless @options.use_local_cache && !@options.is_fork
+      File.open(cache_path, "w") do |f|
+        f.flock(File::LOCK_EX)
+        f.write(PrefabProto::Configs.encode_json(configs))
+      end
+      LOG.debug "Cached configs to #{cache_path}"
+    rescue => e
+      LOG.debug "Failed to cache configs to #{cache_path} #{e}"
+    end
+
+    def load_cache
+      return false unless @options.use_local_cache
+      File.open(cache_path) do |f|
+        f.flock(File::LOCK_SH)
+        configs = PrefabProto::Configs.decode_json(f.read)
+        load_configs(configs, :cache)
+
+        hours_old = ((Time.now - File.mtime(f)) / 60 / 60).round(2)
+        if hours_old > STALE_CACHE_WARN_HOURS
+          LOG.info "Stale Cache Load: #{hours_old} hours old"
+        end
+      end
+    rescue => e
+      LOG.debug "Failed to read cached configs at #{cache_path}. #{e}"
+      false
+    end
+
     # A thread that checks for a checkpoint
     def start_checkpointing_thread
       Thread.new do
         loop do
-          load_checkpoint
-
           started_at = Time.now
           delta = @checkpoint_freq_secs - (Time.now - started_at)
           sleep(delta) if delta > 0
+
+          load_checkpoint
         rescue StandardError => e
-          @base_client.log_internal ::Logger::DEBUG, "Issue Checkpointing #{e.message}"
+          LOG.debug "Issue Checkpointing #{e.message}"
         end
       end
     end
@@ -189,18 +234,19 @@ module Prefab
     def finish_init!(source, project_id)
       return unless @initialization_lock.write_locked?
 
-      @base_client.log_internal ::Logger::DEBUG, "Unlocked Config via #{source}"
+      LOG.debug "Unlocked Config via #{source}"
       @initialization_lock.release_write_lock
-      @base_client.log.config_client = self
+
+      Prefab::LoggerClient.instance.config_client = self
       presenter = Prefab::ConfigClientPresenter.new(
         size: @config_resolver.local_store.size,
         source: source,
         project_id: project_id,
         project_env_id: @config_resolver.project_env_id,
-        api_key: @base_client.options.api_key
+        api_key_id: @base_client.options.api_key_id
       )
-      @base_client.log_internal ::Logger::INFO, presenter.to_s
-      @base_client.log_internal ::Logger::DEBUG, to_s
+      LOG.info presenter.to_s
+      LOG.debug to_s
     end
 
     def start_sse_streaming_connection_thread(start_at_id)
@@ -212,11 +258,11 @@ module Prefab
         'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
       }
       url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
-      @base_client.log_internal ::Logger::DEBUG, "SSE Streaming Connect to #{url} start_at #{start_at_id}"
+      LOG.debug "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::SseLogger.new(@base_client.log)) do |client|
+                                          logger: Prefab::SseLogger.new) do |client|
         client.on_event do |event|
           configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
           load_configs(configs, :sse)

data/lib/prefab/config_client_presenter.rb

@@ -2,12 +2,12 @@
 
 module Prefab
   class ConfigClientPresenter
-    def initialize(size:, source:, project_id:, project_env_id:, api_key:)
+    def initialize(size:, source:, project_id:, project_env_id:, api_key_id:)
       @size = size
       @source = source
       @project_id = project_id
       @project_env_id = project_env_id
-      @api_key_id = api_key&.split("-")&.first
+      @api_key_id = api_key_id
     end
 
     def to_s

data/lib/prefab/config_loader.rb

@@ -2,6 +2,8 @@
 
 module Prefab
   class ConfigLoader
+    LOG = Prefab::InternalLogger.new(ConfigLoader)
+
     attr_reader :highwater_mark
 
     def initialize(base_client)
@@ -29,8 +31,8 @@ module Prefab
         @api_config.delete(config.key)
       else
         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}"
+          LOG.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

data/lib/prefab/config_value_unwrapper.rb

@@ -2,6 +2,7 @@
 
 module Prefab
   class ConfigValueUnwrapper
+    LOG = Prefab::InternalLogger.new(ConfigValueUnwrapper)
     attr_reader :value, :weighted_value_index
 
     def initialize(value, weighted_value_index = nil)
@@ -16,6 +17,7 @@ module Prefab
       when :string_list
         value.string_list.values
       else
+        LOG.error "Unknown type: #{config_value.type}"
         raise "Unknown type: #{config_value.type}"
       end
     end

data/lib/prefab/context_shape_aggregator.rb

@@ -6,6 +6,8 @@ module Prefab
   class ContextShapeAggregator
     include Prefab::PeriodicSync
 
+    LOG = Prefab::InternalLogger.new(ContextShapeAggregator)
+
     attr_reader :data
 
     def initialize(client:, max_shapes:, sync_interval:)
@@ -43,7 +45,7 @@ module Prefab
 
     def flush(to_ship, _)
       pool.post do
-        log_internal "Uploading context shapes for #{to_ship.values.size}"
+        LOG.debug "Uploading context shapes for #{to_ship.values.size}"
 
         shapes = PrefabProto::ContextShapes.new(
           shapes: to_ship.map do |name, shape|
@@ -56,7 +58,7 @@ module Prefab
 
         result = post('/api/v1/context-shapes', shapes)
 
-        log_internal "Uploaded #{to_ship.values.size} shapes: #{result.status}"
+        LOG.debug "Uploaded #{to_ship.values.size} shapes: #{result.status}"
       end
     end
   end

data/lib/prefab/criteria_evaluator.rb

@@ -7,6 +7,7 @@ module Prefab
   # This class evaluates a config's criteria. `evaluate` returns the value of
   # the first match based on the provided properties.
   class CriteriaEvaluator
+    LOG = Prefab::InternalLogger.new(CriteriaEvaluator)
     NAMESPACE_KEY = 'NAMESPACE'
     NO_MATCHING_ROWS = [].freeze
 
@@ -19,8 +20,10 @@ module Prefab
     end
 
     def evaluate(properties)
-      evaluate_for_env(@project_env_id, properties) ||
+      rtn = evaluate_for_env(@project_env_id, properties) ||
         evaluate_for_env(0, properties)
+      LOG.debug "Eval Key #{@config.key} Result #{rtn&.value} with #{properties.to_h}" unless @config.config_type == :LOG_LEVEL
+      rtn
     end
 
     def all_criteria_match?(conditional_value, props)

data/lib/prefab/evaluation_summary_aggregator.rb

@@ -9,6 +9,8 @@ module Prefab
   class EvaluationSummaryAggregator
     include Prefab::PeriodicSync
 
+    LOG = Prefab::InternalLogger.new(EvaluationSummaryAggregator)
+
     attr_reader :data
 
     def initialize(client:, max_keys:, sync_interval:)
@@ -47,7 +49,7 @@ module Prefab
 
     def flush(to_ship, start_at_was)
       pool.post do
-        log_internal "Flushing #{to_ship.size} summaries"
+        LOG.debug "Flushing #{to_ship.size} summaries"
 
         summaries_proto = PrefabProto::ConfigEvaluationSummaries.new(
           start: start_at_was,
@@ -57,7 +59,7 @@ module Prefab
 
         result = post('/api/v1/telemetry', events(summaries_proto))
 
-        log_internal "Uploaded #{to_ship.size} summaries: #{result.status}"
+        LOG.debug "Uploaded #{to_ship.size} summaries: #{result.status}"
       end
     end
 

data/lib/prefab/example_contexts_aggregator.rb

@@ -10,6 +10,8 @@ module Prefab
   class ExampleContextsAggregator
     include Prefab::PeriodicSync
 
+    LOG = Prefab::InternalLogger.new(ExampleContextsAggregator)
+
     attr_reader :data, :cache
 
     ONE_HOUR = 60 * 60
@@ -43,11 +45,11 @@ module Prefab
 
     def flush(to_ship, _)
       pool.post do
-        log_internal "Flushing #{to_ship.size} examples"
+        LOG.debug "Flushing #{to_ship.size} examples"
 
         result = post('/api/v1/telemetry', events(to_ship))
 
-        log_internal "Uploaded #{to_ship.size} examples: #{result.status}"
+        LOG.debug "Uploaded #{to_ship.size} examples: #{result.status}"
       end
     end
 

data/lib/prefab/internal_logger.rb

@@ -2,29 +2,32 @@
 
 module Prefab
   class InternalLogger < ::Logger
-    def initialize(path, logger)
-      @path = path
-      @logger = logger
+    def initialize(path)
+      if path.is_a?(Class)
+        @path = path.name.split('::').last.downcase
+      else
+        @path = path
+      end
     end
 
-    def debug(progname = nil)
-      @logger.log_internal yield, @path, progname, DEBUG
+    def debug msg
+      Prefab::LoggerClient.instance.log_internal ::Logger::DEBUG, msg, @path
     end
 
-    def info(progname = nil)
-      @logger.log_internal yield, @path, progname, INFO
+    def info msg
+      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, msg, @path
     end
 
-    def warn(progname = nil)
-      @logger.log_internal yield, @path, progname, WARN
+    def warn msg
+      Prefab::LoggerClient.instance.log_internal ::Logger::WARN, msg, @path
     end
 
-    def error(progname = nil)
-      @logger.log_internal yield, @path, progname, ERROR
+    def error msg
+      Prefab::LoggerClient.instance.log_internal ::Logger::ERROR, msg, @path
     end
 
-    def fatal(progname = nil)
-      @logger.log_internal yield, @path, progname, FATAL
+    def fatal msg
+      Prefab::LoggerClient.instance.log_internal ::Logger::FATAL, msg, @path
     end
   end
 end

data/lib/prefab/log_path_aggregator.rb

@@ -4,6 +4,8 @@ require_relative 'periodic_sync'
 
 module Prefab
   class LogPathAggregator
+    LOG = Prefab::InternalLogger.new(LogPathAggregator)
+
     include Prefab::PeriodicSync
 
     INCREMENT = ->(count) { (count || 0) + 1 }
@@ -41,7 +43,7 @@ module Prefab
 
     def flush(to_ship, start_at_was)
       pool.post do
-        log_internal "Uploading stats for #{to_ship.size} paths"
+        LOG.debug "Uploading stats for #{to_ship.size} paths"
 
         aggregate = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }
 
@@ -60,7 +62,7 @@ module Prefab
 
         result = post('/api/v1/known-loggers', loggers)
 
-        log_internal "Uploaded #{to_ship.size} paths: #{result.status}"
+        LOG.debug "Uploaded #{to_ship.size} paths: #{result.status}"
       end
     end
   end

data/lib/prefab/logger_client.rb

@@ -17,16 +17,42 @@ module Prefab
       PrefabProto::LogLevel::FATAL => ::Logger::FATAL
     }.freeze
 
-    def initialize(logdev, log_path_aggregator: nil, formatter: nil, prefix: nil)
+    def self.instance
+      @@shared_instance ||= LoggerClient.new($stdout)
+    end
+
+    attr_reader :context_keys
+
+    def initialize(logdev, log_path_aggregator: nil, formatter: Options::DEFAULT_LOG_FORMATTER, prefix: nil)
       super(logdev)
       self.formatter = formatter
       @config_client = BootstrappingConfigClient.new
       @silences = Concurrent::Map.new(initial_capacity: 2)
+      @recurse_check = Concurrent::Map.new(initial_capacity: 2)
       @prefix = "#{prefix}#{prefix && '.'}"
 
+      @context_keys = Concurrent::Set.new
+
       @log_path_aggregator = log_path_aggregator
+      @@shared_instance = self
+    end
+
+    def add_context_keys(*keys)
+      @context_keys += keys
     end
 
+    def with_context_keys(*keys)
+      @context_keys += keys
+      yield
+    ensure
+      @context_keys -= keys
+    end
+
+    def internal_logger(path=nil)
+      InternalLogger.new(path, self)
+    end
+    
+    # InternalLoggers Will Call This
     def add_internal(severity, message, progname, loc, log_context={}, &block)
       path_loc = get_loc_path(loc)
       path = @prefix + path_loc
@@ -36,19 +62,24 @@ module Prefab
       log(message, path, progname, severity, log_context, &block)
     end
 
-    def log_internal(message, path, progname, severity, log_context={}, &block)
+    def log_internal(severity, message, path, log_context={}, &block)
+      return if @recurse_check[local_log_id]
+      @recurse_check[local_log_id] = true
+
       path = if path
                "#{INTERNAL_PREFIX}.#{path}"
              else
                INTERNAL_PREFIX
              end
-
-      log(message, path, progname, severity, log_context, &block)
+      begin
+        log(message, path, nil, severity, log_context, &block)
+      ensure
+        @recurse_check[local_log_id] = false
+      end
     end
 
     def log(message, path, progname, severity, log_context={})
       severity ||= ::Logger::UNKNOWN
-
       return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
       progname = @progname if progname.nil?
@@ -63,7 +94,7 @@ module Prefab
       end
 
       @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message, path, log_context)
+        format_message(format_severity(severity), Time.now, progname, message, path, stringify_keys(log_context.merge(fetch_context_for_context_keys)))
       )
       true
     end
@@ -131,6 +162,17 @@ module Prefab
 
     NO_DEFAULT = nil
 
+    def stringify_keys(hash)
+      Hash[hash.map { |k, v| [k.to_s, v] }]
+    end
+
+    def fetch_context_for_context_keys
+      context = Prefab::Context.current.to_h
+      Hash[@context_keys.map do |key|
+        [key, context.dig(*key.split("."))]
+      end]
+    end
+
     # Find the closest match to 'log_level.path' in config
     def level_of(path)
       closest_log_level_match = nil

data/lib/prefab/options.rb

@@ -16,6 +16,8 @@ module Prefab
     attr_reader :prefab_config_classpath_dir
     attr_reader :prefab_envs
     attr_reader :collect_sync_interval
+    attr_reader :use_local_cache
+    attr_accessor :is_fork
 
     DEFAULT_LOG_FORMATTER = proc { |data|
       severity = data[:severity]
@@ -27,7 +29,9 @@ module Prefab
 
       progname = (progname.nil? || progname.empty?) ? path : "#{progname}: #{path}"
 
-      formatted_log_context = log_context.sort.map{|k, v| "#{k}=#{v}" }.join(" ")
+      formatted_log_context = log_context.sort.map do |k, v|
+        v.nil? ? nil : "#{k}=#{v}"
+      end.compact.join(" ")
       "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}#{log_context.any? ? " " + formatted_log_context : ""}\n"
     }
 
@@ -77,7 +81,8 @@ module Prefab
       context_max_size: DEFAULT_MAX_EVAL_SUMMARIES,
       collect_evaluation_summaries: true,
       collect_max_evaluation_summaries: DEFAULT_MAX_EVAL_SUMMARIES,
-      allow_telemetry_in_local_mode: false
+      allow_telemetry_in_local_mode: false,
+      x_use_local_cache: false
     )
       @api_key = api_key
       @logdev = logdev
@@ -98,6 +103,8 @@ module Prefab
       @collect_evaluation_summaries = collect_evaluation_summaries
       @collect_max_evaluation_summaries = collect_max_evaluation_summaries
       @allow_telemetry_in_local_mode = allow_telemetry_in_local_mode
+      @use_local_cache = x_use_local_cache
+      @is_fork = false
 
       # defaults that may be overridden by context_upload_mode
       @collect_shapes = false
@@ -156,6 +163,16 @@ module Prefab
       ENV['PREFAB_CDN_URL'] || "#{@prefab_api_url.gsub(/\./, '-')}.global.ssl.fastly.net"
     end
 
+    def api_key_id
+      @api_key&.split("-")&.first
+    end
+
+    def for_fork
+      clone = self.clone
+      clone.is_fork = true
+      clone
+    end
+
     private
 
     def telemetry_allowed?(option)

data/lib/prefab/periodic_sync.rb

@@ -2,10 +2,11 @@
 
 module Prefab
   module PeriodicSync
+    LOG = Prefab::InternalLogger.new("periodsync")
     def sync
       return if @data.size.zero?
 
-      log_internal "Syncing #{@data.size} items"
+      LOG.debug "Syncing #{@data.size} items"
 
       start_at_was = @start_at
       @start_at = Prefab::TimeHelpers.now_in_ms
@@ -36,7 +37,7 @@ module Prefab
       @sync_interval = calculate_sync_interval(sync_interval)
 
       Thread.new do
-        log_internal "Initialized #{@name} instance_hash=#{@client.instance_hash}"
+        LOG.debug "Initialized #{@name} instance_hash=#{@client.instance_hash}"
 
         loop do
           sleep @sync_interval.call
@@ -45,10 +46,6 @@ module Prefab
       end
     end
 
-    def log_internal(message)
-      @client.log.log_internal message, @name, nil, ::Logger::DEBUG
-    end
-
     def pool
       @pool ||= Concurrent::ThreadPoolExecutor.new(
         fallback_policy: :discard,

data/lib/prefab/prefab.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Prefab
+  @@lock = Concurrent::ReadWriteLock.new
+
+  def self.init(options = Prefab::Options.new)
+    unless @singleton.nil?
+      Prefab::LoggerClient.instance.warn 'Prefab already initialized.'
+      return @singleton
+    end
+
+    @@lock.with_write_lock {
+      @singleton = Prefab::Client.new(options)
+    }
+  end
+
+  def self.fork
+    ensure_initialized
+    @@lock.with_write_lock {
+      @singleton = @singleton.fork
+    }
+  end
+
+  def self.set_rails_loggers
+    ensure_initialized
+    @singleton.set_rails_loggers
+  end
+
+  def self.get(key, properties = NO_DEFAULT_PROVIDED)
+    ensure_initialized
+    @singleton.get(key, properties)
+  end
+
+  def self.enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
+    ensure_initialized
+    @singleton.enabled?(feature_name, jit_context)
+  end
+
+  def self.with_context(properties, &block)
+    ensure_initialized
+    @singleton.with_context(properties, &block)
+  end
+
+  def self.instance
+    ensure_initialized
+    @singleton
+  end
+
+  private
+
+  def self.ensure_initialized
+    if not defined? @singleton or @singleton.nil?
+      raise "Use Prefab.initialize before calling Prefab.get"
+    end
+  end
+end

data/lib/prefab/sse_logger.rb

@@ -1,14 +1,30 @@
 # frozen_string_literal: true
 
 module Prefab
-  class SseLogger < InternalLogger
-    def initialize(logger)
-      super('sse', logger)
+  class SseLogger < ::Logger
+    def initialize()
+      @path = "sse"
+    end
+
+    def debug(progname = nil, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::DEBUG, progname, @path, &block
+    end
+
+    def info(progname = nil, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, progname, @path, &block
     end
 
     # The SSE::Client warns on a perfectly normal stream disconnect, recast to info
-    def warn(progname = nil)
-      @logger.log_internal yield, @path, progname, INFO
+    def warn(progname = nil, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, progname, @path, &block
+    end
+
+    def error(progname = nil, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::ERROR, progname, @path, &block
+    end
+
+    def fatal(progname = nil, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::FATAL, progname, @path, &block
     end
   end
 end

data/lib/prefab/yaml_config_parser.rb

@@ -2,6 +2,8 @@ require 'yaml'
 
 module Prefab
   class YAMLConfigParser
+    LOG = Prefab::InternalLogger.new(YAMLConfigParser)
+
     def initialize(file, client)
       @file = file
       @client = client
@@ -21,10 +23,10 @@ module Prefab
 
     def load
       if File.exist?(@file)
-        @client.log_internal ::Logger::INFO, "Load #{@file}"
+        LOG.info "Load #{@file}"
         YAML.load_file(@file)
       else
-        @client.log_internal ::Logger::INFO, "No file #{@file}"
+        LOG.info "No file #{@file}"
         {}
       end
     end

data/lib/prefab-cloud-ruby.rb

@@ -43,4 +43,5 @@ require 'prefab/client'
 require 'prefab/config_client_presenter'
 require 'prefab/config_client'
 require 'prefab/feature_flag_client'
+require 'prefab/prefab'
 require 'prefab/murmer3'

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 1.1.1 ruby lib
+# stub: prefab-cloud-ruby 1.2.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "1.1.1"
+  s.version = "1.2.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 = "2023-10-11"
+  s.date = "2023-10-30"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.executables = ["console".freeze]
@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
     "README.md"
   ]
   s.files = [
-    ".envrc",
     ".envrc.sample",
     ".github/workflows/ruby.yml",
     ".gitmodules",
@@ -66,6 +65,7 @@ Gem::Specification.new do |s|
     "lib/prefab/murmer3.rb",
     "lib/prefab/options.rb",
     "lib/prefab/periodic_sync.rb",
+    "lib/prefab/prefab.rb",
     "lib/prefab/rate_limit_cache.rb",
     "lib/prefab/resolved_config_presenter.rb",
     "lib/prefab/sse_logger.rb",
@@ -101,7 +101,9 @@ Gem::Specification.new do |s|
     "test/test_local_config_parser.rb",
     "test/test_log_path_aggregator.rb",
     "test/test_logger.rb",
+    "test/test_logger_initialization.rb",
     "test/test_options.rb",
+    "test/test_prefab.rb",
     "test/test_rate_limit_cache.rb",
     "test/test_weighted_value_resolver.rb"
   ]

data/test/support/common_helpers.rb

@@ -44,24 +44,26 @@ module CommonHelpers
   }.freeze
 
   def new_client(overrides = {})
-    $logs ||= StringIO.new
 
     config = overrides.delete(:config)
     project_env_id = overrides.delete(:project_env_id)
 
-    options = Prefab::Options.new(
-      **DEFAULT_NEW_CLIENT_OPTIONS.merge(
-        overrides.merge(logdev: $logs)
-      )
-    )
-
-    Prefab::Client.new(options).tap do |client|
+    Prefab::Client.new(prefab_options(overrides)).tap do |client|
       inject_config(client, config) if config
 
       client.resolver.project_env_id = project_env_id if project_env_id
     end
   end
 
+  def prefab_options(overrides = {})
+    $logs ||= StringIO.new
+    Prefab::Options.new(
+      **DEFAULT_NEW_CLIENT_OPTIONS.merge(
+        overrides.merge(logdev: $logs)
+      )
+    )
+  end
+
   def string_list(values)
     PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
   end
@@ -145,7 +147,7 @@ module CommonHelpers
   end
 
   def assert_only_expected_logs
-    assert_equal "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints\n", $logs.string
+    assert_equal "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints\n", $logs.string
     # mark nil to indicate we handled it
     $logs = nil
   end

data/test/support/mock_base_client.rb

@@ -9,8 +9,8 @@ class MockBaseClient
   def initialize(options = Prefab::Options.new)
     @options = options
     @namespace = namespace
-    @logger = Prefab::LoggerClient.new($stdout)
     @config_client = MockConfigClient.new
+    Prefab::LoggerClient.new(options.logdev)
     @posts = []
   end
 
@@ -30,8 +30,6 @@ class MockBaseClient
     @logger
   end
 
-  def log_internal(level, message); end
-
   def context_shape_aggregator; end
 
   def evaluation_summary_aggregator; end

data/test/test_client.rb

@@ -185,7 +185,7 @@ class TestClient < Minitest::Test
                             collect_evaluation_summaries: true).evaluation_summary_aggregator.class
 
     assert_logged [
-      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints"
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints"
     ]
   end
 
@@ -395,7 +395,7 @@ class TestClient < Minitest::Test
           values: [
             PrefabProto::ConditionalValue.new(
               criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
-              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::DEBUG)
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::INFO)
             )
           ]
         )
@@ -405,12 +405,21 @@ class TestClient < Minitest::Test
     client = new_client(config: config, project_env_id: PROJECT_ENV_ID,
                         collect_evaluation_summaries: true, allow_telemetry_in_local_mode: true)
 
-    assert_equal :DEBUG, client.get(config.key, IRRELEVANT)
+    assert_equal :INFO, client.get(config.key, IRRELEVANT)
 
     # nothing is summarized for log levels
     assert_summary client, {}
   end
 
+  def test_fork_includes_logger_context_keys
+    client = new_client
+    client.log.add_context_keys "user.name"
+
+    forked = client.fork
+
+    assert forked.log.context_keys.to_a == %w(user.name)
+  end
+
   private
 
   def basic_value_config

data/test/test_config_client.rb

@@ -9,7 +9,8 @@ class TestConfigClient < Minitest::Test
       prefab_config_override_dir: 'none',
       prefab_config_classpath_dir: 'test',
       prefab_envs: 'unit_tests',
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY,
+      x_use_local_cache: true,
     )
 
     @config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
@@ -73,4 +74,36 @@ class TestConfigClient < Minitest::Test
 
     assert_match(/format is invalid/, err.message)
   end
+
+  def test_caching
+    @config_client.send(:cache_configs,
+                        PrefabProto::Configs.new(configs:
+                                                   [PrefabProto::Config.new(key: 'test', id: 1,
+                                                                            rows: [PrefabProto::ConfigRow.new(
+                                                                              values: [
+                                                                                PrefabProto::ConditionalValue.new(
+                                                                                  value: PrefabProto::ConfigValue.new(string: "test value")
+                                                                                )
+                                                                              ]
+                                                                            )])],
+                                                 config_service_pointer: PrefabProto::ConfigServicePointer.new(project_id: 3, project_env_id: 5)))
+    @config_client.send(:load_cache)
+    assert_equal "test value", @config_client.get("test")
+  end
+
+  def test_cache_path_respects_xdg
+    options = Prefab::Options.new(
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY,
+      x_use_local_cache: true,
+      api_key: "123-ENV-KEY-SDK",)
+
+    config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
+    assert_equal "#{Dir.home}/.cache/prefab.cache.123.json", config_client.send(:cache_path)
+
+    with_env('XDG_CACHE_HOME', '/tmp') do
+      config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
+      assert_equal "/tmp/prefab.cache.123.json", config_client.send(:cache_path)
+    end
+  end
+
 end

data/test/test_context_shape_aggregator.rb

@@ -124,8 +124,8 @@ class TestContextShapeAggregator < Minitest::Test
 
 
     assert_logged [
-      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints",
-      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client Couldn't Initialize In 0. Key some.key. Returning what we have"
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints",
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient Couldn't Initialize In 0. Key some.key. Returning what we have"
     ]
   end
 

data/test/test_criteria_evaluator.rb

@@ -710,18 +710,9 @@ class TestCriteriaEvaluator < Minitest::Test
     FakeResolver.new(config, @base_client)
   end
 
-  class FakeLogger
-    def info(msg)
-      # loudly complain about unexpected log messages
-      raise msg
-    end
-
-    def log_internal(*args); end
-  end
-
   class FakeBaseClient
-    def log
-      FakeLogger.new
+    def initialize
+      Prefab::LoggerClient.new($stdout)
     end
 
     def evaluation_summary_aggregator

data/test/test_helper.rb

@@ -3,7 +3,7 @@
 require 'minitest/autorun'
 require 'minitest/focus'
 require 'minitest/reporters'
-Minitest::Reporters.use!
+Minitest::Reporters.use! unless ENV['RM_INFO']
 
 require 'prefab-cloud-ruby'
 

data/test/test_log_path_aggregator.rb

@@ -47,7 +47,7 @@ class TestLogPathAggregator < Minitest::Test
       ]], requests
 
       assert_logged [
-        'WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints',
+        'WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints',
         'ERROR 2023-08-09 15:18:12 -0400: test.test_log_path_aggregator.test_sync here is a message'
       ]
     end

data/test/test_logger.rb

@@ -87,22 +87,22 @@ class TestLogger < Minitest::Test
 
   def test_log_internal
     prefab, io = captured_logger
-    prefab.log.log_internal('test message', 'test.path', '', ::Logger::WARN)
+    prefab.log.log_internal(::Logger::WARN, 'test message', 'test.path')
     assert_logged io, 'WARN', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_unknown
     prefab, io = captured_logger
-    prefab.log.log_internal('test message', 'test.path', '', ::Logger::UNKNOWN)
+    prefab.log.log_internal(::Logger::UNKNOWN, 'test message', 'test.path')
     assert_logged io, 'ANY', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_silencing
     prefab, io = captured_logger
     prefab.log.silence do
-      prefab.log.log_internal('should not log', 'test.path', '', ::Logger::WARN)
+      prefab.log.log_internal(::Logger::WARN, 'should not log', 'test.path')
     end
-    prefab.log.log_internal('should log', 'test.path', '', ::Logger::WARN)
+    prefab.log.log_internal(::Logger::WARN, 'should log', 'test.path')
     assert_logged io, 'WARN', "cloud.prefab.client.test.path", "should log"
     refute_logged io, 'should not log'
   end
@@ -404,6 +404,35 @@ class TestLogger < Minitest::Test
     assert_logged io, 'ERROR', 'test.test_logger.test_logging_with_a_block', message
   end
 
+  def test_add_context_keys
+    assert @logger.context_keys.empty?
+    @logger.add_context_keys("user.name", "role.admin", "company.name")
+
+    assert @logger.context_keys.to_a == %w(user.name role.admin company.name)
+  end
+
+  def test_context_keys_are_a_set
+    @logger.add_context_keys("user.name", "role.admin", "company.name")
+
+    assert @logger.context_keys.to_a == %w(user.name role.admin company.name)
+
+    @logger.add_context_keys("user.name", "user.role")
+
+    assert @logger.context_keys.to_a == %w(user.name role.admin company.name user.role)
+  end
+
+  def test_with_context_keys
+    @logger.add_context_keys("company.name")
+
+    assert @logger.context_keys.to_a == %w(company.name)
+
+    @logger.with_context_keys("user.name", "role.admin") do
+      assert @logger.context_keys.to_a == %w(company.name user.name role.admin)
+    end
+
+    assert @logger.context_keys.to_a == %w(company.name)
+  end
+
   def test_structured_logging
     prefab, io = captured_logger
     message = 'HELLO'
@@ -428,7 +457,7 @@ class TestLogger < Minitest::Test
   def test_structured_internal_logging
     prefab, io = captured_logger
 
-    prefab.log.log_internal('test', 'test.path', '', ::Logger::WARN, user: "michael")
+    prefab.log.log_internal(::Logger::WARN, 'test', 'test.path', user: "michael")
 
     assert_logged io, 'WARN', 'cloud.prefab.client.test.path', "test user=michael"
   end
@@ -444,6 +473,75 @@ class TestLogger < Minitest::Test
     assert_logged io, 'ERROR', 'test.test_logger.test_structured_block_logger', "#{message} user=michael"
   end
 
+  def test_structured_logger_with_context_keys
+    prefab, io = captured_logger
+
+    prefab.with_context({user: {name: "michael", job: "developer", admin: false}, company: { name: "Prefab" }}) do
+
+      prefab.log.add_context_keys "user.name", "company.name", "user.admin"
+
+      prefab.log.error "UH OH"
+
+      assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys',
+        "UH OH company.name=Prefab user.admin=false user.name=michael"
+    end
+  end
+
+  def test_structured_logger_with_context_keys_ignores_nils
+    prefab, io = captured_logger
+
+    prefab.with_context({user: {name: "michael", job: "developer"}, company: { name: "Prefab" }}) do
+
+      prefab.log.add_context_keys "user.name", "company.name", "user.admin"
+
+      prefab.log.error "UH OH"
+
+      assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys_ignores_nils',
+        "UH OH company.name=Prefab user.name=michael"
+    end
+  end
+
+  def test_structured_logger_with_context_keys_and_log_hash
+    prefab, io = captured_logger
+
+    prefab.with_context({user: {name: "michael", job: "developer", admin: false}, company: { name: "Prefab" }}) do
+
+      prefab.log.add_context_keys "user.name", "company.name", "user.admin"
+
+      prefab.log.error "UH OH", user_id: 6
+
+      assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys_and_log_hash',
+        "UH OH company.name=Prefab user.admin=false user.name=michael user_id=6"
+    end
+
+  end
+
+  def test_structured_logger_with_context_keys_block
+    prefab, io = captured_logger
+
+    prefab.with_context({user: {name: "michael", job: "developer", admin: false}, company: { name: "Prefab" }}) do
+
+      prefab.log.add_context_keys "user.name"
+
+      prefab.log.error "UH OH"
+
+      assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys_block',
+        'UH OH user.name=michael'
+
+      prefab.log.with_context_keys("company.name") do
+        prefab.log.error "UH OH"
+
+        assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys_block',
+          'UH OH company.name=Prefab user.name=michael'
+      end
+
+      prefab.log.error "UH OH"
+
+      assert_logged io, 'ERROR', 'test.test_logger.test_structured_logger_with_context_keys_block',
+        'UH OH user.name=michael'
+    end
+  end
+
   private
 
   def assert_logged(logged_io, level, path, message)

data/test/test_logger_initialization.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestLoggerInitialization < Minitest::Test
+
+  def test_init_out_of_order
+    # assert nothing blows up
+    Prefab::LoggerClient.instance.info "anything"
+  end
+
+end

data/test/test_prefab.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestPrefab < Minitest::Test
+  def test_get
+    Prefab.init(prefab_options)
+    assert_equal 'default', Prefab.get('does.not.exist', 'default')
+    assert_equal 'test sample value', Prefab.get('sample')
+    assert_equal 123, Prefab.get('sample_int')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-11 00:00:00.000000000 Z
+date: 2023-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -180,7 +180,6 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- ".envrc"
 - ".envrc.sample"
 - ".github/workflows/ruby.yml"
 - ".gitmodules"
@@ -225,6 +224,7 @@ files:
 - lib/prefab/murmer3.rb
 - lib/prefab/options.rb
 - lib/prefab/periodic_sync.rb
+- lib/prefab/prefab.rb
 - lib/prefab/rate_limit_cache.rb
 - lib/prefab/resolved_config_presenter.rb
 - lib/prefab/sse_logger.rb
@@ -260,7 +260,9 @@ files:
 - test/test_local_config_parser.rb
 - test/test_log_path_aggregator.rb
 - test/test_logger.rb
+- test/test_logger_initialization.rb
 - test/test_options.rb
+- test/test_prefab.rb
 - test/test_rate_limit_cache.rb
 - test/test_weighted_value_resolver.rb
 homepage: http://github.com/prefab-cloud/prefab-cloud-ruby

data/.envrc

@@ -1,2 +0,0 @@
-export AWS_ACCESS_KEY_ID=
-export AWS_SECRET_ACCESS_KEY=