Fix logging configuration

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        pixi-version: ["0.30.0", "0.39.4"]
+        pixi-version: ["0.30.0", "0.40.1"]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repo

pixi_kernel/__init__.py

@@ -1,12 +1,7 @@
-import logging
-
 from jupyter_server.serverapp import ServerApp
 
 from .handlers import setup_handlers
 
-logging.basicConfig(level=logging.INFO, format="pixi-kernel %(levelname)s: %(message)s")
-logger = logging.getLogger(__name__)
-
 
 def _jupyter_labextension_paths() -> list[dict[str, str]]:
     return [{"src": "labextension", "dest": "pixi-kernel"}]
@@ -18,4 +13,4 @@ def _jupyter_server_extension_points() -> list[dict[str, str]]:
 
 def _load_jupyter_server_extension(server_app: ServerApp) -> None:
     setup_handlers(server_app.web_app)
-    logger.info("Registered pixi_kernel server extension")
+    server_app.log.info("Registered pixi_kernel server extension")

pixi_kernel/provisioner.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import os
 import sys
 from pathlib import Path
@@ -11,14 +10,12 @@
 
 from .readiness import verify_env_readiness
 
-logger = logging.getLogger(__name__)
-
 
 class PixiKernelProvisioner(LocalProvisioner):  # type: ignore[misc]
     async def _launch_fallback_kernel(self, *, message: str, **kwargs: Any) -> dict[str, Any]:
         kernel_spec = cast(KernelSpec, self.kernel_spec)
         kernel_spec.argv = [sys.executable, "-m", "pixi_kernel", "{connection_file}", message]
-        logger.info(f"Launching fallback kernel: {kernel_spec.to_dict()}")
+        self.log.info(f"Launching fallback kernel: {kernel_spec.to_dict()}")
         return await super().pre_launch(**kwargs)
 
     async def pre_launch(self, **kwargs: Any) -> dict[str, Any]:
@@ -43,14 +40,14 @@ async def pre_launch(self, **kwargs: Any) -> dict[str, Any]:
             return await self._launch_fallback_kernel(message=message, **kwargs)
 
         cwd = Path(kwargs.get("cwd", Path.cwd()))
-        logger.info(f"Working directory: {cwd} (provided by JupyterLab: {kwargs.get('cwd')})")
+        self.log.info(f"Working directory: {cwd} (provided by JupyterLab: {kwargs.get('cwd')})")
 
         env: dict[str, str] = kwargs.get("env", os.environ.copy())
 
         # https://github.com/jupyterlab/jupyterlab/issues/16282
         notebook_path = env.get("JPY_SESSION_NAME")
         if notebook_path is None:
-            logger.error(
+            self.log.error(
                 "Failed to get notebook path from JPY_SESSION_NAME variable."
                 "Falling back to the default environment."
             )
@@ -60,7 +57,7 @@ async def pre_launch(self, **kwargs: Any) -> dict[str, Any]:
                 notebook = json.loads(Path(notebook_path).read_text())
                 environment_name = notebook["metadata"]["pixi-kernel"]["environment"]
             except Exception as exception:
-                logger.error(
+                self.log.error(
                     f"Failed to get Pixi environment name from notebook metadata."
                     f"Falling back to default environment. {exception}"
                 )
@@ -72,6 +69,7 @@ async def pre_launch(self, **kwargs: Any) -> dict[str, Any]:
             env=env,
             required_package=required_package,
             kernel_name=kernel_spec.display_name,
+            logger=self.log,
         )
         if isinstance(result, Failure):
             return await self._launch_fallback_kernel(message=result.failure(), **kwargs)
@@ -90,5 +88,5 @@ async def pre_launch(self, **kwargs: Any) -> dict[str, Any]:
             kernel_spec.env["R_LIBS_SITE"] = r_libs_path
             kernel_spec.env["R_LIBS_USER"] = r_libs_path
 
-        logger.info(f"Launching {kernel_spec.display_name}: {kernel_spec.to_dict()}")
+        self.log.info(f"Launching {kernel_spec.display_name}: {kernel_spec.to_dict()}")
         return await super().pre_launch(**kwargs)

pixi_kernel/readiness.py

@@ -8,8 +8,6 @@
 from .compatibility import has_compatible_pixi
 from .types import Environment, PixiInfo
 
-logger = logging.getLogger(__name__)
-
 PIXI_KERNEL_NOT_FOUND = """To run the {kernel_name} kernel, you need to add the {required_package}
 package to your project dependencies and restart your kernel. The project environment prefix is
 {prefix}.
@@ -26,6 +24,7 @@ async def verify_env_readiness(
     env: dict[str, str],
     required_package: str,
     kernel_name: str,
+    logger: logging.Logger,
 ) -> Result[Environment, str]:
     """Ensure the Pixi environment is ready to run the kernel.
 

pyproject.toml

@@ -53,7 +53,7 @@ dev-dependencies = [
     "pytest>=8,<9",
     "pytest-asyncio>=0.25,<0.26",
     "pytest-cov>=6,<7",
-    "ruff>=0.8,<0.9",
+    "ruff>=0.9,<0.10",
     "tox-uv>=1,<2",
 ]
 

tests/unit/test_readiness.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import subprocess
 import sys
@@ -23,6 +24,7 @@ def kwargs():
         "env": os.environ.copy(),
         "required_package": "ipykernel",
         "kernel_name": "Pixi",
+        "logger": logging.getLogger("pixi_kernel"),
     }
 
 
@@ -85,10 +87,7 @@ async def test_empty_project(kwargs: dict):
 async def test_bad_pixi_toml(kwargs: dict):
     kwargs["cwd"] = data_dir / "bad_pixi_toml"
     result = await verify_env_readiness(**kwargs)
-    assert (
-        "failed to parse project manifest" in result.failure()
-        or "unknown field" in result.failure()
-    )
+    assert "failed to parse project" in result.failure() or "unknown field" in result.failure()
 
 
 @pytest.mark.usefixtures("_patch_pixi_info_no_default_env")