quonfig 0.0.6 → 0.0.8

data/test/test_evaluation_summaries_aggregator.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEvaluationSummariesAggregator < Minitest::Test
+  def make_aggregator(max_keys: 100)
+    Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: max_keys)
+  end
+
+  def record_eval(agg, overrides = {})
+    defaults = {
+      config_id: 'c1',
+      config_key: 'my-test-key',
+      config_type: 'config',
+      conditional_value_index: 0,
+      weighted_value_index: nil,
+      selected_value: 'hello',
+      reason: 1
+    }
+    agg.record(**defaults.merge(overrides))
+  end
+
+  def test_record_dedupes_identical_evaluations_into_one_counter
+    agg = make_aggregator
+
+    record_eval(agg)
+    record_eval(agg)
+    record_eval(agg)
+
+    event = agg.drain_event
+    refute_nil event
+    summaries = event['summaries']['summaries']
+    assert_equal 1, summaries.size
+
+    counters = summaries[0]['counters']
+    assert_equal 1, counters.size
+    assert_equal 3, counters[0]['count']
+  end
+
+  def test_record_creates_separate_counters_for_different_rule_indexes
+    agg = make_aggregator
+
+    record_eval(agg, conditional_value_index: 0)
+    record_eval(agg, conditional_value_index: 1)
+    record_eval(agg, conditional_value_index: 1)
+
+    summaries = agg.drain_event['summaries']['summaries']
+    assert_equal 1, summaries.size
+
+    counters = summaries[0]['counters']
+    assert_equal 2, counters.size
+
+    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['count'] }
+    assert_equal 1, by_idx[0]
+    assert_equal 2, by_idx[1]
+  end
+
+  def test_record_groups_by_config_key_and_type
+    agg = make_aggregator
+
+    record_eval(agg, config_key: 'alpha', config_type: 'config')
+    record_eval(agg, config_key: 'alpha', config_type: 'config')
+    record_eval(agg, config_key: 'beta',  config_type: 'feature_flag')
+
+    summaries = agg.drain_event['summaries']['summaries']
+    assert_equal 2, summaries.size
+
+    by_key = summaries.each_with_object({}) { |s, h| h[s['key']] = s }
+    assert_equal 'config',        by_key['alpha']['type']
+    assert_equal 'feature_flag',  by_key['beta']['type']
+    assert_equal 2, by_key['alpha']['counters'][0]['count']
+    assert_equal 1, by_key['beta']['counters'][0]['count']
+  end
+
+  def test_drain_event_nil_when_empty
+    agg = make_aggregator
+    assert_nil agg.drain_event
+  end
+
+  def test_drain_clears_state
+    agg = make_aggregator
+    record_eval(agg)
+
+    refute_nil agg.drain_event
+    assert_nil agg.drain_event, 'second drain with no new records should be nil'
+  end
+
+  def test_drain_event_wire_shape
+    agg = make_aggregator
+
+    record_eval(agg,
+                config_id: 'cid-42',
+                config_key: 'my-test-key',
+                config_type: 'config',
+                conditional_value_index: 1,
+                weighted_value_index: nil,
+                selected_value: 'my-test-value',
+                reason: 2)
+
+    event = agg.drain_event
+    refute_nil event
+    assert event.key?('summaries'), 'top-level event key is summaries'
+
+    inner = event['summaries']
+    assert_kind_of Integer, inner['start']
+    assert_kind_of Integer, inner['end']
+    assert inner['end'] >= inner['start']
+
+    summary = inner['summaries'][0]
+    assert_equal 'my-test-key', summary['key']
+    assert_equal 'config',      summary['type']
+
+    counter = summary['counters'][0]
+    assert_equal 'cid-42',         counter['configId']
+    assert_equal 1,                counter['conditionalValueIndex']
+    assert_equal 0,                counter['configRowIndex']
+    assert_equal 1,                counter['count']
+    assert_equal 2,                counter['reason']
+    assert_equal({ 'string' => 'my-test-value' }, counter['selectedValue'])
+    refute counter.key?('weightedValueIndex'),
+           'weightedValueIndex omitted when nil'
+  end
+
+  def test_selected_value_wrapper_keys_match_prefab_shape
+    agg = make_aggregator
+
+    record_eval(agg, selected_value: true,      conditional_value_index: 0)
+    record_eval(agg, selected_value: 3,         conditional_value_index: 1)
+    record_eval(agg, selected_value: 1.5,       conditional_value_index: 2)
+    record_eval(agg, selected_value: 'hi',      conditional_value_index: 3)
+    record_eval(agg, selected_value: %w[a b],   conditional_value_index: 4)
+
+    counters = agg.drain_event['summaries']['summaries'][0]['counters']
+    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['selectedValue'] }
+
+    assert_equal({ 'bool'       => true },  by_idx[0])
+    assert_equal({ 'int'        => 3 },     by_idx[1])
+    assert_equal({ 'double'     => 1.5 },   by_idx[2])
+    assert_equal({ 'string'     => 'hi' },  by_idx[3])
+    assert_equal({ 'stringList' => %w[a b] }, by_idx[4])
+  end
+
+  def test_weighted_value_index_included_when_present
+    agg = make_aggregator
+
+    record_eval(agg, weighted_value_index: 2, reason: 3)
+
+    counter = agg.drain_event['summaries']['summaries'][0]['counters'][0]
+    assert_equal 2, counter['weightedValueIndex']
+    assert_equal 3, counter['reason']
+  end
+
+  def test_log_level_evaluations_are_excluded
+    agg = make_aggregator
+
+    record_eval(agg, config_type: 'log_level')
+
+    assert_nil agg.drain_event
+  end
+
+  def test_record_caps_at_max_keys
+    agg = make_aggregator(max_keys: 2)
+
+    record_eval(agg, config_key: 'a')
+    record_eval(agg, config_key: 'b')
+    record_eval(agg, config_key: 'c') # dropped — at cap
+
+    summaries = agg.drain_event['summaries']['summaries']
+    keys = summaries.map { |s| s['key'] }.sort
+    assert_equal %w[a b], keys
+  end
+
+  def test_noop_when_max_keys_zero
+    agg = make_aggregator(max_keys: 0)
+
+    record_eval(agg)
+
+    assert_nil agg.drain_event
+  end
+end

data/test/test_example_contexts_aggregator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestExampleContextsAggregator < Minitest::Test
+  def test_record_dedupes_within_window
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 2)
+
+    context = Quonfig::Context.new(
+      'user' => { 'key' => 'abc' },
+      'device' => { 'key' => 'def', 'mobile' => true }
+    )
+
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    # Same grouped key → skipped.
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    new_context = Quonfig::Context.new(
+      'user' => { 'key' => 'ghi', 'admin' => true },
+      'team' => { 'key' => '999' }
+    )
+
+    aggregator.record(new_context)
+    assert_equal 2, aggregator.data.size
+
+    # At max_contexts — next record is dropped.
+    aggregator.record(Quonfig::Context.new('user' => { 'key' => 'new' }))
+    assert_equal 2, aggregator.data.size
+  end
+
+  def test_record_drops_contexts_without_a_key_property
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    # Anonymous contexts (no `key` / `trackingId`) produce an empty
+    # grouped_key under the sdk-node-aligned shape. The aggregator drops
+    # them so we don't ship rows the backend can't dedupe.
+    aggregator.record(Quonfig::Context.new('user' => { 'name' => 'no-key' }))
+    aggregator.record(Quonfig::Context.new('user' => { 'name' => 'still-no-key' }))
+    assert_equal 0, aggregator.data.size
+  end
+
+  def test_record_with_expiry_allows_re_recording_after_window
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    context = Quonfig::Context.new(
+      'user' => { 'key' => 'abc' },
+      'device' => { 'key' => 'def', 'mobile' => true }
+    )
+
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    Timecop.travel(Time.now + (60 * 60) - 1) do
+      aggregator.record(context)
+      assert_equal 1, aggregator.data.size
+    end
+
+    Timecop.travel(Time.now + (60 * 60) + 1) do
+      aggregator.record(context)
+      assert_equal 2, aggregator.data.size
+    end
+  end
+
+  def test_drain_event_emits_api_telemetry_wire_shape
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    aggregator.record(
+      Quonfig::Context.new(
+        'user' => { 'key' => 'abc' },
+        'device' => { 'key' => 'def', 'mobile' => true }
+      )
+    )
+    aggregator.record(
+      Quonfig::Context.new('user' => { 'key' => 'kev', 'name' => 'kevin', 'age' => 48.5 })
+    )
+
+    event = aggregator.drain_event
+
+    refute_nil event
+    assert event.key?('exampleContexts')
+    examples = event['exampleContexts']['examples']
+    assert_equal 2, examples.size
+
+    first = examples[0]
+    assert_kind_of Integer, first['timestamp']
+    assert first['timestamp'] > 0
+
+    contexts_list = first['contextSet']['contexts']
+    user_ctx = contexts_list.find { |c| c['type'] == 'user' }
+    device_ctx = contexts_list.find { |c| c['type'] == 'device' }
+
+    refute_nil user_ctx
+    refute_nil device_ctx
+    assert_equal 'abc', user_ctx['values']['key']
+    assert_equal true, device_ctx['values']['mobile']
+
+    second = examples[1]
+    user_ctx = second['contextSet']['contexts'].find { |c| c['type'] == 'user' }
+    assert_equal 'kev', user_ctx['values']['key']
+    assert_equal 'kevin', user_ctx['values']['name']
+    assert_in_delta 48.5, user_ctx['values']['age']
+  end
+
+  def test_drain_event_nil_when_empty
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+    assert_nil aggregator.drain_event
+  end
+
+  def test_drain_clears_data
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+    aggregator.record(Quonfig::Context.new('user' => { 'key' => 'abc' }))
+    aggregator.drain_event
+    assert_equal 0, aggregator.data.size
+  end
+end

data/test/test_http_connection.rb

@@ -23,7 +23,7 @@ module Quonfig
 
     def test_x_quonfig_sdk_version_header
       conn = HttpConnection.new(URI, SDK_KEY).connection
-      assert_equal 'ruby-0.1.0', conn.headers['X-Quonfig-SDK-Version']
+      assert_equal "ruby-#{Quonfig::VERSION}", conn.headers['X-Quonfig-SDK-Version']
     end
 
     def test_no_protobuf_content_type

data/test/test_resolver.rb

@@ -134,11 +134,158 @@ class TestResolverTrio < Minitest::Test
     assert_equal DEFAULT_VALUE, result.unwrapped_value
   end
 
-  def test_resolver_get_returns_nil_for_missing_key
+  def test_resolver_get_raises_missing_default_for_missing_key
     store = Quonfig::ConfigStore.new
     evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
     resolver = Quonfig::Resolver.new(store, evaluator)
 
-    assert_nil resolver.get('nope', Quonfig::Context.new({}))
+    # Resolver.get raises Quonfig::Errors::MissingDefaultError when no
+    # config exists for the key (qfg-9x7 alignment with the shared YAML
+    # get_or_raise.yaml suite). Client.get catches this and folds it into
+    # the on_no_default policy / caller-supplied default.
+    assert_raises(Quonfig::Errors::MissingDefaultError) do
+      resolver.get('nope', Quonfig::Context.new({}))
+    end
+  end
+
+  # ---- ENV_VAR provided value resolution (qfg-08q) ---------------------
+
+  # Build a config whose value comes from a `provided` ENV_VAR lookup.
+  # value_type drives coercion of the env var string back to the SDK type
+  # (mirrors sdk-node/sdk-go behavior).
+  def make_provided_config(key:, value_type:, lookup:)
+    {
+      id: '1',
+      key: key,
+      type: 'config',
+      value_type: value_type,
+      send_to_client_sdk: false,
+      default: {
+        'rules' => [
+          {
+            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
+            'value' => {
+              'type' => 'provided',
+              'value' => { 'source' => 'ENV_VAR', 'lookup' => lookup }
+            }
+          }
+        ]
+      },
+      environment: nil
+    }
+  end
+
+  def with_env(name, value)
+    original = ENV[name]
+    ENV[name] = value
+    yield
+  ensure
+    if original.nil?
+      ENV.delete(name)
+    else
+      ENV[name] = original
+    end
+  end
+
+  def build_resolver(cfg)
+    store = Quonfig::ConfigStore.new({ cfg[:key] => cfg })
+    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
+    Quonfig::Resolver.new(store, evaluator)
+  end
+
+  def test_resolver_get_resolves_provided_env_var_as_string
+    cfg = make_provided_config(key: 'a.string', value_type: 'string', lookup: 'QFG_TEST_STRING')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_STRING', 'hello') do
+      result = resolver.get('a.string', Quonfig::Context.new({}))
+      assert_equal 'hello', result.unwrapped_value
+      assert_equal 'string', result.value_type
+    end
+  end
+
+  def test_resolver_get_resolves_provided_env_var_as_int
+    cfg = make_provided_config(key: 'a.number', value_type: 'int', lookup: 'QFG_TEST_INT')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_INT', '1234') do
+      result = resolver.get('a.number', Quonfig::Context.new({}))
+      assert_equal 1234, result.unwrapped_value
+      assert_equal 'int', result.value_type
+    end
+  end
+
+  def test_resolver_get_resolves_provided_env_var_as_double
+    cfg = make_provided_config(key: 'a.double', value_type: 'double', lookup: 'QFG_TEST_DOUBLE')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_DOUBLE', '3.14') do
+      result = resolver.get('a.double', Quonfig::Context.new({}))
+      assert_in_delta 3.14, result.unwrapped_value, 0.0001
+      assert_equal 'double', result.value_type
+    end
+  end
+
+  def test_resolver_get_resolves_provided_env_var_as_bool
+    cfg = make_provided_config(key: 'a.bool', value_type: 'bool', lookup: 'QFG_TEST_BOOL')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_BOOL', 'true') do
+      result = resolver.get('a.bool', Quonfig::Context.new({}))
+      assert_equal true, result.unwrapped_value
+      assert_equal 'bool', result.value_type
+    end
+
+    with_env('QFG_TEST_BOOL', 'no') do
+      result = resolver.get('a.bool', Quonfig::Context.new({}))
+      assert_equal false, result.unwrapped_value
+    end
+  end
+
+  def test_resolver_get_resolves_provided_env_var_as_string_list
+    cfg = make_provided_config(key: 'a.list', value_type: 'string_list', lookup: 'QFG_TEST_LIST')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_LIST', 'a, b ,c') do
+      result = resolver.get('a.list', Quonfig::Context.new({}))
+      assert_equal %w[a b c], result.unwrapped_value
+      assert_equal 'string_list', result.value_type
+    end
+  end
+
+  def test_resolver_get_raises_missing_env_var_error_when_unset
+    cfg = make_provided_config(key: 'a.missing', value_type: 'string', lookup: 'QFG_DEFINITELY_UNSET')
+    resolver = build_resolver(cfg)
+    ENV.delete('QFG_DEFINITELY_UNSET')
+
+    err = assert_raises(Quonfig::Errors::MissingEnvVarError) do
+      resolver.get('a.missing', Quonfig::Context.new({}))
+    end
+    assert_match(/QFG_DEFINITELY_UNSET/, err.message)
+    assert_match(/a\.missing/, err.message)
+  end
+
+  def test_resolver_get_raises_env_var_parse_error_on_bad_int
+    cfg = make_provided_config(key: 'a.number', value_type: 'int', lookup: 'QFG_TEST_BAD_INT')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_BAD_INT', 'not_a_number') do
+      err = assert_raises(Quonfig::Errors::EnvVarParseError) do
+        resolver.get('a.number', Quonfig::Context.new({}))
+      end
+      assert_match(/a\.number/, err.message)
+      assert_match(/not_a_number/, err.message)
+    end
+  end
+
+  def test_resolver_get_raises_env_var_parse_error_on_bad_double
+    cfg = make_provided_config(key: 'a.double', value_type: 'double', lookup: 'QFG_TEST_BAD_DOUBLE')
+    resolver = build_resolver(cfg)
+
+    with_env('QFG_TEST_BAD_DOUBLE', 'not_a_number') do
+      assert_raises(Quonfig::Errors::EnvVarParseError) do
+        resolver.get('a.double', Quonfig::Context.new({}))
+      end
+    end
   end
 end

data/test/test_should_log.rb

@@ -0,0 +1,186 @@
+# 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