jnav 1.0.0__py3-none-any.whl

jnav/detail_tree.py

@@ -0,0 +1,242 @@
+import json
+import os
+import subprocess
+import tempfile
+from typing import TYPE_CHECKING, ClassVar, TypedDict
+
+from rich.text import Text
+from textual.binding import Binding, BindingType
+from textual.events import Key
+from textual.widgets import Tree
+from textual.widgets.tree import TreeNode
+
+from .filter_provider import FilterProvider
+from .filtering import get_nested, jq_value_literal, resolve_selected_paths
+from .key_sequences import KeySequence, KeySequenceMixin
+from .log_entry_item import format_timestamp
+from .parsing import ParsedEntry
+from .role_mapper import RoleMapper
+from .search_engine import SearchEngine
+from .selector_provider import SelectorProvider
+from .tree_rendering import TreeBuildVisitor, walk_tree
+
+
+class TreeNodeData(TypedDict):
+    path: str
+    value: object
+
+
+def _detail_add_branch(
+    parent: TreeNode[TreeNodeData],
+    label: Text,
+    path: str,
+    value: object,
+) -> TreeNode[TreeNodeData]:
+    return parent.add(label, data={"path": path, "value": value})
+
+
+def _detail_add_leaf(
+    parent: TreeNode[TreeNodeData],
+    label: Text,
+    path: str,
+    value: object,
+) -> None:
+    parent.add_leaf(label, data={"path": path, "value": value})
+
+
+if TYPE_CHECKING:
+    from textual import getters
+    from textual.app import App
+
+
+class DetailTree(KeySequenceMixin, Tree[TreeNodeData]):
+    COMPONENT_CLASSES: ClassVar[set[str]] = {
+        "tree--key",
+        "tree--key-selected",
+        "tree--value",
+        "tree--value-null",
+        "tree--json-string",
+        "tree--search-highlight",
+    }
+
+    DEFAULT_CSS = ""
+
+    if TYPE_CHECKING:
+        app = getters.app(App[None])
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("j", "cursor_down", show=False),
+        Binding("k", "cursor_up", show=False),
+        Binding("g", "scroll_home", show=False),
+        Binding("G", "scroll_end", show=False),
+        Binding("ctrl+d", "page_down", show=False),
+        Binding("ctrl+u", "page_up", show=False),
+        Binding("s", "add_select", "Select"),
+    ]
+
+    SEQUENCES: ClassVar[list[KeySequence]] = [
+        KeySequence("ff", "filter_value", "by value"),
+        KeySequence("fn", "filter_has", "has field"),
+        KeySequence("vo", "toggle_filter_tree", "show selected only"),
+        KeySequence("ve", "view_value", "open in editor"),
+    ]
+    SEQUENCE_GROUPS: ClassVar[dict[str, str]] = {"f": "filter ▸", "v": "view ▸"}
+
+    show_selected_only: bool = False
+    _entry: ParsedEntry | None = None
+    _entry_index: int = 0
+
+    def __init__(
+        self,
+        label: str,
+        *,
+        selectors: SelectorProvider,
+        filters: FilterProvider,
+        search: SearchEngine,
+        role_mapper: RoleMapper,
+        id: str | None = None,
+    ) -> None:
+        super().__init__(label, id=id)
+        self._selectors = selectors
+        self._filters = filters
+        self._search = search
+        self._role_mapper = role_mapper
+
+    def on_focus(self) -> None:
+        if self.parent is not None:
+            self.parent.add_class("focused")
+
+    def on_blur(self) -> None:
+        if self.parent is not None:
+            self.parent.remove_class("focused")
+
+    async def on_mount(self) -> None:  # pyright: ignore[reportIncompatibleMethodOverride, reportImplicitOverride]
+        await self._selectors.on_change.subscribe_async(self._rerender)
+        await self._search.on_change.subscribe_async(self._rerender)
+        await self._role_mapper.on_change.subscribe_async(self._rerender)
+        self.app.theme_changed_signal.subscribe(self, lambda _: self._rebuild_tree())
+
+    async def _rerender(self, _: None) -> None:
+        self._rebuild_tree()
+
+    @property
+    def entry(self) -> ParsedEntry | None:
+        return self._entry
+
+    def show_entry(self, parsed: ParsedEntry, index: int) -> None:
+        self._entry = parsed
+        self._entry_index = index
+        self._rebuild_tree()
+
+    def _rebuild_tree(self) -> None:
+        if self._entry is None:
+            return
+        entry = self._entry.expanded
+        selected = resolve_selected_paths(self._selectors.active_selectors, entry)
+
+        label = f"#{self._entry_index + 1}"
+        ts_field = self._role_mapper.mapping.timestamp
+        if ts_field is not None:
+            ts_val = entry.get(ts_field.path)
+            if ts_val not in (None, ""):
+                label += f" ({format_timestamp(ts_val, ts_field.format)})"
+        if self.show_selected_only:
+            label += " (selected)"
+
+        self.clear()
+        self.root.set_label(label)
+        data = (
+            {s: get_nested(entry, s) for s in self._selectors.active_selectors}
+            if self.show_selected_only
+            else entry
+        )
+        root_data: TreeNodeData = {"path": "", "value": data}
+        self.root.data = root_data
+        visitor = TreeBuildVisitor(
+            root=self.root,
+            add_branch=_detail_add_branch,
+            add_leaf=_detail_add_leaf,
+            selected=selected,
+            key_style=self.get_component_rich_style("tree--key", partial=True),
+            selected_style=self.get_component_rich_style(
+                "tree--key-selected", partial=True
+            ),
+            value_style=self.get_component_rich_style("tree--value", partial=True),
+            value_null_style=self.get_component_rich_style(
+                "tree--value-null", partial=True
+            ),
+            json_string_style=self.get_component_rich_style(
+                "tree--json-string", partial=True
+            ),
+            search_highlight_style=self.get_component_rich_style(
+                "tree--search-highlight", partial=True
+            ),
+            search_term=self._search.term,
+        )
+        walk_tree(
+            value=data, path="", visitor=visitor, json_paths=self._entry.expanded_paths
+        )
+        self.root.expand_all()
+
+    async def on_key(self, event: Key) -> None:
+        if await self._handle_sequence_key(event):
+            return
+
+    async def action_filter_value(self) -> None:
+        node = self.cursor_node
+        if node is None or node.data is None:
+            return
+        path = node.data["path"]
+        value = node.data["value"]
+        if isinstance(value, (dict, list)):
+            return
+        expr = f".{path} == {jq_value_literal(value)}"
+        await self._filters.add_filter(expr)
+
+    async def action_filter_has(self) -> None:
+        node = self.cursor_node
+        if node is None or node.data is None:
+            return
+        path = node.data["path"]
+        await self._filters.add_filter(f".{path} != null")
+
+    def action_toggle_filter_tree(self) -> None:
+        self.show_selected_only = not self.show_selected_only
+        self._rebuild_tree()
+
+    async def action_add_select(self) -> None:
+        node = self.cursor_node
+        if node is None or node.data is None:
+            return
+        selector = "." + node.data["path"]
+        if self._selectors.has_selector(selector):
+            await self._selectors.remove_selector_by_path(selector)
+        else:
+            await self._selectors.add_selector(selector)
+
+    def action_view_value(self) -> None:
+        node = self.cursor_node
+        if node is None or node.data is None:
+            return
+        value = node.data["value"]
+        if isinstance(value, (dict, list)):
+            content = json.dumps(value, indent=2, default=str)
+            suffix = ".json"
+        else:
+            content = str(value)
+            suffix = ".txt"
+        editor = os.environ.get("EDITOR", "less")
+        tmpdir = "/tmp/jnav"
+        os.makedirs(tmpdir, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=suffix,
+            prefix="jnav_",
+            dir=tmpdir,
+            delete=False,
+        ) as f:
+            f.write(content)
+            path = f.name
+        with self.app.suspend():
+            subprocess.run([editor, path], check=False)
+        os.unlink(path)

jnav/field_mapping.py

@@ -0,0 +1,136 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel
+
+TimestampFormat = Literal["iso8601", "epoch_s", "epoch_ms", "epoch_us", "epoch_ns"]
+
+
+class TimestampField(BaseModel):
+    path: str
+    format: TimestampFormat
+
+
+def _build_timestamp(path: str, value: object) -> TimestampField | None:
+    fmt = _detect_timestamp_format(value)
+    return TimestampField(path=path, format=fmt) if fmt is not None else None
+
+
+def _build_string_role(path: str, value: object) -> str | None:
+    return path if value not in (None, "") else None
+
+
+@dataclass(frozen=True)
+class RoleSpec:
+    name: str
+    candidates: list[str]
+    build: Callable[[str, object], object | None]
+
+
+ROLES: list[RoleSpec] = [
+    RoleSpec(
+        name="timestamp",
+        candidates=[
+            "@timestamp",
+            "timestamp",
+            "ts",
+            "time",
+            "@t",
+            "asctime",
+            "eventTime",
+            "Timestamp",
+        ],
+        build=_build_timestamp,
+    ),
+    RoleSpec(
+        name="level",
+        candidates=[
+            "level",
+            "severity",
+            "levelname",
+            "@l",
+            "log_level",
+            "loglevel",
+            "SeverityText",
+        ],
+        build=_build_string_role,
+    ),
+    RoleSpec(
+        name="message",
+        candidates=[
+            "message",
+            "msg",
+            "@m",
+            "event",
+            "Body",
+            "log",
+        ],
+        build=_build_string_role,
+    ),
+]
+
+
+class FieldMapping(BaseModel):
+    timestamp: TimestampField | None = None
+    level: str | None = None
+    message: str | None = None
+
+    def assignments(self) -> dict[str, object | None]:
+        return {
+            "timestamp": self.timestamp,
+            "level": self.level,
+            "message": self.message,
+        }
+
+    def missing_roles(self) -> list[str]:
+        return [name for name, value in self.assignments().items() if value is None]
+
+
+def detect_role_updates(
+    mapping: FieldMapping,
+    entry: dict[str, object],
+    new_fields: set[str],
+) -> dict[str, object]:
+    """Detect updates to the field mapping based on a new entry.
+    For each role, if it's not already set in the mapping, check the candidate fields.
+    If a candidate field is present in the new fields, attempt to build the role value.
+    If successful, add it to the updates dict.
+    """
+    updates: dict[str, object] = {}
+    current = mapping.assignments()
+    for role in ROLES:
+        if current[role.name] is not None:
+            continue
+        for candidate in role.candidates:
+            if candidate not in new_fields:
+                continue
+            built = role.build(candidate, entry.get(candidate))
+            if built is not None:
+                updates[role.name] = built
+                break
+    return updates
+
+
+def _detect_timestamp_format(value: object) -> TimestampFormat | None:
+    if isinstance(value, str) and value:
+        try:
+            _ = datetime.fromisoformat(value)
+            return "iso8601"
+        except ValueError:
+            return None
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return _epoch_format_from_magnitude(float(value))
+    return None
+
+
+def _epoch_format_from_magnitude(value: float) -> TimestampFormat:
+    magnitude = abs(value)
+    if magnitude < 1e11:
+        return "epoch_s"
+    if magnitude < 1e14:
+        return "epoch_ms"
+    if magnitude < 1e17:
+        return "epoch_us"
+    return "epoch_ns"

jnav/filter_manager_screen.py

@@ -0,0 +1,100 @@
+from typing import ClassVar, override
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from jnav.filter_provider import FilterProvider
+from jnav.filter_tree import FilterTree
+from jnav.filtering import build_expression
+from jnav.manager_screen_common import WrappingFooter
+
+
+class FilterManagerScreen(ModalScreen[bool]):
+    DEFAULT_CSS = """
+    FilterManagerScreen {
+        align: center middle;
+    }
+    #filter-modal {
+        width: 70;
+        max-width: 90%;
+        height: auto;
+        max-height: 70%;
+        border: round $primary;
+        background: $background;
+    }
+    #filter-wrapper {
+        padding: 1 2;
+        height: auto;
+    }
+    #filter-expression {
+        color: $accent;
+        background: transparent;
+        border: round $background-lighten-2;
+        margin: 1 0 0 0;
+        padding: 0 1;
+        height: auto;
+        max-height: 5;
+    }
+    #filter-expression.empty {
+        color: $text-muted;
+    }
+    #filter-hints {
+        color: $text-muted;
+        margin: 1 0 0 0;
+    }
+    #filter-modal Footer {
+        background: transparent;
+        layout: grid;
+        grid-size: 4;
+        height: auto;
+    }
+    #filter-modal FooterKey .footer-key--key {
+        color: $primary;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "maybe_close", "Close", priority=True),
+        Binding("q", "maybe_close", show=False),
+        Binding("ctrl+c", "maybe_close", show=False),
+    ]
+
+    def __init__(self, filter_provider: FilterProvider) -> None:
+        super().__init__()
+        self._fp = filter_provider
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Vertical(
+                FilterTree(self._fp, id="filter-tree"),
+                Static(id="filter-expression"),
+                id="filter-wrapper",
+            ),
+            WrappingFooter(columns=4),
+            id="filter-modal",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#filter-modal").border_title = "Filters"
+        self.query_one("#filter-tree", FilterTree).focus()
+        self._update_preview()
+
+    def on_filter_tree_changed(self) -> None:
+        self._update_preview()
+
+    def _update_preview(self) -> None:
+        expr_widget = self.query_one("#filter-expression", Static)
+        expr = build_expression(self._fp.root)
+        if expr:
+            expr_widget.update(f"{expr}")
+            expr_widget.remove_class("empty")
+        else:
+            expr_widget.update("(no active filters)")
+            expr_widget.add_class("empty")
+
+    def action_maybe_close(self) -> None:
+        self.dismiss(True)

jnav/filter_provider.py

@@ -0,0 +1,103 @@
+from typing import Any, Literal
+
+from aioreactive import AsyncSubject
+
+from jnav.filtering import Filter, FilterGroup, FilterNode, build_expression
+
+
+class FilterProvider:
+    on_change: AsyncSubject[None]
+
+    def __init__(self) -> None:
+        self._root = FilterGroup()
+        self.on_change = AsyncSubject[None]()
+
+    @property
+    def root(self) -> FilterGroup:
+        return self._root
+
+    async def add_filter(
+        self,
+        expr: str,
+        label: str | None = None,
+        combine: Literal["and", "or"] = "and",
+    ) -> None:
+        """Add a new filter leaf to the root group."""
+        existing = {
+            leaf.expr for leaf in self._root.children if isinstance(leaf, Filter)
+        }
+        if expr not in existing:
+            leaf = Filter(expr=expr, label=label)
+            if combine == "or":
+                self._root.children.append(
+                    FilterGroup(
+                        operator="or",
+                        children=[leaf],
+                    )
+                )
+            else:
+                self._root.children.append(leaf)
+            await self.on_change.asend(None)
+
+    async def toggle_node(self, node: FilterNode) -> None:
+        node.enabled = not node.enabled
+        await self.on_change.asend(None)
+
+    async def toggle_negated(self, node: FilterNode) -> None:
+        node.negated = not node.negated
+        await self.on_change.asend(None)
+
+    async def add_group(
+        self,
+        parent: FilterGroup,
+        index: int | None = None,
+    ) -> None:
+        op = "or" if parent.operator == "and" else "and"
+        group = FilterGroup(operator=op)
+        if index is not None:
+            parent.children.insert(index + 1, group)
+        else:
+            parent.children.append(group)
+        await self.on_change.asend(None)
+
+    async def remove_node(self, node: FilterNode, parent: FilterGroup) -> None:
+        parent.children.remove(node)
+        await self.on_change.asend(None)
+
+    async def set_node_operator(
+        self,
+        node: FilterNode,
+        parent: FilterGroup,
+    ) -> None:
+        if isinstance(node, FilterGroup):
+            node.operator = "or" if node.operator == "and" else "and"
+        else:
+            idx = parent.children.index(node)
+            parent.children[idx] = FilterGroup(operator="or", children=[node])
+        await self.on_change.asend(None)
+
+    async def flatten_group(self, group: FilterGroup, parent: FilterGroup) -> None:
+        """Replace a group with a single leaf containing its compiled expression."""
+        expr = build_expression(
+            FilterGroup(operator=group.operator, children=group.children)
+        )
+        if expr is None:
+            return
+        idx = parent.children.index(group)
+        parent.children[idx] = Filter(expr=expr)
+        await self.on_change.asend(None)
+
+    async def edit_leaf(self, leaf: Filter, expr: str) -> None:
+        leaf.expr = expr
+        await self.on_change.asend(None)
+
+    async def clear_filters(self) -> None:
+        self._root.children.clear()
+        await self.on_change.asend(None)
+
+    def dump_root(self) -> dict[str, Any]:
+        return self._root.model_dump()
+
+    async def load_root(self, data: dict[str, Any]) -> None:
+        self._root = FilterGroup.model_validate(data)
+        await self.on_change.asend(None)