refactor: move additional_loggers and logging setup to VcsEnvironment

VcsEnvironment now stores additional_loggers and provides
configure_logging() which sets up all loggers at the correct level.
GlobalOverrides.__enter__ delegates to vcs_env.configure_logging().

- Add additional_loggers field to VcsEnvironment
- Add configure_logging() method to VcsEnvironment
- Remove additional_loggers from GlobalOverrides __slots__/__init__
- Add backward-compat property delegating to vcs_env
- from_env() attaches loggers via dataclasses.replace
- Simplify _log._get_all_scm_loggers: no longer reads _active_overrides

Co-authored-by: Cursor AI <ai@cursor.sh>
Co-authored-by: Anthropic Claude Opus 4 <claude@anthropic.com>

Author: 3 people

vcs-versioning/src/vcs_versioning/_environment.py

@@ -15,10 +15,13 @@
 import dataclasses
 import logging
 import os
-from collections.abc import Mapping
+from collections.abc import Mapping, MutableMapping
+from datetime import datetime
 from typing import TYPE_CHECKING, Any, Literal
 
 if TYPE_CHECKING:
+    from pytest import MonkeyPatch
+
     from . import _config, overrides
 
 log = logging.getLogger(__name__)
@@ -61,13 +64,23 @@ class VcsEnvironment:
     _env: Mapping[str, str] = dataclasses.field(
         default_factory=lambda: os.environ, repr=False, compare=False
     )
+    additional_loggers: tuple[logging.Logger, ...] = ()
 
     def log_level(self) -> int:
         """Logging level derived from the debug setting."""
         if self.debug is False:
             return logging.WARNING
         return self.debug
 
+    def configure_logging(self) -> None:
+        """Configure all loggers for this environment's debug level."""
+        from ._log import _configure_loggers
+
+        _configure_loggers(
+            log_level=self.log_level(),
+            additional_loggers=list(self.additional_loggers),
+        )
+
     def make_reader(self, dist_name: str | None = None) -> overrides.EnvReader:
         """Create an :class:`EnvReader` configured with this env's tool names."""
         from .overrides import EnvReader
@@ -76,6 +89,36 @@ def make_reader(self, dist_name: str | None = None) -> overrides.EnvReader:
             tools_names=self.tool_names, env=self._env, dist_name=dist_name
         )
 
+    def source_epoch_or_utc_now(self) -> datetime:
+        """Get datetime from SOURCE_DATE_EPOCH or current UTC time."""
+        from datetime import timezone
+
+        if self.source_date_epoch is not None:
+            return datetime.fromtimestamp(self.source_date_epoch, timezone.utc)
+        return datetime.now(timezone.utc)
+
+    def export(self, target: MutableMapping[str, str] | MonkeyPatch) -> None:
+        """Export settings to environment variables using ``tool_names[0]`` as prefix."""
+
+        def set_var(key: str, value: str) -> None:
+            if isinstance(target, MutableMapping):
+                target[key] = value
+            else:
+                target.setenv(key, value)
+
+        if self.source_date_epoch is not None:
+            set_var("SOURCE_DATE_EPOCH", str(self.source_date_epoch))
+
+        prefix = self.tool_names[0]
+
+        if self.debug is False:
+            set_var(f"{prefix}_DEBUG", "0")
+        else:
+            set_var(f"{prefix}_DEBUG", str(self.debug))
+
+        set_var(f"{prefix}_SUBPROCESS_TIMEOUT", str(self.subprocess_timeout))
+        set_var(f"{prefix}_HG_COMMAND", self.hg_command)
+
     @classmethod
     def from_env(
         cls,

vcs-versioning/src/vcs_versioning/_log.py

@@ -28,25 +28,13 @@ def _get_all_scm_loggers(
 ) -> list[logging.Logger]:
     """Get all SCM-related loggers that need configuration.
 
-    Always configures vcs_versioning logger.
-    If additional_loggers is provided, also configures those loggers.
-    If not provided, tries to get them from active GlobalOverrides context.
+    Always includes the ``vcs_versioning`` logger.
+    If *additional_loggers* is provided, those are appended.
     """
     loggers = [logging.getLogger("vcs_versioning")]
 
     if additional_loggers is not None:
         loggers.extend(additional_loggers)
-    else:
-        # Try to get additional loggers from active overrides context
-        try:
-            from .overrides import _active_overrides
-
-            overrides = _active_overrides.get()
-            if overrides is not None:
-                loggers.extend(overrides.additional_loggers)
-        except ImportError:
-            # During early initialization, overrides module might not be available yet
-            pass
 
     return loggers
 

vcs-versioning/src/vcs_versioning/overrides.py

@@ -262,19 +262,17 @@ class GlobalOverrides:
             version = get_version(...)
     """
 
-    __slots__ = ("vcs_env", "tool", "dist_name", "additional_loggers", "_token")
+    __slots__ = ("vcs_env", "tool", "dist_name", "_token")
 
     def __init__(
         self,
         vcs_env: _environment.VcsEnvironment,
         tool: str,
         dist_name: str | None = None,
-        additional_loggers: tuple[logging.Logger, ...] = (),
     ) -> None:
         self.vcs_env = vcs_env
         self.tool = tool
         self.dist_name = dist_name
-        self.additional_loggers = additional_loggers
         self._token: contextvars.Token[GlobalOverrides | None] | None = None
 
     # ------------------------------------------------------------------
@@ -301,6 +299,10 @@ def source_date_epoch(self) -> int | None:
     def ignore_vcs_roots(self) -> list[str]:
         return list(self.vcs_env.ignore_vcs_roots)
 
+    @property
+    def additional_loggers(self) -> tuple[logging.Logger, ...]:
+        return self.vcs_env.additional_loggers
+
     @property
     def env_reader(self) -> EnvReader:
         return self.vcs_env.make_reader(dist_name=self.dist_name)
@@ -332,6 +334,8 @@ def from_env(
         Returns:
             GlobalOverrides instance ready to use as context manager
         """
+        import dataclasses as dc
+
         from ._environment import VcsEnvironment
 
         vcs_env = VcsEnvironment.from_env(tool, env=env)
@@ -344,11 +348,13 @@ def from_env(
         else:
             logger_tuple = ()
 
+        if logger_tuple:
+            vcs_env = dc.replace(vcs_env, additional_loggers=logger_tuple)
+
         return cls(
             vcs_env=vcs_env,
             tool=tool,
             dist_name=dist_name,
-            additional_loggers=logger_tuple,
         )
 
     # ------------------------------------------------------------------
@@ -358,14 +364,7 @@ def from_env(
     def __enter__(self) -> GlobalOverrides:
         """Enter context: set this as the active override and configure logging."""
         self._token = _active_overrides.set(self)
-
-        from ._log import _configure_loggers
-
-        _configure_loggers(
-            log_level=self.vcs_env.log_level(),
-            additional_loggers=list(self.additional_loggers),
-        )
-
+        self.vcs_env.configure_logging()
         return self
 
     def __exit__(self, *exc_info: Any) -> None:
@@ -384,12 +383,7 @@ def log_level(self) -> int:
 
     def source_epoch_or_utc_now(self) -> datetime:
         """Get datetime from SOURCE_DATE_EPOCH or current UTC time."""
-        from datetime import datetime, timezone
-
-        if self.source_date_epoch is not None:
-            return datetime.fromtimestamp(self.source_date_epoch, timezone.utc)
-        else:
-            return datetime.now(timezone.utc)
+        return self.vcs_env.source_epoch_or_utc_now()
 
     @classmethod
     def from_active(cls, **changes: Any) -> GlobalOverrides:
@@ -418,14 +412,13 @@ def from_active(cls, **changes: Any) -> GlobalOverrides:
 
         new_tool = changes.pop("tool", active.tool)
         new_dist_name = changes.pop("dist_name", active.dist_name)
-        new_loggers = changes.pop("additional_loggers", active.additional_loggers)
 
         if new_tool != active.tool:
             vcs_env = VcsEnvironment.from_env(new_tool, env=active.vcs_env._env)
         else:
             vcs_env = active.vcs_env
 
-        # Remaining changes are VcsEnvironment field overrides
+        # Remaining changes are VcsEnvironment field overrides (includes additional_loggers)
         vcs_env_fields = {f.name for f in dc.fields(VcsEnvironment)}
         env_changes = {k: v for k, v in changes.items() if k in vcs_env_fields}
         if env_changes:
@@ -435,7 +428,6 @@ def from_active(cls, **changes: Any) -> GlobalOverrides:
             vcs_env=vcs_env,
             tool=new_tool,
             dist_name=new_dist_name,
-            additional_loggers=new_loggers,
         )
 
     def export(self, target: MutableMapping[str, str] | MonkeyPatch) -> None:
@@ -444,25 +436,7 @@ def export(self, target: MutableMapping[str, str] | MonkeyPatch) -> None:
         Can export to either a dict-like environment or a pytest monkeypatch fixture.
         This is useful for tests that need to propagate overrides to subprocesses.
         """
-
-        def set_var(key: str, value: str) -> None:
-            if isinstance(target, MutableMapping):
-                target[key] = value
-            else:
-                target.setenv(key, value)
-
-        if self.source_date_epoch is not None:
-            set_var("SOURCE_DATE_EPOCH", str(self.source_date_epoch))
-
-        prefix = self.tool
-
-        if self.debug is False:
-            set_var(f"{prefix}_DEBUG", "0")
-        else:
-            set_var(f"{prefix}_DEBUG", str(self.debug))
-
-        set_var(f"{prefix}_SUBPROCESS_TIMEOUT", str(self.subprocess_timeout))
-        set_var(f"{prefix}_HG_COMMAND", self.hg_command)
+        self.vcs_env.export(target)
 
 
 # Thread-local storage for active global overrides