devlogs 2.3.0__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlogs
-Version: 2.3.0
+Version: 2.3.2
 Summary: Developer-focused logging library for Python with OpenSearch integration.
 Author-email: Dan Driscoll <dan@thedandriscoll.org>
 License: MIT License
@@ -39,6 +39,8 @@ Provides-Extra: dev
 Requires-Dist: httpx>=0.26.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Provides-Extra: proxy
+Requires-Dist: aiohttp>=3.9.0; extra == "proxy"
 Dynamic: license-file
 
 # devlogs

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devlogs"
-version = "2.3.0"
+version = "2.3.2"
 description = "Developer-focused logging library for Python with OpenSearch integration."
 requires-python = ">=3.11"
 readme = "README.md"
@@ -26,6 +26,9 @@ dev = [
   "pytest>=8.0.0",
   "pytest-asyncio>=0.23.0",
 ]
+proxy = [
+  "aiohttp>=3.9.0",
+]
 
 [project.scripts]
 devlogs = "devlogs.wrapper:main"

{devlogs-2.3.0 → 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.0"
+__version__ = "2.3.2"

{devlogs-2.3.0 → 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.0 → 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.0 → 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.0 → 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.2/src/devlogs/proxy/server.py

@@ -0,0 +1,163 @@
+# Devlogs proxy server
+#
+# Routes external traffic to internal services:
+#   POST /ingest/*  →  Collector (token-in-URL auth, unchanged)
+#   GET  /query/*   →  Loki :3100 (Bearer token auth)
+#   GET  /grafana/* →  Grafana :3000 (Bearer token auth)
+#
+# Environment variables:
+#   COLLECTOR_URL     — Collector base URL (default: http://localhost:8081)
+#   LOKI_URL          — Loki base URL     (default: http://localhost:3100)
+#   GRAFANA_URL       — Grafana base URL  (default: http://localhost:3000)
+#   LOKI_ADMIN_TOKEN  — Bearer token for /query and /grafana routes
+#   PORT              — Port to listen on (default: 8080)
+#
+# Run:
+#   python -m devlogs.proxy.server
+
+import hmac
+import logging
+import os
+import posixpath
+
+try:
+    from aiohttp import web, ClientSession, ClientTimeout
+except ImportError as e:
+    raise ImportError("aiohttp is required: pip install devlogs[proxy]") from e
+
+logger = logging.getLogger("devlogs.proxy")
+
+COLLECTOR_URL = os.environ.get("COLLECTOR_URL", "http://localhost:8081").rstrip("/")
+LOKI_URL = os.environ.get("LOKI_URL", "http://localhost:3100").rstrip("/")
+GRAFANA_URL = os.environ.get("GRAFANA_URL", "http://localhost:3000").rstrip("/")
+LOKI_ADMIN_TOKEN = os.environ.get("LOKI_ADMIN_TOKEN", "")
+PORT = int(os.environ.get("PORT", "8080"))
+
+_SKIP_HEADERS = frozenset({
+    "host", "content-length", "transfer-encoding",
+    "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto",
+    "forwarded", "x-real-ip", "x-original-url", "x-rewrite-url",
+})
+
+
+def _proxy_headers(request: web.Request) -> dict:
+    return {k: v for k, v in request.headers.items() if k.lower() not in _SKIP_HEADERS}
+
+
+def _build_target(base: str, strip_prefix: str, request: web.Request) -> str:
+    path = request.path.removeprefix(strip_prefix) or "/"
+    path = posixpath.normpath(path)
+    if not path.startswith("/"):
+        path = "/" + path
+    url = f"{base}{path}"
+    if request.query_string:
+        url += f"?{request.query_string}"
+    return url
+
+
+def _check_admin_token(request: web.Request) -> bool:
+    if not LOKI_ADMIN_TOKEN:
+        return False
+    return hmac.compare_digest(
+        request.headers.get("Authorization", ""),
+        f"Bearer {LOKI_ADMIN_TOKEN}",
+    )
+
+
+async def handle_ingest(request: web.Request) -> web.Response:
+    """Forward /ingest/* to Collector. Token in URL is passed through; Collector validates it."""
+    target = _build_target(COLLECTOR_URL, "/ingest", request)
+    body = await request.read()
+
+    async with request.app["session"].request(
+        method=request.method,
+        url=target,
+        headers=_proxy_headers(request),
+        data=body,
+        allow_redirects=False,
+    ) as resp:
+        resp_body = await resp.read()
+        log_url = target.split("?")[0]
+        logger.info("%s /ingest → %s %d", request.method, log_url, resp.status)
+        content_type = resp.content_type or "application/octet-stream"
+        return web.Response(status=resp.status, body=resp_body, content_type=content_type)
+
+
+async def handle_query(request: web.Request) -> web.Response:
+    """Validate Bearer token, strip /query prefix, forward to Loki."""
+    if not _check_admin_token(request):
+        return web.Response(status=401, text="Unauthorized")
+
+    target = _build_target(LOKI_URL, "/query", request)
+    body = await request.read()
+
+    async with request.app["session"].request(
+        method=request.method,
+        url=target,
+        headers=_proxy_headers(request),
+        data=body,
+        allow_redirects=False,
+    ) as resp:
+        resp_body = await resp.read()
+        logger.info("%s /query → %s %d", request.method, target, resp.status)
+        content_type = resp.content_type or "application/octet-stream"
+        return web.Response(status=resp.status, body=resp_body, content_type=content_type)
+
+
+async def handle_grafana(request: web.Request) -> web.Response:
+    """Validate Bearer token, strip /grafana prefix, forward to Grafana."""
+    if not _check_admin_token(request):
+        return web.Response(status=401, text="Unauthorized")
+
+    target = _build_target(GRAFANA_URL, "/grafana", request)
+    # Strip Authorization so Grafana uses its own session mechanism
+    headers = {k: v for k, v in _proxy_headers(request).items() if k.lower() != "authorization"}
+    body = await request.read()
+
+    async with request.app["session"].request(
+        method=request.method,
+        url=target,
+        headers=headers,
+        data=body,
+        allow_redirects=False,
+    ) as resp:
+        resp_body = await resp.read()
+        logger.info("%s /grafana → %s %d", request.method, target, resp.status)
+        content_type = resp.content_type or "application/octet-stream"
+        return web.Response(status=resp.status, body=resp_body, content_type=content_type)
+
+
+async def on_startup(app: web.Application) -> None:
+    timeout = ClientTimeout(total=30)
+    app["session"] = ClientSession(timeout=timeout)
+
+
+async def on_cleanup(app: web.Application) -> None:
+    await app["session"].close()
+
+
+def create_app() -> web.Application:
+    app = web.Application(client_max_size=1024 * 1024)  # 1 MB
+    app.on_startup.append(on_startup)
+    app.on_cleanup.append(on_cleanup)
+
+    app.router.add_route("*", "/ingest", handle_ingest)
+    app.router.add_route("*", "/ingest/{path_info:.*}", handle_ingest)
+    app.router.add_route("*", "/query", handle_query)
+    app.router.add_route("*", "/query/{path_info:.*}", handle_query)
+    app.router.add_route("*", "/grafana", handle_grafana)
+    app.router.add_route("*", "/grafana/{path_info:.*}", handle_grafana)
+
+    return app
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    if not LOKI_ADMIN_TOKEN:
+        logger.warning("LOKI_ADMIN_TOKEN is not set — /query and /grafana routes will reject all requests")
+
+    app = create_app()
+    web.run_app(app, host="0.0.0.0", port=PORT)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlogs
-Version: 2.3.0
+Version: 2.3.2
 Summary: Developer-focused logging library for Python with OpenSearch integration.
 Author-email: Dan Driscoll <dan@thedandriscoll.org>
 License: MIT License
@@ -39,6 +39,8 @@ Provides-Extra: dev
 Requires-Dist: httpx>=0.26.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Provides-Extra: proxy
+Requires-Dist: aiohttp>=3.9.0; extra == "proxy"
 Dynamic: license-file
 
 # devlogs

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

@@ -47,6 +47,8 @@ src/devlogs/opensearch/client.py
 src/devlogs/opensearch/indexing.py
 src/devlogs/opensearch/mappings.py
 src/devlogs/opensearch/queries.py
+src/devlogs/proxy/__init__.py
+src/devlogs/proxy/server.py
 src/devlogs/web/__init__.py
 src/devlogs/web/server.py
 src/devlogs/web/static/devlogs.css
@@ -70,6 +72,7 @@ tests/test_mappings.py
 tests/test_mcp_server.py
 tests/test_opensearch_client.py
 tests/test_opensearch_queries.py
+tests/test_proxy_server.py
 tests/test_retention.py
 tests/test_scrub.py
 tests/test_time_utils.py

{devlogs-2.3.0 → devlogs-2.3.2}/src/devlogs.egg-info/requires.txt

@@ -10,3 +10,6 @@ mcp>=1.0.0
 httpx>=0.26.0
 pytest>=8.0.0
 pytest-asyncio>=0.23.0
+
+[proxy]
+aiohttp>=3.9.0