prefab-cloud-ruby 1.5.0 → 1.6.0.pre1

data/lib/prefab/logger_client.rb

@@ -1,99 +1,24 @@
 # frozen_string_literal: true
 
 module Prefab
-  class LoggerClient < ::Logger
+  class LoggerClient
     SEP = '.'
     BASE_KEY = 'log-level'
-    UNKNOWN_PATH = 'unknown.'
-    LOG_TAGS = 'log.tags'
-    REQ_TAGS = 'req.tags'
+    NO_DEFAULT = nil
 
     LOG_LEVEL_LOOKUPS = {
-      PrefabProto::LogLevel::NOT_SET_LOG_LEVEL => ::Logger::DEBUG,
-      PrefabProto::LogLevel::TRACE => ::Logger::DEBUG,
-      PrefabProto::LogLevel::DEBUG => ::Logger::DEBUG,
-      PrefabProto::LogLevel::INFO => ::Logger::INFO,
-      PrefabProto::LogLevel::WARN => ::Logger::WARN,
-      PrefabProto::LogLevel::ERROR => ::Logger::ERROR,
-      PrefabProto::LogLevel::FATAL => ::Logger::FATAL
+      PrefabProto::LogLevel::NOT_SET_LOG_LEVEL => :trace,
+      PrefabProto::LogLevel::TRACE => :trace,
+      PrefabProto::LogLevel::DEBUG => :debug,
+      PrefabProto::LogLevel::INFO => :info,
+      PrefabProto::LogLevel::WARN => :warn,
+      PrefabProto::LogLevel::ERROR => :error,
+      PrefabProto::LogLevel::FATAL => :fatal
     }.freeze
 
-    def self.instance
-      @@shared_instance ||= LoggerClient.new($stdout)
-    end
-
-    def initialize(logdev, log_path_aggregator: nil, formatter: Options::DEFAULT_LOG_FORMATTER, prefix: nil)
-      super(logdev)
-      self.formatter = Prefab::Logging::FormatterBase.new(formatter_proc: formatter, logger_client: self)
-      @config_client = BootstrappingConfigClient.new
-      @silences = Concurrent::Map.new(initial_capacity: 2)
-      @recurse_check = Concurrent::Map.new(initial_capacity: 2)
-      @prefix = "#{prefix}#{prefix && '.'}"
-
-      @context_keys_map = Concurrent::Map.new(initial_capacity: 4)
-
+    def initialize(client: ,log_path_aggregator: )
+      @config_client = client
       @log_path_aggregator = log_path_aggregator
-      @@shared_instance = self
-    end
-
-    def add_context_keys(*keys)
-      context_keys.merge(keys)
-    end
-
-    def with_context_keys(*keys)
-      context_keys.merge(keys)
-      yield
-    ensure
-      context_keys.subtract(keys)
-    end
-
-    def internal_logger(path = nil)
-      InternalLogger.new(path, self)
-    end
-
-    def context_keys
-      @context_keys_map.fetch_or_store(local_log_id, Concurrent::Set.new)
-    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
-
-      log(message, path, progname, severity, log_context, &block)
-    end
-
-    def log_internal(severity, message, path, log_context = {}, &block)
-      return if @recurse_check[local_log_id]
-      @recurse_check[local_log_id] = true
-      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 !should_log? severity, path
-      return true if @logdev.nil? || @silences[local_log_id]
-
-      progname = @progname if progname.nil?
-
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message, path, stringify_keys(log_context.merge(fetch_context_for_context_keys)))
-      )
-      true
     end
 
     def should_log?(severity, path)
@@ -101,106 +26,32 @@ module Prefab
       severity >= level_of(path)
     end
 
-    def debug(progname = nil, **log_context, &block)
-      add_internal(DEBUG, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def info(progname = nil, **log_context, &block)
-      add_internal(INFO, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def warn(progname = nil, **log_context, &block)
-      add_internal(WARN, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def error(progname = nil, **log_context, &block)
-      add_internal(ERROR, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def fatal(progname = nil, **log_context, &block)
-      add_internal(FATAL, nil, progname, caller_locations(1, 1)[0], log_context, &block)
+    def semantic_filter(log)
+      class_path = class_path_name(log.name)
+      lookup_path = "#{logger_prefix}.#{class_path}"
+      level = SemanticLogger::Levels.index(log.level)
+      log.named_tags.merge!({ path: lookup_path })
+      should_log? level, lookup_path
     end
 
-    def debug?
-      true
-    end
-
-    def info?
-      true
-    end
-
-    def warn?
-      true
-    end
-
-    def error?
-      true
-    end
-
-    def fatal?
-      true
-    end
-
-    def level
-      DEBUG
-    end
-
-    def tagged(*tags)
-      to_add = tags.flatten.compact
-      if block_given?
-        new_log_tags = current_tags
-        new_log_tags += to_add unless to_add.empty?
-        Prefab::Context.with_merged_context({ "log" => { "tags" => new_log_tags } }) do
-          with_context_keys LOG_TAGS do
-            yield self
-          end
-        end
-      else
-        new_log_tags = Prefab::Context.current.get(REQ_TAGS) || []
-        new_log_tags += to_add unless to_add.empty?
-        add_context_keys REQ_TAGS
-        Prefab::Context.current.set("req", {"tags": new_log_tags})
-        self
-      end
-    end
-
-    def current_tags
-      Prefab::Context.current.get(LOG_TAGS) || []
-    end
-
-    def flush
-      Prefab::Context.current.set("req", {"tags": nil})
-      super if defined?(super)
-    end
 
     def config_client=(config_client)
       @config_client = config_client
     end
 
-    def local_log_id
-      Thread.current.__id__
-    end
-
-    def silence
-      @silences[local_log_id] = true
-      yield self
-    ensure
-      @silences[local_log_id] = false
-    end
-
     private
 
-    NO_DEFAULT = nil
-
-    def stringify_keys(hash)
-      Hash[hash.map { |k, v| [k.to_s, v] }]
+    def class_path_name(class_name)
+      log_class = Logger.const_get(class_name)
+      if log_class.respond_to?(:superclass) && log_class.superclass != Object
+        underscore("#{log_class.superclass.name}.#{log_class.name}")
+      else
+        underscore("#{log_class.name}")
+      end.gsub(/[^a-z_]/i, '.')
     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]
+    def logger_prefix
+      Context.current.get("application.key") ||  "prefab-cloud-ruby"
     end
 
     # Find the closest match to 'log_level.path' in config
@@ -219,46 +70,16 @@ module Prefab
       end
 
       closest_log_level_match_int = PrefabProto::LogLevel.resolve(closest_log_level_match)
-      LOG_LEVEL_LOOKUPS[closest_log_level_match_int]
+      internal_convert = LOG_LEVEL_LOOKUPS[closest_log_level_match_int]
+      return SemanticLogger::Levels.index(internal_convert)
     end
 
-    def get_loc_path(loc)
-      loc_path = loc.absolute_path || loc.to_s
-      get_path(loc_path, loc.base_label)
-    end
-
-    # 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 || UNKNOWN_PATH).dup
-      path.slice! Dir.pwd
-      path.gsub!(%r{(.*)?(?=/lib)}im, '') # replace everything before first lib
-
-      path = path.gsub('/', SEP).gsub(/.rb.*/, '') + SEP + base_label
-      path.slice! '.lib'
-      path.slice! SEP
-      path
-    end
-
-    def format_message(severity, datetime, progname, msg, path = nil, log_context = {})
-      formatter = (@formatter || @default_formatter)
-      compact_context = log_context.reject{ |_, v| v.nil? || ((v.is_a? Array) && v.empty?) }
-      @formatter.call_proc(
-        severity: severity,
-        datetime: datetime,
-        progname: progname,
-        path: path,
-        message: msg,
-        log_context: compact_context
-      )
-    end
-  end
-
-  # StubConfigClient to be used while config client initializes
-  # since it may log
-  class BootstrappingConfigClient
-    def get(_key, default = nil, _properties = {})
-      ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].upcase.to_sym : default
+    def underscore(string)
+      string.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
     end
   end
 end

data/lib/prefab/options.rb

@@ -4,9 +4,6 @@ module Prefab
   # This class contains all the options that can be passed to the Prefab client.
   class Options
     attr_reader :api_key
-    attr_reader :logdev
-    attr_reader :log_prefix
-    attr_reader :log_formatter
     attr_reader :namespace
     attr_reader :prefab_api_url
     attr_reader :on_no_default
@@ -21,39 +18,6 @@ module Prefab
     attr_reader :disable_action_controller_logging
     attr_accessor :is_fork
 
-    DEFAULT_LOG_FORMATTER = proc { |data|
-      severity = data[:severity]
-      datetime = data[:datetime]
-      progname = data[:progname]
-      path = data[:path]
-      msg = data[:message]
-      log_context = data[:log_context]
-
-      progname = (progname.nil? || progname.empty?) ? path : "#{progname}: #{path}"
-
-      formatted_log_context = log_context.sort.map do |k, v|
-        "#{k}=#{v}"
-      end.join(" ")
-      "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}#{log_context.any? ? " " + formatted_log_context : ""}\n"
-    }
-
-    JSON_LOG_FORMATTER = proc { |data|
-      log_context = data.delete(:log_context)
-      data.merge(log_context).compact.to_json << "\n"
-    }
-
-    COMPACT_LOG_FORMATTER = proc { |data|
-      severity = data[:severity]
-      msg = data[:message]
-      log_context = data[:log_context]
-      log_context["path"] = data[:path] || ""
-
-      formatted_log_context = log_context.sort.map do |k, v|
-        "#{k}=#{v}"
-      end.join(" ")
-      "#{severity.ljust(5)} #{msg&.strip} #{formatted_log_context}\n"
-    }
-
     module ON_INITIALIZATION_FAILURE
       RAISE = :raise
       RETURN = :return
@@ -76,10 +40,7 @@ module Prefab
 
     private def init(
       api_key: ENV['PREFAB_API_KEY'],
-      logdev: $stdout,
       namespace: '',
-      log_formatter: DEFAULT_LOG_FORMATTER,
-      log_prefix: nil,
       prefab_api_url: ENV['PREFAB_API_URL'] || 'https://api.prefab.cloud',
       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
@@ -101,10 +62,7 @@ module Prefab
       disable_action_controller_logging: false
     )
       @api_key = api_key
-      @logdev = logdev
       @namespace = namespace
-      @log_formatter = log_formatter
-      @log_prefix = log_prefix
       @prefab_api_url = remove_trailing_slash(prefab_api_url)
       @on_no_default = on_no_default
       @initialization_timeout_sec = initialization_timeout_sec

data/lib/prefab/periodic_sync.rb

@@ -2,7 +2,8 @@
 
 module Prefab
   module PeriodicSync
-    LOG = Prefab::InternalLogger.new("periodsync")
+    LOG = Prefab::InternalLogger.new(self)
+
     def sync
       return if @data.size.zero?
 

data/lib/prefab/prefab.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 module Prefab
+  LOG = Prefab::InternalLogger.new(self)
   @@lock = Concurrent::ReadWriteLock.new
+  @config_has_loaded = false
 
   def self.init(options = Prefab::Options.new)
     unless @singleton.nil?
-      Prefab::LoggerClient.instance.warn 'Prefab already initialized.'
+      LOG.warn 'Prefab already initialized.'
       return @singleton
     end
 
@@ -46,6 +48,26 @@ module Prefab
     @singleton
   end
 
+  def self.log_filter
+    InternalLogger.using_prefab_log_filter!
+    return Proc.new do |log|
+      if defined?(@singleton) && !@singleton.nil? && @singleton.config_client.initialized?
+        @singleton.log.semantic_filter(log)
+      else
+        bootstrap_log_level(log)
+      end
+    end
+  end
+
+  def self.finish_init!
+    @config_has_loaded = true
+  end
+
+  def self.bootstrap_log_level(log)
+    level = ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].downcase.to_sym : :warn
+    SemanticLogger::Levels.index(level) <= SemanticLogger::Levels.index(log.level)
+  end
+
   private
 
   def self.ensure_initialized(key = nil)

data/lib/prefab/yaml_config_parser.rb

@@ -2,7 +2,7 @@ require 'yaml'
 
 module Prefab
   class YAMLConfigParser
-    LOG = Prefab::InternalLogger.new(YAMLConfigParser)
+    LOG = Prefab::InternalLogger.new(self)
 
     def initialize(file, client)
       @file = file

data/lib/prefab-cloud-ruby.rb

@@ -5,6 +5,8 @@ module Prefab
   VERSION = File.read(File.dirname(__FILE__) + '/../VERSION').strip
 end
 
+require 'semantic_logger'
+require 'prefab/internal_logger'
 require 'concurrent/atomics'
 require 'concurrent'
 require 'faraday'
@@ -23,14 +25,11 @@ require 'prefab/errors/env_var_parse_error'
 require 'prefab/errors/missing_env_var_error'
 require 'prefab/errors/uninitialized_error'
 require 'prefab/options'
-require 'prefab/static_logger'
-require 'prefab/internal_logger'
 require 'prefab/rate_limit_cache'
 require 'prefab/context_shape_aggregator'
 require 'prefab/example_contexts_aggregator'
 require 'prefab/evaluation_summary_aggregator'
 require 'prefab/log_path_aggregator'
-require 'prefab/sse_logger'
 require 'prefab/weighted_value_resolver'
 require 'prefab/config_value_wrapper'
 require 'prefab/config_value_unwrapper'
@@ -47,8 +46,6 @@ require 'prefab/logger_client'
 require 'active_support/deprecation'
 require 'active_support'
 require 'action_controller/metal/strong_parameters'
-require 'prefab/logging/formatter_base'
-require 'prefab/log_subscribers/action_controller_subscriber'
 require 'prefab/client'
 require 'prefab/config_client_presenter'
 require 'prefab/config_client'

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.5.0 ruby lib
+# stub: prefab-cloud-ruby 1.6.0.pre1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "1.5.0"
+  s.version = "1.6.0.pre1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2024-02-12"
+  s.date = "2024-02-22"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.executables = ["console".freeze]
@@ -65,17 +65,13 @@ Gem::Specification.new do |s|
     "lib/prefab/internal_logger.rb",
     "lib/prefab/local_config_parser.rb",
     "lib/prefab/log_path_aggregator.rb",
-    "lib/prefab/log_subscribers/action_controller_subscriber.rb",
     "lib/prefab/logger_client.rb",
-    "lib/prefab/logging/formatter_base.rb",
     "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",
-    "lib/prefab/static_logger.rb",
     "lib/prefab/time_helpers.rb",
     "lib/prefab/weighted_value_resolver.rb",
     "lib/prefab/yaml_config_parser.rb",
@@ -89,7 +85,6 @@ Gem::Specification.new do |s|
     "test/support/mock_base_client.rb",
     "test/support/mock_config_client.rb",
     "test/support/mock_config_loader.rb",
-    "test/test_action_controller.rb",
     "test/test_client.rb",
     "test/test_config_client.rb",
     "test/test_config_loader.rb",
@@ -107,6 +102,7 @@ Gem::Specification.new do |s|
     "test/test_feature_flag_client.rb",
     "test/test_helper.rb",
     "test/test_integration.rb",
+    "test/test_internal_logger.rb",
     "test/test_local_config_parser.rb",
     "test/test_log_path_aggregator.rb",
     "test/test_logger.rb",
@@ -134,6 +130,7 @@ Gem::Specification.new do |s|
     s.add_runtime_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_runtime_dependency(%q<actionpack>.freeze, [">= 4"])
+    s.add_runtime_dependency(%q<semantic_logger>.freeze, [">= 0"])
     s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])
@@ -148,6 +145,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_dependency(%q<actionpack>.freeze, [">= 4"])
+    s.add_dependency(%q<semantic_logger>.freeze, [">= 0"])
     s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])

data/test/support/common_helpers.rb

@@ -6,15 +6,12 @@ module CommonHelpers
   def setup
     $oldstderr, $stderr = $stderr, StringIO.new
 
-    $logs = nil
+    $logs ||= StringIO.new
+    SemanticLogger.add_appender(io: $logs)
     Timecop.freeze('2023-08-09 15:18:12 -0400')
   end
 
   def teardown
-    if $logs && !$logs.string.empty?
-      raise "Unexpected logs. Handle logs with assert_only_expected_logs or assert_logged\n\n#{$logs.string}"
-    end
-
     if $stderr != $oldstderr && !$stderr.string.empty?
       # we ignore 2.X because of the number of `instance variable @xyz not initialized` warnings
       if !RUBY_VERSION.start_with?('2.')
@@ -56,11 +53,8 @@ module CommonHelpers
   end
 
   def prefab_options(overrides = {})
-    $logs ||= StringIO.new
     Prefab::Options.new(
-      **DEFAULT_NEW_CLIENT_OPTIONS.merge(
-        overrides.merge(logdev: $logs)
-      )
+      **DEFAULT_NEW_CLIENT_OPTIONS.merge(overrides)
     )
   end
 
@@ -147,7 +141,7 @@ module CommonHelpers
   end
 
   def assert_only_expected_logs
-    assert_equal "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient 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
@@ -155,9 +149,16 @@ module CommonHelpers
   def assert_logged(expected)
     # we do a uniq here because logging can happen in a separate thread so the
     # number of times a log might happen could be slightly variable.
-    assert_equal expected, $logs.string.split("\n").uniq
-    # mark nil to indicate we handled it
-    $logs = nil
+    actuals = $logs.string.split("\n").uniq
+    expected.each do |expectation|
+      matched = false
+
+      actuals.each do |actual|
+        matched = true if actual.match(expectation)
+      end
+
+      assert(matched, "expectation: #{expectation}, got: #{actuals}")
+    end
   end
 
   def assert_stderr(expected)

data/test/support/mock_base_client.rb

@@ -10,7 +10,6 @@ class MockBaseClient
     @options = options
     @namespace = namespace
     @config_client = MockConfigClient.new
-    Prefab::LoggerClient.new(options.logdev)
     @posts = []
   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.configclient No success loading checkpoints"
+      "Prefab::ConfigClient -- No success loading checkpoints"
     ]
   end
 
@@ -411,15 +411,6 @@ class TestClient < Minitest::Test
     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

@@ -27,8 +27,7 @@ class TestConfigClient < Minitest::Test
   def test_initialization_timeout_error
     options = Prefab::Options.new(
       api_key: '123-ENV-KEY-SDK',
-      initialization_timeout_sec: 0.01,
-      logdev: StringIO.new
+      initialization_timeout_sec: 0.01
     )
 
     err = assert_raises(Prefab::Errors::InitializationTimeoutError) do

data/test/test_context_shape_aggregator.rb

@@ -50,8 +50,6 @@ class TestContextShapeAggregator < Minitest::Test
 
     assert_equal [['user', 'name', 2], ['user', 'email', 2], ['user', 'age', 4], ['subscription', 'plan', 2], ['subscription', 'free', 5], ['user', 'dob', 2], ['device', 'name', 2], ['device', 'os', 2], ['device', 'version', 1]],
                  aggregator.data.to_a
-
-    assert_only_expected_logs
   end
 
   def test_prepare_data
@@ -85,7 +83,6 @@ class TestContextShapeAggregator < Minitest::Test
     }
 
     assert_equal [], aggregator.data.to_a
-    assert_only_expected_logs
   end
 
   def test_sync
@@ -124,8 +121,8 @@ class TestContextShapeAggregator < Minitest::Test
 
 
     assert_logged [
-      "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"
+      "No success loading checkpoints",
+      "Couldn't Initialize In 0. Key some.key. Returning what we have"
     ]
   end
 

data/test/test_criteria_evaluator.rb

@@ -711,10 +711,6 @@ class TestCriteriaEvaluator < Minitest::Test
   end
 
   class FakeBaseClient
-    def initialize
-      Prefab::LoggerClient.new($stdout)
-    end
-
     def evaluation_summary_aggregator
       @evaluation_summary_aggregator ||= Prefab::EvaluationSummaryAggregator.new(client: self, max_keys: 9999, sync_interval: 9999)
     end

data/test/test_integration.rb

@@ -45,7 +45,7 @@ class TestIntegration < Minitest::Test
               actual = get_actual_data[it.last_data_sent]
 
               expected.all? do |expected|
-                assert actual.include?(expected)
+                assert actual.include?(expected), "#{actual} should include #{expected}"
               end
             else
               raise "Unknown test type: #{it.test_type}"