docker-orb 1.0.0__py3-none-any.whl

docker_orb/inject.py

@@ -0,0 +1,160 @@
+"""
+docker-orb-inject — test utility for injecting log messages into running
+Compose containers.
+
+Writes directly to the container's PID 1 stdout fd via `docker exec` so the
+message appears in the live log stream exactly like a real log line.
+
+Usage:
+  docker-orb-inject                                # interactive: pick container, loop for messages
+  docker-orb-inject -n myapp -d api -m "ERROR: test error"
+  docker-orb-inject -n myapp -c myapp-api-1 -m "WARN: test"
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import click
+
+
+def _list_containers(project: str) -> list[tuple[str, str]]:
+    """Return list of (container_name, service_name) tuples for a project."""
+    result = subprocess.run(
+        ["docker", "compose", "-p", project, "ps", "--all",
+         "--format", "{{.Name}}\t{{.Service}}"],
+        capture_output=True, text=True,
+    )
+    containers = []
+    for line in result.stdout.strip().splitlines():
+        parts = line.split("\t")
+        if len(parts) >= 2:
+            containers.append((parts[0], parts[1]))
+    return containers
+
+
+def _resolve_container(project: str, service: str | None, container: str | None) -> str | None:
+    """Resolve a specific container name from either a service name or direct container name."""
+    if container:
+        return container
+
+    containers = _list_containers(project)
+    if not containers:
+        return None
+
+    if service:
+        matches = [c for c, s in containers if s == service]
+        if not matches:
+            click.echo(f"No containers found for service '{service}'.", err=True)
+            return None
+        # Pick the first one (could add round-robin later)
+        return matches[0]
+
+    return None
+
+
+def _inject(container_name: str, message: str, prefix: str) -> bool:
+    """Write a message to the container's stdout. Returns True on success."""
+    full_message = f"{prefix}{message}" if prefix else message
+    # Write to /proc/1/fd/1 — the main process's stdout fd — so it appears in `docker logs`
+    result = subprocess.run(
+        ["docker", "exec", container_name,
+         "sh", "-c", f"echo '{full_message}' > /proc/1/fd/1"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        click.echo(f"Inject failed: {result.stderr.strip()}", err=True)
+        return False
+    return True
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option("-n", "--project", default=None,
+              help="Docker Compose project name (default: current directory's compose project).")
+@click.option("-d", "--service", default=None, metavar="NAME",
+              help="Service name — a container from this service will be chosen.")
+@click.option("-c", "--container", default=None, metavar="NAME",
+              help="Exact container name to inject into.")
+@click.option("-m", "--message", "messages", multiple=True, metavar="MSG",
+              help="Message(s) to inject. Omit for interactive mode.")
+@click.option("--prefix", default="[TEST] ", show_default=True,
+              help="Prefix prepended to every injected message.")
+@click.option("--no-prefix", is_flag=True,
+              help="Suppress the prefix entirely.")
+def main(
+    project: str | None,
+    service: str | None,
+    container: str | None,
+    messages: tuple[str, ...],
+    prefix: str,
+    no_prefix: bool,
+) -> None:
+    """
+    Inject log messages into a running container for testing docker-orb
+    filters/monitors.
+
+    Messages are written to the container's stdout so they appear in the
+    live log stream.
+
+    \b
+    Examples:
+      docker-orb-inject                                    # fully interactive
+      docker-orb-inject -d api -m "ERROR: test"
+      docker-orb-inject -d worker -m "job failed" -m "OOM killed"
+      docker-orb-inject -c myapp-api-1 --no-prefix -m "raw message"
+    """
+    from . import compose as k
+
+    if no_prefix:
+        prefix = ""
+
+    # Resolve project
+    if project is None:
+        project = k.get_current_project()
+
+    # If neither service nor container given, show a picker
+    if not service and not container:
+        containers = _list_containers(project)
+        if not containers:
+            click.echo(f"No containers found for project '{project}'.", err=True)
+            sys.exit(1)
+
+        click.echo(f"\nContainers in project '{project}':\n")
+        for i, (cname, sname) in enumerate(containers):
+            click.echo(f"  [{i}] {cname}  ({sname})")
+        click.echo()
+
+        choice = click.prompt("Select container number", type=int)
+        if choice < 0 or choice >= len(containers):
+            click.echo("Invalid choice.", err=True)
+            sys.exit(1)
+        container = containers[choice][0]
+
+    # Resolve to a specific container name
+    target_container = _resolve_container(project, service, container)
+    if not target_container:
+        click.echo("Could not resolve a target container.", err=True)
+        sys.exit(1)
+
+    click.echo(f"Injecting into container: {target_container}  (project: {project})")
+    click.echo(f"Prefix: '{prefix}'\n")
+
+    # One-shot mode
+    if messages:
+        for msg in messages:
+            ok = _inject(target_container, msg, prefix)
+            if ok:
+                click.echo(f"  ✓ {prefix}{msg}")
+        return
+
+    # Interactive loop
+    click.echo("Interactive mode — type a message and press Enter. Ctrl+C to quit.\n")
+    while True:
+        try:
+            msg = click.prompt("Message")
+            ok = _inject(target_container, msg, prefix)
+            if ok:
+                click.echo(f"  ✓ Injected")
+        except (click.Abort, KeyboardInterrupt):
+            click.echo("\nDone.")
+            break

docker_orb/jsonlog.py

@@ -0,0 +1,125 @@
+"""
+Detection and readable-formatting for structured JSON log lines.
+
+Most k8s services that emit structured logs use JSON — nearly unreadable as
+a raw line. parse_json_log_line() detects a JSON object line and extracts
+common level/message/timestamp fields (checking a few conventional key
+names, since loggers disagree on naming), leaving everything else as
+trailing key=value context. The caller decides whether to actually display
+the formatted form or the raw line — detection always runs regardless, so
+the "press Enter for full JSON" detail view works even in raw mode.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+# Checked in order; first key present wins. Covers the common structured
+# logging libraries (zap, logrus, structlog, bunyan, stdlib json logging, ...).
+_LEVEL_KEYS = ("level", "lvl", "severity", "loglevel", "log.level")
+_MESSAGE_KEYS = ("message", "msg", "text")
+_TIME_KEYS = ("timestamp", "time", "ts", "@timestamp", "asctime")
+
+# Level name -> Rich style, for coloring the level token in the main stream.
+LEVEL_STYLES = {
+    "TRACE": "dim",
+    "DEBUG": "dim cyan",
+    "INFO": "cyan",
+    "NOTICE": "cyan",
+    "WARN": "bold yellow",
+    "WARNING": "bold yellow",
+    "ERROR": "bold red",
+    "FATAL": "bold white on red",
+    "CRITICAL": "bold white on red",
+    "PANIC": "bold white on red",
+}
+
+
+@dataclass
+class ParsedJsonLine:
+    raw: dict                      # the full decoded object, for the detail modal
+    level: str | None              # as found in the data, original casing
+    message: str                   # falls back to a placeholder if no message-like key found
+    timestamp: str | None          # already shortened to HH:MM:SS where parseable
+    extras: dict = field(default_factory=dict)  # remaining top-level keys
+
+    @property
+    def extras_text(self) -> str:
+        return " ".join(f"{k}={_format_value(v)}" for k, v in self.extras.items())
+
+    @property
+    def display_text(self) -> str:
+        """Single-line readable rendering: `HH:MM:SS LEVEL  message  k=v k=v`."""
+        parts = []
+        if self.timestamp:
+            parts.append(self.timestamp)
+        if self.level:
+            parts.append(f"{self.level.upper():<5}")
+        parts.append(self.message)
+        if self.extras:
+            parts.append(self.extras_text)
+        return "  ".join(parts)
+
+    @property
+    def pretty(self) -> str:
+        """Full pretty-printed JSON, for the detail modal."""
+        return json.dumps(self.raw, indent=2, sort_keys=False, default=str)
+
+
+def parse_json_log_line(content: str) -> ParsedJsonLine | None:
+    """
+    Return a ParsedJsonLine if `content` is a single JSON object, else None.
+    Cheap to call on every line: bails before attempting to parse anything
+    that doesn't even look like an object.
+    """
+    stripped = content.strip()
+    if len(stripped) < 2 or stripped[0] != "{" or stripped[-1] != "}":
+        return None
+    try:
+        data = json.loads(stripped)
+    except (json.JSONDecodeError, ValueError, RecursionError):
+        return None
+    if not isinstance(data, dict) or not data:
+        return None
+
+    level_key = _first_key(data, _LEVEL_KEYS)
+    message_key = _first_key(data, _MESSAGE_KEYS)
+    time_key = _first_key(data, _TIME_KEYS)
+
+    level = str(data[level_key]) if level_key else None
+    message = str(data[message_key]) if message_key else "(no message field)"
+    timestamp = _short_time(data[time_key]) if time_key else None
+
+    used = {k for k in (level_key, message_key, time_key) if k is not None}
+    extras = {k: v for k, v in data.items() if k not in used}
+
+    return ParsedJsonLine(raw=data, level=level, message=message,
+                          timestamp=timestamp, extras=extras)
+
+
+def _first_key(data: dict, candidates: tuple[str, ...]) -> str | None:
+    for key in candidates:
+        if key in data and data[key] not in (None, ""):
+            return key
+    return None
+
+
+def _short_time(value: object) -> str:
+    if isinstance(value, (int, float)):
+        try:
+            return datetime.fromtimestamp(value, tz=timezone.utc).strftime("%H:%M:%S")
+        except (ValueError, OSError, OverflowError):
+            return str(value)
+    s = str(value)
+    iso = s[:-1] + "+00:00" if s.endswith("Z") else s
+    try:
+        return datetime.fromisoformat(iso).strftime("%H:%M:%S")
+    except ValueError:
+        return s
+
+
+def _format_value(value: object) -> str:
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, separators=(",", ":"), default=str)
+    return str(value)

docker_orb/models.py

@@ -0,0 +1,132 @@
+"""
+Core domain models for docker-orb.
+All data passed between layers is typed via these dataclasses.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+
+
+class LogMode(str, Enum):
+    STREAM = "stream"
+    DUMP = "dump"
+
+
+# ─── Docker Compose objects ────────────────────────────────────────────────────
+
+@dataclass
+class Service:
+    name: str
+    project: str
+    container_count: int  # number of containers currently backing this service
+
+
+@dataclass
+class Container:
+    name: str
+    project: str
+    service: str          # owning service name
+    phase: str               # Running, Pending, Failed, etc.
+    restart_count: int
+    ready: bool
+
+
+@dataclass
+class ContainerStatus:
+    """Snapshot of a container's health at a point in time."""
+    name: str
+    service: str
+    phase: str
+    restart_count: int
+    ready: bool
+    age_seconds: float
+
+    @property
+    def is_healthy(self) -> bool:
+        return self.phase == "Running" and self.ready
+
+
+# ─── Log lines ────────────────────────────────────────────────────────────────
+
+@dataclass
+class LogLine:
+    container_name: str
+    content: str             # raw log text
+    received_at: datetime = field(default_factory=datetime.now)
+    # The real per-line timestamp Docker attaches (from `docker logs
+    # --timestamps`), parsed and stripped back out of `content`. None
+    # when unavailable (dump mode doesn't request it) or unparseable.
+    # received_at is "when docker-orb read this"; log_timestamp is "when the
+    # container actually emitted it" — used to interleave a backfill burst
+    # (see ViewerApp._handle_backfill_line) since arrival order across
+    # concurrent per-container streams doesn't reflect true chronological order.
+    log_timestamp: datetime | None = None
+
+    @property
+    def display(self) -> str:
+        return f"[{self.container_name}] {self.content}"
+
+
+# ─── String matching ─────────────────────────────────────────────────────────
+
+@dataclass
+class SavedStrings:
+    """
+    Global saved string lists, persisted to ~/.config/docker-orb/strings.yaml.
+    Strings prefixed and suffixed with '/' are treated as regex patterns.
+    """
+    filters: list[str] = field(default_factory=list)
+    highlights: list[str] = field(default_factory=list)
+    monitors: list[str] = field(default_factory=list)
+
+
+# ─── Session config ───────────────────────────────────────────────────────────
+
+@dataclass
+class HealthConfig:
+    enabled: bool = False
+    interval_minutes: int = 5
+    restart_threshold: int = 1   # CLI-only tuning knob, default 1
+
+
+@dataclass
+class SessionConfig:
+    """
+    Complete configuration for one viewer session.
+    Produced by the wizard or assembled from CLI flags.
+    Persisted per-project to ~/.config/docker-orb/projects/<proj>.yaml.
+    """
+    project: str
+    services: list[str]       # selected service names
+    mode: LogMode = LogMode.STREAM
+
+    tail: int | None = None      # last N lines (dump mode only)
+    # `docker logs --since` value, e.g. "1h", "30m". Used by both modes:
+    # bounds how far back dump mode fetches (None = full history). In stream
+    # mode, a None/empty value is normalized to "1s" (see
+    # compose._normalize_since) so a live session only collects new lines
+    # instead of replaying a container's full buffered history.
+    since: str | None = None
+
+    # Active string sets for this session
+    filters: list[str] = field(default_factory=list)
+    highlights: list[str] = field(default_factory=list)
+    monitors: list[str] = field(default_factory=list)   # stream only
+
+    # Case sensitivity (False = case-sensitive, True = ignore case)
+    filters_ignore_case: bool = False
+    highlights_ignore_case: bool = False
+    monitors_ignore_case: bool = False
+
+    health: HealthConfig = field(default_factory=HealthConfig)
+
+    # Display options
+    color_full_line: bool = False  # True = color entire line; False = color container name prefix only
+    line_wrap: bool = True
+    json_format: bool = False  # True = reformat detected JSON lines (level/message/time); False = raw
+    collapse_repeats: bool = False  # True = collapse consecutive identical lines (journalctl-style)
+
+    # Config name — set when user chooses to save
+    name: str | None = None