devlogs 2.2.9__tar.gz → 2.3.0__tar.gz

{devlogs-2.2.9/src/devlogs.egg-info → devlogs-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlogs
-Version: 2.2.9
+Version: 2.3.0
 Summary: Developer-focused logging library for Python with OpenSearch integration.
 Author-email: Dan Driscoll <dan@thedandriscoll.org>
 License: MIT License

{devlogs-2.2.9 → devlogs-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devlogs"
-version = "2.2.9"
+version = "2.3.0"
 description = "Developer-focused logging library for Python with OpenSearch integration."
 requires-python = ">=3.11"
 readme = "README.md"

{devlogs-2.2.9 → devlogs-2.3.0}/src/devlogs/_version_static.py

@@ -1,2 +1,2 @@
 # AUTO-GENERATED at build time — do not edit or commit
-__version__ = "2.2.9"
+__version__ = "2.3.0"

devlogs-2.3.0/src/devlogs/collector/loki_plugin.py

@@ -0,0 +1,182 @@
+# Loki output plugin for the devlogs collector
+#
+# Activated by setting DEVLOGS_FORWARD_URL=loki://host:3100 (or lokis:// for TLS).
+# Converts validated DevlogsRecord objects into Loki stream push payloads.
+#
+# Label strategy (low-cardinality only):
+#   application, component, level, area, environment
+#
+# Everything else (message, operation_id, fields, etc.) is stored as a JSON
+# log line and accessible via Loki's | json pipeline.
+
+import json
+import time
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+from urllib.parse import urlparse
+
+from .errors import PluginError
+from .plugins import OutputPlugin, register_plugin
+from .schema import DevlogsRecord
+
+# Labels promoted to Loki stream labels (kept low-cardinality)
+_LOKI_LABEL_FIELDS = ("application", "component", "level", "area", "environment")
+
+
+def _record_to_ns(record: DevlogsRecord) -> int:
+    """Convert record timestamp to Unix nanoseconds for Loki."""
+    ts_str = record.timestamp or record.collected_ts
+    if not ts_str:
+        return int(time.time() * 1e9)
+    try:
+        # fromisoformat() doesn't accept 'Z' suffix in Python < 3.11
+        ts_clean = ts_str
+        if ts_clean.endswith("Z"):
+            ts_clean = ts_clean[:-1] + "+00:00"
+        dt = datetime.fromisoformat(ts_clean)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp() * 1e9)
+    except Exception:
+        return int(time.time() * 1e9)
+
+
+def _build_log_line(record: DevlogsRecord) -> str:
+    """Serialize the log record as a JSON log line for Loki storage."""
+    payload: Dict[str, Any] = {}
+    if record.message is not None:
+        payload["message"] = record.message
+    if record.operation_id is not None:
+        payload["operation_id"] = record.operation_id
+    payload["timestamp"] = record.timestamp
+    if record.collected_ts is not None:
+        payload["collected_ts"] = record.collected_ts
+    if record.version is not None:
+        payload["version"] = record.version
+    if record.fields:
+        payload["fields"] = record.fields
+    return json.dumps(payload, ensure_ascii=False)
+
+
+def _stream_key(record: DevlogsRecord) -> tuple:
+    """Return a hashable key representing this record's Loki stream labels."""
+    labels = []
+    if record.application:
+        labels.append(("application", record.application))
+    if record.component:
+        labels.append(("component", record.component))
+    if record.level:
+        labels.append(("level", record.level.lower()))
+    if record.area:
+        labels.append(("area", record.area))
+    if record.environment:
+        labels.append(("environment", record.environment))
+    return tuple(labels)
+
+
+class LokiOutputPlugin(OutputPlugin):
+    """Pushes log records to Grafana Loki via the HTTP push API.
+
+    URL schemes:
+        loki://host:port   — plain HTTP
+        lokis://host:port  — HTTPS
+    """
+
+    name = "loki"
+    schemes = ["loki", "lokis"]
+
+    def __init__(self, url: str, cfg: Any):
+        parsed = urlparse(url)
+        scheme = "https" if parsed.scheme == "lokis" else "http"
+        host = parsed.hostname or "localhost"
+        port = parsed.port or 3100
+        base = f"{scheme}://{host}:{port}"
+        self._push_url = f"{base}/loki/api/v1/push"
+        self._ready_url = f"{base}/ready"
+        self._display_url = url  # original url for display_info
+
+    def send(self, records: List[DevlogsRecord]) -> Dict[str, Any]:
+        """Push records to Loki, grouped into streams by label combination."""
+        streams: Dict[tuple, list] = {}
+        for record in records:
+            key = _stream_key(record)
+            if key not in streams:
+                streams[key] = []
+            ns = _record_to_ns(record)
+            line = _build_log_line(record)
+            streams[key].append([str(ns), line])
+
+        payload = {
+            "streams": [
+                {"stream": dict(key), "values": values}
+                for key, values in streams.items()
+            ]
+        }
+
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            self._push_url,
+            data=body,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        for attempt in range(3):
+            try:
+                with urllib.request.urlopen(req, timeout=10) as resp:
+                    # Loki returns 204 No Content on success
+                    if resp.status in (200, 204):
+                        return {"ingested": len(records)}
+                    raise PluginError(
+                        "UNEXPECTED_STATUS",
+                        f"Loki push returned unexpected status {resp.status}",
+                    )
+            except urllib.error.HTTPError as e:
+                if e.code in (429, 500, 502, 503, 504) and attempt < 2:
+                    time.sleep(0.5 * (2 ** attempt))
+                    continue
+                try:
+                    detail = e.read().decode("utf-8", errors="replace")[:300]
+                except Exception:
+                    detail = ""
+                raise PluginError(
+                    "HTTP_ERROR",
+                    f"Loki push failed with HTTP {e.code}: {detail}",
+                )
+            except urllib.error.URLError as e:
+                if attempt < 2:
+                    time.sleep(0.5 * (2 ** attempt))
+                    continue
+                raise PluginError(
+                    "SEND_FAILED",
+                    f"Failed to connect to Loki: {e.reason}",
+                )
+            except PluginError:
+                raise
+            except Exception as e:
+                if attempt < 2:
+                    time.sleep(0.5 * (2 ** attempt))
+                    continue
+                raise PluginError("SEND_FAILED", f"Loki send failed: {e}")
+
+        raise PluginError("SEND_FAILED", "Failed to push to Loki after retries")
+
+    def check(self) -> str:
+        """Verify Loki is reachable via its /ready endpoint."""
+        try:
+            req = urllib.request.Request(self._ready_url, method="GET")
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                if resp.status == 200:
+                    return f"Loki: OK ({self._push_url})"
+                return f"Loki: /ready returned {resp.status}"
+        except Exception as e:
+            raise Exception(f"Loki not reachable at {self._ready_url}: {e}")
+
+    def display_info(self) -> str:
+        return f"Loki: {self._display_url}"
+
+
+# Self-register when this module is imported
+register_plugin(LokiOutputPlugin)

{devlogs-2.2.9 → devlogs-2.3.0}/src/devlogs/collector/server.py

@@ -44,6 +44,13 @@ from .ingestor import ingest_records
 from .plugins import get_plugin_for_url
 from ..version import __version__
 
+# Register built-in output plugins by importing them (side-effect: register_plugin is called)
+try:
+    from . import loki_plugin as _loki_plugin  # noqa: F401
+except ImportError:
+    pass
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Emit a startup trace to the index so operators can see when the collector started."""

devlogs-2.3.0/src/devlogs/loki/__init__.py

@@ -0,0 +1 @@
+# Loki query module for devlogs

devlogs-2.3.0/src/devlogs/loki/queries.py

@@ -0,0 +1,332 @@
+# LogQL query module for devlogs
+#
+# Provides search, tail, and aggregation operations against a Grafana Loki
+# instance via its HTTP API.
+#
+# Label strategy mirrors the collector's Loki plugin:
+#   Indexed labels: application, component, level, area, environment
+#   Log line payload: message, operation_id, timestamp, fields, version
+
+import json
+import re
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import datetime, timedelta, timezone
+from typing import Any, Callable, Dict, List, Optional
+
+# ---------------------------------------------------------------------------
+# Input validation
+# ---------------------------------------------------------------------------
+
+_LABEL_NAME_RE = re.compile(r'^[a-z_][a-z0-9_]*$')
+_DURATION_RE = re.compile(r'^[0-9]+(ms|s|m|h|d|w)$')
+
+
+def _validate_label_name(name: str) -> str:
+    """Ensure a label name contains only safe characters."""
+    if not _LABEL_NAME_RE.match(name):
+        raise ValueError(f"Invalid label name for group_by: {name!r}")
+    return name
+
+
+def _validate_duration(interval: str) -> str:
+    """Ensure a duration string matches the Loki duration format."""
+    if not _DURATION_RE.match(interval):
+        raise ValueError(
+            f"Invalid interval {interval!r}. Must match [0-9]+(ms|s|m|h|d|w), e.g. '5m', '1h'."
+        )
+    return interval
+
+
+# ---------------------------------------------------------------------------
+# LogQL builder helpers
+# ---------------------------------------------------------------------------
+
+def build_stream_selector(labels: Dict[str, str]) -> str:
+    """Build a Loki stream selector from a label dict.
+
+    Returns e.g. {application="my-app", level="error"}
+    Returns {} when labels is empty (matches all streams).
+    """
+    if not labels:
+        return "{}"
+    parts = ", ".join(
+        f'{k}="{_escape_label_value(v)}"'
+        for k, v in sorted(labels.items())
+    )
+    return "{" + parts + "}"
+
+
+def build_log_pipeline(filter_text: Optional[str], use_json: bool = True) -> str:
+    """Build a Loki log pipeline expression.
+
+    Returns e.g. | json | message =~ "timeout"
+    """
+    parts = []
+    if use_json:
+        parts.append("| json")
+    if filter_text:
+        escaped = filter_text.replace("\\", "\\\\").replace('"', '\\"')
+        parts.append(f'|= "{escaped}"')
+    return " ".join(parts)
+
+
+def _escape_label_value(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+# ---------------------------------------------------------------------------
+# Timestamp helpers
+# ---------------------------------------------------------------------------
+
+def _to_ns(dt: datetime) -> int:
+    """Convert datetime to Unix nanoseconds (Loki's time format)."""
+    return int(dt.timestamp() * 1e9)
+
+
+def _parse_time_param(value: Optional[str]) -> Optional[datetime]:
+    """Parse an ISO timestamp or relative duration string to a datetime.
+
+    Accepts:
+    - ISO 8601: "2024-01-15T10:30:00Z"
+    - Relative: "1h", "30m", "7d"
+    - None → returns None
+    """
+    if not value:
+        return None
+    from ..time_utils import resolve_relative_time
+    resolved = resolve_relative_time(value)
+    if resolved is None:
+        return None
+    try:
+        ts = resolved.rstrip("Z")
+        return datetime.fromisoformat(ts).replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# HTTP helpers
+# ---------------------------------------------------------------------------
+
+def _loki_get(loki_url: str, path: str, params: Dict[str, str]) -> Dict[str, Any]:
+    """Execute a GET request against the Loki HTTP API."""
+    base = loki_url.rstrip("/")
+    qs = urllib.parse.urlencode(params)
+    url = f"{base}{path}?{qs}"
+    req = urllib.request.Request(url, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        detail = ""
+        try:
+            detail = e.read().decode("utf-8", errors="replace")[:300]
+        except Exception:
+            pass
+        raise RuntimeError(f"Loki HTTP {e.code}: {detail}")
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"Loki connection failed: {e.reason}")
+    except Exception as e:
+        raise RuntimeError(f"Loki request failed: {e}")
+
+
+# ---------------------------------------------------------------------------
+# Response parsing
+# ---------------------------------------------------------------------------
+
+def _parse_log_streams(data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Parse a Loki query_range (streams) response into a list of log dicts."""
+    results = []
+    for stream in data.get("data", {}).get("result", []):
+        stream_labels = stream.get("stream", {})
+        for ts_ns, line in stream.get("values", []):
+            try:
+                log_data: Dict[str, Any] = json.loads(line)
+            except json.JSONDecodeError:
+                log_data = {"message": line}
+            # Merge stream labels into the record (labels take precedence)
+            log_data.update(stream_labels)
+            # Add the Loki timestamp (nanoseconds) as a convenience field
+            log_data["_loki_ts_ns"] = ts_ns
+            results.append(log_data)
+    return results
+
+
+def _parse_metric_matrix(data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Parse a Loki metric query_range (matrix) response."""
+    results = []
+    for series in data.get("data", {}).get("result", []):
+        labels = series.get("metric", {})
+        for ts, value in series.get("values", []):
+            entry: Dict[str, Any] = {
+                "timestamp": datetime.fromtimestamp(float(ts), tz=timezone.utc)
+                .strftime("%Y-%m-%dT%H:%M:%S.000Z"),
+                "value": float(value),
+            }
+            entry.update(labels)
+            results.append(entry)
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Public query API
+# ---------------------------------------------------------------------------
+
+def search(
+    loki_url: str,
+    app: str,
+    level: Optional[str] = None,
+    component: Optional[str] = None,
+    area: Optional[str] = None,
+    environment: Optional[str] = None,
+    start: Optional[str] = None,
+    end: Optional[str] = None,
+    limit: int = 100,
+    filter_text: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """Search log entries in a time range.
+
+    Maps to GET /loki/api/v1/query_range with direction=backward.
+
+    Args:
+        loki_url: Base URL of the Loki instance (e.g. "http://loki:3100")
+        app: Application label to filter by
+        level: Log level label filter (e.g. "error")
+        component: Component label filter
+        area: Area label filter
+        environment: Environment label filter
+        start: ISO timestamp or relative duration string (e.g. "1h") for range start
+        end: ISO timestamp or relative duration for range end
+        limit: Maximum number of entries to return
+        filter_text: Optional text to match against the message field
+
+    Returns:
+        List of log record dicts (stream labels merged with JSON payload)
+    """
+    now = datetime.now(timezone.utc)
+    start_dt = _parse_time_param(start) or (now - timedelta(hours=1))
+    end_dt = _parse_time_param(end) or now
+
+    labels: Dict[str, str] = {"application": app}
+    if level:
+        labels["level"] = level.lower()
+    if component:
+        labels["component"] = component
+    if area:
+        labels["area"] = area
+    if environment:
+        labels["environment"] = environment
+
+    selector = build_stream_selector(labels)
+    pipeline = build_log_pipeline(filter_text)
+    query = f"{selector} {pipeline}".strip()
+
+    data = _loki_get(loki_url, "/loki/api/v1/query_range", {
+        "query": query,
+        "start": str(_to_ns(start_dt)),
+        "end": str(_to_ns(end_dt)),
+        "limit": str(limit),
+        "direction": "backward",
+    })
+
+    entries = _parse_log_streams(data)
+    # Sort by Loki timestamp descending (most recent first)
+    entries.sort(key=lambda e: e.get("_loki_ts_ns", "0"), reverse=True)
+    return entries
+
+
+def tail(
+    loki_url: str,
+    app: str,
+    level: Optional[str] = None,
+    component: Optional[str] = None,
+    since: Optional[str] = None,
+    limit: int = 50,
+) -> List[Dict[str, Any]]:
+    """Get the most recent log entries (non-streaming snapshot).
+
+    Uses query_range with a short lookback window. For real-time streaming
+    use the WebSocket endpoint /loki/api/v1/tail directly.
+
+    Args:
+        loki_url: Base URL of the Loki instance
+        app: Application label to filter by
+        level: Optional level label filter
+        component: Optional component label filter
+        since: Lookback window as relative string (default "10m")
+        limit: Maximum number of entries to return
+    """
+    now = datetime.now(timezone.utc)
+    start_dt = _parse_time_param(since or "10m") or (now - timedelta(minutes=10))
+
+    labels: Dict[str, str] = {"application": app}
+    if level:
+        labels["level"] = level.lower()
+    if component:
+        labels["component"] = component
+
+    selector = build_stream_selector(labels)
+    query = f"{selector} | json"
+
+    data = _loki_get(loki_url, "/loki/api/v1/query_range", {
+        "query": query,
+        "start": str(_to_ns(start_dt)),
+        "end": str(_to_ns(now)),
+        "limit": str(limit),
+        "direction": "backward",
+    })
+
+    entries = _parse_log_streams(data)
+    entries.sort(key=lambda e: e.get("_loki_ts_ns", "0"), reverse=True)
+    return entries
+
+
+def count_over_time(
+    loki_url: str,
+    app: str,
+    interval: str = "5m",
+    group_by: Optional[List[str]] = None,
+    start: Optional[str] = None,
+    end: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """Aggregate log counts over a time interval.
+
+    Maps to GET /loki/api/v1/query_range with a metric query.
+
+    LogQL example:
+        sum by (level) (count_over_time({application="my-app"}[5m]))
+
+    Args:
+        loki_url: Base URL of the Loki instance
+        app: Application label to filter by
+        interval: Duration window for count_over_time (e.g. "1m", "5m", "1h")
+        group_by: Labels to group by (e.g. ["level", "component"])
+        start: Range start as ISO timestamp or relative string
+        end: Range end as ISO timestamp or relative string
+    """
+    now = datetime.now(timezone.utc)
+    start_dt = _parse_time_param(start) or (now - timedelta(hours=1))
+    end_dt = _parse_time_param(end) or now
+
+    _validate_duration(interval)
+
+    selector = build_stream_selector({"application": app})
+    inner = f"count_over_time({selector}[{interval}])"
+
+    if group_by:
+        validated_labels = [_validate_label_name(lbl) for lbl in group_by]
+        by_clause = ", ".join(validated_labels)
+        query = f"sum by ({by_clause}) ({inner})"
+    else:
+        query = f"sum({inner})"
+
+    data = _loki_get(loki_url, "/loki/api/v1/query_range", {
+        "query": query,
+        "start": str(_to_ns(start_dt)),
+        "end": str(_to_ns(end_dt)),
+        "step": interval,
+    })
+
+    return _parse_metric_matrix(data)

{devlogs-2.2.9 → devlogs-2.3.0}/src/devlogs/mcp/server.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import json
+import os
 from typing import Any
 
 import mcp.server.stdio
@@ -113,6 +114,101 @@ def _error_response(message: str, error_type: str = "Error") -> list[types.TextC
     return _json_response(error={"type": error_type, "message": message})
 
 
+def _get_loki_url() -> str | None:
+    """Return LOKI_URL from environment, or None if not set."""
+    return os.environ.get("LOKI_URL") or None
+
+
+def _handle_loki_search(arguments: dict) -> list[types.TextContent]:
+    """Handle search_logs when LOKI_URL is configured."""
+    from ..loki.queries import search as loki_search
+
+    loki_url = _get_loki_url()
+    app = arguments.get("application") or load_config().application
+    if not app:
+        return _error_response(
+            "application is required for Loki backend (set via argument or DEVLOGS_URL)",
+            "ValidationError",
+        )
+
+    try:
+        entries = loki_search(
+            loki_url=loki_url,
+            app=app,
+            level=arguments.get("level"),
+            component=arguments.get("component"),
+            area=arguments.get("area"),
+            start=arguments.get("since"),
+            end=arguments.get("until"),
+            limit=_coerce_limit(arguments.get("limit"), 50, 100),
+            filter_text=arguments.get("query"),
+        )
+        return _json_response(
+            data={"entries": entries},
+            meta={"count": len(entries)},
+        )
+    except Exception as e:
+        return _error_response(f"Loki search error: {e}", "SearchError")
+
+
+def _handle_loki_tail(arguments: dict) -> list[types.TextContent]:
+    """Handle tail_logs when LOKI_URL is configured."""
+    from ..loki.queries import tail as loki_tail
+
+    loki_url = _get_loki_url()
+    app = arguments.get("application") or load_config().application
+    if not app:
+        return _error_response(
+            "application is required for Loki backend (set via argument or DEVLOGS_URL)",
+            "ValidationError",
+        )
+
+    try:
+        entries = loki_tail(
+            loki_url=loki_url,
+            app=app,
+            level=arguments.get("level"),
+            component=arguments.get("component"),
+            since=arguments.get("since", "10m"),
+            limit=_coerce_limit(arguments.get("limit"), 20, 100),
+        )
+        return _json_response(
+            data={"entries": entries},
+            meta={"count": len(entries)},
+        )
+    except Exception as e:
+        return _error_response(f"Loki tail error: {e}", "TailError")
+
+
+def _handle_loki_get_log_stats(arguments: dict) -> list[types.TextContent]:
+    """Handle get_log_stats using Loki count_over_time."""
+    from ..loki.queries import count_over_time as loki_count_over_time
+
+    loki_url = _get_loki_url()
+    app = arguments.get("application") or load_config().application
+    if not app:
+        return _error_response(
+            "application is required for Loki backend (set via argument or DEVLOGS_URL)",
+            "ValidationError",
+        )
+
+    try:
+        stats = loki_count_over_time(
+            loki_url=loki_url,
+            app=app,
+            interval=arguments.get("interval", "5m"),
+            group_by=arguments.get("group_by"),
+            start=arguments.get("since"),
+            end=arguments.get("until"),
+        )
+        return _json_response(
+            data={"stats": stats},
+            meta={"count": len(stats)},
+        )
+    except Exception as e:
+        return _error_response(f"Loki stats error: {e}", "StatsError")
+
+
 def _handle_emit_log(arguments: dict) -> list[types.TextContent]:
     """Handle the emit_log tool call."""
     from ..devlogs_client import DevlogsClient
@@ -568,6 +664,37 @@ async def main():
                     "required": ["anchor_timestamp"],
                 },
             ),
+            types.Tool(
+                name="get_log_stats",
+                description="Get log counts aggregated over a time interval. Requires Loki backend (LOKI_URL).",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "application": {
+                            "type": "string",
+                            "description": "Application name to aggregate stats for",
+                        },
+                        "interval": {
+                            "type": "string",
+                            "description": "Aggregation interval (e.g. '1m', '5m', '1h')",
+                            "default": "5m",
+                        },
+                        "group_by": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "Labels to group by (e.g. ['level', 'component'])",
+                        },
+                        "since": {
+                            "type": "string",
+                            "description": "Range start as ISO timestamp or relative duration like '1h'",
+                        },
+                        "until": {
+                            "type": "string",
+                            "description": "Range end as ISO timestamp or relative duration",
+                        },
+                    },
+                },
+            ),
             types.Tool(
                 name="emit_log",
                 description="Emit a log entry to the configured devlogs backend (collector, OpenSearch, or plugin).",
@@ -599,6 +726,21 @@ async def main():
         if name == "emit_log":
             return _handle_emit_log(arguments)
 
+        # get_log_stats is a Loki-only tool
+        if name == "get_log_stats":
+            if not _get_loki_url():
+                return _error_response(
+                    "get_log_stats requires LOKI_URL to be set", "ConfigurationError"
+                )
+            return _handle_loki_get_log_stats(arguments)
+
+        # Route search_logs and tail_logs to Loki when LOKI_URL is configured
+        if _get_loki_url():
+            if name == "search_logs":
+                return _handle_loki_search(arguments)
+            if name == "tail_logs":
+                return _handle_loki_tail(arguments)
+
         try:
             client, index, config_application = _create_client_and_index()
         except RuntimeError as e:

{devlogs-2.2.9 → devlogs-2.3.0/src/devlogs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlogs
-Version: 2.2.9
+Version: 2.3.0
 Summary: Developer-focused logging library for Python with OpenSearch integration.
 Author-email: Dan Driscoll <dan@thedandriscoll.org>
 License: MIT License

{devlogs-2.2.9 → devlogs-2.3.0}/src/devlogs.egg-info/SOURCES.txt

@@ -31,12 +31,15 @@ src/devlogs/collector/cli.py
 src/devlogs/collector/errors.py
 src/devlogs/collector/forwarder.py
 src/devlogs/collector/ingestor.py
+src/devlogs/collector/loki_plugin.py
 src/devlogs/collector/plugins.py
 src/devlogs/collector/schema.py
 src/devlogs/collector/server.py
 src/devlogs/jenkins/__init__.py
 src/devlogs/jenkins/cli.py
 src/devlogs/jenkins/core.py
+src/devlogs/loki/__init__.py
+src/devlogs/loki/queries.py
 src/devlogs/mcp/__init__.py
 src/devlogs/mcp/server.py
 src/devlogs/opensearch/__init__.py

{devlogs-2.2.9 → devlogs-2.3.0}/tests/test_build_info.py

@@ -91,7 +91,8 @@ class TestEnvBuildIdPrecedence:
 class TestEnvBranchAndTimestamp:
     """Test env provides branch and timestamp (build_id computed)."""
 
-    def test_env_branch_generates_build_id(self, monkeypatch):
+    def test_env_branch_generates_build_id(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.setenv("DEVLOGS_BRANCH", "feature/my-feature")
 
@@ -102,7 +103,8 @@ class TestEnvBranchAndTimestamp:
         assert result.timestamp_utc == FIXED_TIMESTAMP
         assert result.source == "env"
 
-    def test_env_timestamp_used(self, monkeypatch):
+    def test_env_timestamp_used(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.setenv("DEVLOGS_BRANCH", "main")
         monkeypatch.setenv("DEVLOGS_BUILD_TIMESTAMP_UTC", "20250101T120000Z")
@@ -333,7 +335,8 @@ class TestWriteIfMissing:
 class TestAllowGitFalse:
     """Test that allow_git=False never calls git."""
 
-    def test_no_subprocess_called_when_allow_git_false(self, monkeypatch):
+    def test_no_subprocess_called_when_allow_git_false(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -357,7 +360,8 @@ class TestAllowGitFalse:
 class TestAllowGitTrue:
     """Test allow_git=True behavior with various git scenarios."""
 
-    def test_git_success_gets_branch(self, monkeypatch):
+    def test_git_success_gets_branch(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -371,7 +375,8 @@ class TestAllowGitTrue:
         assert result.branch == "feature/test-branch"
         assert result.build_id == f"feature/test-branch-{FIXED_TIMESTAMP}"
 
-    def test_git_command_not_found(self, monkeypatch):
+    def test_git_command_not_found(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -381,7 +386,8 @@ class TestAllowGitTrue:
         assert result.branch is None
         assert result.build_id == f"unknown-{FIXED_TIMESTAMP}"
 
-    def test_git_nonzero_exit(self, monkeypatch):
+    def test_git_nonzero_exit(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -395,7 +401,8 @@ class TestAllowGitTrue:
         assert result.branch is None
         assert result.build_id == f"unknown-{FIXED_TIMESTAMP}"
 
-    def test_git_timeout(self, monkeypatch):
+    def test_git_timeout(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -405,7 +412,8 @@ class TestAllowGitTrue:
         assert result.branch is None
         assert result.build_id == f"unknown-{FIXED_TIMESTAMP}"
 
-    def test_git_returns_HEAD_detached(self, monkeypatch):
+    def test_git_returns_HEAD_detached(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -434,7 +442,8 @@ class TestDeterministicBuildId:
         assert result1.build_id == result2.build_id
         assert result1.timestamp_utc == result2.timestamp_utc
 
-    def test_different_now_fn_gives_different_result(self, monkeypatch):
+    def test_different_now_fn_gives_different_result(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)
 
@@ -533,7 +542,8 @@ class TestSearchUpBehavior:
 class TestResolveBuildId:
     """Test the resolve_build_id convenience function."""
 
-    def test_returns_string_only(self, monkeypatch):
+    def test_returns_string_only(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
         monkeypatch.delenv("DEVLOGS_BUILD_ID", raising=False)
         monkeypatch.delenv("DEVLOGS_BRANCH", raising=False)