devlogs 2.3.1__tar.gz → 2.3.2__tar.gz

{devlogs-2.3.1/src/devlogs.egg-info → devlogs-2.3.2}/PKG-INFO

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

{devlogs-2.3.1 → devlogs-2.3.2}/pyproject.toml

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

{devlogs-2.3.1 → devlogs-2.3.2}/src/devlogs/_version_static.py

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

{devlogs-2.3.1 → devlogs-2.3.2}/src/devlogs/cli.py

@@ -10,7 +10,7 @@ import click
 import typer
 from pathlib import Path
 
-from .config import load_config, set_dotenv_path, set_url, URLParseError, _parse_opensearch_url, parse_url, CollectorURLConfig
+from .config import load_config, set_dotenv_path, set_url, URLParseError, _parse_opensearch_url, parse_url, CollectorURLConfig, LokiURLConfig
 from .formatting import format_timestamp, all_entries_today, format_entry_text
 from .opensearch.client import (
 	get_opensearch_client,
@@ -313,6 +313,12 @@ def init(
 	automatically migrate data from v1 to v2 schema.
 	"""
 	_apply_common_options(env, url)
+
+	cfg = load_config()
+	if cfg.is_loki:
+		typer.echo("Loki backends do not require initialization. No action needed.")
+		return
+
 	client, cfg = require_opensearch(check_idx=False)
 
 	# Check existing index schema
@@ -780,6 +786,123 @@ def diagnose(
 		raise typer.Exit(1)
 
 
+def _format_loki_entries(entries, utc=False, jsonl=False):
+	"""Format and print Loki log entries."""
+	if jsonl:
+		for entry in entries:
+			typer.echo(json.dumps(entry, default=str))
+	else:
+		use_color = sys.stdout.isatty()
+		normalized = []
+		for e in entries:
+			normalized.append({
+				"timestamp": e.get("timestamp") or "",
+				"level": e.get("level") or "",
+				"area": e.get("area") or "",
+				"component": e.get("component") or "",
+				"operation_id": e.get("operation_id") or "",
+				"message": e.get("message") or "",
+				"fields": e.get("fields"),
+			})
+		omit_date = all_entries_today(normalized, use_utc=utc)
+		for doc in normalized:
+			line = format_entry_text(
+				doc, use_utc=utc, omit_date=omit_date,
+				color=use_color, format_features_fn=_format_features,
+			)
+			typer.echo(line)
+
+
+def _tail_loki(cfg, application=None, operation_id=None, area=None,
+	component=None, level=None, since=None, limit=20, follow=False,
+	utc=False, jsonl=False):
+	"""Tail logs from a Loki backend."""
+	from .loki.queries import tail as loki_tail
+
+	effective_app = application or cfg.application
+	if not effective_app:
+		typer.echo(typer.style(
+			"Error: --application is required for Loki backends",
+			fg=typer.colors.RED
+		), err=True)
+		raise typer.Exit(1)
+
+	first_poll = True
+	while True:
+		try:
+			entries = loki_tail(
+				loki_url=cfg.loki_url,
+				app=effective_app,
+				level=level,
+				component=component,
+				since=since or "10m",
+				limit=limit,
+				token=cfg.loki_token,
+			)
+		except Exception as e:
+			typer.echo(typer.style(
+				f"Error: {type(e).__name__}: {e}",
+				fg=typer.colors.RED
+			), err=True)
+			raise typer.Exit(1)
+
+		if first_poll and not entries:
+			typer.echo(typer.style("No logs found.", dim=True), err=True)
+		first_poll = False
+
+		_format_loki_entries(entries, utc=utc, jsonl=jsonl)
+
+		if not follow:
+			break
+		time.sleep(2)
+
+
+def _search_loki(cfg, q="", application=None, area=None, component=None,
+	level=None, operation_id=None, since=None, limit=50, follow=False,
+	utc=False, jsonl=False):
+	"""Search logs from a Loki backend."""
+	from .loki.queries import search as loki_search
+
+	effective_app = application or cfg.application
+	if not effective_app:
+		typer.echo(typer.style(
+			"Error: --application is required for Loki backends",
+			fg=typer.colors.RED
+		), err=True)
+		raise typer.Exit(1)
+
+	first_poll = True
+	while True:
+		try:
+			entries = loki_search(
+				loki_url=cfg.loki_url,
+				app=effective_app,
+				level=level,
+				component=component,
+				area=area,
+				start=since,
+				limit=limit,
+				filter_text=q or None,
+				token=cfg.loki_token,
+			)
+		except Exception as e:
+			typer.echo(typer.style(
+				f"Error: {type(e).__name__}: {e}",
+				fg=typer.colors.RED
+			), err=True)
+			raise typer.Exit(1)
+
+		if first_poll and not entries:
+			typer.echo(typer.style("No logs found.", dim=True), err=True)
+		first_poll = False
+
+		_format_loki_entries(entries, utc=utc, jsonl=jsonl)
+
+		if not follow:
+			break
+		time.sleep(2)
+
+
 @app.command()
 def tail(
 	operation_id: str = typer.Option(None, "--operation", "-o"),
@@ -801,6 +924,14 @@ def tail(
 	import traceback
 
 	_apply_common_options(env, url)
+
+	cfg = load_config()
+	if cfg.is_loki:
+		_tail_loki(cfg, application=application, operation_id=operation_id, area=area,
+			component=component, level=level, since=since, limit=limit, follow=follow,
+			utc=utc, jsonl=jsonl)
+		return
+
 	client, cfg = require_opensearch()
 
 	def _verbose_echo(message, color=typer.colors.BLUE):
@@ -982,6 +1113,14 @@ def search(
 	import urllib.error
 
 	_apply_common_options(env, url)
+
+	cfg = load_config()
+	if cfg.is_loki:
+		_search_loki(cfg, q=q, application=application, area=area,
+			component=component, level=level, operation_id=operation_id,
+			since=since, limit=limit, follow=follow, utc=utc, jsonl=jsonl)
+		return
+
 	client, cfg = require_opensearch()
 	effective_application = application or cfg.application
 	search_after = None
@@ -1094,6 +1233,14 @@ def last_error(
 	import urllib.error
 
 	_apply_common_options(env, url)
+
+	cfg = load_config()
+	if cfg.is_loki:
+		_search_loki(cfg, q=q, application=application, area=area,
+			component=component, level="error", operation_id=operation_id,
+			since=since, limit=limit, follow=False, utc=utc, jsonl=False)
+		return
+
 	client, cfg = require_opensearch()
 	effective_application = application or cfg.application
 

{devlogs-2.3.1 → devlogs-2.3.2}/src/devlogs/config.py

@@ -129,6 +129,13 @@ class CollectorURLConfig:
 	token: Optional[str] = None  # Bearer token
 
 
+@dataclass
+class LokiURLConfig:
+	"""Parsed Loki URL configuration (loki:// or lokis:// scheme)."""
+	url: str  # Base HTTP(S) URL for Loki API (no credentials)
+	token: Optional[str] = None  # Bearer token
+
+
 @dataclass
 class OpenSearchURLConfig:
 	"""Parsed OpenSearch URL configuration."""
@@ -142,19 +149,24 @@ class OpenSearchURLConfig:
 
 
 def parse_url(url: str):
-	"""Parse a URL and return a CollectorURLConfig or OpenSearchURLConfig.
+	"""Parse a URL and return a CollectorURLConfig, LokiURLConfig, or OpenSearchURLConfig.
 
 	Detection logic:
+	- loki:// (non-TLS) or lokis:// (TLS) → Loki
 	- opensearchs:// (TLS) or opensearch:// (non-TLS) → OpenSearch
 	- https:// or http:// with both user+pass → legacy OpenSearch (deprecation warning)
 	- https:// or http:// with token-only or ?token= → Collector
 
-	Returns: CollectorURLConfig or OpenSearchURLConfig
+	Returns: CollectorURLConfig, LokiURLConfig, or OpenSearchURLConfig
 	Raises: URLParseError if URL is malformed
 	"""
 	if not url:
 		raise URLParseError("Empty URL")
 
+	# Check for loki:// or lokis:// schemes
+	if url.startswith("lokis://") or url.startswith("loki://"):
+		return _parse_loki_url(url)
+
 	# Check for opensearch:// or opensearchs:// schemes
 	if url.startswith("opensearchs://") or url.startswith("opensearch://"):
 		return _parse_opensearch_scheme_url(url)
@@ -188,6 +200,39 @@ def parse_url(url: str):
 	return _parse_collector_url_config(url)
 
 
+def _parse_loki_url(url: str) -> LokiURLConfig:
+	"""Parse loki:// (non-TLS) or lokis:// (TLS) URL into LokiURLConfig."""
+	if url.startswith("lokis://"):
+		transport_scheme = "https"
+		parse_url_str = "https://" + url[len("lokis://"):]
+	else:
+		transport_scheme = "http"
+		parse_url_str = "http://" + url[len("loki://"):]
+
+	parsed = urlparse(parse_url_str)
+
+	if not parsed.hostname:
+		raise URLParseError(f"Invalid URL '{url}': missing hostname")
+
+	token = None
+	if parsed.username and not parsed.password:
+		token = unquote(parsed.username)
+
+	# Rebuild clean URL without credentials
+	if parsed.port:
+		netloc = f"{parsed.hostname}:{parsed.port}"
+	else:
+		netloc = parsed.hostname or ""
+
+	from urllib.parse import urlunparse
+	clean_url = urlunparse((
+		transport_scheme, netloc, parsed.path,
+		parsed.params, parsed.query, parsed.fragment,
+	))
+
+	return LokiURLConfig(url=clean_url, token=token)
+
+
 def _parse_opensearch_scheme_url(url: str) -> OpenSearchURLConfig:
 	"""Parse opensearchs:// (TLS) or opensearch:// (non-TLS) URL into OpenSearchURLConfig."""
 	# Determine the transport scheme
@@ -342,6 +387,8 @@ class DevlogsConfig:
 		# DEVLOGS_URL is the standard env var. It auto-detects collector vs OpenSearch
 		# via parse_url(). DEVLOGS_OPENSEARCH_URL is a legacy alias for OpenSearch URLs.
 		self.collector_url = ""
+		self.loki_url = None  # Loki base URL (set when loki:// or lokis:// scheme used)
+		self.loki_token = None  # Loki auth token
 		self.application = None
 		opensearch_url_config = None  # result from _parse_opensearch_url if found
 
@@ -351,7 +398,10 @@ class DevlogsConfig:
 		if devlogs_url:
 			try:
 				parsed = parse_url(devlogs_url)
-				if isinstance(parsed, CollectorURLConfig):
+				if isinstance(parsed, LokiURLConfig):
+					self.loki_url = parsed.url
+					self.loki_token = parsed.token
+				elif isinstance(parsed, CollectorURLConfig):
 					self.collector_url = devlogs_url
 				else:
 					# OpenSearch URL via DEVLOGS_URL
@@ -427,9 +477,16 @@ class DevlogsConfig:
 		self.collector_workers = int(_getenv("DEVLOGS_COLLECTOR_WORKERS", "1"))
 		self.collector_log_level = _getenv("DEVLOGS_COLLECTOR_LOG_LEVEL", "info")
 
+	@property
+	def is_loki(self) -> bool:
+		"""Return True if a Loki backend is configured."""
+		return bool(self.loki_url)
+
 	@property
 	def url_mode(self) -> str:
-		"""Return 'collector' if DEVLOGS_URL is set, 'opensearch' if OpenSearch is configured, else 'none'."""
+		"""Return 'loki', 'collector', 'opensearch', or 'none'."""
+		if self.loki_url:
+			return "loki"
 		if self.collector_url:
 			return "collector"
 		if self.has_opensearch_config():

{devlogs-2.3.1 → devlogs-2.3.2}/src/devlogs/loki/queries.py

@@ -110,12 +110,14 @@ def _parse_time_param(value: Optional[str]) -> Optional[datetime]:
 # HTTP helpers
 # ---------------------------------------------------------------------------
 
-def _loki_get(loki_url: str, path: str, params: Dict[str, str]) -> Dict[str, Any]:
+def _loki_get(loki_url: str, path: str, params: Dict[str, str], token: Optional[str] = None) -> 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")
+    if token:
+        req.add_header("Authorization", f"Bearer {token}")
     try:
         with urllib.request.urlopen(req, timeout=30) as resp:
             return json.loads(resp.read().decode("utf-8"))
@@ -185,6 +187,7 @@ def search(
     end: Optional[str] = None,
     limit: int = 100,
     filter_text: Optional[str] = None,
+    token: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """Search log entries in a time range.
 
@@ -229,7 +232,7 @@ def search(
         "end": str(_to_ns(end_dt)),
         "limit": str(limit),
         "direction": "backward",
-    })
+    }, token=token)
 
     entries = _parse_log_streams(data)
     # Sort by Loki timestamp descending (most recent first)
@@ -244,6 +247,7 @@ def tail(
     component: Optional[str] = None,
     since: Optional[str] = None,
     limit: int = 50,
+    token: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """Get the most recent log entries (non-streaming snapshot).
 
@@ -276,7 +280,7 @@ def tail(
         "end": str(_to_ns(now)),
         "limit": str(limit),
         "direction": "backward",
-    })
+    }, token=token)
 
     entries = _parse_log_streams(data)
     entries.sort(key=lambda e: e.get("_loki_ts_ns", "0"), reverse=True)
@@ -290,6 +294,7 @@ def count_over_time(
     group_by: Optional[List[str]] = None,
     start: Optional[str] = None,
     end: Optional[str] = None,
+    token: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """Aggregate log counts over a time interval.
 
@@ -327,6 +332,6 @@ def count_over_time(
         "start": str(_to_ns(start_dt)),
         "end": str(_to_ns(end_dt)),
         "step": interval,
-    })
+    }, token=token)
 
     return _parse_metric_matrix(data)

{devlogs-2.3.1 → devlogs-2.3.2}/src/devlogs/mcp/server.py

@@ -115,8 +115,20 @@ def _error_response(message: str, error_type: str = "Error") -> list[types.TextC
 
 
 def _get_loki_url() -> str | None:
-    """Return LOKI_URL from environment, or None if not set."""
-    return os.environ.get("LOKI_URL") or None
+    """Return Loki URL from LOKI_URL env var or auto-detected from DEVLOGS_URL."""
+    url = os.environ.get("LOKI_URL")
+    if url:
+        return url
+    cfg = load_config()
+    if cfg.is_loki:
+        return cfg.loki_url
+    return None
+
+
+def _get_loki_token() -> str | None:
+    """Return Loki auth token from config, if available."""
+    cfg = load_config()
+    return cfg.loki_token
 
 
 def _handle_loki_search(arguments: dict) -> list[types.TextContent]:
@@ -142,6 +154,7 @@ def _handle_loki_search(arguments: dict) -> list[types.TextContent]:
             end=arguments.get("until"),
             limit=_coerce_limit(arguments.get("limit"), 50, 100),
             filter_text=arguments.get("query"),
+            token=_get_loki_token(),
         )
         return _json_response(
             data={"entries": entries},
@@ -171,6 +184,7 @@ def _handle_loki_tail(arguments: dict) -> list[types.TextContent]:
             component=arguments.get("component"),
             since=arguments.get("since", "10m"),
             limit=_coerce_limit(arguments.get("limit"), 20, 100),
+            token=_get_loki_token(),
         )
         return _json_response(
             data={"entries": entries},
@@ -200,6 +214,7 @@ def _handle_loki_get_log_stats(arguments: dict) -> list[types.TextContent]:
             group_by=arguments.get("group_by"),
             start=arguments.get("since"),
             end=arguments.get("until"),
+            token=_get_loki_token(),
         )
         return _json_response(
             data={"stats": stats},

{devlogs-2.3.1 → devlogs-2.3.2/src/devlogs.egg-info}/PKG-INFO

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

{devlogs-2.3.1 → devlogs-2.3.2}/tests/test_cli.py

@@ -875,3 +875,47 @@ class TestDiagnosePluginMode:
         finally:
             _registry.clear()
             _registry.update(old_registry)
+
+
+class TestLokiCLI:
+    """Test CLI commands with Loki backends."""
+
+    def test_init_refuses_loki_backend(self, monkeypatch):
+        """Test that init exits cleanly for Loki URLs."""
+        monkeypatch.setattr(config, "_dotenv_loaded", True)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_HOST", raising=False)
+        runner = CliRunner()
+        result = runner.invoke(cli.app, ["--url", "lokis://token@host.example.io/query", "init"])
+        assert result.exit_code == 0
+        assert "Loki backends do not require initialization" in result.output
+
+    def test_tail_requires_application_for_loki(self, monkeypatch):
+        """Test that tail requires --application for Loki backends."""
+        monkeypatch.setattr(config, "_dotenv_loaded", True)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_HOST", raising=False)
+        runner = CliRunner()
+        result = runner.invoke(cli.app, ["--url", "lokis://token@host.example.io/query", "tail"])
+        assert result.exit_code == 1
+        assert "--application is required" in result.output
+
+    def test_search_requires_application_for_loki(self, monkeypatch):
+        """Test that search requires --application for Loki backends."""
+        monkeypatch.setattr(config, "_dotenv_loaded", True)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_HOST", raising=False)
+        runner = CliRunner()
+        result = runner.invoke(cli.app, ["--url", "lokis://token@host.example.io/query", "search"])
+        assert result.exit_code == 1
+        assert "--application is required" in result.output
+
+    def test_last_error_requires_application_for_loki(self, monkeypatch):
+        """Test that last-error requires --application for Loki backends."""
+        monkeypatch.setattr(config, "_dotenv_loaded", True)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+        monkeypatch.delenv("DEVLOGS_OPENSEARCH_HOST", raising=False)
+        runner = CliRunner()
+        result = runner.invoke(cli.app, ["--url", "lokis://token@host.example.io/query", "last-error"])
+        assert result.exit_code == 1
+        assert "--application is required" in result.output

{devlogs-2.3.1 → devlogs-2.3.2}/tests/test_config.py

@@ -206,6 +206,73 @@ def test_retention_duration_strings(monkeypatch):
 
 # URL format tests
 
+# Loki URL format tests
+
+def test_parse_url_lokis_with_token_and_path():
+    """Test lokis:// URL parsing extracts token and converts to https."""
+    result = config.parse_url("lokis://mytoken@host.example.io/query")
+    assert isinstance(result, config.LokiURLConfig)
+    assert result.url == "https://host.example.io/query"
+    assert result.token == "mytoken"
+
+
+def test_parse_url_loki_no_token():
+    """Test loki:// URL parsing without token."""
+    result = config.parse_url("loki://localhost:3100")
+    assert isinstance(result, config.LokiURLConfig)
+    assert result.url == "http://localhost:3100"
+    assert result.token is None
+
+
+def test_parse_url_lokis_no_path():
+    """Test lokis:// URL with no path."""
+    result = config.parse_url("lokis://host.example.io")
+    assert isinstance(result, config.LokiURLConfig)
+    assert result.url == "https://host.example.io"
+    assert result.token is None
+
+
+def test_parse_url_loki_with_port():
+    """Test loki:// URL with custom port."""
+    result = config.parse_url("loki://token@localhost:3100/loki")
+    assert isinstance(result, config.LokiURLConfig)
+    assert result.url == "http://localhost:3100/loki"
+    assert result.token == "token"
+
+
+def test_parse_url_loki_missing_hostname():
+    """Test loki:// URL with missing hostname raises error."""
+    import pytest
+    with pytest.raises(config.URLParseError, match="missing hostname"):
+        config.parse_url("loki://")
+
+
+def test_config_loki_url(monkeypatch):
+    """Test DevlogsConfig detects Loki URL from DEVLOGS_URL."""
+    monkeypatch.setattr(config, "_dotenv_loaded", True)
+    monkeypatch.setenv("DEVLOGS_URL", "lokis://mytoken@host.example.io/query")
+    monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+
+    cfg = config.load_config()
+    assert cfg.is_loki is True
+    assert cfg.loki_url == "https://host.example.io/query"
+    assert cfg.loki_token == "mytoken"
+    assert cfg.url_mode == "loki"
+
+
+def test_config_not_loki_when_opensearch(monkeypatch):
+    """Test DevlogsConfig.is_loki is False for OpenSearch URLs."""
+    monkeypatch.setattr(config, "_dotenv_loaded", True)
+    monkeypatch.setenv("DEVLOGS_URL", "opensearchs://admin:pass@host:9200/myindex")
+    monkeypatch.delenv("DEVLOGS_OPENSEARCH_URL", raising=False)
+
+    cfg = config.load_config()
+    assert cfg.is_loki is False
+    assert cfg.loki_url is None
+
+
+# OpenSearch URL format tests
+
 def test_parse_opensearch_url_with_index():
     """Test URL parsing extracts index from path."""
     result = config._parse_opensearch_url("https://admin:pass@host:9200/myindex")