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

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

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

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

{loki_reader_core-0.2.3 → 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.3"
+__version__ = "0.2.4"
 
 __all__ = [
     "LokiClient",

{loki_reader_core-0.2.3 → 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:
@@ -312,24 +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}"' + '}'])
 
         for label_name in SEVERITY_LABEL_NAMES:
-            values = self.get_label_values(label_name)
-            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(
@@ -376,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}"'

{loki_reader_core-0.2.3 → 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:
@@ -474,19 +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_with("level")
 
     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:
@@ -502,13 +515,16 @@ class TestLabelDiscovery:
 
     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"]
+        with patch.object(client, "get_series") as mock_gs:
+            mock_gs.return_value = [
+                {"application": "myapp", "severity": "info"},
+            ]
 
-            client._find_severity_label()
-            client._find_severity_label()
+            client._find_severity_label("application", "myapp")
+            client._find_severity_label("application", "myapp")
 
-            mock_glv.assert_called_once_with("level")
+            # Only called once - second call uses cache
+            mock_gs.assert_called_once()
 
 
 class TestMergeStreams:
@@ -639,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")