logler 1.0.7__cp311-cp311-macosx_10_12_x86_64.whl → 1.1.2__cp311-cp311-macosx_10_12_x86_64.whl

logler/__init__.py

@@ -2,7 +2,7 @@
 Logler - Beautiful local log viewer with thread tracking and real-time updates.
 """
 
-__version__ = "1.0.7"
+__version__ = "1.1.2"
 __author__ = "Logler Contributors"
 
 from .parser import LogParser, LogEntry
@@ -10,7 +10,62 @@ from .tracker import ThreadTracker
 from .log_reader import LogReader
 from .tree_formatter import format_tree, format_waterfall, print_tree, print_waterfall
 
+# Pydantic models for type-safe log analysis
+from .models import (
+    # Core entry models
+    LogEntry as TypedLogEntry,
+    LogLevel,
+    LogFormat,
+    # Search models
+    SearchResult,
+    SearchResults,
+    SearchSummary,
+    SearchCount,
+    # Timeline models
+    ThreadTimeline,
+    # Hierarchy models
+    SpanNode,
+    ThreadHierarchy,
+    BottleneckInfo,
+    NodeType,
+    DetectionMethod,
+    # Pattern models
+    PatternMatch,
+    PatternResults,
+    # Sampling
+    SamplingResult,
+    # Error analysis
+    ErrorAnalysis,
+    RootCause,
+    PropagationChain,
+    ImpactSummary,
+    # File/context
+    FileMetadata,
+    ContextResult,
+    # Cross-service
+    TimelineEntry,
+    CrossServiceTimeline,
+    # Correlation
+    CorrelationLink,
+    CorrelationChains,
+    # Export
+    TraceSpan,
+    TraceExport,
+    # Insights
+    Insight,
+    InsightsResult,
+    # Schema
+    SchemaField,
+    LogSchema,
+    # Helper functions
+    parse_log_entry,
+    parse_search_results,
+    parse_thread_hierarchy,
+    parse_error_analysis,
+)
+
 __all__ = [
+    # Original exports
     "LogParser",
     "LogEntry",
     "ThreadTracker",
@@ -19,4 +74,54 @@ __all__ = [
     "format_waterfall",
     "print_tree",
     "print_waterfall",
+    # Pydantic models - Core
+    "TypedLogEntry",
+    "LogLevel",
+    "LogFormat",
+    # Pydantic models - Search
+    "SearchResult",
+    "SearchResults",
+    "SearchSummary",
+    "SearchCount",
+    # Pydantic models - Timeline
+    "ThreadTimeline",
+    # Pydantic models - Hierarchy
+    "SpanNode",
+    "ThreadHierarchy",
+    "BottleneckInfo",
+    "NodeType",
+    "DetectionMethod",
+    # Pydantic models - Patterns
+    "PatternMatch",
+    "PatternResults",
+    # Pydantic models - Sampling
+    "SamplingResult",
+    # Pydantic models - Error analysis
+    "ErrorAnalysis",
+    "RootCause",
+    "PropagationChain",
+    "ImpactSummary",
+    # Pydantic models - File/context
+    "FileMetadata",
+    "ContextResult",
+    # Pydantic models - Cross-service
+    "TimelineEntry",
+    "CrossServiceTimeline",
+    # Pydantic models - Correlation
+    "CorrelationLink",
+    "CorrelationChains",
+    # Pydantic models - Export
+    "TraceSpan",
+    "TraceExport",
+    # Pydantic models - Insights
+    "Insight",
+    "InsightsResult",
+    # Pydantic models - Schema
+    "SchemaField",
+    "LogSchema",
+    # Helper functions
+    "parse_log_entry",
+    "parse_search_results",
+    "parse_thread_hierarchy",
+    "parse_error_analysis",
 ]

logler/bootstrap.py

@@ -2,7 +2,7 @@
 Helper to ensure the Rust backend is installed.
 
 Attempts to import `logler_rs`; if missing, runs `maturin develop` against
-`crates/logler-py/Cargo.toml` with the `sql` feature enabled.
+`crates/logler-py/Cargo.toml`.
 """
 
 from __future__ import annotations
@@ -33,8 +33,6 @@ def ensure_rust_backend(auto_install: bool = True) -> bool:
         "--release",
         "-m",
         str(repo_root / "crates" / "logler-py" / "Cargo.toml"),
-        "--features",
-        "sql",
     ]
     try:
         subprocess.run(

logler/cli.py

@@ -2,16 +2,12 @@
 Command-line interface for Logler.
 """
 
+import asyncio
 import click
 import sys
-from pathlib import Path
 from typing import Optional
-import asyncio
-import socket
-from contextlib import closing
 
 from .terminal import TerminalViewer
-from .web.app import run_server
 from .llm_cli import llm as llm_group
 
 
@@ -28,56 +24,6 @@ def main(ctx):
         click.echo(ctx.get_help())
 
 
-def _find_open_port(host: str, start_port: int, max_tries: int = 20) -> int:
-    """Find the next available port starting from start_port."""
-    for candidate in range(start_port, start_port + max_tries):
-        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            try:
-                sock.bind((host, candidate))
-                return candidate
-            except OSError:
-                continue
-    raise RuntimeError(f"No open port found in range {start_port}-{start_port + max_tries - 1}")
-
-
-@main.command()
-@click.option("--host", default="0.0.0.0", help="Host to bind to")
-@click.option("--port", default=7607, help="Port to bind to (default 7607 ~ 'LOGL')")
-@click.option(
-    "--auto-port/--no-auto-port",
-    default=True,
-    help="Pick the next free port if the chosen one is busy",
-)
-@click.option("--open", "-o", is_flag=True, help="Open browser automatically")
-@click.argument("files", nargs=-1, type=click.Path(exists=True))
-def serve(host: str, port: int, auto_port: bool, open: bool, files: tuple):
-    """
-    Start the web server interface.
-
-    Examples:
-        logler serve                    # Start with file picker
-        logler serve app.log            # Start with specific file
-        logler serve *.log              # Start with multiple files
-    """
-    if auto_port:
-        chosen_port = _find_open_port(host, port)
-        if chosen_port != port:
-            click.echo(f"⚠️  Port {port} busy, using {chosen_port} instead")
-        port = chosen_port
-
-    click.echo(f"🚀 Starting Logler web server on http://{host}:{port}")
-
-    file_paths = [str(Path(f).absolute()) for f in files] if files else []
-
-    if open:
-        import webbrowser
-
-        webbrowser.open(f"http://localhost:{port}")
-
-    asyncio.run(run_server(host, port, file_paths))
-
-
 @main.command()
 @click.argument("files", nargs=-1, required=True, type=click.Path(exists=True))
 @click.option("-n", "--lines", type=int, help="Number of lines to show")

logler/investigate.py

@@ -1942,7 +1942,20 @@ class Investigator:
         """Search loaded files."""
         filters = {"levels": []}
         if level:
-            filters["levels"] = [level.upper()]
+            level_map = {
+                "trace": "Trace",
+                "debug": "Debug",
+                "info": "Info",
+                "warn": "Warn",
+                "warning": "Warn",
+                "error": "Error",
+                "fatal": "Fatal",
+                "critical": "Fatal",
+            }
+            normalized_level = level_map.get(level.lower())
+            if not normalized_level:
+                raise ValueError(f"Unknown log level: {level}")
+            filters["levels"] = [normalized_level]
         if thread_id:
             filters["thread_id"] = thread_id
         if correlation_id:
@@ -2005,7 +2018,7 @@ class Investigator:
 
     def sql_query(self, query: str) -> List[Dict[str, Any]]:
         """
-        Execute SQL query on loaded logs (requires 'sql' feature).
+        Execute SQL query on loaded logs.
 
         Args:
             query: SQL query string
@@ -2021,24 +2034,52 @@ class Investigator:
                 ORDER BY count DESC
             \"\"\")
         """
-        if not hasattr(self._investigator, "sql_query"):
-            raise RuntimeError("SQL feature not available. Build with --features sql")
-        result_json = self._investigator.sql_query(query)
+        engine = self._get_sql_engine()
+        result_json = engine.query(query)
         return json.loads(result_json)
 
     def sql_tables(self) -> List[str]:
-        """Get list of available SQL tables (requires 'sql' feature)."""
-        if not hasattr(self._investigator, "sql_tables"):
-            raise RuntimeError("SQL feature not available. Build with --features sql")
-        return self._investigator.sql_tables()
+        """Get list of available SQL tables."""
+        engine = self._get_sql_engine()
+        return engine.get_tables()
 
     def sql_schema(self, table: str) -> List[Dict[str, Any]]:
-        """Get schema for a SQL table (requires 'sql' feature)."""
-        if not hasattr(self._investigator, "sql_schema"):
-            raise RuntimeError("SQL feature not available. Build with --features sql")
-        result_json = self._investigator.sql_schema(table)
+        """Get schema for a SQL table."""
+        engine = self._get_sql_engine()
+        result_json = engine.get_schema(table)
         return json.loads(result_json)
 
+    def _get_sql_engine(self):
+        """Get a SQL engine loaded with current log data."""
+        from logler.parser import LogParser
+        from logler.sql import SqlEngine
+
+        # Parse files and build index
+        parser = LogParser()
+        indices: Dict[str, Any] = {}
+
+        for file_path in self._files:
+            entries = []
+            with open(file_path, encoding="utf-8", errors="replace") as f:
+                for line_number, line in enumerate(f, start=1):
+                    line = line.rstrip("\n\r")
+                    if line:
+                        entry = parser.parse_line(line_number, line)
+                        entries.append(entry)
+
+            # Create a simple object with entries attribute
+            class LogIndex:
+                pass
+
+            idx = LogIndex()
+            idx.entries = entries
+            indices[file_path] = idx
+
+        # Create and load SQL engine
+        engine = SqlEngine()
+        engine.load_files(indices)
+        return engine
+
     def build_hierarchy(
         self,
         root_identifier: str,
@@ -2156,7 +2197,11 @@ def cross_service_timeline(
 
     for service_name, service_files in files.items():
         if correlation_id:
-            result = follow_thread(service_files, correlation_id=correlation_id, trace_id=trace_id)
+            # WORKAROUND: Only pass correlation_id OR trace_id, not both, to avoid
+            # Rust-side deduplication bug that causes duplicate entries when multiple
+            # IDs match the same log entry. Prefer correlation_id when both are provided.
+            # TODO: Remove this workaround when Rust deduplication is fixed (Phase 2)
+            result = follow_thread(service_files, correlation_id=correlation_id)
             entries = result.get("entries", [])
         elif trace_id:
             result = follow_thread(service_files, trace_id=trace_id)