quonfig 0.0.10 → 0.0.12

data/test/test_should_log.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Verifies the client-level should_log?(logger_path:, desired_level:, contexts:)
-# API — a Reforge-style convenience built on top of the primitive get() that
-# uses the client's `logger_key` option as the config key and injects the
-# logger path under `quonfig-sdk-logging.key`. Parallels sdk-node's
-# shouldLog({loggerPath}) and sdk-go's ShouldLogPath.
-class TestShouldLog < Minitest::Test
-  LOG_LEVEL_KEY = 'log-level.my-app'
-
-  # Minimal config fixture mirroring what ConfigStore expects: a string
-  # config whose rule returns the configured log level.
-  def make_log_level_config(key:, level:)
-    {
-      'id' => '1',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => 'string',
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => 'string', 'value' => level } }
-        ]
-      },
-      'environment' => nil
-    }
-  end
-
-  def store_with(*configs)
-    store = Quonfig::ConfigStore.new
-    configs.each { |c| store.set(c['key'], c) }
-    store
-  end
-
-  def client_with(store, **options)
-    Quonfig::Client.new(Quonfig::Options.new(**options), store: store)
-  end
-
-  # ---- logger_key option surface ---------------------------------------
-
-  def test_logger_key_option_defaults_to_nil
-    assert_nil Quonfig::Options.new.logger_key
-  end
-
-  def test_logger_key_option_accepts_value
-    opts = Quonfig::Options.new(logger_key: LOG_LEVEL_KEY)
-    assert_equal LOG_LEVEL_KEY, opts.logger_key
-  end
-
-  def test_client_exposes_logger_key_from_options
-    client = client_with(Quonfig::ConfigStore.new, logger_key: LOG_LEVEL_KEY)
-    assert_equal LOG_LEVEL_KEY, client.logger_key
-  end
-
-  # ---- should_log? requires logger_key ---------------------------------
-
-  def test_should_log_raises_without_logger_key
-    client = client_with(Quonfig::ConfigStore.new)
-    err = assert_raises(Quonfig::Error) do
-      client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    end
-    assert_match(/logger_key/, err.message)
-  end
-
-  # ---- should_log? gating ----------------------------------------------
-
-  def test_should_log_true_when_desired_at_or_above_configured
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'info'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :warn)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :error)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :fatal)
-  end
-
-  def test_should_log_false_when_desired_below_configured
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :trace)
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :debug)
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    assert_equal true,  client.should_log?(logger_path: 'MyApp::Foo', desired_level: :warn)
-  end
-
-  def test_should_log_accepts_string_desired_level
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal true,  client.should_log?(logger_path: 'MyApp::Foo', desired_level: 'warn')
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: 'info')
-  end
-
-  def test_should_log_returns_true_when_no_config_found
-    # Missing config key → log everything (match go/node).
-    client = client_with(Quonfig::ConfigStore.new, logger_key: LOG_LEVEL_KEY)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :trace)
-  end
-
-  # ---- context injection -----------------------------------------------
-
-  # Capture what context reaches get() by injecting a spy client that wraps
-  # a real store-backed client.
-  class ContextCapturingClient
-    attr_reader :captured_contexts
-
-    def initialize(delegate)
-      @delegate = delegate
-      @captured_contexts = []
-    end
-
-    def logger_key
-      @delegate.logger_key
-    end
-
-    def get(key, default = Quonfig::NO_DEFAULT_PROVIDED, jit_context = Quonfig::NO_DEFAULT_PROVIDED)
-      @captured_contexts << jit_context
-      @delegate.get(key, default, jit_context)
-    end
-  end
-
-  def test_should_log_injects_logger_path_under_quonfig_sdk_logging_key
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    # Reach into the context that get() sees. We do this by asserting on the
-    # resolver via a fake — simplest path: call should_log? with a sentinel
-    # path and verify the evaluator would see it. We assert via the public
-    # contract: context reaches get(), so we patch get() temporarily.
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << { key: key, jit_context: jit_context }
-      'trace'
-    end
-
-    client.should_log?(logger_path: 'MyApp::Services::Auth', desired_level: :info)
-
-    assert_equal 1, captured.size
-    assert_equal LOG_LEVEL_KEY, captured.first[:key]
-    ctx = captured.first[:jit_context]
-    assert_equal({ 'quonfig-sdk-logging' => { 'key' => 'MyApp::Services::Auth' } }, ctx)
-  end
-
-  def test_should_log_merges_caller_contexts_with_logger_context
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << jit_context
-      'trace'
-    end
-
-    client.should_log?(
-      logger_path: 'MyApp::Foo',
-      desired_level: :info,
-      contexts: { 'user' => { 'id' => 'u1' } }
-    )
-
-    assert_equal(
-      {
-        'user' => { 'id' => 'u1' },
-        'quonfig-sdk-logging' => { 'key' => 'MyApp::Foo' }
-      },
-      captured.first
-    )
-  end
-
-  def test_should_log_logger_path_verbatim_no_normalization
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << jit_context
-      'trace'
-    end
-
-    client.should_log?(logger_path: 'HTMLParser', desired_level: :info)
-    assert_equal 'HTMLParser', captured.first['quonfig-sdk-logging']['key']
-  end
-end

data/test/test_sse_config_client.rb

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'webrick'
-require 'ostruct'
-require 'json'
-
-class TestSSEConfigClient < Minitest::Test
-  def test_connect_url_is_api_v2_sse_config
-    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'test')
-    config_loader = OpenStruct.new(highwater_mark: 0)
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    captured_url = nil
-    fake = OpenStruct.new(closed?: false)
-    fake.define_singleton_method(:on_event) { |&_b| }
-    fake.define_singleton_method(:on_error) { |&_b| }
-    fake.define_singleton_method(:close) { }
-
-    SSE::Client.stub :new, ->(url, *_args, **_kwargs, &block) {
-      captured_url = url
-      block.call(fake) if block
-      fake
-    } do
-      client.connect { |_e, _ev, _s| }
-    end
-
-    assert_equal 'https://stream.example.com/api/v2/sse/config', captured_url
-  end
-
-  def test_on_event_parses_json_into_config_envelope
-    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'test')
-    config_loader = OpenStruct.new(highwater_mark: 0)
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    captured = {}
-    event_handler = nil
-    fake = Object.new
-    fake.define_singleton_method(:on_event) { |&block| event_handler = block }
-    fake.define_singleton_method(:on_error) { |&_b| }
-    fake.define_singleton_method(:close) { }
-    fake.define_singleton_method(:closed?) { false }
-
-    SSE::Client.stub :new, ->(*_args, **_kwargs, &block) {
-      block.call(fake) if block
-      fake
-    } do
-      client.connect do |envelope, event, source|
-        captured[:envelope] = envelope
-        captured[:event] = event
-        captured[:source] = source
-      end
-    end
-
-    json_data = JSON.generate({
-      configs: [{ key: 'my.key', valueType: 'string', default: { rules: [] } }],
-      meta: { version: 'abc123', environment: 'prod' }
-    })
-
-    event_handler.call(OpenStruct.new(data: json_data))
-
-    assert_instance_of Quonfig::ConfigEnvelope, captured[:envelope]
-    assert_equal 1, captured[:envelope].configs.length
-    assert_equal 'my.key', captured[:envelope].configs[0]['key']
-    assert_equal 'abc123', captured[:envelope].meta['version']
-    assert_equal :sse, captured[:source]
-  end
-
-  def test_headers_basic_auth_uses_1_prefix
-    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'mykey')
-    config_loader = OpenStruct.new(highwater_mark: 0)
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    h = client.headers
-
-    assert_equal "Basic #{Base64.strict_encode64('1:mykey')}", h['Authorization']
-    assert_match(/\Asdk-ruby-/, h['X-Quonfig-SDK-Version'])
-    refute h.key?('X-Reforge-SDK-Version')
-  end
-
-  def test_recovering_from_disconnection
-    server, = start_webrick_server(4567, DisconnectingEndpoint)
-
-    config_loader = OpenStruct.new(highwater_mark: 4)
-
-    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4567'], sdk_key: 'test')
-    last_event_id = nil
-    client = nil
-
-    begin
-      Thread.new do
-        server.start
-      end
-
-      sse_options = Quonfig::SSEConfigClient::Options.new(
-        sse_default_reconnect_time: 0.1
-      )
-      client = Quonfig::SSEConfigClient.new(prefab_options, config_loader, sse_options)
-
-      client.start do |_configs, event, _source|
-        last_event_id = event.id.to_i
-      end
-
-      wait_for -> { last_event_id && last_event_id > 1 }
-    ensure
-      client.close
-      server.stop
-
-      refute_nil last_event_id, 'Expected to have received an event'
-      assert last_event_id > 1, 'Expected to have received multiple events (indicating a retry)'
-    end
-  end
-
-  def test_recovering_from_an_error
-    log_output = StringIO.new
-    logger = Logger.new(log_output)
-
-    server, = start_webrick_server(4568, ErroringEndpoint)
-
-    config_loader = OpenStruct.new(highwater_mark: 4)
-
-    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4568'], sdk_key: 'test')
-    last_event_id = nil
-    client = nil
-
-    begin
-      Thread.new do
-        server.start
-      end
-
-      sse_options = Quonfig::SSEConfigClient::Options.new(
-        sse_default_reconnect_time: 0.1,
-        seconds_between_new_connection: 0.1,
-        sleep_delay_for_new_connection_check: 0.1,
-        errors_to_close_connection: [SSE::Errors::HTTPStatusError]
-      )
-      client = Quonfig::SSEConfigClient.new(prefab_options, config_loader, sse_options, logger)
-
-      client.start do |_configs, event, _source|
-        last_event_id = event.id.to_i
-      end
-
-      wait_for -> { last_event_id && last_event_id > 2 }
-    ensure
-      server.stop
-      client.close
-
-      refute_nil last_event_id, 'Expected to have received an event'
-      assert last_event_id > 2, 'Expected to have received multiple events (indicating a reconnect)'
-    end
-
-    log_lines = log_output.string.split("\n")
-
-    assert_match(/SSE Streaming Connect/, log_lines[0])
-    assert_match(/SSE Streaming Error/, log_lines[1], 'Expected to have logged an error. If this starts failing after an ld-eventsource upgrade, you might need to tweak NUMBER_OF_FAILURES below')
-    assert_match(/Closing SSE connection/, log_lines[2])
-    assert_match(/Reconnecting SSE client/, log_lines[3])
-    assert_match(/SSE Streaming Connect/, log_lines[4])
-  end
-
-  def start_webrick_server(port, endpoint_class)
-    log_string = StringIO.new
-    logger = WEBrick::Log.new(log_string)
-    server = WEBrick::HTTPServer.new(Port: port, Logger: logger, AccessLog: [])
-    server.mount '/api/v2/sse', endpoint_class
-
-    [server, log_string]
-  end
-
-  module SharedEndpointLogic
-    def event_id
-      @@event_id ||= 0
-      @@event_id += 1
-    end
-
-    def setup_response(response)
-      response.status = 200
-      response['Content-Type'] = 'text/event-stream'
-      response['Cache-Control'] = 'no-cache'
-      response['Connection'] = 'keep-alive'
-
-      response.chunked = false
-    end
-  end
-
-  SAMPLE_JSON_PAYLOAD = '{"configs":[],"meta":{"version":"1","environment":"test"}}'
-
-  class DisconnectingEndpoint < WEBrick::HTTPServlet::AbstractServlet
-    include SharedEndpointLogic
-
-    def do_GET(_request, response)
-      setup_response(response)
-
-      output = response.body
-
-      output << "id: #{event_id}\n"
-      output << "event: message\n"
-      output << "data: #{SAMPLE_JSON_PAYLOAD}\n\n"
-    end
-  end
-
-  class ErroringEndpoint < WEBrick::HTTPServlet::AbstractServlet
-    include SharedEndpointLogic
-    NUMBER_OF_FAILURES = 5
-
-    def do_GET(_request, response)
-      setup_response(response)
-
-      output = response.body
-
-      output << "id: #{event_id}\n"
-
-      if event_id < NUMBER_OF_FAILURES
-        raise 'ErroringEndpoint' # This manifests as an SSE::Errors::HTTPStatusError
-      end
-
-      output << "event: message\n"
-      output << "data: #{SAMPLE_JSON_PAYLOAD}\n\n"
-    end
-  end
-
-  def test_empty_data_validation
-    # Unit test to verify that empty data is properly detected and handled
-    log_output = StringIO.new
-    logger = Logger.new(log_output)
-
-    # Test that empty event.data is detected
-    mock_event = OpenStruct.new(data: '')
-    mock_client = Minitest::Mock.new
-    mock_client.expect(:close, nil)
-
-    # Simulate the on_event handler logic
-    if mock_event.data.nil? || mock_event.data.empty?
-      logger.error "SSE Streaming Error: Received empty data for url http://test"
-      mock_client.close
-    end
-
-    log_lines = log_output.string.split("\n")
-    assert log_lines.any? { |line| line.include?('SSE Streaming Error') && line.include?('empty data') },
-           'Expected to have logged an error about empty data'
-    mock_client.verify
-
-    # Test that nil event.data is detected
-    log_output = StringIO.new
-    logger = Logger.new(log_output)
-    mock_event = OpenStruct.new(data: nil)
-    mock_client = Minitest::Mock.new
-    mock_client.expect(:close, nil)
-
-    if mock_event.data.nil? || mock_event.data.empty?
-      logger.error "SSE Streaming Error: Received empty data for url http://test"
-      mock_client.close
-    end
-
-    log_lines = log_output.string.split("\n")
-    assert log_lines.any? { |line| line.include?('SSE Streaming Error') && line.include?('empty data') },
-           'Expected to have logged an error about empty data for nil'
-    mock_client.verify
-  end
-
-  def test_last_event_id_initialization
-    # Test with positive highwater_mark
-    config_loader = OpenStruct.new(highwater_mark: 42)
-    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4567'], sdk_key: 'test')
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    # Mock SSE::Client.new to capture the last_event_id argument
-    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
-      assert_equal '42', kwargs[:last_event_id], 'Expected last_event_id to be "42"'
-      OpenStruct.new(closed?: false, close: nil)
-    } do
-      client.connect { |_configs, _event, _source| }
-    end
-
-    # Test with nil highwater_mark
-    config_loader = OpenStruct.new(highwater_mark: nil)
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
-      assert_nil kwargs[:last_event_id], 'Expected last_event_id to be nil when highwater_mark is nil'
-      OpenStruct.new(closed?: false, close: nil)
-    } do
-      client.connect { |_configs, _event, _source| }
-    end
-
-    # Test with zero highwater_mark
-    config_loader = OpenStruct.new(highwater_mark: 0)
-    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
-
-    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
-      assert_nil kwargs[:last_event_id], 'Expected last_event_id to be nil when highwater_mark is 0'
-      OpenStruct.new(closed?: false, close: nil)
-    } do
-      client.connect { |_configs, _event, _source| }
-    end
-  end
-end

data/test/test_stdlib_formatter.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'logger'
-require 'stringio'
-
-# Verifies Quonfig::StdlibFormatter — an adapter that plugs Quonfig's dynamic
-# log-level evaluation into Ruby's built-in ::Logger via the
-# `logger.formatter = <proc>` contract. The formatter is a callable with
-# signature (severity, datetime, progname, msg) -> String. Returning an empty
-# string suppresses the log line (Logger writes exactly what the formatter
-# returns).
-#
-# The Ruby stdlib severity strings ("DEBUG", "INFO", "WARN", "ERROR", "FATAL",
-# "ANY") are mapped to the quonfig level symbols used by the evaluator
-# (:debug, :info, :warn, :error, :fatal). progname flows into the evaluator
-# under `quonfig-sdk-logging.key` verbatim, no normalization — matching the
-# SemanticLoggerFilter.
-class TestStdlibFormatter < Minitest::Test
-  LOG_LEVEL_KEY = 'log-level.my-app'
-
-  # Build a minimal config fixture: a string config whose single rule always
-  # resolves to `level`. Mirrors the shape used in test_should_log.rb so we
-  # exercise the full get()/resolver/evaluator path rather than stubbing.
-  def make_log_level_config(key:, level:)
-    {
-      'id' => '1',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => 'string',
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => 'string', 'value' => level } }
-        ]
-      },
-      'environment' => nil
-    }
-  end
-
-  def store_with(*configs)
-    store = Quonfig::ConfigStore.new
-    configs.each { |c| store.set(c['key'], c) }
-    store
-  end
-
-  def client_with(store, **options)
-    Quonfig::Client.new(Quonfig::Options.new(**options), store: store)
-  end
-
-  # ---- error behavior --------------------------------------------------
-
-  def test_stdlib_formatter_raises_without_logger_key
-    client = client_with(Quonfig::ConfigStore.new)
-    err = assert_raises(Quonfig::Error) { client.stdlib_formatter }
-    assert_match(/logger_key/, err.message)
-  end
-
-  # ---- proc contract ---------------------------------------------------
-
-  def test_stdlib_formatter_returns_a_callable_with_4_arity
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'info'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    formatter = client.stdlib_formatter
-    assert_respond_to formatter, :call
-    # Ruby Logger invokes formatter with exactly 4 args; a Proc takes any arity,
-    # but arity should be 4 so it matches the Logger contract faithfully.
-    assert_equal 4, formatter.arity
-  end
-
-  # ---- gating ----------------------------------------------------------
-
-  def test_formatter_drops_below_configured_level_returning_empty_string
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    formatter = client.stdlib_formatter
-    now = Time.utc(2026, 4, 22, 12, 0, 0)
-
-    # Below configured warn — suppressed (empty string, which Logger writes
-    # as zero bytes, effectively dropping the line).
-    assert_equal '', formatter.call('DEBUG', now, 'MyApp::Foo', 'hi')
-    assert_equal '', formatter.call('INFO',  now, 'MyApp::Foo', 'hi')
-  end
-
-  def test_formatter_emits_at_or_above_configured_level
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    formatter = client.stdlib_formatter
-    now = Time.utc(2026, 4, 22, 12, 0, 0)
-
-    refute_equal '', formatter.call('WARN',  now, 'MyApp::Foo', 'hi')
-    refute_equal '', formatter.call('ERROR', now, 'MyApp::Foo', 'hi')
-    refute_equal '', formatter.call('FATAL', now, 'MyApp::Foo', 'hi')
-  end
-
-  def test_formatter_default_format_includes_severity_time_progname_msg
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'debug'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    formatter = client.stdlib_formatter
-    now = Time.utc(2026, 4, 22, 12, 34, 56)
-
-    out = formatter.call('INFO', now, 'MyApp::Foo', 'hello world')
-    assert_includes out, 'INFO'
-    assert_includes out, 'MyApp::Foo'
-    assert_includes out, 'hello world'
-    assert out.end_with?("\n"), "formatter output should end with a newline"
-  end
-
-  # ---- progname -> context ---------------------------------------------
-
-  def test_progname_flows_into_logger_context_verbatim
-    # We capture the context the formatter passes to should_log? by replacing
-    # the client's should_log? — avoids building a matcher fixture and lets
-    # us assert the exact context shape the adapter builds.
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:should_log?) do |logger_path:, desired_level:, contexts: {}|
-      captured << { logger_path: logger_path, desired_level: desired_level }
-      true
-    end
-
-    formatter = client.stdlib_formatter
-    formatter.call('INFO', Time.now, 'HTMLParser', 'x')
-
-    assert_equal 1, captured.size
-    assert_equal 'HTMLParser', captured.first[:logger_path]
-    assert_equal :info,        captured.first[:desired_level]
-  end
-
-  def test_explicit_logger_name_option_overrides_progname
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:should_log?) do |logger_path:, desired_level:, contexts: {}|
-      captured << logger_path
-      true
-    end
-
-    formatter = client.stdlib_formatter(logger_name: 'ExplicitName')
-    # Pass a different progname — the explicit logger_name should win.
-    formatter.call('INFO', Time.now, 'DifferentProgname', 'x')
-
-    assert_equal 'ExplicitName', captured.first
-  end
-
-  def test_nil_progname_and_no_logger_name_falls_through_as_nil
-    # Ruby's Logger can invoke the formatter with a nil progname; the adapter
-    # should not crash. We pass through nil, and should_log? sees nil. The
-    # evaluator treats missing context values as absent.
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:should_log?) do |logger_path:, desired_level:, contexts: {}|
-      captured << logger_path
-      true
-    end
-
-    formatter = client.stdlib_formatter
-    formatter.call('INFO', Time.now, nil, 'x')
-
-    assert_nil captured.first
-  end
-
-  # ---- end-to-end with a real ::Logger ---------------------------------
-
-  def test_end_to_end_real_logger_drops_below_and_emits_above
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    io = StringIO.new
-    logger = ::Logger.new(io)
-    # stdlib Logger has its own static level; set it permissive so our
-    # formatter is the thing actually gating output.
-    logger.level = ::Logger::DEBUG
-    logger.formatter = client.stdlib_formatter(logger_name: 'MyApp::Svc')
-
-    logger.info  'should be dropped'
-    logger.warn  'should be emitted'
-    logger.error 'also emitted'
-
-    out = io.string
-    refute_includes out, 'should be dropped'
-    assert_includes out, 'should be emitted'
-    assert_includes out, 'also emitted'
-  end
-end