Fix get_logger returning agentfield.result_cache for all loggers (#635)

* issue/fix-get-logger-name-bug: fix get_logger to respect name parameter using dictionary cache

* chore: finalize repo for handoff

* fix(logger): guard logger cache with a lock for thread-safe access

The per-name logger cache introduced in this PR is shared mutable module
state. `get_logger()` could insert into `_logger_cache` while
`set_log_level()`/`set_cp_client()` iterate `.values()`, raising
`RuntimeError: dictionary changed size during iteration`.

Add a reentrant lock around all cache access. set_log_level/set_cp_client
snapshot the values under the lock and apply outside it, so we never hold
the lock during the loggers' own work. Addresses the thread-safety findings
from the PR review.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(logger): fix lint, isolate global logging state, cover concurrency

Three issues in the new logger test:

- Removed unused imports (`AgentFieldLogger`, `_global_log_level`) that
  failed `ruff check` (F401) and broke CI lint on 3.10/3.11/3.12.
- The fixture's `global _global_log_level = None` only rebound this
  module's copy, never the real `agentfield.logger` global, so the level
  reset silently did nothing. Reference the module so the reset bites.
- `AgentFieldLogger` mutates the stdlib logging registry (adds a handler,
  sets `propagate=False`). Those mutations outlived each test and leaked
  across the session. The fixture now snapshots and restores the registry
  so this file is order-independent and can't mute unrelated loggers.

Also add a concurrency test exercising get_logger()/set_log_level() from
several threads, locking in the thread-safety fix.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(cancel): capture cancel log directly, not via caplog/root

Fixing get_logger() to honour the requested name means get_logger()
now creates the real "agentfield" logger, on which the SDK sets
propagate=False. That stops every "agentfield.*" child (including the
plain "agentfield.cancel" logger) from reaching the root logger — where
pytest's `caplog` handler lives. The assertion only ever passed because
the old singleton bug meant the real "agentfield" logger was usually
never created, so this was silently order-dependent and failed once
test_logger ran first.

Attach a handler directly to the "agentfield.cancel" logger instead.
It asserts the identical contract (an INFO "cancel-callback fired"
record is emitted) but is independent of namespace propagation and
suite ordering. Use getMessage() since no formatter runs to set
record.message on a bare handler.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(logger): note set_log_level no longer implicitly creates a logger

Document the behavior change flagged in review: set_log_level() now only
records the level and updates cached loggers; it no longer creates the
default logger as a side effect. New loggers pick up the stored level
when created via get_logger().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(conftest): isolate execution-context state and drain leaked tasks

A pre-existing flake surfaced on Python 3.12 CI: tests that rely on the
agent / execution-context ContextVars (e.g.
test_execute_with_tracking_registers_child_context) intermittently saw
get_current_agent_instance() return None mid-test, skipping workflow
registration (assert 0 == 1). The suite also leaked many fire-and-forget
asyncio tasks across tests ("Task was destroyed but it is pending!").

Add an autouse fixture that resets the agent/execution-context ContextVars
around every test and best-effort drains tasks the test left pending, so
ordering and stray tasks can't pollute later tests. All teardown work is
guarded to never raise. Verified locally on 3.10 and 3.12: full suite
green and the leaked-task warnings drop from dozens to zero.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(logger): forward structured logs to loggers created after set_cp_client

set_cp_client() only mutated loggers already in the cache, so any logger
created afterward kept the class default _cp_client=None and silently
dropped all structured telemetry in _dispatch_to_cp(). The concrete victim
is the agentfield.verification logger: it is created at module import time
inside Agent.__init__ (lazy `from agentfield.verification import LocalVerifier`)
which runs *after* set_cp_client(self.client), so under local_verification=True
none of its execution logs ever reached the control plane.

Mirror the existing _global_log_level pattern: record the client in a
module-level _global_cp_client under the cache lock, and apply it to new
loggers in get_logger(). Forwarding now works regardless of import/creation
order. set_cp_client(None) detaches globally as well.

Add regression tests covering loggers created after set_cp_client, the
existing already-cached path, and the None reset; extend reset_logger_state
to isolate the new global.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: SWE-AF <eng@agentfield.ai>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

.gitignore

@@ -6,6 +6,8 @@
 *.swo
 test-reports/
 .env
+.worktrees/
+.artifacts/
 
 # Go
 bin/

sdk/python/agentfield/logger.py

@@ -75,8 +75,9 @@ def __init__(self, name: str = "agentfield"):
 
     def set_level(self, level: str):
         """Set log level at runtime (e.g., 'DEBUG', 'INFO', 'WARN', 'ERROR')"""
-
-        self.logger.setLevel(_LEVEL_TO_LOGGING.get(level.upper(), logging.INFO))
+        level_upper = level.upper()
+        self.log_level = level_upper
+        self.logger.setLevel(_LEVEL_TO_LOGGING.get(level_upper, logging.INFO))
 
     def _setup_logger(self):
         """Setup logger with console handler if not already configured"""
@@ -113,8 +114,10 @@ def _format_payload(self, payload: Any) -> str:
 
     @staticmethod
     def _now_iso() -> str:
-        return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace(
-            "+00:00", "Z"
+        return (
+            datetime.now(timezone.utc)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z")
         )
 
     @staticmethod
@@ -174,7 +177,9 @@ def _build_execution_record(
         }
 
     def _emit_structured_record(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        line = json.dumps(record, ensure_ascii=False, separators=(",", ":"), default=str)
+        line = json.dumps(
+            record, ensure_ascii=False, separators=(",", ":"), default=str
+        )
         print(line, file=sys.stdout, flush=True)
         self._dispatch_to_cp(record)
         return record
@@ -454,28 +459,74 @@ def log_execution(
         return self._emit_structured_record(record)
 
 
-# Global logger instance
-_global_logger = None
+# Global logger cache: name -> AgentFieldLogger instance
+_logger_cache: Dict[str, AgentFieldLogger] = {}
+
+# Global log level override (set via set_log_level)
+_global_log_level: Optional[str] = None
+
+# Global control-plane client (set via set_cp_client). Stored at module scope so
+# loggers created *after* set_cp_client() still forward structured logs — mirrors
+# the _global_log_level pattern. Without this, a logger created late (e.g. the
+# lazily-imported agentfield.verification logger) would keep the class default
+# _cp_client=None and silently drop telemetry in _dispatch_to_cp().
+_global_cp_client: Optional["AgentFieldClient"] = None
+
+# Guards _logger_cache, _global_log_level and _global_cp_client against concurrent
+# access. Reentrant so a future helper holding the lock can still call get_logger()
+# safely.
+_logger_cache_lock = threading.RLock()
 
 
 def get_logger(name: str = "agentfield") -> AgentFieldLogger:
     """Get or create a AgentField SDK logger instance"""
 
-    global _global_logger
-    if _global_logger is None:
-        _global_logger = AgentFieldLogger(name)
-    return _global_logger
+    with _logger_cache_lock:
+        if name not in _logger_cache:
+            logger = AgentFieldLogger(name)
+            if _global_log_level is not None:
+                logger.set_level(_global_log_level)
+            if _global_cp_client is not None:
+                logger._cp_client = _global_cp_client
+            _logger_cache[name] = logger
+        return _logger_cache[name]
 
 
 def set_log_level(level: str):
-    """Set log level for the global logger at runtime (e.g., 'DEBUG', 'INFO', 'WARN', 'ERROR')"""
+    """Set log level for all logger instances at runtime (e.g., 'DEBUG', 'INFO', 'WARN', 'ERROR').
 
-    get_logger().set_level(level)
+    Behavior note: this records the level and applies it to every *cached*
+    logger; it does not create a logger when the cache is empty. Loggers
+    created later via ``get_logger()`` pick up the stored level on creation.
+    (Previously this implicitly created the default logger as a side effect.)
+    """
+
+    global _global_log_level
+    # Snapshot under the lock so a concurrent get_logger() can't mutate the dict
+    # mid-iteration; apply levels outside the lock to avoid holding it during I/O.
+    with _logger_cache_lock:
+        _global_log_level = level
+        loggers = list(_logger_cache.values())
+    for logger in loggers:
+        logger.set_level(level)
 
 
 def set_cp_client(client: Optional["AgentFieldClient"]) -> None:
-    """Attach a control-plane client so structured logs are forwarded."""
-    get_logger()._cp_client = client
+    """Attach a control-plane client so structured logs are forwarded to all loggers.
+
+    Records the client at module scope and applies it to every *cached* logger.
+    Loggers created later via ``get_logger()`` pick up the stored client on
+    creation, so forwarding works regardless of import/creation order (e.g. the
+    lazily-imported ``agentfield.verification`` logger).
+    """
+    global _global_cp_client
+    # Snapshot under the lock so a concurrent get_logger() can't mutate the dict
+    # mid-iteration; apply to existing loggers outside the lock.
+    with _logger_cache_lock:
+        _global_cp_client = client
+        loggers = list(_logger_cache.values())
+    for logger in loggers:
+        logger._cp_client = client
 
 
 # Convenience functions for common logging patterns

sdk/python/tests/conftest.py

@@ -50,9 +50,7 @@
 
 
 def _network_allowed(node: "pytest.Node") -> bool:
-    return bool(
-        node.get_closest_marker("integration")
-    )
+    return bool(node.get_closest_marker("integration"))
 
 
 @pytest.fixture(autouse=True)
@@ -61,6 +59,7 @@ def _ensure_event_loop():
     raises RuntimeError in non-async contexts. Agent() constructor and
     handle_serverless() depend on asyncio internally."""
     import asyncio
+
     try:
         asyncio.get_event_loop()
     except RuntimeError:
@@ -69,6 +68,53 @@ def _ensure_event_loop():
     yield
 
 
+@pytest.fixture(autouse=True)
+def _isolate_execution_context():
+    """Keep per-test agent/execution-context state from bleeding across tests.
+
+    The SDK tracks the active agent and execution context in module-level
+    ContextVars and spawns best-effort fire-and-forget tasks (note/log
+    forwarding). Under loaded CI on Python 3.12 these have intermittently
+    polluted a later test's view of the context (observed flake:
+    get_current_agent_instance() returning None mid-test, so workflow
+    registration is skipped). Reset the vars and drain any tasks the test
+    left pending around every test. Everything here is best-effort and must
+    never raise — a teardown hiccup must not fail an otherwise-green test.
+    """
+    import asyncio
+    from agentfield import agent_registry
+    from agentfield.execution_context import _context_manager
+
+    def _reset_vars():
+        try:
+            agent_registry._current_agent.set(None)
+        except Exception:
+            pass
+        try:
+            _context_manager._context_var.set(None)
+        except Exception:
+            pass
+
+    _reset_vars()
+    try:
+        yield
+    finally:
+        # Drain fire-and-forget tasks so none can resume during a later test.
+        try:
+            loop = asyncio.get_event_loop_policy().get_event_loop()
+            if loop is not None and not loop.is_closed() and not loop.is_running():
+                pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
+                for t in pending:
+                    t.cancel()
+                if pending:
+                    loop.run_until_complete(
+                        asyncio.gather(*pending, return_exceptions=True)
+                    )
+        except Exception:
+            pass
+        _reset_vars()
+
+
 @pytest.fixture(autouse=True)
 def _no_network_by_default(request):
     yield

sdk/python/tests/test_cancel.py

@@ -136,12 +136,20 @@ def test_cancel_route_returns_200_for_unknown_execution():
 
 
 @pytest.mark.asyncio
-async def test_cancel_route_emits_info_log_on_active_cancel(caplog):
+async def test_cancel_route_emits_info_log_on_active_cancel():
     """The route logs a structured info line when it actually cancelled
     something. We register the task and call the route handler directly
     rather than via TestClient because TestClient creates a fresh event
     loop per request, so a task registered in one request isn't visible
     from the next.
+
+    We capture with a handler attached directly to the ``agentfield.cancel``
+    logger rather than pytest's ``caplog``. The SDK deliberately sets
+    ``propagate=False`` on the ``agentfield`` parent logger (see logger.py), so
+    once any AgentField logger is created, ``agentfield.cancel`` records no
+    longer reach the root logger where ``caplog``'s handler lives — which made
+    this assertion silently order-dependent. A direct handler asserts the same
+    contract independent of namespace propagation and suite ordering.
     """
     agent = _FakeAgent()
     install_cancel_route(agent)
@@ -155,10 +163,7 @@ async def long() -> None:
     # Find the route handler we just installed.
     handler = None
     for route in agent.router.routes:
-        if (
-            getattr(route, "path", "")
-            == "/_internal/executions/{execution_id}/cancel"
-        ):
+        if getattr(route, "path", "") == "/_internal/executions/{execution_id}/cancel":
             handler = route.endpoint
             break
     assert handler is not None, "cancel route was not installed"
@@ -175,19 +180,34 @@ class _Request:
         def __init__(self, headers):
             self.headers = _Headers(headers)
 
-    with caplog.at_level(logging.INFO, logger="agentfield.cancel"):
+    records: list[logging.LogRecord] = []
+
+    class _Capture(logging.Handler):
+        def emit(self, record: logging.LogRecord) -> None:
+            records.append(record)
+
+    cancel_logger = logging.getLogger("agentfield.cancel")
+    capture = _Capture(level=logging.INFO)
+    prev_level = cancel_logger.level
+    cancel_logger.addHandler(capture)
+    cancel_logger.setLevel(logging.INFO)
+    try:
         resp = await handler(
             execution_id="exec-active",
             request=_Request({"X-AgentField-Source": "cancel-dispatcher"}),
         )
+    finally:
+        cancel_logger.removeHandler(capture)
+        cancel_logger.setLevel(prev_level)
 
     # FastAPI JSONResponse — body is bytes, status is on the object.
     import json as _json
 
     assert resp.status_code == 200
     body = _json.loads(resp.body.decode())
     assert body == {"cancelled": True, "execution_id": "exec-active"}
-    assert any("cancel-callback fired" in rec.message for rec in caplog.records)
+    # getMessage() applies the %-args; rec.message is only set once a formatter runs.
+    assert any("cancel-callback fired" in rec.getMessage() for rec in records)
 
     with pytest.raises(asyncio.CancelledError):
         await task