fix: remove import-time logging side effects (closes z3z1ma#136)

Previously, importing dbt-core-interface would immediately configure logging
to DEBUG level and add a RichHandler, polluting user's console
when dbt-core scanned for plugins. This was caused by module-level
execution of logger.setLevel() and logger.addHandler().

Changes:
- Moved logging configuration from module-level to DbtProject.setup_logging()
  classmethod that must be called explicitly
- Moved disable_tracking() and _set_invocation_context() calls into
  DbtProject.__init__() instead of executing at import time
- Added tests to verify logging is not configured at import and that
  setup_logging() works correctly and idempotently
- Bumped version to 1.1.6

The module can now be imported without side effects, making it safe
for dbt-core's plugin scanner which imports any package starting with
dbt- or dbt_.

Author: z3z1ma

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dbt-core-interface"
-version = "1.1.5"
+version = "1.1.6"
 dynamic = []
 description = "Dbt Core Interface"
 authors = [

src/dbt_core_interface/project.py

@@ -66,22 +66,25 @@ def _patched_adapter_accessor(config: t.Any) -> t.Any:
     from sqlfluff.core.linter.linted_dir import LintingRecord
 
 
-disable_tracking()
-
-
 def _set_invocation_context() -> None:
     set_invocation_context(get_env())
 
 
-_set_invocation_context()
+def _setup_logging(level: int = logging.DEBUG) -> logging.Logger:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(level)
 
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-logger.addHandler(rich.logging.RichHandler())
+    if not any(isinstance(h, rich.logging.RichHandler) for h in logger.handlers):
+        logger.addHandler(rich.logging.RichHandler())
+
+    add_logger_to_manager(
+        LoggerConfig(name=__name__, logger=logger),
+    )
+
+    return logger
 
-add_logger_to_manager(
-    LoggerConfig(name=__name__, logger=logger),
-)
+
+logger = logging.getLogger(__name__)
 
 __all__ = ["DbtProject", "DbtConfiguration"]
 
@@ -253,6 +256,9 @@ def __init__(
         if hasattr(self, "_args"):
             return
 
+        disable_tracking()
+        _set_invocation_context()
+
         project_dir = project_dir or _get_profiles_dir()
         profiles_dir = profiles_dir or _get_profiles_dir(project_dir)
 
@@ -321,6 +327,20 @@ def __repr__(self) -> str:  # pyright: ignore[reportImplicitOverride]
 
     set_invocation_context = staticmethod(_set_invocation_context)
 
+    @classmethod
+    def setup_logging(cls, level: int = logging.DEBUG) -> logging.Logger:
+        logger = logging.getLogger(__name__)
+        logger.setLevel(level)
+
+        if not any(isinstance(h, rich.logging.RichHandler) for h in logger.handlers):
+            logger.addHandler(rich.logging.RichHandler())
+
+        add_logger_to_manager(
+            LoggerConfig(name=__name__, logger=logger),
+        )
+
+        return logger
+
     @classmethod
     def from_config(cls, config: DbtConfiguration) -> DbtProject:
         """Create project from configuration."""

tests/test_main.py

@@ -1,5 +1,7 @@
 """Test cases for the project module."""
 
+import logging
+
 
 def test_import_succeeds() -> None:
     """A simple test to ensure that the project module can be imported.
@@ -11,3 +13,57 @@ def test_import_succeeds() -> None:
     from dbt_core_interface import project
 
     _ = project
+
+
+def test_logging_not_configured_at_import() -> None:
+    """Verify logging is NOT configured at import time.
+
+    This is critical for issue #136 - importing dbt-core-interface
+    should not cause side effects like setting DEBUG log level or
+    adding RichHandler to dbt's logger.
+    """
+    from dbt_core_interface import project
+
+    logger = logging.getLogger("dbt_core_interface.project")
+
+    assert logger.level == 0 or logger.level == logging.NOTSET, (
+        f"Logger should NOT be configured at import, but level is {logger.level}"
+    )
+    assert len(logger.handlers) == 0, (
+        f"Logger should have NO handlers at import, but has {len(logger.handlers)}"
+    )
+
+
+def test_setup_logging_works() -> None:
+    """Verify DbtProject.setup_logging() correctly configures logging."""
+    from dbt_core_interface import DbtProject
+
+    DbtProject.setup_logging(level=logging.DEBUG)
+
+    logger = logging.getLogger("dbt_core_interface.project")
+
+    assert logger.level == logging.DEBUG, (
+        f"Logger level should be DEBUG after setup_logging, but is {logger.level}"
+    )
+    assert len(logger.handlers) > 0, "Logger should have handlers after setup_logging"
+    assert any(h.__class__.__name__ == "RichHandler" for h in logger.handlers), (
+        "Logger should have RichHandler after setup_logging"
+    )
+
+
+def test_setup_logging_idempotent() -> None:
+    """Verify DbtProject.setup_logging() can be called multiple times safely."""
+    from dbt_core_interface import DbtProject
+
+    DbtProject.setup_logging(level=logging.DEBUG)
+    handler_count_after_first_call = len(logging.getLogger("dbt_core_interface.project").handlers)
+
+    DbtProject.setup_logging(level=logging.INFO)
+
+    logger = logging.getLogger("dbt_core_interface.project")
+
+    handler_count_after_second_call = len(logger.handlers)
+
+    assert handler_count_after_second_call == handler_count_after_first_call, (
+        "setup_logging should be idempotent - should not add duplicate handlers"
+    )