sbxloop 0.7.7__tar.gz → 0.7.8__tar.gz

{sbxloop-0.7.7 → sbxloop-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sbxloop
-Version: 0.7.7
+Version: 0.7.8
 Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop
@@ -20,6 +20,7 @@ Requires-Dist: pydantic>=2.7
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: rich>=13.7
 Requires-Dist: sbxloop-worker
+Requires-Dist: structlog>=24.1
 Requires-Dist: typer>=0.12
 Provides-Extra: copilot
 Requires-Dist: github-copilot-sdk>=1.0.8; extra == 'copilot'

{sbxloop-0.7.7 → sbxloop-0.7.8}/pyproject.toml

@@ -25,6 +25,7 @@ dependencies = [
     # to the wheel metadata at build time.
     "sbxloop-worker",
     "gitpython>=3.1.59",
+    "structlog>=24.1",
 ]
 
 [project.optional-dependencies]

{sbxloop-0.7.7 → sbxloop-0.7.8}/src/sbxloop/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.7'
-__version_tuple__ = version_tuple = (0, 7, 7)
+__version__ = version = '0.7.8'
+__version_tuple__ = version_tuple = (0, 7, 8)
 
 __commit_id__ = commit_id = None

{sbxloop-0.7.7 → sbxloop-0.7.8}/src/sbxloop/cli/app.py

@@ -41,6 +41,7 @@ from sbxloop.engine.store import StateStore
 from sbxloop.errors import SbxloopError
 from sbxloop.events import Event, EventBus, HostEventTypes
 from sbxloop.gc import DAY_S, format_bytes, prune_run_dirs
+from sbxloop.log import configure_logging, get_logger
 from sbxloop.sbx.bake import DEFAULT_TEMPLATE_REF, bake_template
 from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.models import SandboxRole
@@ -100,6 +101,11 @@ def _main_callback(
     ] = False,
 ) -> None:
     """sbxloop — agentic loops on Docker Sandboxes."""
+    # Library warnings (provisioning rollbacks, worker install fallbacks)
+    # render through the same pipeline as the daemon's instead of falling
+    # through to logging's bare last-resort handler. The daemon re-configures
+    # with its own level/format once its config is loaded.
+    configure_logging("WARNING")
     # Every command sees ./.env (tokens + SBXLOOP_* settings); real
     # environment variables always take precedence.
     load_dotenv_file()
@@ -1409,6 +1415,17 @@ def daemon(
     dry_run: Annotated[
         bool, typer.Option("--dry-run", help="Poll and print candidates; claim and run nothing.")
     ] = False,
+    log_level: Annotated[
+        str | None,
+        typer.Option(
+            "--log-level",
+            help="Daemon log level: DEBUG|INFO|WARNING|ERROR (also SBXLOOP_DAEMON__LOG_LEVEL).",
+        ),
+    ] = None,
+    log_format: Annotated[
+        str | None,
+        typer.Option("--log-format", help="Daemon log rendering: console|json."),
+    ] = None,
 ) -> None:
     """Run the always-on outer loop: discover work (labeled GitHub issues,
     inbox files), run each item through the inner loop, report back, and
@@ -1417,18 +1434,16 @@ def daemon(
     daemon instead."""
     if ctx.invoked_subcommand is not None:
         return
-    import logging
-
     from sbxloop.daemon.control import ControlServer
     from sbxloop.daemon.discord import DiscordBridge
     from sbxloop.daemon.github import DaemonGithub
+    from sbxloop.daemon.logsink import event_log_subscriber
     from sbxloop.daemon.loop import DaemonLoop
     from sbxloop.daemon.paths import resolve_state_dir
     from sbxloop.daemon.sources import GitHubIssueSource, GitHubLabels, InboxSource, WorkSource
 
-    logging.basicConfig(
-        level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s"
-    )
+    log = get_logger("sbxloop.daemon")
+    started_at = time.monotonic()
     config, config_sources = load_config_with_sources()
     # The daemon's state lives at an absolute path outside the workspace
     # (#255): a relative `.sbxloop` inside the checkout it works on would
@@ -1444,6 +1459,8 @@ def daemon(
             ("backlog", backlog),
             ("max_runs_per_day", max_runs_per_day),
             ("poll_interval_s", poll_interval),
+            ("log_level", log_level),
+            ("log_format", log_format),
         )
         if v is not None
     }
@@ -1462,38 +1479,39 @@ def daemon(
             )
             config = config.model_copy(update={"discord": discord_cfg})
     except ValidationError as exc:
-        console.print(f"[bold red]invalid daemon option:[/] {exc.errors()[0]['msg']}")
+        # Before the pipeline is configured with the daemon's own settings:
+        # the WARNING-level default from the app callback carries this.
+        log.error("daemon.invalid_option", error=exc.errors()[0]["msg"])
         raise typer.Exit(2) from exc
+    configure_logging(config.daemon.log_level, fmt=config.daemon.log_format)
 
     github_active = config.github.enabled
     inbox_active = bool(config.daemon.inbox_dir)
     if not github_active and not inbox_active:
-        console.print(
-            "[bold red]no work sources:[/] set [cyan]--repo owner/name[/] (or "
-            "[cyan]\\[github] repo[/]) to poll issues, and/or an inbox directory "
-            "([cyan]--inbox DIR[/] / [cyan]\\[daemon] inbox_dir[/])."
+        log.error(
+            "daemon.no_work_sources",
+            hint="set --repo owner/name (or [github] repo) to poll issues, and/or an "
+            "inbox directory (--inbox DIR / [daemon] inbox_dir)",
         )
         raise typer.Exit(2)
     if config.daemon.backlog == "github" and not github_active:
-        console.print("[bold red]--backlog github needs a GitHub repository[/] (--repo).")
+        log.error("daemon.backlog_needs_github", hint="--backlog github needs --repo owner/name")
         raise typer.Exit(2)
     if github_active and config.daemon.backlog != "github":
         # The audit lane is always on when issues are a source; its
         # findings only have somewhere to go with backlog = "github".
-        console.print(
-            f"[yellow]note:[/] audit issues (`{config.daemon.audit_label}`) file their "
-            "findings as backlog issues, which needs [cyan]--backlog github[/]; with "
-            f"backlog={config.daemon.backlog!r} an audit run completes but files nothing."
+        log.warning(
+            "daemon.audit_findings_unfiled",
+            audit_label=config.daemon.audit_label,
+            backlog=config.daemon.backlog,
+            hint="audit runs complete but file nothing without --backlog github",
         )
 
-    # Say where the state went: with the anchored default, `sbxloop status`
-    # in the runner dir shows nothing unless SBXLOOP_STATE_DIR points here.
-    console.print(f"state dir: [cyan]{config.state_dir}[/] ({state_choice.reason})")
     store = _store(config)
     dstore = DaemonStore(config.state_dir / "state.db")
     sbx = SbxCLI(app_name=config.app_name or None)
     bus = EventBus()
-    bus.subscribe(plain_printer(console))
+    bus.subscribe(event_log_subscriber)
     sources: list[WorkSource] = []
     github: DaemonGithub | None = None
     if inbox_active:
@@ -1521,17 +1539,64 @@ def daemon(
             )
         )
 
+    # One line an operator can read back from the journal to know exactly
+    # what this daemon is: where its state went (with the anchored default,
+    # `sbxloop status` in the runner dir shows nothing unless
+    # SBXLOOP_STATE_DIR points here), what it polls, and every guardrail.
+    log.info(
+        "daemon.starting",
+        version=sbxloop.__version__,
+        pid=os.getpid(),
+        state_dir=str(config.state_dir),
+        state_dir_reason=state_choice.reason,
+        sources=[s.name for s in sources],
+        repo=config.github.repo,
+        trigger_label=config.daemon.trigger_label if github_active else None,
+        inbox_dir=config.daemon.inbox_dir or None,
+        poll_interval_s=config.daemon.poll_interval_s,
+        max_runs_per_day=config.daemon.max_runs_per_day,
+        max_attempts_per_item=config.daemon.max_attempts_per_item,
+        max_resumes_per_item=config.daemon.max_resumes_per_item,
+        retry_backoff_s=config.daemon.retry_backoff_s,
+        max_consecutive_failures=config.daemon.max_consecutive_failures,
+        breaker_cooldown_s=config.daemon.breaker_cooldown_s,
+        workspace_isolation=config.daemon.workspace_isolation,
+        refresh_workspace=config.daemon.refresh_workspace,
+        backlog=config.daemon.backlog,
+        audits=config.daemon.audits,
+        postmortems=config.daemon.postmortems,
+        review_deliveries=config.daemon.review_deliveries,
+        discord=("on" if config.discord.enabled else "off"),
+        discord_channel=config.discord.channel_id if config.discord.enabled else None,
+        log_level=config.daemon.log_level,
+        log_format=config.daemon.log_format,
+        once=once,
+        dry_run=dry_run,
+    )
+
     if dry_run:
         code = 0
         try:
             for source in sources:
+                found = 0
                 for item in source.poll():
+                    found += 1
+                    # The listing IS this command's output: stdout, so it
+                    # pipes and greps; the log keeps the structured record.
                     console.print(
                         f"[cyan]{item.item_id}[/]  {item.title}"
                         + (f"  {item.url}" if item.url else "")
                     )
+                    log.debug(
+                        "daemon.dry_run_candidate",
+                        source=source.name,
+                        item=item.item_id,
+                        title=item.title,
+                        url=item.url or None,
+                    )
+                log.info("daemon.dry_run_polled", source=source.name, candidates=found)
         except SbxloopError as exc:
-            console.print(f"[bold red]poll failed:[/] {exc}")
+            log.error("daemon.poll_failed", error=str(exc), exc_info=True)
             code = 1
         finally:
             if github is not None:
@@ -1545,13 +1610,14 @@ def daemon(
             bridge = DiscordBridge(config, dstore, loop_ref=loop)
             bridge.start()
         except SbxloopError as exc:
-            console.print(f"[bold red]discord bridge:[/] {exc}")
+            log.error("discord.bridge_failed", error=str(exc), exc_info=True)
             raise typer.Exit(2) from exc
         loop.frontend = bridge
 
     ctl = ControlServer(loop, config.state_dir)
     cleanup_registry.install_handlers()
     cleanup_registry.set_quiesce(loop.quiesce)
+    stop_reason = "finished"
     try:
         loop.recover()
         # Only now: an `abandon`/`requeue` served while recover() is still
@@ -1561,19 +1627,41 @@ def daemon(
         ctl.start()
         if once:
             result = loop.tick()
+            # --once is a smoke/cron probe: its one-line verdict stays on
+            # stdout for the human or script that invoked it.
             console.print(f"tick: {result}")
+            log.info(
+                "daemon.tick",
+                discovered=result.discovered,
+                dispatched=result.dispatched,
+                outcome=result.outcome,
+                idle=result.idle_kind,
+                idle_detail=result.idle_detail,
+            )
         else:
             loop.run_forever()
     except KeyboardInterrupt:
-        console.print("\n[bold yellow]daemon interrupted[/]")
+        stop_reason = "interrupted"
+        log.warning("daemon.interrupted", hint="KeyboardInterrupt; shutting down")
+    except BaseException as exc:
+        stop_reason = type(exc).__name__
+        raise
     finally:
         cleanup_registry.set_quiesce(None)
+        log.debug("daemon.shutdown", step="control server")
         ctl.close()
         if bridge is not None:
+            log.debug("daemon.shutdown", step="discord bridge")
             bridge.close()
         if github is not None:
+            log.debug("daemon.shutdown", step="github sandbox")
             github.close()
         dstore.close()
+        log.info(
+            "daemon.stopped",
+            reason=stop_reason,
+            uptime_s=round(time.monotonic() - started_at, 1),
+        )
 
 
 def _daemon_state_dir() -> Path:

{sbxloop-0.7.7 → sbxloop-0.7.8}/src/sbxloop/cli/tui.py

@@ -35,7 +35,7 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from sbxloop.events import Event, HostEventTypes
+from sbxloop.events import Event, HostEventTypes, summarize_event
 from sbxloop_worker.protocol import EventTypes
 
 TASK_STATE_STYLES = {
@@ -474,47 +474,29 @@ class Dashboard:
 
 def format_event(event: Event) -> str:
     """Dense single-line form (used by `sbxloop logs` and lifecycle lines)."""
+    fields = summarize_event(event)
     parts = [_stamp(event), event.type]
-    if event.data.get("task_id"):
-        parts.append(f"[{event.data['task_id']}]")
-    if event.data.get("agent"):
-        parts.append(f"[{event.data['agent']}]")
-    keys = (
-        "state",
-        "content",
-        "text",
-        "reply",
-        "tool",
-        "op",
-        "line",
-        "message",
-        "outcome",
-        "error",
-        "url",
-        "path",
-    )
-    picked = ""
-    for key in keys:
-        if event.data.get(key):
-            picked = key
-            value = str(event.data[key]).replace("\n", " ")
-            parts.append(value[:160])
-            break
-    if event.data.get("disk_used_pct") is not None:
+    if "task" in fields:
+        parts.append(f"[{fields['task']}]")
+    if "agent" in fields:
+        parts.append(f"[{fields['agent']}]")
+    if "summary" in fields:
+        parts.append(fields["summary"])
+    if "disk" in fields:
         # Resource samples: make `sbxloop logs --type-prefix sandbox.resources`
         # answer "what did disk look like before the failure" at a glance.
-        summary = [f"disk={event.data['disk_used_pct']}%"]
-        if event.data.get("mem_used_pct") is not None:
-            summary.append(f"mem={event.data['mem_used_pct']}%")
-        if event.data.get("load1") is not None:
-            summary.append(f"load={event.data['load1']}")
-        if event.data.get("level"):
-            summary.append(str(event.data["level"]))
+        summary = [f"disk={fields['disk']}"]
+        if "mem" in fields:
+            summary.append(f"mem={fields['mem']}")
+        if "load" in fields:
+            summary.append(f"load={fields['load']}")
+        if "resource_level" in fields:
+            summary.append(str(fields["resource_level"]))
         parts.append(" ".join(summary))
-    if event.data.get("args"):
-        parts.append(_one_line(str(event.data["args"]), 120))
-    if picked != "error" and event.data.get("error"):
-        parts.append(_one_line(str(event.data["error"]), 160))
+    if "args" in fields:
+        parts.append(fields["args"])
+    if "error" in fields:
+        parts.append(fields["error"])
     return " ".join(parts)
 
 

{sbxloop-0.7.7 → sbxloop-0.7.8}/src/sbxloop/config.py

@@ -37,8 +37,11 @@ from pydantic import (
 )
 
 from sbxloop.errors import ConfigError
+from sbxloop.log import LogFormat, LogLevel, get_logger
 from sbxloop.toolchains import DEFAULT_LANGUAGES, normalize_language, supported_languages
 
+log = get_logger(__name__)
+
 ENV_PREFIX = "SBXLOOP_"
 
 # SBXLOOP_-prefixed variables consumed by the *worker process* rather than
@@ -409,6 +412,23 @@ class DaemonConfig(_ConfigModel):
     # artifacts). Swept on daemon start and daily; 0 disables. The SQLite
     # rows are never removed. See sbxloop.gc for what is exempt.
     prune_runs_after_days: float = Field(default=14.0, ge=0)
+    # The daemon's own log stream (stderr → journald under systemd). INFO is
+    # the lifecycle tier: startup summary, claims, run dispatch/finish, task
+    # and phase transitions, operator commands; DEBUG adds every tool call,
+    # sbx invocation and poll. ``json`` renders one object per line for log
+    # shippers; ``console`` is key=value for humans and journalctl.
+    log_level: LogLevel = "INFO"
+    log_format: LogFormat = "console"
+
+    @field_validator("log_level", mode="before")
+    @classmethod
+    def _upper_level(cls, value: Any) -> Any:
+        return value.upper() if isinstance(value, str) else value
+
+    @field_validator("log_format", mode="before")
+    @classmethod
+    def _lower_format(cls, value: Any) -> Any:
+        return value.lower() if isinstance(value, str) else value
 
     @model_validator(mode="after")
     def _check(self) -> DaemonConfig:
@@ -708,6 +728,15 @@ def load_config_with_sources(
 
     for dotted in _flatten(config.model_dump()):
         sources.setdefault(dotted, "default")
+    # Which layer set which key — never the values (tokens live in env).
+    overridden = {k: v for k, v in sources.items() if v != "default"}
+    log.debug(
+        "config.loaded",
+        cwd=str(cwd),
+        state_dir=str(config.state_dir),
+        layers={name: len(_flatten(layer)) for name, layer in layers},
+        overrides=overridden,
+    )
     return config, sources
 
 

{sbxloop-0.7.7 → sbxloop-0.7.8}/src/sbxloop/daemon/backlog.py

@@ -18,15 +18,15 @@ flood the daemon.
 from __future__ import annotations
 
 import hashlib
-import logging
 from pathlib import Path
 from typing import NamedTuple
 
 from sbxloop.daemon.sources import WorkSource, parse_markdown_item
 from sbxloop.daemon.store import DaemonStore
 from sbxloop.engine.model import RunRecord
+from sbxloop.log import get_logger
 
-logger = logging.getLogger(__name__)
+log = get_logger(__name__)
 
 BACKLOG_SUBDIR = Path(".sbxloop") / "backlog"
 
@@ -87,6 +87,7 @@ def collect_tool_findings(
         try:
             title, body = parse_markdown_item(path.read_text(), path.stem)
         except OSError:
+            log.warning("backlog.finding_unreadable", run=run.run_id, path=str(path), exc_info=True)
             continue
         if filer is None:
             unfiled.append(title)
@@ -100,9 +101,7 @@ def collect_tool_findings(
         try:
             ref = filer(title, body, run.run_id)
         except Exception:
-            logger.warning(
-                "tool finding %r from run %s could not be filed", title, run.run_id, exc_info=True
-            )
+            log.warning("backlog.tool_finding_failed", run=run.run_id, title=title, exc_info=True)
             unfiled.append(title)
             continue
         if ref is None:
@@ -137,10 +136,10 @@ def collect_backlog(
 ) -> list[str]:
     """File the run's backlog items via ``source``; returns the refs filed."""
     if not run.mounted or run.workspace is None:
-        logger.warning(
-            "backlog skipped for run %s: workspace not mounted (agent-filed backlog "
-            "requires the mounted-workspace mode)",
-            run.run_id,
+        log.warning(
+            "backlog.skipped",
+            run=run.run_id,
+            reason="workspace not mounted; agent-filed backlog needs the mounted-workspace mode",
         )
         return []
     folder = run.workspace / BACKLOG_SUBDIR
@@ -148,13 +147,16 @@ def collect_backlog(
         return []
     filed: list[str] = []
     skipped = 0
+    seen = 0
     for path in sorted(folder.glob("*.md")):
         try:
             title, body = parse_markdown_item(path.read_text(), path.stem)
         except OSError:
+            log.warning("backlog.finding_unreadable", run=run.run_id, path=str(path), exc_info=True)
             continue
         fp = fingerprint(title, body)
         if dstore.backlog_seen(fp):
+            seen += 1
             continue
         if len(filed) >= max_items:
             skipped += 1
@@ -162,18 +164,24 @@ def collect_backlog(
         try:
             ref = source.file_backlog(title, body, run.run_id, trigger=trigger)
         except Exception:
-            logger.warning(
-                "backlog: filing %r from run %s failed", title, run.run_id, exc_info=True
-            )
+            log.warning("backlog.file_failed", run=run.run_id, title=title, exc_info=True)
             continue
         dstore.backlog_record(fp, run.run_id, ref, now)
         filed.append(ref)
+    log.debug(
+        "backlog.collected",
+        run=run.run_id,
+        filed=len(filed),
+        already_seen=seen,
+        deferred=skipped,
+        trigger=trigger,
+    )
     if skipped:
-        logger.warning(
-            "backlog: run %s produced %d item(s) beyond the per-run cap of %d; deferred "
-            "(not fingerprint-recorded, so the next collection pass files them)",
-            run.run_id,
-            skipped,
-            max_items,
+        log.warning(
+            "backlog.cap_deferred",
+            run=run.run_id,
+            deferred=skipped,
+            cap=max_items,
+            hint="not fingerprint-recorded, so the next collection pass files them",
         )
     return filed