fix(test): stop telemetry bootstrap tests blocking on real OTel exporter under py3.14

Tests in TestConfigureTelemetryIdempotency and related classes were hanging
~277 s each on Python 3.14 (just under the 300 s pytest --timeout), causing
the CI unit leg to take ~40 min instead of 7-19 min.

Root cause: the _reset_otel_globals autouse fixture captured the current
global MeterProvider (which is _PROXY_METER_PROVIDER, the OTel process-wide
proxy singleton) and attempted to "restore" it in teardown by calling
set_meter_provider(_PROXY_METER_PROVIDER).  OTel's set_meter_provider is
intentionally a one-shot operation guarded by a Once object.  When no real
provider had yet been installed (because the test mocked set_meter_provider
at the opentelemetry.metrics namespace), the Once gate had not yet fired, so
the teardown call fired it for the first time with the proxy as its own
argument.  This triggered:

  _PROXY_METER_PROVIDER.on_set_meter_provider(_PROXY_METER_PROVIDER)
    → acquires _PROXY_METER_PROVIDER._lock
    → iterates proxy meters, calls meter.on_set_meter_provider(proxy)
    → _ProxyMeter.on_set_meter_provider calls proxy.get_meter()
    → _PROXY_METER_PROVIDER.get_meter() tries to acquire _PROXY_METER_PROVIDER._lock
    → deadlock (non-reentrant Lock, blocks forever)

On Python 3.12 this was order-dependent: if TestConfigureTelemetryEnabled ran
first, its teardown fired the Once gate harmlessly, making all later teardowns
no-ops.  On Python 3.14, CI runs these test classes in isolation (per-class or
per-file grouping changed by bumping python.default_version 3.12→3.14), so the
gate fires in teardown of the very first test that mocked set_meter_provider,
hitting the deadlock deterministically every time.

Fix: remove the restore logic from _reset_otel_globals entirely.  OTel's
global meter provider is a process-wide Once-guarded singleton; it is not
designed to be reset between tests.  The module-level _state object
(_reset_telemetry_state) is the correct isolation boundary for unit tests
of idempotency/flag logic.  Tests that need to intercept set_meter_provider
already mock it at the call site (which they do).

Author: fgogolli

tests/unit/infrastructure/di/test_telemetry_bootstrap.py

@@ -59,29 +59,30 @@ def _make_container_with_otel(otel_config: OtelConfig) -> DIContainer:
 def _reset_otel_globals():
     """Reset telemetry state before and after every test for isolation.
 
-    Also restores the global OTel MeterProvider so that enabled=True tests
-    installing a real provider do not leak into subsequent tests.
+    OTel's set_meter_provider() is intentionally a one-shot operation
+    (guarded by a Once gate): calling it a second time is a no-op.  Trying
+    to "restore" the original proxy provider after each test by calling
+    set_meter_provider(_PROXY_METER_PROVIDER) is therefore wrong — if the
+    Once gate has not yet fired it fires with the proxy as its own argument,
+    causing _ProxyMeterProvider.on_set_meter_provider(_PROXY_METER_PROVIDER)
+    to hold _ProxyMeterProvider._lock and then call back into
+    _ProxyMeterProvider.get_meter(), which tries to acquire the same lock a
+    second time and deadlocks indefinitely (seen as ~277 s hangs under
+    Python 3.14, where the deadlock is reliably deterministic because
+    threading.Lock acquire now always blocks without a timeout by default).
+
+    The correct approach for unit tests that only test idempotency flags and
+    module-level _state is to reset _state via _reset_telemetry_state() and
+    to mock opentelemetry.metrics.set_meter_provider at the call sites that
+    need it (which the enabled-path tests already do).  We must not attempt
+    to mutate OTel's process-wide Once-guarded singleton in teardown.
     """
     telemetry_module._reset_telemetry_state()
-    # Capture the current global meter provider so we can restore it.
-    try:
-        from opentelemetry import metrics as _otel_metrics
-
-        _original_meter_provider = _otel_metrics.get_meter_provider()
-    except (ImportError, Exception):
-        _original_meter_provider = None
 
     yield
 
     telemetry_module._reset_telemetry_state()
 
-    # Restore the global meter provider to what it was before the test.
-    if _original_meter_provider is not None:
-        with suppress(Exception):
-            from opentelemetry import metrics as _otel_metrics
-
-            _otel_metrics.set_meter_provider(_original_meter_provider)
-
 
 # ---------------------------------------------------------------------------
 # Test: enabled=False is a no-op