devlogs 2.0.1__tar.gz → 2.0.2__tar.gz

{devlogs-2.0.1/src/devlogs.egg-info → devlogs-2.0.2}/PKG-INFO

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

{devlogs-2.0.1 → devlogs-2.0.2}/pyproject.toml

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

{devlogs-2.0.1 → devlogs-2.0.2}/src/devlogs/devlogs_client.py

@@ -8,18 +8,104 @@ import urllib.request
 import urllib.error
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlparse, unquote, urlunparse
+
+
+def _parse_collector_url(url: str) -> Tuple[str, Optional[str]]:
+    """Parse a URL and extract auth token if it's a collector URL.
+
+    Distinguishes between OpenSearch URLs and collector URLs:
+    - OpenSearch URL: has BOTH username AND password - keep credentials in URL
+    - Collector URL: has only token in username position - extract for Bearer auth
+
+    Collector URL format: http://token@host:port
+    OpenSearch URL format: http://user:password@host:port
+
+    Args:
+        url: The URL, optionally with credentials in userinfo
+
+    Returns:
+        Tuple of (url, token):
+        - For OpenSearch URLs (user:pass): returns original URL, None
+        - For collector URLs (token only): returns clean URL without userinfo, token
+        - For plain URLs: returns original URL, None
+    """
+    if not url:
+        return url, None
+
+    parsed = urlparse(url)
+
+    # If no userinfo, return as-is
+    if not parsed.username and not parsed.password:
+        return url, None
+
+    # OpenSearch URL: has BOTH username AND password
+    # Keep the URL as-is with credentials, no Bearer token
+    if parsed.username and parsed.password:
+        return url, None
+
+    # Collector URL: token in username position only (no password)
+    # Extract token and strip userinfo from URL
+    token = unquote(parsed.username) if parsed.username else None
+
+    # Rebuild URL without userinfo
+    # netloc without userinfo is just host:port
+    if parsed.port:
+        netloc = f"{parsed.hostname}:{parsed.port}"
+    else:
+        netloc = parsed.hostname or ""
+
+    clean_url = urlunparse((
+        parsed.scheme,
+        netloc,
+        parsed.path,
+        parsed.params,
+        parsed.query,
+        parsed.fragment,
+    ))
+
+    return clean_url, token
 
 
 @dataclass
 class DevlogsClient:
-    """Client for sending logs to a devlogs collector.
+    """Client for sending logs to a devlogs collector or OpenSearch.
+
+    URL Types:
+        This client distinguishes between collector URLs and OpenSearch URLs:
+
+        Collector URL (token in username position):
+            http://dl1_myapp_secret@localhost:8080
+            - Token is extracted and sent as Bearer auth header
+            - Userinfo is stripped from the request URL
+
+        OpenSearch URL (both username AND password):
+            https://admin:password@opensearch.example.com:9200
+            - Credentials remain in the URL for HTTP Basic auth
+            - No Bearer token is used
 
     Usage:
+        # Collector URL with token:
+        client = DevlogsClient(
+            collector_url="http://dl1_myapp_secret@localhost:8080",
+            application="my-app",
+            component="api-server",
+        )
+
+        # OpenSearch URL with credentials:
+        client = DevlogsClient(
+            collector_url="https://admin:password@opensearch.example.com:9200",
+            application="my-app",
+            component="api-server",
+        )
+
+        # Or with explicit auth_token parameter:
         client = DevlogsClient(
             collector_url="http://localhost:8080",
             application="my-app",
             component="api-server",
+            auth_token="dl1_myapp_secret",
         )
 
         # Send a single log
@@ -34,6 +120,8 @@ class DevlogsClient:
             {"message": "Event 1", "level": "info"},
             {"message": "Event 2", "level": "warning"},
         ])
+
+    If both URL token and auth_token parameter are provided, auth_token takes precedence.
     """
 
     collector_url: str
@@ -44,16 +132,27 @@ class DevlogsClient:
     auth_token: Optional[str] = None
     timeout: int = 30
 
+    # Internal fields set by __post_init__
+    _clean_url: str = field(default="", init=False, repr=False)
+    _resolved_token: Optional[str] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self):
+        """Parse collector URL and extract token if present."""
+        clean_url, url_token = _parse_collector_url(self.collector_url)
+        self._clean_url = clean_url
+        # Explicit auth_token parameter takes precedence over URL token
+        self._resolved_token = self.auth_token if self.auth_token else url_token
+
     def _get_endpoint(self) -> str:
         """Get the collector endpoint URL."""
-        base = self.collector_url.rstrip("/")
+        base = self._clean_url.rstrip("/")
         return f"{base}/v1/logs"
 
     def _get_headers(self) -> Dict[str, str]:
         """Get request headers."""
         headers = {"Content-Type": "application/json"}
-        if self.auth_token:
-            headers["Authorization"] = f"Bearer {self.auth_token}"
+        if self._resolved_token:
+            headers["Authorization"] = f"Bearer {self._resolved_token}"
         return headers
 
     def _now(self) -> str:
@@ -209,15 +308,17 @@ def create_client(
     version: Optional[str] = None,
     auth_token: Optional[str] = None,
 ) -> DevlogsClient:
-    """Create an Devlogs client.
+    """Create a Devlogs client.
 
     Args:
-        collector_url: The collector endpoint URL (DEVLOGS_URL)
+        collector_url: The endpoint URL. URL type is auto-detected:
+            - Collector URL: http://token@host:port (token becomes Bearer auth)
+            - OpenSearch URL: http://user:pass@host:port (credentials kept in URL)
         application: Application name
         component: Component name within the application
         environment: Deployment environment (optional)
         version: Application version (optional)
-        auth_token: Bearer token for authentication (optional)
+        auth_token: Bearer token for authentication (optional, overrides URL token)
 
     Returns:
         Configured DevlogsClient instance
@@ -248,7 +349,9 @@ def emit_log(
     For repeated logging, use create_client() instead.
 
     Args:
-        collector_url: The collector endpoint URL
+        collector_url: The endpoint URL. URL type is auto-detected:
+            - Collector URL: http://token@host:port (token becomes Bearer auth)
+            - OpenSearch URL: http://user:pass@host:port (credentials kept in URL)
         application: Application name
         component: Component name
         message: Log message
@@ -256,7 +359,7 @@ def emit_log(
         fields: Custom fields
         environment: Deployment environment
         version: Application version
-        auth_token: Bearer token
+        auth_token: Bearer token (optional, overrides URL token)
 
     Returns:
         True if accepted, False on error

{devlogs-2.0.1 → devlogs-2.0.2/src/devlogs.egg-info}/PKG-INFO

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

{devlogs-2.0.1 → devlogs-2.0.2}/tests/test_devlogs_client.py

@@ -4,7 +4,65 @@ import json
 import pytest
 from unittest.mock import Mock, patch
 
-from devlogs.devlogs_client import DevlogsClient, create_client, emit_log
+from devlogs.devlogs_client import DevlogsClient, create_client, emit_log, _parse_collector_url
+
+
+class TestParseCollectorUrl:
+    """Tests for URL parsing - distinguishes collector vs OpenSearch URLs."""
+
+    def test_no_userinfo(self):
+        """Plain URL without credentials."""
+        url, token = _parse_collector_url("http://localhost:8080")
+        assert url == "http://localhost:8080"
+        assert token is None
+
+    def test_collector_url_token_in_username(self):
+        """Collector URL: token in username position only."""
+        url, token = _parse_collector_url("http://mytoken@localhost:8080")
+        assert url == "http://localhost:8080"
+        assert token == "mytoken"
+
+    def test_opensearch_url_user_and_password(self):
+        """OpenSearch URL: both username and password - keep credentials in URL."""
+        url, token = _parse_collector_url("http://admin:secretpass@localhost:9200")
+        assert url == "http://admin:secretpass@localhost:9200"
+        assert token is None
+
+    def test_opensearch_url_preserves_all_parts(self):
+        """OpenSearch URL preserves scheme, path, query."""
+        url, token = _parse_collector_url("https://user:pass@opensearch.example.com:9200/_bulk?refresh=true")
+        assert url == "https://user:pass@opensearch.example.com:9200/_bulk?refresh=true"
+        assert token is None
+
+    def test_collector_url_preserves_port(self):
+        url, token = _parse_collector_url("http://token@localhost:9999")
+        assert url == "http://localhost:9999"
+        assert token == "token"
+
+    def test_collector_url_preserves_path(self):
+        url, token = _parse_collector_url("http://token@localhost:8080/path/to/api")
+        assert url == "http://localhost:8080/path/to/api"
+        assert token == "token"
+
+    def test_collector_url_https_scheme(self):
+        url, token = _parse_collector_url("https://token@example.com")
+        assert url == "https://example.com"
+        assert token == "token"
+
+    def test_collector_url_encoded_token(self):
+        url, token = _parse_collector_url("http://my%3Atoken%40special@localhost:8080")
+        assert url == "http://localhost:8080"
+        assert token == "my:token@special"
+
+    def test_empty_url(self):
+        url, token = _parse_collector_url("")
+        assert url == ""
+        assert token is None
+
+    def test_devlogs_token_format(self):
+        url, token = _parse_collector_url("http://dl1_myapp_abcdefghijklmnopqrstuvwxyz123456@localhost:8080")
+        assert url == "http://localhost:8080"
+        assert token == "dl1_myapp_abcdefghijklmnopqrstuvwxyz123456"
 
 
 class TestDevlogsClient:
@@ -116,6 +174,46 @@ class TestDevlogsClient:
         headers = client._get_headers()
         assert headers["Authorization"] == "Bearer my-secret-token"
 
+    def test_get_headers_with_token_in_url(self):
+        """Collector URL: token in username position extracts Bearer auth."""
+        client = DevlogsClient(
+            collector_url="http://url-token@localhost:8080",
+            application="test-app",
+            component="api",
+        )
+        headers = client._get_headers()
+        assert headers["Authorization"] == "Bearer url-token"
+
+    def test_auth_token_param_overrides_url_token(self):
+        client = DevlogsClient(
+            collector_url="http://url-token@localhost:8080",
+            application="test-app",
+            component="api",
+            auth_token="param-token",
+        )
+        headers = client._get_headers()
+        assert headers["Authorization"] == "Bearer param-token"
+
+    def test_get_endpoint_strips_userinfo_for_collector_url(self):
+        """Collector URL: userinfo is stripped from endpoint."""
+        client = DevlogsClient(
+            collector_url="http://mytoken@localhost:8080",
+            application="test-app",
+            component="api",
+        )
+        assert client._get_endpoint() == "http://localhost:8080/v1/logs"
+
+    def test_opensearch_url_keeps_credentials(self):
+        """OpenSearch URL: credentials remain in URL, no Bearer token."""
+        client = DevlogsClient(
+            collector_url="https://admin:password@opensearch.example.com:9200",
+            application="test-app",
+            component="api",
+        )
+        headers = client._get_headers()
+        assert "Authorization" not in headers
+        assert client._get_endpoint() == "https://admin:password@opensearch.example.com:9200/v1/logs"
+
     def test_emit_sends_single_record(self):
         client = DevlogsClient(
             collector_url="http://localhost:8080",