devlogs 2.0.2__tar.gz → 2.1.0__tar.gz

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

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

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

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

{devlogs-2.0.2 → devlogs-2.1.0}/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
+from .config import load_config, set_dotenv_path, set_url, URLParseError, _parse_opensearch_url, parse_url, CollectorURLConfig
 from .formatting import format_timestamp
 from .opensearch.client import (
 	get_opensearch_client,
@@ -39,7 +39,7 @@ OLD_TEMPLATE_NAMES = ("devlogs-template", "devlogs-logs-template")
 
 # Common options for commands - these can be placed anywhere in the command line
 ENV_OPTION = typer.Option(None, "--env", help="Path to .env file to load")
-URL_OPTION = typer.Option(None, "--url", help="OpenSearch URL (e.g., https://user:pass@host:port/index)")
+URL_OPTION = typer.Option(None, "--url", help="URL (e.g., opensearchs://user:pass@host:port/index or https://TOKEN@host:port/path)")
 
 
 def _apply_common_options(env: str = None, url: str = None):
@@ -61,11 +61,17 @@ def main_callback(
 	_apply_common_options(env, url)
 
 
+_HIDDEN_FIELDS = {"run_id", "build_number", "build_url", "job", "node_id", "seq"}
+
+
 def _format_features(features):
 	if not features:
 		return ""
 	if isinstance(features, dict):
-		items = sorted(features.items(), key=lambda item: str(item[0]))
+		items = sorted(
+			((k, v) for k, v in features.items() if k not in _HIDDEN_FIELDS),
+			key=lambda item: str(item[0]),
+		)
 		parts = []
 		for key, value in items:
 			key_text = str(key)
@@ -1166,7 +1172,13 @@ def demo(
 	"""Generate demo logs to illustrate devlogs capabilities."""
 	_apply_common_options(env, url)
 	from .demo import run_demo
-	run_demo(duration, count, require_opensearch)
+
+	cfg = load_config()
+	if cfg.url_mode == "collector":
+		from .devlogs_client import DevlogsClient
+		run_demo(duration, count, require_opensearch=None, collector_url=cfg.collector_url)
+	else:
+		run_demo(duration, count, require_opensearch=require_opensearch)
 
 
 @app.command()
@@ -1181,8 +1193,20 @@ def serve(
 
 
 def _build_opensearch_url(scheme: str, host: str, port: int, user: str, password: str, index: str) -> str:
-	"""Build an OpenSearch URL from components, URL-encoding credentials."""
+	"""Build an OpenSearch URL from components, URL-encoding credentials.
+
+	Uses the opensearchs:// scheme (TLS) or opensearch:// (non-TLS).
+	The scheme parameter accepts 'https'/'http' (mapped to opensearch schemes)
+	or 'opensearchs'/'opensearch' directly.
+	"""
 	from urllib.parse import quote
+	# Map legacy schemes to opensearch:// variants
+	if scheme == "https":
+		url_scheme = "opensearchs"
+	elif scheme == "http":
+		url_scheme = "opensearch"
+	else:
+		url_scheme = scheme
 	# URL-encode username and password to handle special characters
 	encoded_user = quote(user, safe="") if user else ""
 	encoded_pass = quote(password, safe="") if password else ""
@@ -1193,7 +1217,7 @@ def _build_opensearch_url(scheme: str, host: str, port: int, user: str, password
 	else:
 		auth = ""
 	path = f"/{index}" if index else ""
-	return f"{scheme}://{auth}{host}:{port}{path}"
+	return f"{url_scheme}://{auth}{host}:{port}{path}"
 
 
 def _format_env_output(scheme: str, host: str, port: int, user: str, password: str, index: str) -> str:
@@ -1211,155 +1235,6 @@ def _format_env_output(scheme: str, host: str, port: int, user: str, password: s
 	return "\n".join(lines)
 
 
-@app.command()
-def initjenkins(
-	jenkinsfile: str = typer.Argument("Jenkinsfile", help="Path to Jenkinsfile to modify"),
-	credential_id: str = typer.Option("devlogs-opensearch-url", "--credential-id", "-c", help="Jenkins credential ID to use"),
-	env: str = ENV_OPTION,
-	url: str = URL_OPTION,
-):
-	"""Add devlogs configuration to an existing Jenkinsfile.
-
-	This command modifies an existing Jenkinsfile to add an options block
-	with the devlogs pipeline step configured to use a Jenkins credential.
-
-	After running this command, you need to create a Jenkins credential
-	of type "Secret text" with the OpenSearch URL.
-
-	Examples:
-	  devlogs initjenkins                        # Modify ./Jenkinsfile
-	  devlogs initjenkins path/to/Jenkinsfile    # Modify specific file
-	  devlogs initjenkins --credential-id my-cred  # Use custom credential ID
-	"""
-	import re
-
-	_apply_common_options(env, url)
-
-	jenkinsfile_path = Path(jenkinsfile)
-	if not jenkinsfile_path.is_file():
-		typer.echo(typer.style(f"Error: Jenkinsfile not found: {jenkinsfile_path}", fg=typer.colors.RED), err=True)
-		raise typer.Exit(1)
-
-	content = jenkinsfile_path.read_text(encoding="utf-8")
-
-	# Check if this looks like a declarative pipeline
-	if "pipeline" not in content:
-		typer.echo(typer.style("Error: File does not appear to be a declarative Jenkins pipeline.", fg=typer.colors.RED), err=True)
-		typer.echo("This command only supports declarative pipelines with a 'pipeline { }' block.", err=True)
-		raise typer.Exit(1)
-
-	# Check if devlogs is already configured
-	if "devlogs(" in content:
-		typer.echo(typer.style("Warning: Jenkinsfile already appears to have devlogs configuration.", fg=typer.colors.YELLOW))
-		typer.echo("Review the file manually to ensure correct configuration.")
-		raise typer.Exit(0)
-
-	options_line = f"        devlogs(credentialsId: '{credential_id}')"
-
-	modified = False
-	lines = content.split("\n")
-	result_lines = []
-	i = 0
-
-	# Track brace depth and whether we're inside pipeline block
-	in_pipeline = False
-	pipeline_brace_depth = 0
-	added_options = False
-
-	while i < len(lines):
-		line = lines[i]
-		result_lines.append(line)
-
-		# Detect entering pipeline block
-		if not in_pipeline and re.match(r'^\s*pipeline\s*\{', line):
-			in_pipeline = True
-			pipeline_brace_depth = 1
-			i += 1
-			continue
-
-		if in_pipeline:
-			# Count braces to track depth
-			pipeline_brace_depth += line.count('{') - line.count('}')
-
-			# Check for existing options block and add our line
-			if not added_options and re.match(r'^\s*options\s*\{', line):
-				result_lines.append(options_line)
-				added_options = True
-				modified = True
-
-			# If we hit stages and haven't added options, add it before stages
-			if re.match(r'^\s*stages\s*\{', line) and not added_options:
-				# Insert before the stages line
-				result_lines.pop()  # Remove the stages line we just added
-
-				result_lines.append("")
-				result_lines.append("    options {")
-				result_lines.append(options_line)
-				result_lines.append("    }")
-				added_options = True
-				modified = True
-
-				result_lines.append("")
-				result_lines.append(line)  # Re-add the stages line
-
-			# Exit pipeline tracking when we close the pipeline block
-			if pipeline_brace_depth == 0:
-				in_pipeline = False
-
-		i += 1
-
-	if not modified:
-		typer.echo(typer.style("Error: Could not find a suitable location to add devlogs configuration.", fg=typer.colors.RED), err=True)
-		typer.echo("Ensure the Jenkinsfile has a 'pipeline { stages { } }' structure.", err=True)
-		raise typer.Exit(1)
-
-	# Write the modified file
-	new_content = "\n".join(result_lines)
-	jenkinsfile_path.write_text(new_content, encoding="utf-8")
-
-	typer.echo(typer.style(f"Modified {jenkinsfile_path}", fg=typer.colors.GREEN))
-	typer.echo()
-	typer.echo("Added:")
-	typer.echo(f"  - Options: devlogs(credentialsId: '{credential_id}')")
-
-	# Print setup instructions
-	typer.echo()
-	typer.echo(typer.style("Next steps - Create Jenkins credential:", fg=typer.colors.CYAN, bold=True))
-	typer.echo("=" * 60)
-	typer.echo()
-	typer.echo("1. Go to Jenkins > Manage Jenkins > Credentials")
-	typer.echo("2. Select the appropriate domain (e.g., Global)")
-	typer.echo("3. Click 'Add Credentials'")
-	typer.echo("4. Configure:")
-	typer.echo(f"   - Kind: Secret text")
-	typer.echo(f"   - ID: {credential_id}")
-	typer.echo("   - Secret: <your OpenSearch URL>")
-	typer.echo()
-
-	# Try to load config and show the URL value
-	try:
-		cfg = load_config()
-		if cfg.enabled:
-			# Build the URL from config
-			credential_url = _build_opensearch_url(
-				cfg.opensearch_scheme,
-				cfg.opensearch_host,
-				cfg.opensearch_port,
-				cfg.opensearch_user,
-				cfg.opensearch_pass,
-				cfg.index,
-			)
-			typer.echo(typer.style("Credential value (from your .env/environment):", fg=typer.colors.GREEN, bold=True))
-			typer.echo("-" * 60)
-			typer.echo(credential_url)
-			typer.echo("-" * 60)
-		else:
-			typer.echo("Tip: Set up a .env file with DEVLOGS_OPENSEARCH_URL to see the exact value here.")
-			typer.echo("     Run 'devlogs mkurl' to interactively build the URL.")
-	except Exception:
-		typer.echo("Tip: Run 'devlogs mkurl' to interactively build the OpenSearch URL.")
-
-
 @app.command()
 def mkurl():
 	"""Interactively create an OpenSearch URL and show .env formats.
@@ -1410,10 +1285,8 @@ def mkurl():
 	else:
 		# Prompt for each component
 		typer.echo()
-		scheme = typer.prompt("Scheme (http/https)", default="https")
-		if scheme not in ("http", "https"):
-			typer.echo(typer.style("Error: Scheme must be 'http' or 'https'.", fg=typer.colors.RED), err=True)
-			raise typer.Exit(1)
+		use_tls = typer.prompt("Use TLS? (yes/no)", default="yes")
+		scheme = "https" if use_tls.lower() in ("yes", "y") else "http"
 		host = typer.prompt("Host", default="localhost")
 		default_port = 443 if scheme == "https" else 9200
 		port = int(typer.prompt("Port", default=str(default_port)))

{devlogs-2.0.2 → devlogs-2.1.0}/src/devlogs/collector/cli.py

@@ -75,6 +75,8 @@ def serve(
             typer.echo(f"  OpenSearch: {cfg.opensearch_host}:{cfg.opensearch_port}")
             typer.echo(f"  Index: {cfg.index}")
 
+    from ..version import __version__
+    typer.echo(f"  Version: {__version__}")
     typer.echo(f"  Listening on: {host}:{port}")
     typer.echo()
 

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

@@ -5,6 +5,8 @@
 # - Ingest mode: write directly to OpenSearch
 
 import json
+import platform
+from contextlib import asynccontextmanager
 from typing import Optional
 
 from fastapi import FastAPI, Request, Response, HTTPException
@@ -17,6 +19,7 @@ from .schema import (
     validate_record,
     normalize_records,
     enrich_record,
+    get_current_timestamp,
 )
 from .errors import (
     CollectorError,
@@ -33,12 +36,73 @@ from .auth import (
 )
 from .forwarder import forward_request
 from .ingestor import ingest_records
+from ..version import __version__
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Emit a startup trace to the index so operators can see when the collector started."""
+    cfg = load_config()
+    mode = cfg.get_collector_mode()
+
+    if mode == "ingest":
+        try:
+            client = get_opensearch_client()
+            doc = DevlogsRecord(
+                application="devlogs-collector",
+                component="lifecycle",
+                timestamp=get_current_timestamp(),
+                message="Collector started",
+                level="info",
+                area="startup",
+                version=__version__,
+                fields={
+                    "mode": mode,
+                    "host": platform.node(),
+                    "opensearch_host": cfg.opensearch_host,
+                    "index": cfg.index,
+                },
+            )
+            doc.collected_ts = get_current_timestamp()
+            doc.client_ip = "127.0.0.1"
+            doc._identity = {"mode": "internal"}
+            client.index(index=cfg.index, body=doc.to_dict())
+        except Exception:
+            # Startup trace is best-effort; don't block the server
+            pass
+
+    yield
+
+    # Emit shutdown trace
+    if mode == "ingest":
+        try:
+            client = get_opensearch_client()
+            doc = DevlogsRecord(
+                application="devlogs-collector",
+                component="lifecycle",
+                timestamp=get_current_timestamp(),
+                message="Collector stopped",
+                level="info",
+                area="shutdown",
+                version=__version__,
+                fields={
+                    "mode": mode,
+                    "host": platform.node(),
+                },
+            )
+            doc.collected_ts = get_current_timestamp()
+            doc.client_ip = "127.0.0.1"
+            doc._identity = {"mode": "internal"}
+            client.index(index=cfg.index, body=doc.to_dict())
+        except Exception:
+            pass
+
 
 # Create FastAPI app for collector
 app = FastAPI(
     title="Devlogs Collector",
     description="HTTP log collector for the devlogs format",
-    version="1.0.0",
+    version=__version__,
+    lifespan=lifespan,
 )
 
 
@@ -83,6 +147,7 @@ async def health():
     return {
         "status": "healthy",
         "mode": mode,
+        "version": __version__,
     }
 
 

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

@@ -2,7 +2,11 @@
 
 import os
 import re
-from urllib.parse import urlparse, unquote
+import sys
+import warnings
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import urlparse, unquote, parse_qs
 
 # Lazy load dotenv - only when config is first accessed
 _dotenv_loaded = False
@@ -118,16 +122,180 @@ class URLParseError(ValueError):
 	pass
 
 
+@dataclass
+class CollectorURLConfig:
+	"""Parsed collector URL configuration."""
+	url: str  # Base URL (scheme://host:port/path, no credentials)
+	token: Optional[str] = None  # Bearer token
+
+
+@dataclass
+class OpenSearchURLConfig:
+	"""Parsed OpenSearch URL configuration."""
+	scheme: str
+	host: str
+	port: int
+	user: Optional[str] = None
+	password: Optional[str] = None
+	index: Optional[str] = None
+	application: Optional[str] = None  # Optional application filter from second path segment
+
+
+def parse_url(url: str):
+	"""Parse a URL and return a CollectorURLConfig or OpenSearchURLConfig.
+
+	Detection logic:
+	- 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
+	Raises: URLParseError if URL is malformed
+	"""
+	if not url:
+		raise URLParseError("Empty URL")
+
+	# Check for opensearch:// or opensearchs:// schemes
+	if url.startswith("opensearchs://") or url.startswith("opensearch://"):
+		return _parse_opensearch_scheme_url(url)
+
+	parsed = urlparse(url)
+
+	if parsed.scheme not in ("http", "https"):
+		raise URLParseError(f"Invalid URL scheme '{parsed.scheme}': expected 'http', 'https', 'opensearch', or 'opensearchs'")
+
+	if not parsed.hostname:
+		raise URLParseError(f"Invalid URL '{url}': missing hostname")
+
+	# If both user AND password → legacy OpenSearch format, emit deprecation warning
+	if parsed.username and parsed.password:
+		warnings.warn(
+			f"Using https://user:pass@host URL format for OpenSearch is deprecated. "
+			f"Use opensearchs://user:pass@host instead.",
+			DeprecationWarning,
+			stacklevel=2,
+		)
+		return _parse_opensearch_url_to_config(url)
+
+	# Otherwise it's a collector URL
+	return _parse_collector_url_config(url)
+
+
+def _parse_opensearch_scheme_url(url: str) -> OpenSearchURLConfig:
+	"""Parse opensearchs:// (TLS) or opensearch:// (non-TLS) URL into OpenSearchURLConfig."""
+	# Determine the transport scheme
+	if url.startswith("opensearchs://"):
+		transport_scheme = "https"
+		parse_url_str = "https://" + url[len("opensearchs://"):]
+	else:
+		transport_scheme = "http"
+		parse_url_str = "http://" + url[len("opensearch://"):]
+
+	parsed = urlparse(parse_url_str)
+
+	if not parsed.hostname:
+		raise URLParseError(f"Invalid URL '{url}': missing hostname")
+
+	host = parsed.hostname
+	port = parsed.port or (443 if transport_scheme == "https" else 9200)
+	user = unquote(parsed.username) if parsed.username else None
+	password = unquote(parsed.password) if parsed.password else None
+
+	# Path segments: first = index, second = application
+	path = parsed.path.strip("/")
+	parts = path.split("/", 1) if path else []
+	index = parts[0] if parts else None
+	application = parts[1] if len(parts) > 1 else None
+
+	return OpenSearchURLConfig(
+		scheme=transport_scheme,
+		host=host,
+		port=port,
+		user=user,
+		password=password,
+		index=index or None,
+		application=application or None,
+	)
+
+
+def _parse_collector_url_config(url: str) -> CollectorURLConfig:
+	"""Parse an http(s) URL as a collector URL, extracting token."""
+	parsed = urlparse(url)
+
+	token = None
+
+	# Check for token in userinfo (token-only, no password)
+	if parsed.username and not parsed.password:
+		token = unquote(parsed.username)
+		# Rebuild URL without userinfo
+		if parsed.port:
+			netloc = f"{parsed.hostname}:{parsed.port}"
+		else:
+			netloc = parsed.hostname or ""
+		from urllib.parse import urlunparse
+		clean_url = urlunparse((
+			parsed.scheme, netloc, parsed.path,
+			parsed.params, parsed.query, parsed.fragment,
+		))
+	else:
+		clean_url = url
+
+	# Check for ?token= query param
+	if not token:
+		query_params = parse_qs(parsed.query)
+		token_values = query_params.get("token")
+		if token_values:
+			token = token_values[0]
+			# Strip token param from the URL
+			from urllib.parse import urlencode
+			remaining = {k: v[0] for k, v in query_params.items() if k != "token"}
+			new_query = urlencode(remaining) if remaining else ""
+			reparsed = urlparse(clean_url)
+			from urllib.parse import urlunparse
+			clean_url = urlunparse((
+				reparsed.scheme, reparsed.netloc, reparsed.path,
+				reparsed.params, new_query, reparsed.fragment,
+			))
+
+	return CollectorURLConfig(url=clean_url, token=token)
+
+
+def _parse_opensearch_url_to_config(url: str) -> OpenSearchURLConfig:
+	"""Parse a standard http(s) URL into OpenSearchURLConfig."""
+	result = _parse_opensearch_url(url)
+	if result is None:
+		raise URLParseError(f"Invalid URL '{url}'")
+	scheme, host, port, user, password, index = result
+	return OpenSearchURLConfig(
+		scheme=scheme, host=host, port=port,
+		user=user, password=password, index=index,
+	)
+
+
 def _parse_opensearch_url(url: str):
 	"""Parse DEVLOGS_OPENSEARCH_URL into components.
 
 	Supports format: https://user:pass@host:port/index
+	Also supports: opensearchs://user:pass@host:port/index (TLS)
+	              opensearch://user:pass@host:port/index (non-TLS)
 	Returns: (scheme, host, port, user, pass, index) or None if no URL
 	Raises: URLParseError if URL is malformed
 	"""
 	if not url:
 		return None
-	parsed = urlparse(url)
+
+	# Handle opensearchs:// (TLS) and opensearch:// (non-TLS) schemes
+	if url.startswith("opensearchs://"):
+		actual_url = "https://" + url[len("opensearchs://"):]
+		force_scheme = "https"
+	elif url.startswith("opensearch://"):
+		actual_url = "http://" + url[len("opensearch://"):]
+		force_scheme = "http"
+	else:
+		actual_url = url
+		force_scheme = None
+
+	parsed = urlparse(actual_url)
 
 	# Validate scheme
 	if parsed.scheme and parsed.scheme not in ("http", "https"):
@@ -137,7 +305,7 @@ def _parse_opensearch_url(url: str):
 	if not parsed.hostname:
 		raise URLParseError(f"Invalid URL '{url}': missing hostname")
 
-	scheme = parsed.scheme or "http"
+	scheme = force_scheme or parsed.scheme or "http"
 	host = parsed.hostname
 	port = parsed.port or (443 if scheme == "https" else 9200)
 	# URL-decode username and password since urlparse doesn't do this automatically
@@ -227,6 +395,15 @@ class DevlogsConfig:
 		self.collector_workers = int(_getenv("DEVLOGS_COLLECTOR_WORKERS", "1"))
 		self.collector_log_level = _getenv("DEVLOGS_COLLECTOR_LOG_LEVEL", "info")
 
+	@property
+	def url_mode(self) -> str:
+		"""Return 'collector' if DEVLOGS_URL is set, 'opensearch' if OpenSearch is configured, else 'none'."""
+		if self.collector_url:
+			return "collector"
+		if self.has_opensearch_config():
+			return "opensearch"
+		return "none"
+
 	def has_opensearch_config(self) -> bool:
 		"""Check if OpenSearch admin connection is configured."""
 		return bool(
@@ -257,8 +434,27 @@ def set_dotenv_path(path: str):
 
 
 def set_url(url: str):
-	"""Set the OpenSearch URL. Must be called before load_config()."""
-	os.environ["DEVLOGS_OPENSEARCH_URL"] = url
+	"""Set the URL, auto-detecting whether it's a collector or OpenSearch URL.
+
+	Uses parse_url() to detect the URL type:
+	- Collector URLs → sets DEVLOGS_URL
+	- OpenSearch URLs → sets DEVLOGS_OPENSEARCH_URL
+	"""
+	if not url:
+		return
+	try:
+		parsed = parse_url(url)
+	except URLParseError:
+		# Fall back to legacy behavior
+		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
 
 def load_config() -> DevlogsConfig:
 	"""Return a config object with all settings loaded."""

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

@@ -13,29 +13,42 @@ from .handler import OpenSearchHandler
 def run_demo(
 	duration: int,
 	count: int,
-	require_opensearch,
+	require_opensearch=None,
+	collector_url: str = None,
 ):
 	"""Generate demo logs to illustrate devlogs capabilities."""
 	cfg = load_config()
 
-	# Show loaded configuration
-	typer.echo("=== DevLogs Demo ===\n")
-	typer.echo("Configuration loaded from .env:")
-	typer.echo(f"  DEVLOGS_OPENSEARCH_HOST: {cfg.opensearch_host}")
-	typer.echo(f"  DEVLOGS_OPENSEARCH_PORT: {cfg.opensearch_port}")
-	typer.echo(f"  DEVLOGS_OPENSEARCH_USER: {cfg.opensearch_user}")
-	typer.echo(f"  DEVLOGS_OPENSEARCH_PASS: {'*' * len(cfg.opensearch_pass)}")
-	typer.echo(f"  DEVLOGS_INDEX: {cfg.index}")
-	typer.echo(f"  DEVLOGS_RETENTION_DEBUG: {cfg.retention_debug_hours}h")
-	typer.echo("")
-
-	# Check OpenSearch connection and index
-	client, cfg = require_opensearch()
-	handler = OpenSearchHandler(
-		level=logging.DEBUG,
-		opensearch_client=client,
-		index_name=cfg.index,
-	)
+	if collector_url:
+		# Collector mode
+		typer.echo("=== DevLogs Demo (Collector Mode) ===\n")
+		typer.echo(f"  Collector URL: {collector_url}")
+		typer.echo("")
+
+		handler = OpenSearchHandler(
+			level=logging.DEBUG,
+			collector_url=collector_url,
+		)
+	else:
+		# OpenSearch mode
+		typer.echo("=== DevLogs Demo ===\n")
+		typer.echo("Configuration loaded from .env:")
+		typer.echo(f"  DEVLOGS_OPENSEARCH_HOST: {cfg.opensearch_host}")
+		typer.echo(f"  DEVLOGS_OPENSEARCH_PORT: {cfg.opensearch_port}")
+		typer.echo(f"  DEVLOGS_OPENSEARCH_USER: {cfg.opensearch_user}")
+		typer.echo(f"  DEVLOGS_OPENSEARCH_PASS: {'*' * len(cfg.opensearch_pass)}")
+		typer.echo(f"  DEVLOGS_INDEX: {cfg.index}")
+		typer.echo(f"  DEVLOGS_RETENTION_DEBUG: {cfg.retention_debug_hours}h")
+		typer.echo("")
+
+		# Check OpenSearch connection and index
+		client, cfg = require_opensearch()
+		handler = OpenSearchHandler(
+			level=logging.DEBUG,
+			opensearch_client=client,
+			index_name=cfg.index,
+		)
+
 	handler.setFormatter(logging.Formatter("%(message)s"))
 
 	logger = logging.getLogger("devlogs.demo")