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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loki-reader-core
-Version: 0.2.2
+Version: 0.2.4
 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.2 → loki_reader_core-0.2.4}/pyproject.toml

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

{loki_reader_core-0.2.2 → loki_reader_core-0.2.4}/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.2"
+__version__ = "0.2.4"
 
 __all__ = [
     "LokiClient",

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

@@ -187,7 +187,7 @@ class LokiClient:
 
         self._session: Optional[requests.Session] = None
         self._app_label_cache: dict[str, str] = {}
-        self._severity_label_cache: Optional[str] = None
+        self._severity_label_cache: dict[str, Optional[str]] = {}
 
     @property
     def session(self) -> requests.Session:
@@ -301,9 +301,8 @@ 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, start=start, end=end)
+            values = self.get_label_values(label_name)
             if app_value in values:
                 self._app_label_cache[app_value] = label_name
                 return label_name
@@ -313,25 +312,32 @@ class LokiClient:
             f"({', '.join(APP_LABEL_NAMES)}). Use logql param for custom labels."
         )
 
-    def _find_severity_label(self) -> Optional[str]:
-        """Discover which label name is used for severity/level.
+    def _find_severity_label(self, app_label: str, app_value: str) -> Optional[str]:
+        """Discover which severity label name is used by a specific app.
 
-        Checks a prioritized list of common severity label names and
-        returns the first one that has values. Result is cached.
+        Queries the actual stream labels for the given app and checks
+        which severity label name appears. This avoids false matches
+        from other apps using a different severity label.
+
+        Args:
+            app_label: The label name for the application (e.g. "application").
+            app_value: The application name (e.g. "materia-server").
 
         Returns:
-            The severity label name, or None if not found.
+            The severity label name for this app, or None if not found.
         """
-        if self._severity_label_cache is not None:
-            return self._severity_label_cache
+        if app_value in self._severity_label_cache:
+            return self._severity_label_cache[app_value]
+
+        series = self.get_series(match=['{' + f'{app_label}="{app_value}"' + '}'])
 
-        start, end = self._discovery_time_range()
         for label_name in SEVERITY_LABEL_NAMES:
-            values = self.get_label_values(label_name, start=start, end=end)
-            if values:
-                self._severity_label_cache = label_name
-                return label_name
+            for s in series:
+                if label_name in s:
+                    self._severity_label_cache[app_value] = label_name
+                    return label_name
 
+        self._severity_label_cache[app_value] = None
         return None
 
     def query(
@@ -378,7 +384,7 @@ class LokiClient:
             app_label = self._find_app_label(app)
             selector = f'{app_label}="{app}"'
             if severity is not None:
-                sev_label = self._find_severity_label()
+                sev_label = self._find_severity_label(app_label, app)
                 if sev_label:
                     regex = _build_severity_regex(severity)
                     selector += f', {sev_label}=~"{regex}"'
@@ -452,6 +458,10 @@ class LokiClient:
         """
         Get list of available label names.
 
+        Defaults to a 30-day lookback when no time range is provided,
+        since Loki's label API may only return labels for recently
+        active streams without an explicit range.
+
         Args:
             start: Optional start timestamp in nanoseconds.
             end: Optional end timestamp in nanoseconds.
@@ -459,14 +469,15 @@ class LokiClient:
         Returns:
             List of label names.
         """
-        params = {}
+        if start is None and end is None:
+            start, end = self._discovery_time_range()
 
-        if start is not None:
-            params["start"] = str(start)
-        if end is not None:
-            params["end"] = str(end)
+        params = {
+            "start": str(start),
+            "end": str(end),
+        }
 
-        response = self._request("GET", "/loki/api/v1/labels", params or None)
+        response = self._request("GET", "/loki/api/v1/labels", params)
         return response.get("data", [])
 
     def get_label_values(
@@ -478,6 +489,10 @@ class LokiClient:
         """
         Get list of values for a specific label.
 
+        Defaults to a 30-day lookback when no time range is provided,
+        since Loki's label API may only return values for recently
+        active streams without an explicit range.
+
         Args:
             label: Label name to get values for.
             start: Optional start timestamp in nanoseconds.
@@ -486,12 +501,13 @@ class LokiClient:
         Returns:
             List of label values.
         """
-        params = {}
+        if start is None and end is None:
+            start, end = self._discovery_time_range()
 
-        if start is not None:
-            params["start"] = str(start)
-        if end is not None:
-            params["end"] = str(end)
+        params = {
+            "start": str(start),
+            "end": str(end),
+        }
 
         endpoint = f"/loki/api/v1/label/{label}/values"
         response = self._request("GET", endpoint, params or None)

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

@@ -75,7 +75,7 @@ class TestLokiClientInit:
     def test_init_label_caches_empty(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
         assert client._app_label_cache == {}
-        assert client._severity_label_cache is None
+        assert client._severity_label_cache == {}
 
 
 class TestLokiClientSession:
@@ -453,16 +453,12 @@ class TestLabelDiscovery:
             mock_glv.return_value = ["myapp", "otherapp"]
             result = client._find_app_label("myapp")
             assert result == "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
+            mock_glv.assert_called_once_with("application")
 
     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, start: int = None, end: int = None) -> list[str]:
+            def side_effect(label: str) -> list[str]:
                 if label == "job":
                     return ["myapp", "worker"]
                 return []
@@ -478,23 +474,32 @@ class TestLabelDiscovery:
             with pytest.raises(ValueError, match="Could not find 'myapp'"):
                 client._find_app_label("myapp")
 
-    def test_find_severity_label(self) -> None:
+    def test_find_severity_label_from_series(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
-        with patch.object(client, "get_label_values") as mock_glv:
-            mock_glv.return_value = ["info", "error", "warn"]
-            result = client._find_severity_label()
+        with patch.object(client, "get_series") as mock_gs:
+            mock_gs.return_value = [
+                {"application": "myapp", "severity": "info", "logger": "root"},
+            ]
+            result = client._find_severity_label("application", "myapp")
+            assert result == "severity"
+            mock_gs.assert_called_once_with(match=['{application="myapp"}'])
+
+    def test_find_severity_label_level(self) -> None:
+        client = LokiClient(base_url="http://localhost:3100")
+        with patch.object(client, "get_series") as mock_gs:
+            mock_gs.return_value = [
+                {"application": "myapp", "level": "info", "logger": "root"},
+            ]
+            result = client._find_severity_label("application", "myapp")
             assert result == "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")
-        with patch.object(client, "get_label_values") as mock_glv:
-            mock_glv.return_value = []
-            result = client._find_severity_label()
+        with patch.object(client, "get_series") as mock_gs:
+            mock_gs.return_value = [
+                {"application": "myapp", "logger": "root"},
+            ]
+            result = client._find_severity_label("application", "myapp")
             assert result is None
 
     def test_label_discovery_cached(self) -> None:
@@ -506,29 +511,20 @@ class TestLabelDiscovery:
             client._find_app_label("myapp")
 
             # Only called once - second call uses cache
-            mock_glv.assert_called_once()
+            mock_glv.assert_called_once_with("application")
 
     def test_severity_label_cached(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")
-        with patch.object(client, "get_label_values") as mock_glv:
-            mock_glv.return_value = ["info", "error"]
-
-            client._find_severity_label()
-            client._find_severity_label()
-
-            mock_glv.assert_called_once()
+        with patch.object(client, "get_series") as mock_gs:
+            mock_gs.return_value = [
+                {"application": "myapp", "severity": "info"},
+            ]
 
-    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")
+            client._find_severity_label("application", "myapp")
+            client._find_severity_label("application", "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
+            # Only called once - second call uses cache
+            mock_gs.assert_called_once()
 
 
 class TestMergeStreams:
@@ -659,14 +655,14 @@ class TestLokiClientQueryRedesign:
     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, "_find_severity_label", return_value="severity"), \
              patch.object(client, "query_range") as mock_qr:
             mock_qr.return_value = self._make_multi_stream_result()
 
             client.query(app="myapp", severity="error")
 
             args = mock_qr.call_args
-            assert args.kwargs["logql"] == '{application="myapp", level=~"error|fatal|critical"}'
+            assert args.kwargs["logql"] == '{application="myapp", severity=~"error|fatal|critical"}'
 
     def test_query_app_since_minutes(self) -> None:
         client = LokiClient(base_url="http://localhost:3100")