loki-reader-core 0.2.0__tar.gz → 0.2.2__tar.gz

{loki_reader_core-0.2.0 → loki_reader_core-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loki-reader-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python library for querying Grafana Loki logs via REST API
 Project-URL: Homepage, https://github.com/jmazzahacks/loki-reader-core
 Project-URL: Issues, https://github.com/jmazzahacks/loki-reader-core/issues

{loki_reader_core-0.2.0 → loki_reader_core-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loki-reader-core"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
   { name="Jason Byteforge", email="jason@mzmail.me" },
 ]

{loki_reader_core-0.2.0 → loki_reader_core-0.2.2}/src/loki_reader_core/__init__.py

@@ -6,7 +6,7 @@ from .client import LokiClient
 from .exceptions import LokiAuthError, LokiConnectionError, LokiError, LokiQueryError
 from .models import LogEntry, LogStream, MetricSample, MetricSeries, QueryResult, QueryStats
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     "LokiClient",

{loki_reader_core-0.2.0 → loki_reader_core-0.2.2}/src/loki_reader_core/client.py

@@ -7,7 +7,7 @@ from typing import Optional
 import requests
 
 from .exceptions import LokiAuthError, LokiConnectionError, LokiQueryError
-from .models import QueryResult
+from .models import LogStream, QueryResult
 from .utils import now_ns, NANOSECONDS_PER_MINUTE, NANOSECONDS_PER_HOUR
 
 APP_LABEL_NAMES = ["application", "app", "job", "service", "service_name", "logger"]
@@ -106,6 +106,44 @@ def _resolve_since(
     return None
 
 
+def _merge_streams(result: QueryResult, app_label: str, app_value: str) -> QueryResult:
+    """Merge multiple log streams into a single stream sorted by timestamp.
+
+    Used for app-based queries where Loki returns separate streams per
+    logger/severity combination. Combines all entries into one flat
+    chronological list.
+
+    Args:
+        result: QueryResult with potentially multiple streams.
+        app_label: The label name used for the application (e.g. "application").
+        app_value: The application name (e.g. "materia-server").
+
+    Returns:
+        QueryResult with a single merged stream.
+    """
+    if len(result.streams) <= 1:
+        return result
+
+    all_entries = []
+    for stream in result.streams:
+        all_entries.extend(stream.entries)
+
+    all_entries.sort(key=lambda e: e.timestamp, reverse=True)
+
+    merged_stream = LogStream(
+        labels={app_label: app_value},
+        entries=all_entries,
+    )
+
+    return QueryResult(
+        status=result.status,
+        streams=[merged_stream],
+        stats=result.stats,
+        result_type=result.result_type,
+        metric_series=result.metric_series,
+    )
+
+
 class LokiClient:
     """
     Client for querying Grafana Loki logs.
@@ -231,6 +269,20 @@ class LokiClient:
 
         return data
 
+    def _discovery_time_range(self) -> tuple[int, int]:
+        """Get a 30-day time range for label discovery queries.
+
+        Without a time range, Loki's label API only returns labels for
+        recently active streams. Using a 30-day window ensures we find
+        apps that haven't logged in a while.
+
+        Returns:
+            Tuple of (start_ns, end_ns) covering the last 30 days.
+        """
+        end = now_ns()
+        start = end - (30 * 24 * NANOSECONDS_PER_HOUR)
+        return (start, end)
+
     def _find_app_label(self, app_value: str) -> str:
         """Discover which label name contains the given app value.
 
@@ -249,8 +301,9 @@ class LokiClient:
         if app_value in self._app_label_cache:
             return self._app_label_cache[app_value]
 
+        start, end = self._discovery_time_range()
         for label_name in APP_LABEL_NAMES:
-            values = self.get_label_values(label_name)
+            values = self.get_label_values(label_name, start=start, end=end)
             if app_value in values:
                 self._app_label_cache[app_value] = label_name
                 return label_name
@@ -272,8 +325,9 @@ class LokiClient:
         if self._severity_label_cache is not None:
             return self._severity_label_cache
 
+        start, end = self._discovery_time_range()
         for label_name in SEVERITY_LABEL_NAMES:
-            values = self.get_label_values(label_name)
+            values = self.get_label_values(label_name, start=start, end=end)
             if values:
                 self._severity_label_cache = label_name
                 return label_name
@@ -319,9 +373,10 @@ class LokiClient:
         if logql is None and app is None:
             raise ValueError("Must provide either 'logql' or 'app'")
 
+        app_label = None
         if app is not None:
-            label_name = self._find_app_label(app)
-            selector = f'{label_name}="{app}"'
+            app_label = self._find_app_label(app)
+            selector = f'{app_label}="{app}"'
             if severity is not None:
                 sev_label = self._find_severity_label()
                 if sev_label:
@@ -344,7 +399,7 @@ class LokiClient:
             start = end - (30 * 24 * NANOSECONDS_PER_HOUR)
             time_range = (start, end)
 
-        return self.query_range(
+        result = self.query_range(
             logql=logql,
             start=time_range[0],
             end=time_range[1],
@@ -352,6 +407,11 @@ class LokiClient:
             direction="backward",
         )
 
+        if app_label is not None:
+            result = _merge_streams(result, app_label, app)
+
+        return result
+
     def query_range(
         self,
         logql: str,

{loki_reader_core-0.2.0 → loki_reader_core-0.2.2}/tests/test_client.py

@@ -4,8 +4,10 @@ from unittest.mock import MagicMock, patch, call
 
 import pytest
 
-from loki_reader_core import LokiClient
-from loki_reader_core.client import _is_metric_query, _build_severity_regex, _resolve_since
+from loki_reader_core import LokiClient, LogEntry, LogStream, QueryResult
+from loki_reader_core.client import (
+    _is_metric_query, _build_severity_regex, _resolve_since, _merge_streams,
+)
 from loki_reader_core.exceptions import LokiAuthError, LokiConnectionError, LokiQueryError
 
 
@@ -451,12 +453,16 @@ class TestLabelDiscovery:
             mock_glv.return_value = ["myapp", "otherapp"]
             result = client._find_app_label("myapp")
             assert result == "application"
-            mock_glv.assert_called_once_with("application")
+            mock_glv.assert_called_once()
+            args = mock_glv.call_args
+            assert args.args[0] == "application"
+            assert "start" in args.kwargs
+            assert "end" in args.kwargs
 
     def test_find_app_label_job(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
         with patch.object(client, "get_label_values") as mock_glv:
-            def side_effect(label: str) -> list[str]:
+            def side_effect(label: str, start: int = None, end: int = None) -> list[str]:
                 if label == "job":
                     return ["myapp", "worker"]
                 return []
@@ -478,7 +484,11 @@ class TestLabelDiscovery:
             mock_glv.return_value = ["info", "error", "warn"]
             result = client._find_severity_label()
             assert result == "level"
-            mock_glv.assert_called_once_with("level")
+            mock_glv.assert_called_once()
+            args = mock_glv.call_args
+            assert args.args[0] == "level"
+            assert "start" in args.kwargs
+            assert "end" in args.kwargs
 
     def test_find_severity_label_none(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
@@ -496,7 +506,7 @@ class TestLabelDiscovery:
             client._find_app_label("myapp")
 
             # Only called once - second call uses cache
-            mock_glv.assert_called_once_with("application")
+            mock_glv.assert_called_once()
 
     def test_severity_label_cached(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
@@ -506,19 +516,116 @@ class TestLabelDiscovery:
             client._find_severity_label()
             client._find_severity_label()
 
-            mock_glv.assert_called_once_with("level")
+            mock_glv.assert_called_once()
+
+    def test_discovery_uses_30_day_range(self) -> None:
+        client = LokiClient(base_url="http://localhost:3100")
+        with patch.object(client, "get_label_values") as mock_glv:
+            mock_glv.return_value = ["myapp"]
+            client._find_app_label("myapp")
+
+            args = mock_glv.call_args
+            start = args.kwargs["start"]
+            end = args.kwargs["end"]
+            diff_days = (end - start) / (24 * 60 * 60 * 1_000_000_000)
+            assert diff_days == 30
+
+
+class TestMergeStreams:
+    """Test _merge_streams helper function."""
+
+    def test_single_stream_unchanged(self) -> None:
+        stream = LogStream(
+            labels={"application": "myapp", "logger": "root"},
+            entries=[LogEntry(timestamp=100, message="hello")],
+        )
+        result = QueryResult(status="success", streams=[stream], stats=None)
+
+        merged = _merge_streams(result, "application", "myapp")
+
+        assert len(merged.streams) == 1
+        assert merged.streams[0] is stream  # same object, not rebuilt
+
+    def test_empty_streams_unchanged(self) -> None:
+        result = QueryResult(status="success", streams=[], stats=None)
+        merged = _merge_streams(result, "application", "myapp")
+        assert len(merged.streams) == 0
+
+    def test_multiple_streams_merged(self) -> None:
+        stream1 = LogStream(
+            labels={"application": "myapp", "logger": "root", "severity": "info"},
+            entries=[
+                LogEntry(timestamp=300, message="root msg 1"),
+                LogEntry(timestamp=100, message="root msg 2"),
+            ],
+        )
+        stream2 = LogStream(
+            labels={"application": "myapp", "logger": "__main__", "severity": "info"},
+            entries=[
+                LogEntry(timestamp=200, message="main msg 1"),
+            ],
+        )
+        result = QueryResult(
+            status="success", streams=[stream1, stream2], stats=None,
+        )
+
+        merged = _merge_streams(result, "application", "myapp")
+
+        assert len(merged.streams) == 1
+        assert merged.streams[0].labels == {"application": "myapp"}
+        assert len(merged.streams[0].entries) == 3
+        # Sorted descending by timestamp
+        timestamps = [e.timestamp for e in merged.streams[0].entries]
+        assert timestamps == [300, 200, 100]
+
+    def test_merged_preserves_stats(self) -> None:
+        from loki_reader_core import QueryStats
+        stats = QueryStats(
+            exec_time_seconds=0.05, bytes_processed=1024,
+            lines_processed=10,
+        )
+        stream1 = LogStream(
+            labels={"app": "x", "logger": "a"},
+            entries=[LogEntry(timestamp=2, message="a")],
+        )
+        stream2 = LogStream(
+            labels={"app": "x", "logger": "b"},
+            entries=[LogEntry(timestamp=1, message="b")],
+        )
+        result = QueryResult(
+            status="success", streams=[stream1, stream2], stats=stats,
+        )
+
+        merged = _merge_streams(result, "app", "x")
+
+        assert merged.stats is stats
+        assert merged.status == "success"
 
 
 class TestLokiClientQueryRedesign:
     """Test redesigned query() method."""
 
+    def _make_multi_stream_result(self) -> QueryResult:
+        """Helper to create a QueryResult with multiple streams."""
+        stream1 = LogStream(
+            labels={"application": "myapp", "logger": "root", "severity": "info"},
+            entries=[LogEntry(timestamp=300, message="root log")],
+        )
+        stream2 = LogStream(
+            labels={"application": "myapp", "logger": "__main__", "severity": "info"},
+            entries=[LogEntry(timestamp=200, message="main log")],
+        )
+        return QueryResult(
+            status="success", streams=[stream1, stream2], stats=None,
+        )
+
     def test_query_app_only(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
         with patch.object(client, "_find_app_label", return_value="application"), \
              patch.object(client, "query_range") as mock_qr:
-            mock_qr.return_value = MagicMock()
+            mock_qr.return_value = self._make_multi_stream_result()
 
-            client.query(app="myapp")
+            result = client.query(app="myapp")
 
             mock_qr.assert_called_once()
             args = mock_qr.call_args
@@ -526,12 +633,35 @@ class TestLokiClientQueryRedesign:
             assert args.kwargs["limit"] == 100
             assert args.kwargs["direction"] == "backward"
 
+    def test_query_app_merges_streams(self) -> None:
+        client = LokiClient(base_url="http://localhost:3100")
+        with patch.object(client, "_find_app_label", return_value="application"), \
+             patch.object(client, "query_range") as mock_qr:
+            mock_qr.return_value = self._make_multi_stream_result()
+
+            result = client.query(app="myapp")
+
+            assert len(result.streams) == 1
+            assert result.streams[0].labels == {"application": "myapp"}
+            assert len(result.streams[0].entries) == 2
+            timestamps = [e.timestamp for e in result.streams[0].entries]
+            assert timestamps == [300, 200]
+
+    def test_query_logql_does_not_merge(self) -> None:
+        client = LokiClient(base_url="http://localhost:3100")
+        with patch.object(client, "query_range") as mock_qr:
+            mock_qr.return_value = self._make_multi_stream_result()
+
+            result = client.query(logql='{application="myapp"}')
+
+            assert len(result.streams) == 2
+
     def test_query_app_with_severity(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
         with patch.object(client, "_find_app_label", return_value="application"), \
              patch.object(client, "_find_severity_label", return_value="level"), \
              patch.object(client, "query_range") as mock_qr:
-            mock_qr.return_value = MagicMock()
+            mock_qr.return_value = self._make_multi_stream_result()
 
             client.query(app="myapp", severity="error")
 
@@ -542,7 +672,7 @@ class TestLokiClientQueryRedesign:
         client = LokiClient(base_url="http://localhost:3100")
         with patch.object(client, "_find_app_label", return_value="application"), \
              patch.object(client, "query_range") as mock_qr:
-            mock_qr.return_value = MagicMock()
+            mock_qr.return_value = self._make_multi_stream_result()
 
             client.query(app="myapp", since_minutes=10)
 
@@ -590,7 +720,7 @@ class TestLokiClientQueryRedesign:
         client = LokiClient(base_url="http://localhost:3100")
         with patch.object(client, "_find_app_label", return_value="job"), \
              patch.object(client, "query_range") as mock_qr:
-            mock_qr.return_value = MagicMock()
+            mock_qr.return_value = self._make_multi_stream_result()
 
             client.query(app="myapp")