devlogs 2.1.0__tar.gz → 2.2.0__tar.gz

{devlogs-2.1.0/src/devlogs.egg-info → devlogs-2.2.0}/PKG-INFO

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

{devlogs-2.1.0 → devlogs-2.2.0}/pyproject.toml

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

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/cli.py

@@ -728,6 +728,7 @@ def tail(
 				since=since,
 				limit=limit,
 				search_after=search_after,
+				application=cfg.application,
 			)
 			_verbose_echo(f"Received {len(docs)} docs, next cursor={search_after}")
 			if verbose and docs:
@@ -851,6 +852,7 @@ def search(
 					since=since,
 					limit=limit,
 					search_after=search_after,
+					application=cfg.application,
 				)
 			else:
 				docs = search_logs(
@@ -862,6 +864,7 @@ def search(
 					level=level,
 					since=since,
 					limit=limit,
+					application=cfg.application,
 				)
 			entries = normalize_log_entries(docs, limit=limit)
 			consecutive_errors = 0
@@ -947,6 +950,7 @@ def last_error(
 			since=since,
 			until=until,
 			limit=limit,
+			application=cfg.application,
 		)
 		entries = normalize_log_entries(docs, limit=limit)
 	except (ConnectionFailedError, urllib.error.URLError) as e:
@@ -1244,7 +1248,7 @@ def mkurl():
 	the components (host, port, credentials, index) one by one.
 
 	The output shows three equivalent formats:
-	- A bare URL (for --url flag or DEVLOGS_OPENSEARCH_URL)
+	- A bare URL (for --url flag or DEVLOGS_URL)
 	- The URL as a single .env variable
 	- Individual .env variables for each component
 	"""
@@ -1314,7 +1318,7 @@ def mkurl():
 	typer.echo()
 	typer.echo(typer.style("2. Single .env variable:", fg=typer.colors.CYAN, bold=True))
 	typer.echo("-" * 50)
-	typer.echo(f"DEVLOGS_OPENSEARCH_URL={url}")
+	typer.echo(f"DEVLOGS_URL={url}")
 
 	# Format 3: Individual .env variables
 	typer.echo()

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/collector/forwarder.py

@@ -24,7 +24,7 @@ def forward_request(
     Forwards the request body as-is, preserving relevant headers.
 
     Args:
-        forward_url: The upstream URL to forward to (should end with /v1/logs)
+        forward_url: The upstream URL to forward to
         body: The raw request body bytes
         content_type: The Content-Type header value
         auth_header: Optional Authorization header to forward
@@ -37,9 +37,7 @@ def forward_request(
     Raises:
         ForwardError: If the forward request fails
     """
-    # Ensure URL ends with /v1/logs
-    if not forward_url.endswith("/v1/logs"):
-        forward_url = forward_url.rstrip("/") + "/v1/logs"
+    forward_url = forward_url.rstrip("/")
 
     headers = {
         "Content-Type": content_type,

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/collector/server.py

@@ -139,19 +139,8 @@ async def collector_error_handler(request: Request, exc: CollectorError):
     )
 
 
-@app.get("/health")
-async def health():
-    """Health check endpoint."""
-    cfg = load_config()
-    mode = cfg.get_collector_mode()
-    return {
-        "status": "healthy",
-        "mode": mode,
-        "version": __version__,
-    }
-
 
-@app.post("/v1/logs")
+@app.post("/")
 async def ingest_logs(request: Request):
     """Ingest log records.
 

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/config.py

@@ -311,7 +311,9 @@ def _parse_opensearch_url(url: str):
 	# URL-decode username and password since urlparse doesn't do this automatically
 	user = unquote(parsed.username) if parsed.username else None
 	password = unquote(parsed.password) if parsed.password else None
-	index = parsed.path.strip("/") or None
+	path = parsed.path.strip("/")
+	parts = path.split("/", 1) if path else []
+	index = parts[0] if parts else None
 	return (scheme, host, port, user, password, index)
 
 
@@ -327,18 +329,41 @@ class DevlogsConfig:
 	def __init__(self, enabled: bool = True):
 		self.enabled = enabled
 
-		# Collector URL (where apps send logs)
-		self.collector_url = _getenv("DEVLOGS_URL", "")
-
 		# Forward URL (if set, collector operates in forward mode)
 		self.forward_url = _getenv("DEVLOGS_FORWARD_URL", "")
 
-		# Check for URL shortcut first - it overrides individual settings
-		# This is the admin OpenSearch connection used for search/tail/UI/CLI and ingest mode
-		url_config = _parse_opensearch_url(os.getenv("DEVLOGS_OPENSEARCH_URL", ""))
-
-		if url_config:
-			scheme, host, port, url_user, url_pass, url_index = url_config
+		# 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.application = None
+		opensearch_url_config = None  # result from _parse_opensearch_url if found
+
+		devlogs_url = os.getenv("DEVLOGS_URL", "")
+		legacy_opensearch_url = os.getenv("DEVLOGS_OPENSEARCH_URL", "")
+
+		if devlogs_url:
+			try:
+				parsed = parse_url(devlogs_url)
+				if isinstance(parsed, CollectorURLConfig):
+					self.collector_url = devlogs_url
+				else:
+					# OpenSearch URL via DEVLOGS_URL
+					opensearch_url_config = _parse_opensearch_url(devlogs_url)
+					self.application = parsed.application
+			except URLParseError:
+				# Treat unparseable DEVLOGS_URL as legacy OpenSearch
+				opensearch_url_config = _parse_opensearch_url(devlogs_url)
+
+		# Legacy: DEVLOGS_OPENSEARCH_URL overrides OpenSearch settings from DEVLOGS_URL
+		if legacy_opensearch_url:
+			opensearch_url_config = _parse_opensearch_url(legacy_opensearch_url)
+			# Parse application filter from opensearch:// URL (second path segment)
+			if legacy_opensearch_url.startswith("opensearchs://") or legacy_opensearch_url.startswith("opensearch://"):
+				parsed_os = _parse_opensearch_scheme_url(legacy_opensearch_url)
+				self.application = parsed_os.application
+
+		if opensearch_url_config:
+			scheme, host, port, url_user, url_pass, url_index = opensearch_url_config
 			self.opensearch_scheme = scheme
 			self.opensearch_host = host
 			self.opensearch_port = port
@@ -406,6 +431,15 @@ class DevlogsConfig:
 
 	def has_opensearch_config(self) -> bool:
 		"""Check if OpenSearch admin connection is configured."""
+		# DEVLOGS_URL with an OpenSearch URL also counts
+		devlogs_url = os.getenv("DEVLOGS_URL", "")
+		if devlogs_url:
+			try:
+				parsed = parse_url(devlogs_url)
+				if isinstance(parsed, OpenSearchURLConfig):
+					return True
+			except URLParseError:
+				pass
 		return bool(
 			os.getenv("DEVLOGS_OPENSEARCH_URL") or
 			os.getenv("DEVLOGS_OPENSEARCH_HOST")
@@ -449,12 +483,8 @@ def set_url(url: str):
 		os.environ["DEVLOGS_OPENSEARCH_URL"] = url
 		return
 
-	if isinstance(parsed, CollectorURLConfig):
-		# Reconstruct the full collector URL for DEVLOGS_URL
-		os.environ["DEVLOGS_URL"] = url
-	else:
-		# OpenSearch URL - reconstruct with the correct scheme for _parse_opensearch_url
-		os.environ["DEVLOGS_OPENSEARCH_URL"] = url
+	# Always set DEVLOGS_URL as the standard env var
+	os.environ["DEVLOGS_URL"] = url
 
 def load_config() -> DevlogsConfig:
 	"""Return a config object with all settings loaded."""

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/demo.py

@@ -7,7 +7,7 @@ import typer
 
 from .config import load_config
 from .context import operation
-from .handler import OpenSearchHandler
+from .handler import OpenSearchHandler, DevlogsHandler
 
 
 def run_demo(
@@ -25,6 +25,23 @@ def run_demo(
 		typer.echo(f"  Collector URL: {collector_url}")
 		typer.echo("")
 
+		# Validate first write before starting
+		from .devlogs_client import DevlogsClient
+		test_client = DevlogsClient(
+			collector_url=collector_url,
+			application="devlogs-demo",
+			component="connectivity-check",
+			timeout=5,
+		)
+		if not test_client.emit(message="Demo starting", level="info"):
+			typer.echo(typer.style(
+				f"  Error: failed to write to collector at {test_client._get_endpoint()}",
+				fg=typer.colors.RED,
+			))
+			raise typer.Exit(1)
+		typer.echo(typer.style("  First write succeeded.", fg=typer.colors.GREEN))
+		typer.echo("")
+
 		handler = OpenSearchHandler(
 			level=logging.DEBUG,
 			collector_url=collector_url,
@@ -229,6 +246,9 @@ def run_demo(
 
 		generated += 1
 
+	# Reset counters before starting
+	DevlogsHandler.reset_counters()
+
 	# Main loop: emit logs and show countdown
 	while generated < count:
 		check_countdown()
@@ -238,4 +258,18 @@ def run_demo(
 	elapsed = time.time() - start_time
 	typer.echo(typer.style(f"\n--- Demo complete! ---", fg=typer.colors.GREEN))
 	typer.echo(f"Generated {generated} log entries in {elapsed:.1f} seconds.")
+
+	# Report send results
+	sent = DevlogsHandler._emit_count
+	errors = DevlogsHandler._emit_errors
+	skipped = DevlogsHandler._emit_skipped
+	succeeded = sent - errors - skipped
+	if errors or skipped:
+		typer.echo(typer.style(
+			f"  Delivered: {succeeded}/{sent} (errors: {errors}, skipped: {skipped})",
+			fg=typer.colors.RED,
+		))
+	else:
+		typer.echo(typer.style(f"  Delivered: {succeeded}/{sent}", fg=typer.colors.GREEN))
+
 	typer.echo(f"View logs with: devlogs tail --follow")

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/devlogs_client.py

@@ -161,8 +161,7 @@ class DevlogsClient:
 
     def _get_endpoint(self) -> str:
         """Get the collector endpoint URL."""
-        base = self._clean_url.rstrip("/")
-        return f"{base}/v1/logs"
+        return self._clean_url.rstrip("/")
 
     def _get_headers(self) -> Dict[str, str]:
         """Get request headers."""

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/handler.py

@@ -76,6 +76,9 @@ class DevlogsHandler(logging.Handler):
 	_circuit_breaker_duration = 60.0  # seconds to wait before retrying
 	_last_error_printed = 0.0
 	_error_print_interval = 10.0  # only print errors every 10 seconds
+	_emit_count = 0
+	_emit_errors = 0
+	_emit_skipped = 0
 
 	def __init__(
 		self,
@@ -119,17 +122,22 @@ class DevlogsHandler(logging.Handler):
 			except Exception:
 				parsed = None
 			if isinstance(parsed, CollectorURLConfig):
-				base = parsed.url.rstrip("/")
-				self._collector_endpoint = f"{base}/v1/logs"
+				self._collector_endpoint = parsed.url.rstrip("/")
 				self._collector_headers = {"Content-Type": "application/json"}
 				if parsed.token:
 					self._collector_headers["Authorization"] = f"Bearer {parsed.token}"
 			else:
 				# Treat as plain collector URL without token extraction
-				base = collector_url.rstrip("/")
-				self._collector_endpoint = f"{base}/v1/logs"
+				self._collector_endpoint = collector_url.rstrip("/")
 				self._collector_headers = {"Content-Type": "application/json"}
 
+	@classmethod
+	def reset_counters(cls):
+		"""Reset emit counters."""
+		cls._emit_count = 0
+		cls._emit_errors = 0
+		cls._emit_skipped = 0
+
 	def emit(self, record: logging.LogRecord) -> None:
 		"""Emit a log record to OpenSearch or a collector endpoint."""
 		# Build log document
@@ -137,13 +145,14 @@ class DevlogsHandler(logging.Handler):
 
 		# Circuit breaker: skip indexing if we know the target is unavailable
 		current_time = time.time()
+		DevlogsHandler._emit_count += 1
 		if DevlogsHandler._circuit_open and current_time < DevlogsHandler._circuit_open_until:
-			# Silently fail - circuit is open
+			DevlogsHandler._emit_skipped += 1
 			return
 
 		try:
 			if self._collector_endpoint:
-				# Collector mode: POST to /v1/logs
+				# Collector mode: POST to collector endpoint
 				data = json.dumps(doc).encode("utf-8")
 				req = urllib.request.Request(
 					self._collector_endpoint,
@@ -164,6 +173,7 @@ class DevlogsHandler(logging.Handler):
 					DevlogsHandler._circuit_open = False
 					print(f"[devlogs] Connection restored, resuming indexing")
 		except Exception as e:
+			DevlogsHandler._emit_errors += 1
 			# Open circuit breaker to prevent further attempts
 			DevlogsHandler._circuit_open = True
 			DevlogsHandler._circuit_open_until = current_time + DevlogsHandler._circuit_breaker_duration
@@ -259,8 +269,9 @@ class DiagnosticsHandler(DevlogsHandler):
 	def emit(self, record: logging.LogRecord) -> None:
 		# Circuit breaker: skip indexing if we know the index is unavailable
 		current_time = time.time()
+		DevlogsHandler._emit_count += 1
 		if DevlogsHandler._circuit_open and current_time < DevlogsHandler._circuit_open_until:
-			# Silently fail - circuit is open
+			DevlogsHandler._emit_skipped += 1
 			return
 
 		doc = self.format_record(record)
@@ -279,6 +290,7 @@ class DiagnosticsHandler(DevlogsHandler):
 					DevlogsHandler._circuit_open = False
 					print(f"[devlogs] Connection restored, resuming indexing")
 		except Exception as e:
+			DevlogsHandler._emit_errors += 1
 			# Open circuit breaker to prevent further attempts
 			DevlogsHandler._circuit_open = True
 			DevlogsHandler._circuit_open_until = current_time + DevlogsHandler._circuit_breaker_duration

{devlogs-2.1.0 → devlogs-2.2.0}/src/devlogs/mcp/server.py

@@ -1,5 +1,5 @@
-"""MCP server for devlogs - allows AI assistants to search and analyze logs."""
-
+"""MCP server for devlogs - allows AI assistants to search and analyze logs."""
+
 import asyncio
 import json
 from typing import Any
@@ -33,11 +33,11 @@ from ..opensearch.queries import (
 
 
 def _create_client_and_index():
-    """Create OpenSearch client and get index name from config."""
+    """Create OpenSearch client and get index name and application filter from config."""
     try:
         client = get_opensearch_client()
         cfg = load_config()
-        return client, cfg.index
+        return client, cfg.index, cfg.application
     except DevlogsDisabledError as e:
         raise RuntimeError(str(e))
     except ConnectionFailedError as e:
@@ -116,7 +116,7 @@ def _error_response(message: str, error_type: str = "Error") -> list[types.TextC
 async def main():
     """Run the MCP server."""
     server = Server("devlogs")
-
+
     @server.list_tools()
     async def handle_list_tools() -> list[types.Tool]:
         """List available MCP tools."""
@@ -266,24 +266,24 @@ async def main():
                 description="List recent operations with summary stats. Use this to discover operations without knowing their IDs.",
                 inputSchema={
                     "type": "object",
-                    "properties": {
-                        "area": {
-                            "type": "string",
-                            "description": "Filter by application area",
-                        },
+                    "properties": {
+                        "area": {
+                            "type": "string",
+                            "description": "Filter by application area",
+                        },
                         "since": {
                             "type": "string",
                             "description": "ISO timestamp or relative duration like '1h' to filter operations after this time",
                         },
-                        "limit": {
-                            "type": "integer",
-                            "description": "Maximum number of operations to return (default: 20)",
-                            "default": 20,
-                        },
-                        "with_errors_only": {
-                            "type": "boolean",
-                            "description": "Only show operations that had errors",
-                            "default": False,
+                        "limit": {
+                            "type": "integer",
+                            "description": "Maximum number of operations to return (default: 20)",
+                            "default": 20,
+                        },
+                        "with_errors_only": {
+                            "type": "boolean",
+                            "description": "Only show operations that had errors",
+                            "default": False,
                         },
                     },
                 },
@@ -329,15 +329,15 @@ async def main():
                 description="List all application areas with activity counts. Use this to discover what subsystems exist in the application.",
                 inputSchema={
                     "type": "object",
-                    "properties": {
+                    "properties": {
                         "since": {
                             "type": "string",
                             "description": "ISO timestamp or relative duration like '1h' to filter activity after this time",
                         },
-                        "min_operations": {
-                            "type": "integer",
-                            "description": "Minimum number of operations an area must have to be included",
-                            "default": 1,
+                        "min_operations": {
+                            "type": "integer",
+                            "description": "Minimum number of operations an area must have to be included",
+                            "default": 1,
                         },
                     },
                 },
@@ -457,17 +457,17 @@ async def main():
                 },
             ),
         ]
-
-    @server.call_tool()
-    async def handle_call_tool(
-        name: str, arguments: dict | None
-    ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-        """Handle tool calls."""
-        if arguments is None:
-            arguments = {}
-
+
+    @server.call_tool()
+    async def handle_call_tool(
+        name: str, arguments: dict | None
+    ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+        """Handle tool calls."""
+        if arguments is None:
+            arguments = {}
+
         try:
-            client, index = _create_client_and_index()
+            client, index, application = _create_client_and_index()
         except RuntimeError as e:
             return _error_response(str(e), "InitializationError")
 
@@ -494,6 +494,7 @@ async def main():
                     limit=limit,
                     cursor=cursor,
                     sort_order="desc",
+                    application=application,
                 )
                 entries = _normalize_entries(docs, limit=limit)
 
@@ -531,6 +532,7 @@ async def main():
                     until=until,
                     limit=limit,
                     search_after=cursor,
+                    application=application,
                 )
                 entries = _normalize_entries(docs, limit=limit)
 
@@ -552,7 +554,7 @@ async def main():
                 return _error_response("operation_id is required", "ValidationError")
 
             try:
-                summary = get_operation_summary(client, index, operation_id)
+                summary = get_operation_summary(client, index, operation_id, application=application)
 
                 if not summary:
                     return _json_response(
@@ -591,6 +593,7 @@ async def main():
                     until=until,
                     limit=limit,
                     cursor=cursor,
+                    application=application,
                 )
                 entries = _normalize_entries(docs, limit=limit)
 
@@ -614,11 +617,12 @@ async def main():
             try:
                 operations = list_operations(
                     client=client,
-                    index=index,
-                    area=area,
-                    since=since,
-                    limit=limit,
+                    index=index,
+                    area=area,
+                    since=since,
+                    limit=limit,
                     with_errors_only=with_errors_only,
+                    application=application,
                 )
 
                 return _json_response(
@@ -649,6 +653,7 @@ async def main():
                     limit=limit,
                     order_by=order_by,
                     with_errors_only=with_errors_only,
+                    application=application,
                 )
 
                 return _json_response(
@@ -665,11 +670,12 @@ async def main():
             min_operations = arguments.get("min_operations", 1)
 
             try:
-                areas = list_areas(
-                    client=client,
-                    index=index,
-                    since=since,
+                areas = list_areas(
+                    client=client,
+                    index=index,
+                    since=since,
                     min_operations=min_operations,
+                    application=application,
                 )
 
                 return _json_response(
@@ -702,6 +708,7 @@ async def main():
                     limit=limit,
                     min_count=min_count,
                     include_missing=include_missing,
+                    application=application,
                 )
                 return _json_response(
                     data={"signatures": signatures},
@@ -730,6 +737,7 @@ async def main():
                     since=since,
                     until=until,
                     limit=limit,
+                    application=application,
                 )
                 entries = _normalize_entries(docs, limit=limit)
                 return _json_response(
@@ -766,6 +774,7 @@ async def main():
                     level=level,
                     before=before,
                     after=after,
+                    application=application,
                 )
                 entries = _normalize_entries(docs)
                 return _json_response(
@@ -781,15 +790,15 @@ async def main():
 
         else:
             raise ValueError(f"Unknown tool: {name}")
-
-    # Run the server using stdio transport
-    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            server.create_initialization_options()
-        )
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
+
+    # Run the server using stdio transport
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options()
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())