prefab-cloud-ruby 1.5.1 → 1.6.0.pre1

data/test/test_internal_logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestInternalLogger < Minitest::Test
+
+  def test_levels
+    logger_a = Prefab::InternalLogger.new(A)
+    logger_b = Prefab::InternalLogger.new(B)
+
+    assert_equal :warn, logger_a.level
+    assert_equal :warn, logger_b.level
+
+    Prefab::InternalLogger.using_prefab_log_filter!
+    assert_equal :trace, logger_a.level
+    assert_equal :trace, logger_b.level
+  end
+
+end
+
+class A
+end
+
+class B
+end

data/test/test_log_path_aggregator.rb

@@ -25,10 +25,10 @@ class TestLogPathAggregator < Minitest::Test
 
   def test_sync
     Timecop.freeze do
-      client = new_client(namespace: 'this.is.a.namespace')
+      client = new_client(namespace: 'this.is.a.namespace', allow_telemetry_in_local_mode: true)
 
-      2.times { client.log.info('here is a message') }
-      3.times { client.log.error('here is a message') }
+      2.times { client.log.should_log? 1, "test.test_log_path_aggregator.test_sync"}
+      3.times { client.log.should_log? 3, "test.test_log_path_aggregator.test_sync"}
 
       requests = wait_for_post_requests(client) do
         client.log_path_aggregator.send(:sync)
@@ -41,12 +41,6 @@ class TestLogPathAggregator < Minitest::Test
       assert_equal Prefab::TimeHelpers.now_in_ms, sent_logger.end_at
       assert_equal client.instance_hash, sent_logger.instance_hash
       assert_includes sent_logger.loggers, PrefabProto::Logger.new(logger_name: 'test.test_log_path_aggregator.test_sync', infos: 2, errors: 3)
-      assert_includes sent_logger.loggers, PrefabProto::Logger.new(logger_name: 'cloud.prefab.client.client', debugs: 1) # spot test that internal logging is here too
-
-      assert_logged [
-                      '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
   end
 
@@ -54,8 +48,9 @@ class TestLogPathAggregator < Minitest::Test
 
   def new_client(overrides = {})
     super(**{
-      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY,
       api_key: '123-development-yourapikey-SDK',
+      collect_max_paths: 1000,
       collect_sync_interval: 1000 # we'll trigger sync manually in our test
     }.merge(overrides))
   end

data/test/test_logger.rb

@@ -20,165 +20,41 @@ class TestLogger < Minitest::Test
 
   def setup
     super
-    Prefab::LoggerClient.send(:public, :get_path)
-    Prefab::LoggerClient.send(:public, :get_loc_path)
+    Prefab::LoggerClient.send(:public, :class_path_name)
     Prefab::LoggerClient.send(:public, :level_of)
-    @logger = Prefab::LoggerClient.new($stdout)
+    @client = new_client
+    @logger = @client.log
   end
 
-  def test_get_path
-    assert_equal 'test_l.foo_warn',
-                 @logger.get_path('/Users/jdwyah/Documents/workspace/RateLimitInc/prefab-cloud-ruby/lib/test_l.rb',
-                                  'foo_warn')
-
-    assert_equal 'active_support.log_subscriber.info',
-                 @logger.get_path('/Users/jdwyah/.rvm/gems/ruby-2.3.3@forcerank/gems/activesupport-4.1.16/lib/active_support/log_subscriber.rb',
-                                  'info')
-    assert_equal 'active_support.log_subscriber.info',
-                 @logger.get_path("/Users/jeffdwyer/.asdf/installs/ruby/3.1.2/lib/ruby/gems/3.1.0/gems/activesupport-7.0.2.4/lib/active_support/log_subscriber.rb:130:in `info'",
-                                  'info')
-    assert_equal 'unknown.info',
-                 @logger.get_path(nil,
-                                  'info')
-  end
-
-  def test_loc_resolution
-    backtrace_location = Struct.new(:absolute_path, :base_label, :string) do
-      def to_s
-        string
-      end
-    end # https://ruby-doc.org/core-3.0.0/Thread/Backtrace/Location.html
-
-    # verify that even if the Thread::Backtrace::Location does not have an absolute_location, we do our best
-    assert_equal 'active_support.log_subscriber.info',
-                 @logger.get_loc_path(backtrace_location.new(nil,
-                                                             'info',
-                                                             "/Users/jeffdwyer/.asdf/installs/ruby/3.1.2/lib/ruby/gems/3.1.0/gems/activesupport-7.0.2.4/lib/active_support/log_subscriber.rb:130:in `info'"))
-    assert_equal 'test_l.info',
-                 @logger.get_loc_path(backtrace_location.new('/Users/jdwyah/Documents/workspace/RateLimitInc/prefab-cloud-ruby/lib/test_l.rb',
-                                                             'info',
-                                                             "/Users/jeffdwyer/.asdf/installs/ruby/3.1.2/lib/ruby/gems/3.1.0/gems/activesupport-7.0.2.4/lib/active_support/log_subscriber.rb:130:in `info'"))
-  end
-
-  def test_level_of
+  def test_bootstrap_log_level
+    assert !Prefab.bootstrap_log_level(SemanticLogger::Log.new("TestLogger",:info))
     with_env('PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL', 'info') do
-      # env var overrides the default level
-      assert_equal ::Logger::INFO,
-                   @logger.level_of('app.models.user'), 'PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL is info'
-
-      @logger.config_client = MockConfigClient.new({})
-      assert_equal ::Logger::WARN,
-                   @logger.level_of('app.models.user'), 'default is warn'
-
-      @logger.config_client = MockConfigClient.new('log-level.app' => :INFO)
-      assert_equal ::Logger::INFO,
-                   @logger.level_of('app.models.user')
-
-      @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG)
-      assert_equal ::Logger::DEBUG,
-                   @logger.level_of('app.models.user')
-
-      @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG,
-                                                   'log-level.app.models' => :ERROR)
-      assert_equal ::Logger::ERROR,
-                   @logger.level_of('app.models.user'), 'test leveling'
-    end
-  end
-
-  def test_log_internal
-    prefab, io = captured_logger
-    prefab.log.log_internal(::Logger::WARN, 'test message', 'cloud.prefab.client.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(::Logger::UNKNOWN, 'test message', 'cloud.prefab.client.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(::Logger::WARN, 'should not log', 'cloud.prefab.client.test.path')
-    end
-    prefab.log.log_internal(::Logger::WARN, 'should log', 'cloud.prefab.client.test.path')
-    assert_logged io, 'WARN', "cloud.prefab.client.test.path", "should log"
-    refute_logged io, 'should not log'
-  end
-
-  def test_log
-    prefab, io = captured_logger
-    prefab.log.log('test message', 'test.path', '', ::Logger::WARN)
-    assert_logged io, 'WARN', "test.path", "test message"
-  end
-
-  def test_log_unknown
-    prefab, io = captured_logger
-    prefab.log.log('test message', 'test.path', '', ::Logger::UNKNOWN)
-    assert_logged io, 'ANY', "test.path", "test message"
-  end
-
-  def test_log_silencing
-    prefab, io = captured_logger
-    prefab.log.silence do
-      prefab.log.log('should not log', 'test.path', '', ::Logger::WARN)
+      assert Prefab.bootstrap_log_level(SemanticLogger::Log.new("TestLogger",:info))
     end
-    prefab.log.log('should log', 'test.path', '', ::Logger::WARN)
-    assert_logged io, 'WARN', "test.path", "should log"
-    refute_logged io, 'should not log'
-  end
-
-  def test_logging_with_prefix
-    prefix = 'my.own.prefix'
-    message = 'this is a test'
-
-    prefab, io = captured_logger(log_prefix: prefix)
-
-    prefixed_logger = prefab.log
-    prefixed_logger.error message
-
-    assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_prefix", message
-  end
-
-  def test_logging_without_a_progname
-    prefab, io = captured_logger
-    message = 'MY MESSAGE'
-
-    prefab.log.error message
-
-    assert_logged io, 'ERROR', 'test.test_logger.test_logging_without_a_progname', message
   end
 
-  def test_logging_without_a_progname_or_message
-    prefab, io = captured_logger
+  def test_level_of
+    @logger.config_client = MockConfigClient.new({})
+    assert_equal SemanticLogger::Levels.index(:warn),
+                 @logger.level_of('app.models.user'), 'default is warn'
 
-    prefab.log.error
+    @logger.config_client = MockConfigClient.new('log-level.app' => :INFO)
+    assert_equal SemanticLogger::Levels.index(:info),
+                 @logger.level_of('app.models.user')
 
-    assert_logged io, 'ERROR', 'test.test_logger.test_logging_without_a_progname_or_message', ''
-  end
+    @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG)
+    assert_equal SemanticLogger::Levels.index(:debug),
+                 @logger.level_of('app.models.user')
 
-  def test_logging_with_a_progname
-    prefab, io = captured_logger
-    message = 'MY MESSAGE'
+    @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG,
+                                                 'log-level.app.models' => :ERROR)
+    assert_equal SemanticLogger::Levels.index(:error),
+                 @logger.level_of('app.models.user'), 'test leveling'
 
-    prefab.log.progname = 'MY_PROGNAME'
-    prefab.log.error message
-
-    assert_logged io, 'ERROR', 'MY_PROGNAME: test.test_logger.test_logging_with_a_progname', message
   end
 
-  def test_logging_with_a_progname_and_no_message
-    prefab, io = captured_logger
-
-    prefab.log.progname = 'MY_PROGNAME'
-    prefab.log.error
-
-    assert_logged io, 'ERROR', 'MY_PROGNAME: test.test_logger.test_logging_with_a_progname_and_no_message', 'MY_PROGNAME'
-  end
 
   def test_logging_with_criteria_on_top_level_key
-    prefix = 'my.own.prefix'
 
     config = PrefabProto::Config.new(
       key: 'log-level',
@@ -224,57 +100,36 @@ class TestLogger < Minitest::Test
       ]
     )
 
-    prefab, io = captured_logger(log_prefix: prefix)
-
-    inject_config(prefab, config)
-    inject_project_env_id(prefab, PROJECT_ENV_ID)
+    inject_config(@client, config)
+    inject_project_env_id(@client, PROJECT_ENV_ID)
 
     # without any context, the level should be the default for the env (info)
-    prefab.with_context({}) do
-      prefab.log.debug 'Test debug'
-      refute_logged io, 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test error'
+    @client.with_context({}) do
+      refute @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
 
-    reset_io(io)
 
     # with the wrong context, the level should be the default for the env (info)
-    prefab.with_context(user: { email_suffix: 'yahoo.com' }) do
-      prefab.log.debug 'Test debug'
-      refute_logged io, 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test error'
+    @client.with_context(user: { email_suffix: 'yahoo.com' }) do
+      refute @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
 
-    reset_io(io)
-
     # with the correct context, the level should be the desired value (debug)
-    prefab.with_context(user: { email_suffix: 'hotmail.com' }) do
-      prefab.log.debug 'Test debug'
-      assert_logged io, 'DEBUG', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_top_level_key", 'Test error'
+    @client.with_context(user: { email_suffix: 'hotmail.com' }) do
+      assert @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
   end
 
   def test_logging_with_criteria_on_key_path
-    prefix = 'my.own.prefix'
 
     config = PrefabProto::Config.new(
-      key: 'log-level.my.own.prefix.test.test_logger',
+      key: 'log-level.test.test_logger',
       rows: [
         DEFAULT_ROW,
 
@@ -328,294 +183,43 @@ class TestLogger < Minitest::Test
         )
       ]
     )
+    inject_config(@client, config)
+    inject_project_env_id(@client, PROJECT_ENV_ID)
 
-    prefab, io = captured_logger(log_prefix: prefix)
-
-    inject_config(prefab, config)
-    inject_project_env_id(prefab, PROJECT_ENV_ID)
 
     # without any context, the level should be the default for the env (info)
-    prefab.with_context({}) do
-      prefab.log.debug 'Test debug'
-      refute_logged io, 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test error'
+    @client.with_context({ }) do
+      refute @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
 
-    reset_io(io)
-
     # with the wrong context, the level should be the default for the env (info)
-    prefab.with_context(user: { email_suffix: 'yahoo.com' }) do
-      prefab.log.debug 'Test debug'
-      refute_logged io, 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test error'
+    @client.with_context(user: { email_suffix: 'yahoo.com' }) do
+      refute @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
 
-    reset_io(io)
-
     # with the correct context, the level should be the desired value (debug)
-    prefab.with_context(user: { email_suffix: 'hotmail.com' }) do
-      prefab.log.debug 'Test debug'
-      assert_logged io, 'DEBUG', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test error'
+    @client.with_context(user: { email_suffix: 'hotmail.com' }) do
+      assert @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:error), "test.test_logger" )
     end
 
-    reset_io(io)
-
     # with the correct lookup key
-    prefab.with_context(user: { tracking_id: 'user:4567' }) do
-      prefab.log.debug 'Test debug'
-      assert_logged io, 'DEBUG', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test debug'
-
-      prefab.log.info 'Test info'
-      assert_logged io, 'INFO', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test info'
-
-      prefab.log.error 'Test error'
-      assert_logged io, 'ERROR', "#{prefix}.test.test_logger.test_logging_with_criteria_on_key_path", 'Test error'
+    @client.with_context(user: { tracking_id: 'user:4567' }) do
+      assert @logger.should_log?(SemanticLogger::Levels.index(:debug), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
+      assert @logger.should_log?(SemanticLogger::Levels.index(:info), "test.test_logger" )
     end
   end
 
-  def test_logging_with_a_block
-    prefab, io = captured_logger
-    message = 'MY MESSAGE'
-
-    prefab.log.error do
-      message
-    end
-
-    prefab.log.info do
-      raise 'THIS WILL NEVER BE EVALUATED'
-    end
-
-    assert_logged io, 'ERROR', 'test.test_logger.test_logging_with_a_block', message
+  def test_class_path_name
+    assert_equal "minitest.test.test_logger", @logger.class_path_name("TestLogger")
+    assert_equal "prefab.logger_client", @logger.class_path_name("Prefab::LoggerClient")
+    assert_equal "semantic_logger.logger.prefab.internal_logger", @logger.class_path_name("Prefab::InternalLogger")
   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'
-
-    prefab.log.error message, user: "michael", id: 123
-
-    assert_logged io, 'ERROR', 'test.test_logger.test_structured_logging', "#{message} id=123 user=michael"
-  end
-
-  def test_structured_json_logging
-    prefab, io = captured_logger(log_formatter: Prefab::Options::JSON_LOG_FORMATTER)
-    message = 'HELLO'
-
-    prefab.log.error message, user: "michael", id: 123
-
-    log_data = JSON.parse(io.string)
-    assert log_data["message"] == message
-    assert log_data["user"] == "michael"
-    assert log_data["id"] == 123
-  end
-
-  def test_structured_internal_logging
-    prefab, io = captured_logger
-
-    prefab.log.log_internal(::Logger::WARN, 'test', 'cloud.prefab.client.test.path', user: "michael")
-
-    assert_logged io, 'WARN', 'cloud.prefab.client.test.path', "test user=michael"
-  end
-
-  def test_structured_block_logger
-    prefab, io = captured_logger
-    message = 'MY MESSAGE'
-
-    prefab.log.error user: "michael" do
-      message
-    end
-
-    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
-
-  def test_context_key_threads
-    prefab, io = captured_logger
-
-    threads = []
-    1000.times.map do |i|
-      threads << Thread.new do
-        prefab.with_context({test: {"thread_#{i}": "thread_#{i}"}}) do
-          prefab.log.add_context_keys "test.thread_#{i}"
-          prefab.log.error "UH OH"
-          assert_logged io, 'ERROR', 'test.test_logger.test_context_key_threads',
-                        "UH OH test.thread_#{i}=thread_#{i}"
-        end
-      end
-    end
-    threads.each { |thr| thr.join }
-  end
-
-  def test_tagged
-    prefab, io = captured_logger
-
-    prefab.log.tagged([[]]) do # rails sends some of these
-      prefab.log.tagged("outside") do
-        prefab.log.tagged("nested", "tag2") do
-          prefab.log.error "msg"
-          assert_logged io, 'ERROR', 'test.test_logger.test_tagged',
-                        'msg log.tags=\["outside", "nested", "tag2"\]'
-        end
-      end
-    end
-  end
-
-  def test_req_tagged
-    prefab, io = captured_logger
-    prefab.log.tagged("tag-1").error "first"
-    assert_logged io, 'ERROR', 'test.test_logger.test_req_tagged',
-                  'first req.tags=\["tag-1"\]'
-    reset_io(io)
-
-    prefab.log.tagged("tag-2").error "2nd"
-    assert_logged io, 'ERROR', 'test.test_logger.test_req_tagged',
-                  '2nd req.tags=\["tag-1", "tag-2"\]'
-    prefab.log.flush
-
-    prefab.log.tagged("tag-3").error "3rd"
-    assert_logged io, 'ERROR', 'test.test_logger.test_req_tagged',
-                  '3rd req.tags=\["tag-3"\]'
-    prefab.log.flush
-  end
-
-  private
-
-  def assert_logged(logged_io, level, path, message)
-    assert_match(/#{level}\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-+]?\d+:\s+#{path} #{message}\n/, logged_io.string)
-  end
-
-  def refute_logged(logged_io, message)
-    refute_match(/#{message}/, logged_io.string)
-  end
-
-  def captured_logger(options = {})
-    io = StringIO.new
-    options = Prefab::Options.new(**options.merge(
-      logdev: io,
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
-    ))
-    prefab = Prefab::Client.new(options)
-
-    [prefab, io]
-  end
-
-  def reset_io(io)
-    io.close
-    io.reopen
-
-    assert_equal '', io.string
-  end
 end

data/test/test_logger_initialization.rb

@@ -6,7 +6,7 @@ class TestLoggerInitialization < Minitest::Test
 
   def test_init_out_of_order
     # assert nothing blows up
-    Prefab::LoggerClient.instance.info "anything"
+    Prefab.log_filter
   end
 
 end