snakemake-logger-plugin-panoptes 0.1.1__tar.gz

snakemake_logger_plugin_panoptes-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,63 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ['3.11', '3.12', '3.13', '3.14']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install plugin + dev deps
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e '.[dev]'
+
+      - name: Run unit tests
+        run: pytest -v
+
+      - name: Verify plugin is discoverable by Snakemake 9
+        run: |
+          pip install 'snakemake>=9'
+          python -c "
+          from snakemake_logger_plugin_panoptes import LogHandler, LogHandlerSettings
+          fields = sorted(LogHandlerSettings.__dataclass_fields__)
+          assert 'address' in fields and 'timeout' in fields, fields
+          print('plugin imports + settings exposed:', fields)
+          "
+          # Real wiring check: Snakemake should advertise `--logger-panoptes-address`
+          # in its help once the plugin is installed.
+          snakemake --help 2>&1 | grep -qi 'logger-panoptes-address' && echo 'snakemake sees the panoptes logger plugin'
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build
+      - name: Verify package contents
+        run: |
+          pip install twine
+          twine check dist/*
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

snakemake_logger_plugin_panoptes-0.1.1/.github/workflows/python-publish.yml

@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

snakemake_logger_plugin_panoptes-0.1.1/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+.tox/
+.idea/
+.vscode/

snakemake_logger_plugin_panoptes-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 panoptes-organization
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

snakemake_logger_plugin_panoptes-0.1.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: snakemake-logger-plugin-panoptes
+Version: 0.1.1
+Summary: Snakemake logger plugin that forwards workflow events to a panoptes server.
+Project-URL: repository, https://github.com/panoptes-organization/snakemake-logger-plugin-panoptes
+Author: panoptes-organization
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: requests>=2.22.0
+Requires-Dist: snakemake-interface-logger-plugins<3,>=1.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# snakemake-logger-plugin-panoptes
+
+A [Snakemake 9](https://snakemake.readthedocs.io/) logger plugin that forwards
+workflow events to a running [panoptes](https://github.com/panoptes-organization/panoptes)
+server, replacing the legacy `--wms-monitor` integration that was removed in
+Snakemake 9.
+
+## Install
+
+```bash
+pip install snakemake-logger-plugin-panoptes
+```
+
+## Use
+
+Start a panoptes server (see the panoptes README), then run Snakemake with the
+plugin enabled:
+
+```bash
+snakemake \
+    --cores 1 \
+    --logger panoptes \
+    --logger-panoptes-address http://127.0.0.1:5000
+```
+
+You can also point at the address via an environment variable:
+
+```bash
+export SNAKEMAKE_LOGGER_PANOPTES_ADDRESS=http://127.0.0.1:5000
+snakemake --cores 1 --logger panoptes
+```
+
+### Settings
+
+| Flag | Env var | Default | Description |
+| --- | --- | --- | --- |
+| `--logger-panoptes-address` | `SNAKEMAKE_LOGGER_PANOPTES_ADDRESS` | _(required)_ | Base URL of the panoptes server. |
+| `--logger-panoptes-timeout` | — | `10.0` | Per-request HTTP timeout in seconds. |
+
+## How it works
+
+On workflow start the plugin calls `GET /create_workflow` to register a new
+workflow with the panoptes server and remembers the returned workflow id. It
+then translates Snakemake [`LogEvent`](https://github.com/snakemake/snakemake-interface-logger-plugins)
+records (`JOB_INFO`, `JOB_STARTED`, `JOB_FINISHED`, `JOB_ERROR`, `SHELLCMD`,
+`PROGRESS`, `ERROR`, `RUN_INFO`) into the JSON message format that panoptes'
+`/update_workflow_status` endpoint already understands.
+
+Network errors are logged but never crash the workflow.
+
+## Development
+
+```bash
+pip install -e .[dev]   # editable install with test deps
+pytest
+```
+
+## License
+
+MIT

snakemake_logger_plugin_panoptes-0.1.1/README.md

@@ -0,0 +1,60 @@
+# snakemake-logger-plugin-panoptes
+
+A [Snakemake 9](https://snakemake.readthedocs.io/) logger plugin that forwards
+workflow events to a running [panoptes](https://github.com/panoptes-organization/panoptes)
+server, replacing the legacy `--wms-monitor` integration that was removed in
+Snakemake 9.
+
+## Install
+
+```bash
+pip install snakemake-logger-plugin-panoptes
+```
+
+## Use
+
+Start a panoptes server (see the panoptes README), then run Snakemake with the
+plugin enabled:
+
+```bash
+snakemake \
+    --cores 1 \
+    --logger panoptes \
+    --logger-panoptes-address http://127.0.0.1:5000
+```
+
+You can also point at the address via an environment variable:
+
+```bash
+export SNAKEMAKE_LOGGER_PANOPTES_ADDRESS=http://127.0.0.1:5000
+snakemake --cores 1 --logger panoptes
+```
+
+### Settings
+
+| Flag | Env var | Default | Description |
+| --- | --- | --- | --- |
+| `--logger-panoptes-address` | `SNAKEMAKE_LOGGER_PANOPTES_ADDRESS` | _(required)_ | Base URL of the panoptes server. |
+| `--logger-panoptes-timeout` | — | `10.0` | Per-request HTTP timeout in seconds. |
+
+## How it works
+
+On workflow start the plugin calls `GET /create_workflow` to register a new
+workflow with the panoptes server and remembers the returned workflow id. It
+then translates Snakemake [`LogEvent`](https://github.com/snakemake/snakemake-interface-logger-plugins)
+records (`JOB_INFO`, `JOB_STARTED`, `JOB_FINISHED`, `JOB_ERROR`, `SHELLCMD`,
+`PROGRESS`, `ERROR`, `RUN_INFO`) into the JSON message format that panoptes'
+`/update_workflow_status` endpoint already understands.
+
+Network errors are logged but never crash the workflow.
+
+## Development
+
+```bash
+pip install -e .[dev]   # editable install with test deps
+pytest
+```
+
+## License
+
+MIT

snakemake_logger_plugin_panoptes-0.1.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "snakemake-logger-plugin-panoptes"
+version = "0.1.1"
+description = "Snakemake logger plugin that forwards workflow events to a panoptes server."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "panoptes-organization" },
+]
+requires-python = ">=3.11"
+dependencies = [
+    "snakemake-interface-logger-plugins>=1.2.0,<3",
+    "requests>=2.22.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+]
+
+[project.urls]
+repository = "https://github.com/panoptes-organization/snakemake-logger-plugin-panoptes"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/snakemake_logger_plugin_panoptes"]

snakemake_logger_plugin_panoptes-0.1.1/src/snakemake_logger_plugin_panoptes/__init__.py

@@ -0,0 +1,81 @@
+"""Snakemake logger plugin that forwards workflow events to a panoptes server."""
+
+from dataclasses import dataclass, field
+from logging import LogRecord
+from typing import Optional
+
+from snakemake_interface_logger_plugins.base import LogHandlerBase
+from snakemake_interface_logger_plugins.settings import LogHandlerSettingsBase
+
+from snakemake_logger_plugin_panoptes.log_handler import PanoptesLogHandler
+
+
+@dataclass
+class LogHandlerSettings(LogHandlerSettingsBase):
+    """Settings exposed via ``--logger-panoptes-*`` on the Snakemake CLI."""
+
+    address: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Base URL of the panoptes server, e.g. http://127.0.0.1:5000. "
+                "Required."
+            ),
+            "env_var": True,
+            "required": True,
+        },
+    )
+    timeout: Optional[float] = field(
+        default=10.0,
+        metadata={
+            "help": "Per-request HTTP timeout in seconds.",
+            "env_var": False,
+            "required": False,
+        },
+    )
+
+
+class LogHandler(LogHandlerBase, PanoptesLogHandler):
+    """Snakemake logger plugin entry point."""
+
+    def __post_init__(self) -> None:
+        # ``self.settings`` and ``self.common_settings`` are populated by
+        # the Snakemake plugin runtime before __post_init__ is called.
+        settings: LogHandlerSettings = self.settings  # type: ignore[assignment]
+        if not settings.address:
+            raise ValueError(
+                "snakemake-logger-plugin-panoptes requires --logger-panoptes-address "
+                "(or the SNAKEMAKE_LOGGER_PANOPTES_ADDRESS env var) to be set."
+            )
+        PanoptesLogHandler.__init__(
+            self,
+            common_settings=self.common_settings,
+            address=settings.address,
+            timeout=settings.timeout if settings.timeout is not None else 10.0,
+        )
+
+    def emit(self, record: LogRecord) -> None:
+        PanoptesLogHandler.emit(self, record)
+
+    @property
+    def writes_to_stream(self) -> bool:
+        return False
+
+    @property
+    def writes_to_file(self) -> bool:
+        return False
+
+    @property
+    def has_filter(self) -> bool:
+        return False
+
+    @property
+    def has_formatter(self) -> bool:
+        return False
+
+    @property
+    def needs_rulegraph(self) -> bool:
+        return False
+
+
+__all__ = ["LogHandler", "LogHandlerSettings"]

snakemake_logger_plugin_panoptes-0.1.1/src/snakemake_logger_plugin_panoptes/log_handler.py

@@ -0,0 +1,232 @@
+"""HTTP log handler that forwards Snakemake LogEvents to a panoptes server."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from logging import Handler, LogRecord
+from typing import Any, Dict, Optional
+
+import requests
+from snakemake_interface_logger_plugins.common import LogEvent
+from snakemake_interface_logger_plugins.settings import OutputSettingsLoggerInterface
+
+
+_LOG = logging.getLogger(__name__)
+
+
+def _to_jsonable(value: Any) -> Any:
+    """Best-effort conversion to JSON-serialisable primitives."""
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, dict):
+        return {str(k): _to_jsonable(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_to_jsonable(v) for v in value]
+    # Snakemake's Namedlist / IOFile / Wildcards behave like sequences/mappings;
+    # fall back to repr() so the panoptes server still sees something.
+    try:
+        return list(value)  # type: ignore[arg-type]
+    except TypeError:
+        return str(value)
+
+
+def _resources_to_dict(resources: Any) -> Dict[str, Any]:
+    if resources is None:
+        return {}
+    names = getattr(resources, "_names", None)
+    if names is None:
+        return _to_jsonable(resources) if isinstance(resources, dict) else {}
+    return {
+        name: _to_jsonable(value)
+        for name, value in zip(names, resources)
+        if name not in {"_cores", "_nodes"}
+    }
+
+
+class PanoptesLogHandler(Handler):
+    """Translate Snakemake LogRecords into panoptes HTTP API calls."""
+
+    def __init__(
+        self,
+        common_settings: OutputSettingsLoggerInterface,
+        address: str,
+        timeout: float = 10.0,
+    ):
+        super().__init__()
+        self.common_settings = common_settings
+        self.address = address.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.workflow_id: Optional[int] = None
+        self.workflow_name: Optional[str] = None
+        # Map (Snakemake-side) jobid -> rule name, so we can re-attach context
+        # to events like JOB_FINISHED / JOB_ERROR that don't carry the rule.
+        self._job_rules: Dict[int, str] = {}
+
+    # ------------------------------------------------------------------ #
+    # registration with panoptes
+    # ------------------------------------------------------------------ #
+
+    def _ensure_workflow(self) -> bool:
+        if self.workflow_id is not None:
+            return True
+        try:
+            response = self.session.get(
+                f"{self.address}/create_workflow", timeout=self.timeout
+            )
+            response.raise_for_status()
+            payload = response.json()
+            self.workflow_id = payload.get("id")
+            self.workflow_name = payload.get("name")
+            return self.workflow_id is not None
+        except Exception as exc:
+            _LOG.warning("panoptes: could not register workflow: %s", exc)
+            return False
+
+    def _post_message(self, message: Dict[str, Any]) -> None:
+        if not self._ensure_workflow():
+            return
+        payload = {
+            "msg": json.dumps(message),
+            "timestamp": time.asctime(),
+            "id": self.workflow_id,
+        }
+        try:
+            self.session.post(
+                f"{self.address}/update_workflow_status",
+                data=payload,
+                timeout=self.timeout,
+            )
+        except Exception as exc:
+            _LOG.warning("panoptes: failed to deliver event %r: %s", message.get("level"), exc)
+
+    # ------------------------------------------------------------------ #
+    # event translation
+    # ------------------------------------------------------------------ #
+
+    def _on_workflow_started(self, record: LogRecord) -> Optional[Dict[str, Any]]:
+        # Make sure panoptes has a workflow row before any other event lands.
+        self._ensure_workflow()
+        snakefile = getattr(record, "snakefile", None)
+        return {
+            "level": "info",
+            "msg": f"Workflow started: {snakefile}" if snakefile else "Workflow started",
+        }
+
+    def _on_job_info(self, record: LogRecord) -> Dict[str, Any]:
+        jobid = int(getattr(record, "jobid", 0) or 0)
+        rule_name = getattr(record, "rule_name", "") or ""
+        self._job_rules[jobid] = rule_name
+        return {
+            "level": "job_info",
+            "jobid": jobid,
+            "name": rule_name,
+            "msg": getattr(record, "rule_msg", None),
+            "input": _to_jsonable(getattr(record, "input", []) or []),
+            "output": _to_jsonable(getattr(record, "output", []) or []),
+            "log": _to_jsonable(getattr(record, "log", []) or []),
+            "wildcards": _to_jsonable(getattr(record, "wildcards", {}) or {}),
+            "is_checkpoint": bool(getattr(record, "is_checkpoint", False)),
+            "shellcmd": getattr(record, "shellcmd", None),
+            "threads": getattr(record, "threads", None),
+            "priority": getattr(record, "priority", None),
+            "reason": getattr(record, "reason", None),
+            "resources": _resources_to_dict(getattr(record, "resources", None)),
+        }
+
+    def _on_job_started(self, record: LogRecord) -> Optional[Dict[str, Any]]:
+        jobs = getattr(record, "jobs", None)
+        if jobs is None:
+            return None
+        if isinstance(jobs, int):
+            jobs = [jobs]
+        return {"level": "job_started", "jobs": [int(j) for j in jobs]}
+
+    def _on_job_finished(self, record: LogRecord) -> Optional[Dict[str, Any]]:
+        jobid = getattr(record, "job_id", None)
+        if jobid is None:
+            jobid = getattr(record, "jobid", None)
+        if jobid is None:
+            return None
+        return {"level": "job_finished", "jobid": int(jobid)}
+
+    def _on_job_error(self, record: LogRecord) -> Dict[str, Any]:
+        jobid = int(getattr(record, "jobid", 0) or 0)
+        return {
+            "level": "job_error",
+            "jobid": jobid,
+            "name": self._job_rules.get(jobid, ""),
+        }
+
+    def _on_shellcmd(self, record: LogRecord) -> Optional[Dict[str, Any]]:
+        shellcmd = getattr(record, "shellcmd", None)
+        if not shellcmd:
+            return None
+        jobid = getattr(record, "jobid", None)
+        return {
+            "level": "shellcmd",
+            "jobid": int(jobid) if jobid is not None else None,
+            "msg": shellcmd,
+        }
+
+    def _on_progress(self, record: LogRecord) -> Dict[str, Any]:
+        return {
+            "level": "progress",
+            "done": int(getattr(record, "done", 0) or 0),
+            "total": int(getattr(record, "total", 0) or 0),
+        }
+
+    def _on_error(self, record: LogRecord) -> Dict[str, Any]:
+        return {
+            "level": "error",
+            "msg": getattr(record, "exception", None) or record.getMessage(),
+            "rule": getattr(record, "rule", None),
+            "location": getattr(record, "location", None),
+            "traceback": getattr(record, "traceback", None),
+        }
+
+    def _on_run_info(self, record: LogRecord) -> Optional[Dict[str, Any]]:
+        stats = getattr(record, "stats", None) or {}
+        total = stats.get("total")
+        if total is None:
+            return None
+        return {"level": "progress", "done": 0, "total": int(total)}
+
+    # ------------------------------------------------------------------ #
+    # Handler interface
+    # ------------------------------------------------------------------ #
+
+    _DISPATCH = {
+        LogEvent.WORKFLOW_STARTED: "_on_workflow_started",
+        LogEvent.JOB_INFO: "_on_job_info",
+        LogEvent.JOB_STARTED: "_on_job_started",
+        LogEvent.JOB_FINISHED: "_on_job_finished",
+        LogEvent.JOB_ERROR: "_on_job_error",
+        LogEvent.SHELLCMD: "_on_shellcmd",
+        LogEvent.PROGRESS: "_on_progress",
+        LogEvent.ERROR: "_on_error",
+        LogEvent.RUN_INFO: "_on_run_info",
+    }
+
+    def emit(self, record: LogRecord) -> None:
+        try:
+            event = getattr(record, "event", None)
+            if event is None:
+                return
+            method_name = self._DISPATCH.get(event)
+            if method_name is None:
+                return
+            message = getattr(self, method_name)(record)
+            if message is None:
+                return
+            self._post_message(message)
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        try:
+            self.session.close()
+        finally:
+            super().close()

snakemake_logger_plugin_panoptes-0.1.1/tests/test_plugin.py

@@ -0,0 +1,170 @@
+"""Unit tests for the panoptes log handler.
+
+The tests stub out the HTTP layer so they run without Snakemake or a live
+panoptes server.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from types import SimpleNamespace
+from typing import Any, Dict, List
+
+import pytest
+
+from snakemake_interface_logger_plugins.common import LogEvent
+
+from snakemake_logger_plugin_panoptes.log_handler import PanoptesLogHandler
+
+
+class _Resp:
+    def __init__(self, payload: Dict[str, Any], status: int = 200) -> None:
+        self._payload = payload
+        self.status_code = status
+
+    def raise_for_status(self) -> None:
+        if not 200 <= self.status_code < 300:
+            raise RuntimeError(f"status {self.status_code}")
+
+    def json(self) -> Dict[str, Any]:
+        return self._payload
+
+
+class _FakeSession:
+    def __init__(self) -> None:
+        self.get_calls: List[str] = []
+        self.post_calls: List[Dict[str, Any]] = []
+
+    def get(self, url: str, timeout: float = 0) -> _Resp:  # noqa: ARG002
+        self.get_calls.append(url)
+        return _Resp({"id": 7, "name": "wf-uuid"})
+
+    def post(self, url: str, data: Dict[str, Any], timeout: float = 0) -> _Resp:  # noqa: ARG002
+        self.post_calls.append({"url": url, "data": data})
+        return _Resp({}, status=200)
+
+    def close(self) -> None:
+        pass
+
+
+def _make_handler() -> PanoptesLogHandler:
+    common = SimpleNamespace(dryrun=False)
+    h = PanoptesLogHandler(common_settings=common, address="http://example.test")
+    h.session = _FakeSession()  # type: ignore[assignment]
+    return h
+
+
+def _record(event: LogEvent, **attrs: Any) -> logging.LogRecord:
+    record = logging.LogRecord(
+        name="snakemake",
+        level=logging.INFO,
+        pathname="",
+        lineno=0,
+        msg="",
+        args=(),
+        exc_info=None,
+    )
+    record.event = event  # type: ignore[attr-defined]
+    for key, value in attrs.items():
+        setattr(record, key, value)
+    return record
+
+
+def _last_message(handler: PanoptesLogHandler) -> Dict[str, Any]:
+    fake = handler.session  # type: ignore[assignment]
+    assert isinstance(fake, _FakeSession)
+    assert fake.post_calls, "expected at least one POST"
+    return json.loads(fake.post_calls[-1]["data"]["msg"])
+
+
+def test_workflow_registration_uses_create_workflow() -> None:
+    h = _make_handler()
+    h.emit(_record(LogEvent.WORKFLOW_STARTED, snakefile="/tmp/Snakefile"))
+    assert h.workflow_id == 7
+    assert any("/create_workflow" in url for url in h.session.get_calls)  # type: ignore[attr-defined]
+    msg = _last_message(h)
+    assert msg["level"] == "info"
+
+
+def test_job_info_payload_shape() -> None:
+    h = _make_handler()
+    h.emit(
+        _record(
+            LogEvent.JOB_INFO,
+            jobid=3,
+            rule_name="samtools_sort",
+            input=["samples/c.bam"],
+            output=["results/c.sorted.bam"],
+            log=["logs/c.log"],
+            wildcards={"sample": "c"},
+            is_checkpoint=False,
+            rule_msg=None,
+            shellcmd="samtools sort ...",
+            threads=4,
+        )
+    )
+    msg = _last_message(h)
+    assert msg["level"] == "job_info"
+    assert msg["jobid"] == 3
+    assert msg["name"] == "samtools_sort"
+    assert msg["input"] == ["samples/c.bam"]
+    assert msg["wildcards"] == {"sample": "c"}
+    assert msg["is_checkpoint"] is False
+
+
+def test_job_finished_accepts_job_id_or_jobid() -> None:
+    h = _make_handler()
+    h.emit(_record(LogEvent.JOB_FINISHED, job_id=5))
+    assert _last_message(h) == {"level": "job_finished", "jobid": 5}
+
+    h.emit(_record(LogEvent.JOB_FINISHED, jobid=6))
+    assert _last_message(h) == {"level": "job_finished", "jobid": 6}
+
+
+def test_progress_payload() -> None:
+    h = _make_handler()
+    h.emit(_record(LogEvent.PROGRESS, done=2, total=10))
+    assert _last_message(h) == {"level": "progress", "done": 2, "total": 10}
+
+
+def test_job_error_carries_rule_from_prior_job_info() -> None:
+    h = _make_handler()
+    h.emit(
+        _record(
+            LogEvent.JOB_INFO,
+            jobid=11,
+            rule_name="bwa_map",
+            input=[],
+            output=[],
+            log=[],
+            wildcards={},
+            is_checkpoint=False,
+        )
+    )
+    h.emit(_record(LogEvent.JOB_ERROR, jobid=11))
+    msg = _last_message(h)
+    assert msg == {"level": "job_error", "jobid": 11, "name": "bwa_map"}
+
+
+def test_unknown_event_is_silently_ignored() -> None:
+    h = _make_handler()
+    rec = _record(LogEvent.RULEGRAPH, rulegraph={})
+    h.emit(rec)
+    # rulegraph isn't mapped — no POST should be sent (only the auto-registration GET).
+    assert h.session.post_calls == []  # type: ignore[attr-defined]
+
+
+def test_record_without_event_is_dropped() -> None:
+    h = _make_handler()
+    rec = logging.LogRecord("x", logging.INFO, "", 0, "msg", (), None)
+    h.emit(rec)
+    assert h.session.post_calls == []  # type: ignore[attr-defined]
+    assert h.session.get_calls == []  # type: ignore[attr-defined]
+
+
+def test_run_info_sets_total() -> None:
+    h = _make_handler()
+    h.emit(_record(LogEvent.RUN_INFO, stats={"total": 14, "bwa": 7, "sort": 7}))
+    msg = _last_message(h)
+    assert msg == {"level": "progress", "done": 0, "total": 14}