logler 1.0.7__cp311-cp311-win_amd64.whl

logler/__init__.py

@@ -0,0 +1,22 @@
+"""
+Logler - Beautiful local log viewer with thread tracking and real-time updates.
+"""
+
+__version__ = "1.0.7"
+__author__ = "Logler Contributors"
+
+from .parser import LogParser, LogEntry
+from .tracker import ThreadTracker
+from .log_reader import LogReader
+from .tree_formatter import format_tree, format_waterfall, print_tree, print_waterfall
+
+__all__ = [
+    "LogParser",
+    "LogEntry",
+    "ThreadTracker",
+    "LogReader",
+    "format_tree",
+    "format_waterfall",
+    "print_tree",
+    "print_waterfall",
+]

logler/bootstrap.py

@@ -0,0 +1,57 @@
+"""
+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.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+
+def ensure_rust_backend(auto_install: bool = True) -> bool:
+    """Ensure logler_rs is importable. Optionally auto-installs via maturin."""
+    try:
+        import logler_rs  # noqa: F401
+
+        return True
+    except Exception:
+        if not auto_install:
+            return False
+
+    maturin = _which("maturin")
+    if not maturin:
+        return False
+
+    repo_root = Path(__file__).resolve().parents[2]
+    cmd = [
+        maturin,
+        "develop",
+        "--release",
+        "-m",
+        str(repo_root / "crates" / "logler-py" / "Cargo.toml"),
+        "--features",
+        "sql",
+    ]
+    try:
+        subprocess.run(
+            cmd, cwd=repo_root, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+    except Exception:
+        return False
+
+    try:
+        import logler_rs  # noqa: F401
+
+        return True
+    except Exception:
+        return False
+
+
+def _which(cmd: str) -> Optional[str]:
+    from shutil import which
+
+    return which(cmd)

logler/cache.py

@@ -0,0 +1,75 @@
+"""
+Performance optimization: Add file-level index caching to standalone functions.
+
+Currently, standalone functions like search(), follow_thread() create a new
+Investigator and re-read files every time. This is inefficient for repeated
+queries on the same files.
+
+Solution: Add a module-level LRU cache that reuses Investigator instances.
+"""
+
+import threading
+from typing import Dict
+import logler_rs
+
+# Thread-safe cache for Investigator instances
+_investigator_lock = threading.Lock()
+_investigator_cache: Dict[tuple, logler_rs.PyInvestigator] = {}
+_cache_max_size = 10  # Keep up to 10 file sets in cache
+
+
+def _get_cached_investigator(files: tuple) -> logler_rs.PyInvestigator:
+    """
+    Get or create a cached Investigator for the given files.
+
+    This allows standalone functions to reuse parsed indices when
+    called multiple times with the same files.
+    """
+    with _investigator_lock:
+        # Check cache
+        if files in _investigator_cache:
+            return _investigator_cache[files]
+
+        # Create new investigator
+        inv = logler_rs.PyInvestigator()
+        inv.load_files(list(files))
+
+        # Add to cache (with simple size limit)
+        if len(_investigator_cache) >= _cache_max_size:
+            # Remove oldest entry (simple FIFO)
+            oldest = next(iter(_investigator_cache))
+            del _investigator_cache[oldest]
+
+        _investigator_cache[files] = inv
+        return inv
+
+
+def get_cached_investigator(files) -> logler_rs.PyInvestigator:
+    """
+    Public accessor that normalizes the incoming file list into a stable cache key.
+    """
+    key = tuple(sorted(str(f) for f in files))
+    return _get_cached_investigator(key)
+
+
+def clear_cache():
+    """Clear the investigator cache (useful for testing or freeing memory)"""
+    with _investigator_lock:
+        _investigator_cache.clear()
+
+
+# Example usage showing the difference:
+#
+# SLOW (current):
+#   for i in range(100):
+#       search(["app.log"], level="ERROR")  # Re-reads file 100 times!
+#
+# FAST (with cache):
+#   for i in range(100):
+#       search(["app.log"], level="ERROR")  # Reads once, caches index!
+#
+# FASTEST (explicit Investigator):
+#   inv = Investigator()
+#   inv.load_files(["app.log"])
+#   for i in range(100):
+#       inv.search(level="ERROR")  # Explicit control, no cache overhead