logler 1.1.2__cp311-cp311-win_amd64.whl → 1.2.0__cp311-cp311-win_amd64.whl

logler/cli.py

@@ -135,13 +135,16 @@ def stats(files: tuple, output_json: bool):
 
 @main.command()
 @click.argument("files", nargs=-1, required=True, type=click.Path(exists=True))
-@click.option("--auto-insights", is_flag=True, help="Run automatic insights analysis")
+@click.option("--auto-insights", is_flag=True, hidden=True, help="[DEPRECATED] Removed")
 @click.option("--errors", is_flag=True, help="Show only errors with analysis")
-@click.option("--patterns", is_flag=True, help="Find repeated patterns")
+@click.option("--patterns", is_flag=True, hidden=True, help="[DEPRECATED] Removed")
 @click.option("--thread", type=str, help="Follow specific thread ID")
 @click.option("--correlation", type=str, help="Follow specific correlation ID")
+@click.option("--trace", type=str, help="Follow specific trace ID")
 @click.option(
-    "--hierarchy", is_flag=True, help="Show thread hierarchy tree (with --thread or --correlation)"
+    "--hierarchy",
+    is_flag=True,
+    help="Show thread hierarchy tree (with --thread, --correlation, or --trace)",
 )
 @click.option("--waterfall", is_flag=True, help="Show waterfall timeline (with --hierarchy)")
 @click.option("--flamegraph", is_flag=True, help="Show flamegraph visualization (with --hierarchy)")
@@ -175,6 +178,7 @@ def investigate(
     patterns: bool,
     thread: Optional[str],
     correlation: Optional[str],
+    trace: Optional[str],
     hierarchy: bool,
     waterfall: bool,
     flamegraph: bool,
@@ -187,24 +191,21 @@ def investigate(
     min_occurrences: int,
 ):
     """
-    Investigate log files with smart analysis and insights.
+    Investigate log files with analysis tools.
 
     Examples:
-        logler investigate app.log --auto-insights     # Auto-detect issues
         logler investigate app.log --errors            # Analyze errors
-        logler investigate app.log --patterns          # Find repeated patterns
         logler investigate app.log --thread worker-1   # Follow specific thread
         logler investigate app.log --correlation req-123  # Follow request
-        logler investigate app.log --thread req-123 --hierarchy   # Show hierarchy tree
-        logler investigate app.log --thread req-123 --hierarchy --waterfall  # Show waterfall timeline
-        logler investigate app.log --thread req-123 --hierarchy --flamegraph  # Show flamegraph
+        logler investigate app.log --trace trace-abc123  # Follow distributed trace
+        logler investigate app.log --correlation req-123 --hierarchy   # Show hierarchy tree
+        logler investigate app.log --correlation req-123 --hierarchy --waterfall  # Show waterfall timeline
+        logler investigate app.log --correlation req-123 --hierarchy --flamegraph  # Show flamegraph
         logler investigate app.log --hierarchy --show-error-flow  # Analyze error propagation
         logler investigate app.log --output summary    # Token-efficient output
     """
     from .investigate import (
-        analyze_with_insights,
         search,
-        find_patterns,
         follow_thread,
         follow_thread_hierarchy,
         get_hierarchy_summary,
@@ -213,101 +214,44 @@ def investigate(
     )
     from rich.console import Console
     from rich.table import Table
-    from rich.panel import Panel
 
     console = Console()
     file_list = list(files)
+    id_args = {"thread": thread, "correlation": correlation, "trace": trace}
+    provided_ids = [name for name, value in id_args.items() if value]
 
     try:
-        # Auto-insights mode (most powerful)
-        if auto_insights:
-            console.print("[bold cyan]🎯 Running automatic insights analysis...[/bold cyan]\n")
-            result = analyze_with_insights(files=file_list, auto_investigate=True)
-
-            if output_json:
-                console.print_json(data=result)
-                return
+        if len(provided_ids) > 1:
+            console.print("[red]❌ Provide only one of --thread, --correlation, or --trace.[/red]")
+            sys.exit(2)
 
-            # Display overview
-            overview = result["overview"]
+        # Deprecated: Auto-insights mode
+        if auto_insights:
             console.print(
-                Panel(
-                    f"[bold]Total Logs:[/bold] {overview['total_logs']}\n"
-                    f"[bold]Error Count:[/bold] {overview['error_count']}\n"
-                    f"[bold]Error Rate:[/bold] {overview['error_rate']:.1%}\n"
-                    f"[bold]Log Levels:[/bold] {overview['log_levels']}",
-                    title="📊 Overview",
-                    border_style="cyan",
-                )
+                "[yellow]WARNING: --auto-insights is deprecated and has been removed.[/yellow]"
             )
+            console.print(
+                "[dim]Use 'logler llm search --level ERROR' for error analysis instead.[/dim]"
+            )
+            sys.exit(0)
 
-            # Display insights
-            if result["insights"]:
-                console.print("\n[bold cyan]💡 Automatic Insights[/bold cyan]\n")
-                for i, insight in enumerate(result["insights"], 1):
-                    severity_color = {"high": "red", "medium": "yellow", "low": "green"}.get(
-                        insight["severity"], "white"
-                    )
-
-                    severity_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
-                        insight["severity"], "⚪"
-                    )
-
-                    console.print(
-                        f"{severity_icon} [bold {severity_color}]Insight #{i}:[/bold {severity_color}] {insight['type']}"
-                    )
-                    console.print(
-                        f"   [dim]Severity:[/dim] [{severity_color}]{insight['severity'].upper()}[/{severity_color}]"
-                    )
-                    console.print(f"   [dim]Description:[/dim] {insight['description']}")
-                    console.print(f"   [dim]Suggestion:[/dim] {insight['suggestion']}\n")
-
-            # Display suggestions
-            if result["suggestions"]:
-                console.print("[bold cyan]📝 Suggestions[/bold cyan]\n")
-                for i, suggestion in enumerate(result["suggestions"], 1):
-                    console.print(f"  {i}. {suggestion}")
-
-            # Display next steps
-            if result["next_steps"]:
-                console.print("\n[bold cyan]🚀 Next Steps[/bold cyan]\n")
-                for i, step in enumerate(result["next_steps"], 1):
-                    console.print(f"  {i}. {step}")
-
-        # Pattern detection mode
+        # Deprecated: Pattern detection mode
         elif patterns:
             console.print(
-                f"[bold cyan]🔍 Finding repeated patterns (min {min_occurrences} occurrences)...[/bold cyan]\n"
+                "[yellow]WARNING: --patterns is deprecated and has been removed.[/yellow]"
             )
-            result = find_patterns(files=file_list, min_occurrences=min_occurrences)
-
-            if output_json:
-                console.print_json(data=result)
-                return
-
-            pattern_list = result.get("patterns", [])
-            if pattern_list:
-                table = Table(title=f"Found {len(pattern_list)} Patterns")
-                table.add_column("Pattern", style="cyan", no_wrap=False)
-                table.add_column("Count", justify="right", style="green")
-                table.add_column("First Seen", style="yellow")
-                table.add_column("Last Seen", style="yellow")
-
-                for pattern in pattern_list[:20]:  # Show top 20
-                    pattern_text = pattern.get("pattern", "")[:80]
-                    count = pattern.get("occurrences", 0)
-                    first = pattern.get("first_seen", "N/A")
-                    last = pattern.get("last_seen", "N/A")
-                    table.add_row(pattern_text, str(count), first, last)
-
-                console.print(table)
-            else:
-                console.print("[yellow]No repeated patterns found.[/yellow]")
+            console.print(
+                "[dim]Pattern detection requires specialized tools like Drain3 or LogMine.[/dim]"
+            )
+            console.print(
+                "[dim]Use 'logler llm search' with SQL grouping for similar results.[/dim]"
+            )
+            sys.exit(0)
 
         # Thread/correlation following mode
-        elif thread or correlation:
-            identifier = thread or correlation
-            id_type = "thread" if thread else "correlation"
+        elif thread or correlation or trace:
+            identifier = thread or correlation or trace
+            id_type = "thread" if thread else "correlation" if correlation else "trace"
 
             # Hierarchy mode
             if hierarchy:
@@ -377,7 +321,7 @@ def investigate(
                 console.print(f"[bold cyan]🧵 Following {id_type}: {identifier}...[/bold cyan]\n")
 
                 result = follow_thread(
-                    files=file_list, thread_id=thread, correlation_id=correlation
+                    files=file_list, thread_id=thread, correlation_id=correlation, trace_id=trace
                 )
 
                 if output_json:

logler/helpers.py

@@ -46,21 +46,6 @@ def quick_summary(files: List[str]) -> Dict[str, Any]:
     }
 
 
-def find_top_errors(files: List[str], limit: int = 10) -> List[Dict[str, Any]]:
-    """
-    Find the most common error patterns.
-
-    Returns a list of error patterns sorted by frequency.
-
-    Example:
-        errors = find_top_errors(["app.log"], limit=5)
-        for err in errors:
-            print(f"{err['occurrences']}x: {err['pattern']}")
-    """
-    patterns = investigate.find_patterns(files, min_occurrences=2)
-    return sorted(patterns["patterns"], key=lambda x: x["occurrences"], reverse=True)[:limit]
-
-
 def search_errors(
     files: List[str], query: Optional[str] = None, limit: int = 100
 ) -> List[Dict[str, Any]]:
@@ -111,38 +96,6 @@ def trace_request(files: List[str], correlation_id: str) -> Dict[str, Any]:
     }
 
 
-def detect_spikes(files: List[str], window_minutes: int = 5) -> List[Dict[str, Any]]:
-    """
-    Detect error rate spikes.
-
-    Note: This requires the SQL feature to be enabled.
-
-    Returns list of time windows with abnormally high error rates.
-
-    Example:
-        spikes = detect_spikes(["app.log"], window_minutes=5)
-        for spike in spikes:
-            print(f"Spike at {spike['time']}: {spike['errors']} errors")
-    """
-    # This would require SQL queries to implement properly
-    # For now, use pattern detection as a simpler alternative
-    patterns = investigate.find_patterns(files, min_occurrences=3)
-
-    spikes = []
-    for pattern in patterns["patterns"]:
-        if pattern["occurrences"] >= 5:  # Threshold for "spike"
-            spikes.append(
-                {
-                    "pattern": pattern["pattern"],
-                    "occurrences": pattern["occurrences"],
-                    "first_seen": pattern["first_seen"],
-                    "last_seen": pattern["last_seen"],
-                }
-            )
-
-    return spikes
-
-
 def get_error_context(file: str, line_number: int, lines: int = 10) -> Dict[str, Any]:
     """
     Get context around an error line.
@@ -190,39 +143,6 @@ def analyze_thread_health(files: List[str]) -> Dict[str, Dict[str, int]]:
     }
 
 
-def find_cascading_failures(files: List[str]) -> List[Dict[str, Any]]:
-    """
-    Find patterns that suggest cascading failures.
-
-    Looks for:
-    - Multiple errors in quick succession
-    - Errors across multiple threads/services
-    - Increasing error rates over time
-
-    Example:
-        cascades = find_cascading_failures(["app.log"])
-        for cascade in cascades:
-            print(f"Cascade: {cascade['pattern']} across {len(cascade['threads'])} threads")
-    """
-    patterns = investigate.find_patterns(files, min_occurrences=3)
-
-    cascades = []
-    for pattern in patterns["patterns"]:
-        # Cascading failures typically affect multiple threads
-        if len(pattern["affected_threads"]) >= 3:
-            cascades.append(
-                {
-                    "pattern": pattern["pattern"],
-                    "occurrences": pattern["occurrences"],
-                    "threads": pattern["affected_threads"],
-                    "first_seen": pattern["first_seen"],
-                    "last_seen": pattern["last_seen"],
-                }
-            )
-
-    return cascades
-
-
 def get_timeline_summary(files: List[str], correlation_id: str) -> str:
     """
     Get a human-readable timeline summary for a request.
@@ -275,8 +195,3 @@ def trace(files: List[str], correlation_id: str) -> Dict[str, Any]:
 def summary(files: List[str]) -> Dict[str, Any]:
     """Shorthand for quick_summary()"""
     return quick_summary(files)
-
-
-def patterns(files: List[str], limit: int = 10) -> List[Dict[str, Any]]:
-    """Shorthand for find_top_errors()"""
-    return find_top_errors(files, limit)