log4lab 0.1.0__py3-none-any.whl

log4lab/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

log4lab/cli.py

@@ -0,0 +1,64 @@
+import typer
+import uvicorn
+from pathlib import Path
+from typing import Optional
+from . import server
+from .tail import LogTailer
+
+app = typer.Typer(help="Log4Lab — a lightweight structured log dashboard")
+
+
+@app.command()
+def serve(
+    logfile: Path = typer.Argument(
+        "logs/app.log",
+        exists=False,
+        help="Path to the JSONL log file to stream (default: logs/app.log)"
+    ),
+    host: str = typer.Option("127.0.0.1", help="Host to bind to"),
+    port: int = typer.Option(8000, help="Port to listen on"),
+    reload: bool = typer.Option(False, help="Enable auto-reload"),
+):
+    """Start the Log4Lab web server."""
+    server.set_log_path(logfile)
+    uvicorn.run("log4lab.server:app", host=host, port=port, reload=reload)
+
+
+@app.command()
+def tail(
+    logfile: Path = typer.Argument(
+        "logs/app.log",
+        help="Path to the JSONL log file to tail"
+    ),
+    level: Optional[str] = typer.Option(None, "--level", "-l", help="Filter by log level (e.g., INFO, ERROR)"),
+    section: Optional[str] = typer.Option(None, "--section", "-s", help="Filter by section name"),
+    run_name: Optional[str] = typer.Option(None, "--run-name", "-r", help="Filter by run name"),
+    run_id: Optional[str] = typer.Option(None, "--run-id", help="Filter by run ID"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Filter by group name"),
+    time_range: Optional[int] = typer.Option(None, "--time-range", "-t", help="Only show logs from last N seconds"),
+    follow: bool = typer.Option(True, "--follow/--no-follow", "-f", help="Follow log file for new entries"),
+    show_images: bool = typer.Option(True, "--images/--no-images", help="Try to show images inline in terminal"),
+    open_images: bool = typer.Option(False, "--open-images", help="Open images in system default viewer (Preview, etc.)"),
+):
+    """Tail logs to the terminal with rich formatting and filters."""
+    tailer = LogTailer(
+        log_path=logfile,
+        level=level,
+        section=section,
+        run_name=run_name,
+        run_id=run_id,
+        group=group,
+        time_range=time_range,
+        follow=follow,
+        show_images=show_images,
+        open_images=open_images,
+    )
+    try:
+        tailer.tail()
+    except KeyboardInterrupt:
+        pass  # Clean exit on Ctrl+C
+
+
+if __name__ == "__main__":
+    app()
+

log4lab/server.py

@@ -0,0 +1,155 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse, StreamingResponse, FileResponse
+from jinja2 import Environment, FileSystemLoader
+import asyncio, json
+from pathlib import Path
+import mimetypes
+
+# Global variable to store the log path
+_LOG_PATH = Path("logs/app.log")
+
+env = Environment(loader=FileSystemLoader(str(Path(__file__).parent / "templates")))
+template = env.get_template("index.html")
+
+def set_log_path(log_path: Path):
+    """Set the log path for the server."""
+    global _LOG_PATH
+    _LOG_PATH = log_path
+
+def get_log_path() -> Path:
+    """Get the current log path."""
+    return _LOG_PATH
+
+app = FastAPI()
+
+@app.get("/", response_class=HTMLResponse)
+async def show_page():
+    return template.render()
+
+@app.get("/runs", response_class=HTMLResponse)
+async def show_runs_page():
+    """Show the run IDs index page."""
+    runs_template = env.get_template("runs.html")
+    return runs_template.render()
+
+@app.get("/api/runs")
+async def get_runs():
+    """Get run_names with their run_ids from the log file."""
+    log_path = get_log_path()
+    runs = {}  # {run_name: {run_ids: {run_id: {count, earliest, latest}}, total: X}}
+
+    if log_path.exists():
+        with log_path.open() as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                    run_name = obj.get('run_name')
+                    run_id = obj.get('run_id')
+                    timestamp = obj.get('time')
+
+                    if run_name:
+                        run_name = str(run_name)
+                        if run_name not in runs:
+                            runs[run_name] = {'run_ids': {}, 'total': 0}
+
+                        runs[run_name]['total'] += 1
+
+                        if run_id:
+                            run_id = str(run_id)
+                            if run_id not in runs[run_name]['run_ids']:
+                                runs[run_name]['run_ids'][run_id] = {
+                                    'count': 0,
+                                    'earliest': None,
+                                    'latest': None
+                                }
+                            runs[run_name]['run_ids'][run_id]['count'] += 1
+
+                            # Track earliest and latest timestamps
+                            if timestamp:
+                                if runs[run_name]['run_ids'][run_id]['earliest'] is None:
+                                    runs[run_name]['run_ids'][run_id]['earliest'] = timestamp
+                                    runs[run_name]['run_ids'][run_id]['latest'] = timestamp
+                                else:
+                                    if timestamp < runs[run_name]['run_ids'][run_id]['earliest']:
+                                        runs[run_name]['run_ids'][run_id]['earliest'] = timestamp
+                                    if timestamp > runs[run_name]['run_ids'][run_id]['latest']:
+                                        runs[run_name]['run_ids'][run_id]['latest'] = timestamp
+
+                except json.JSONDecodeError:
+                    continue
+
+    # Convert to frontend-friendly format
+    result = {}
+    for run_name, data in runs.items():
+        result[run_name] = {
+            'total': data['total'],
+            'run_ids': [
+                {
+                    'run_id': rid,
+                    'count': info['count'],
+                    'earliest': info['earliest'],
+                    'latest': info['latest']
+                }
+                for rid, info in sorted(data['run_ids'].items())
+            ]
+        }
+
+    return {"runs": result}
+
+async def stream_logs():
+    last_size = 0
+    while True:
+        log_path = get_log_path()
+        if log_path.exists():
+            size = log_path.stat().st_size
+            if size < last_size:
+                last_size = 0
+            if size > last_size:
+                with log_path.open() as f:
+                    f.seek(last_size)
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            obj = json.loads(line)
+                            yield f"data: {json.dumps(obj)}\n\n"
+                        except json.JSONDecodeError:
+                            continue
+                    last_size = f.tell()
+        await asyncio.sleep(1)
+
+@app.get("/stream")
+async def sse_endpoint():
+    return StreamingResponse(stream_logs(), media_type="text/event-stream")
+
+@app.get("/cache/{file_path:path}")
+async def serve_cache_file(file_path: str):
+    """Serve cache files relative to the log file directory."""
+    log_dir = get_log_path().parent
+    requested_file = log_dir / file_path
+
+    # Security: ensure the file is within the log directory or subdirectories
+    try:
+        requested_file = requested_file.resolve()
+        log_dir = log_dir.resolve()
+        if not str(requested_file).startswith(str(log_dir)):
+            raise HTTPException(status_code=403, detail="Access denied")
+    except (ValueError, OSError):
+        raise HTTPException(status_code=400, detail="Invalid file path")
+
+    if not requested_file.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+
+    if not requested_file.is_file():
+        raise HTTPException(status_code=400, detail="Not a file")
+
+    # Determine the media type
+    mime_type, _ = mimetypes.guess_type(str(requested_file))
+    if mime_type is None:
+        mime_type = "application/octet-stream"
+
+    return FileResponse(requested_file, media_type=mime_type)

log4lab/tail.py

@@ -0,0 +1,283 @@
+"""Terminal-based log tailing with live streaming and image support."""
+import json
+import time
+import subprocess
+import platform
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Optional, List
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.live import Live
+from rich.layout import Layout
+from rich import box
+
+try:
+    from term_image.image import from_file
+    IMAGES_SUPPORTED = True
+except (ImportError, Exception):
+    # term-image may not be available or may have dependency issues
+    IMAGES_SUPPORTED = False
+
+
+class LogTailer:
+    """Tail JSONL log files with rich terminal output."""
+
+    def __init__(
+        self,
+        log_path: Path,
+        level: Optional[str] = None,
+        section: Optional[str] = None,
+        run_name: Optional[str] = None,
+        run_id: Optional[str] = None,
+        group: Optional[str] = None,
+        time_range: Optional[int] = None,
+        follow: bool = True,
+        show_images: bool = True,
+        open_images: bool = False,
+    ):
+        self.log_path = log_path
+        self.level = level.upper() if level else None
+        self.section = section
+        self.run_name = run_name
+        self.run_id = run_id
+        self.group = group
+        self.time_range = time_range  # seconds
+        self.follow = follow
+        self.show_images = show_images and IMAGES_SUPPORTED
+        self.open_images = open_images
+        self.console = Console()
+
+    def matches_filters(self, entry: dict) -> bool:
+        """Check if log entry matches all filters."""
+        # Level filter
+        if self.level and entry.get("level", "").upper() != self.level:
+            return False
+
+        # Section filter
+        if self.section and self.section.lower() not in entry.get("section", "").lower():
+            return False
+
+        # Run name filter
+        if self.run_name and self.run_name.lower() not in entry.get("run_name", "").lower():
+            return False
+
+        # Run ID filter
+        if self.run_id and self.run_id.lower() not in entry.get("run_id", "").lower():
+            return False
+
+        # Group filter
+        if self.group and self.group.lower() not in entry.get("group", "").lower():
+            return False
+
+        # Time range filter
+        if self.time_range and "time" in entry:
+            try:
+                log_time = datetime.fromisoformat(entry["time"].replace("Z", "+00:00"))
+                now = datetime.now(timezone.utc)
+                if (now - log_time).total_seconds() > self.time_range:
+                    return False
+            except (ValueError, AttributeError):
+                pass
+
+        return True
+
+    def format_level(self, level: str) -> Text:
+        """Format log level with colors."""
+        level = level.upper()
+        colors = {
+            "ERROR": "red bold",
+            "WARN": "yellow bold",
+            "WARNING": "yellow bold",
+            "INFO": "blue bold",
+            "DEBUG": "cyan",
+            "TRACE": "dim",
+        }
+        color = colors.get(level, "white")
+        return Text(level.ljust(7), style=color)
+
+    def format_timestamp(self, timestamp: str) -> Text:
+        """Format timestamp."""
+        try:
+            dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+            return Text(dt.strftime("%H:%M:%S"), style="dim")
+        except (ValueError, AttributeError):
+            return Text(timestamp[:8] if len(timestamp) > 8 else timestamp, style="dim")
+
+    def format_entry(self, entry: dict) -> Panel:
+        """Format a log entry as a rich panel."""
+        # Header with timestamp, level, and metadata
+        header_parts = []
+
+        if "time" in entry:
+            header_parts.append(self.format_timestamp(entry["time"]))
+
+        if "level" in entry:
+            header_parts.append(self.format_level(entry["level"]))
+
+        if "section" in entry:
+            header_parts.append(Text(f"[{entry['section']}]", style="magenta"))
+
+        if "run_name" in entry:
+            header_parts.append(Text(f"run:{entry['run_name']}", style="green"))
+
+        if "run_id" in entry:
+            header_parts.append(Text(f"id:{entry['run_id']}", style="green dim"))
+
+        if "group" in entry:
+            header_parts.append(Text(f"group:{entry['group']}", style="yellow"))
+
+        header = Text(" ").join(header_parts)
+
+        # Message (main content)
+        message = entry.get("message") or entry.get("msg", "")
+        message_text = Text(message, style="white")
+
+        # Additional fields (exclude known fields)
+        known_fields = {"time", "level", "section", "message", "msg", "run_name", "run_id", "group", "cache_path"}
+        extra_fields = {k: v for k, v in entry.items() if k not in known_fields}
+
+        content_parts = [message_text]
+
+        if extra_fields:
+            content_parts.append(Text("\n"))
+            extra_text = Text(json.dumps(extra_fields, indent=2), style="dim")
+            content_parts.append(extra_text)
+
+        content = Text("").join(content_parts)
+
+        # Create panel
+        border_style = {
+            "ERROR": "red",
+            "WARN": "yellow",
+            "WARNING": "yellow",
+            "INFO": "blue",
+            "DEBUG": "cyan",
+        }.get(entry.get("level", "").upper(), "white")
+
+        panel = Panel(
+            content,
+            title=header,
+            title_align="left",
+            border_style=border_style,
+            box=box.ROUNDED,
+        )
+
+        return panel
+
+    def open_image_externally(self, image_path: Path):
+        """Open image in system default viewer."""
+        try:
+            system = platform.system()
+            if system == 'Darwin':  # macOS
+                subprocess.run(['open', str(image_path)], check=True)
+            elif system == 'Linux':
+                subprocess.run(['xdg-open', str(image_path)], check=True)
+            elif system == 'Windows':
+                subprocess.run(['start', str(image_path)], shell=True, check=True)
+            self.console.print(f"[dim green]✓ Opened {image_path.name} in system viewer[/dim green]")
+        except Exception as e:
+            self.console.print(f"[dim yellow]Could not open image: {e}[/dim yellow]")
+
+    def show_image(self, image_path: Path):
+        """Display image inline in terminal if supported."""
+        if not image_path.exists():
+            self.console.print(f"[dim red]📷 Image not found: {image_path}[/dim red]")
+            return
+
+        # Check if file is an image
+        if image_path.suffix.lower() not in {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"}:
+            self.console.print(f"[dim]📄 File: {image_path}[/dim]")
+            return
+
+        # Option 1: Open in external viewer (most reliable)
+        if self.open_images:
+            self.open_image_externally(image_path)
+            return
+
+        # Option 2: Show path with helpful message (default behavior)
+        # Inline rendering is disabled by default due to unreliability
+        self.console.print(f"[dim cyan]📷 Image: {image_path}[/dim cyan]")
+        if self.show_images:
+            self.console.print(f"[dim]   💡 Tip: Use --open-images to view in Preview/image viewer[/dim]")
+
+    def tail(self):
+        """Tail the log file and display entries."""
+        if not self.log_path.exists():
+            self.console.print(f"[red]Error: Log file not found: {self.log_path}[/red]")
+            return
+
+        # Print header
+        self.console.print(Panel(
+            f"[bold]Tailing log file:[/bold] {self.log_path}\n"
+            f"[dim]Press Ctrl+C to stop[/dim]",
+            border_style="blue",
+        ))
+
+        # Show active filters
+        if any([self.level, self.section, self.run_name, self.run_id, self.group, self.time_range]):
+            filters = []
+            if self.level:
+                filters.append(f"level={self.level}")
+            if self.section:
+                filters.append(f"section={self.section}")
+            if self.run_name:
+                filters.append(f"run_name={self.run_name}")
+            if self.run_id:
+                filters.append(f"run_id={self.run_id}")
+            if self.group:
+                filters.append(f"group={self.group}")
+            if self.time_range:
+                filters.append(f"time_range={self.time_range}s")
+            self.console.print(f"[yellow]Active filters: {', '.join(filters)}[/yellow]\n")
+
+        with open(self.log_path, 'r') as f:
+            # Read existing lines first
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    entry = json.loads(line)
+                    if self.matches_filters(entry):
+                        self.console.print(self.format_entry(entry))
+
+                        # Show image if cache_path exists
+                        if "cache_path" in entry:
+                            cache_path = Path(entry["cache_path"])
+                            if not cache_path.is_absolute():
+                                cache_path = self.log_path.parent / cache_path
+                            self.show_image(cache_path)
+
+                        self.console.print()  # Empty line between entries
+                except json.JSONDecodeError:
+                    continue
+
+            # Follow mode: watch for new lines
+            if self.follow:
+                while True:
+                    line = f.readline()
+                    if line:
+                        line = line.strip()
+                        if line:
+                            try:
+                                entry = json.loads(line)
+                                if self.matches_filters(entry):
+                                    self.console.print(self.format_entry(entry))
+
+                                    # Show image if cache_path exists
+                                    if "cache_path" in entry:
+                                        cache_path = Path(entry["cache_path"])
+                                        if not cache_path.is_absolute():
+                                            cache_path = self.log_path.parent / cache_path
+                                        self.show_image(cache_path)
+
+                                    self.console.print()  # Empty line between entries
+                            except json.JSONDecodeError:
+                                continue
+                    else:
+                        time.sleep(0.1)  # Short sleep to avoid busy waiting