Simplify default log format: drop stream_id and env tags, shorten PID

Remove [stream_id=...] and [prod]/[test] from the default formatter strings. Show only the last four decimal digits of the process id as [pid=*XXXX]. Align Uvicorn formatters and add unit tests for format_log_pid_short and EnvironmentTaggingFormatter. EnvironmentTaggingFilter still sets env_tag for custom formats that reference it.

Made-with: Cursor

Author: Mateusz

src/core/common/logging_utils.py

@@ -6,7 +6,7 @@
 - Redaction of sensitive information
 - Consistent log level usage
 - Enhanced context information
-- Test/production environment tagging
+- Optional test/production ``env_tag`` on records (for filters and custom formats)
 """
 
 from __future__ import annotations
@@ -86,6 +86,21 @@ def get_environment_tag() -> str:
     return _get_environment_tag()
 
 
+def format_log_pid_short(process: int | None) -> str:
+    """Format a process id for log lines: asterisk plus last four decimal digits.
+
+    Used inside ``[pid=...]``, e.g. process ``440852`` -> ``*0852`` so the tag reads
+    ``[pid=*0852]``.
+    """
+    if process is None:
+        return "*----"
+    try:
+        pid_int = int(process)
+    except (TypeError, ValueError):
+        return "*----"
+    return f"*{pid_int % 10000:04d}"
+
+
 class EnvironmentTaggingFilter(logging.Filter):
     """Logging filter that adds environment tags to log records."""
 
@@ -107,9 +122,10 @@ def filter(self, record: logging.LogRecord) -> bool:  # type: ignore[override]
 
 
 class EnvironmentTaggingFormatter(logging.Formatter):
-    """Logging formatter that includes environment tags and PID.
+    """Logging formatter with shortened ``pid`` placeholder for log lines.
 
-    Format: YYYY-MM-DD HH:MM:SS,mmm [LEVEL] [env] [pid=XXX] name:lineno message
+    Default format: ``YYYY-MM-DD HH:MM:SS,mmm [LEVEL] [pid=*XXXX] name:lineno message``
+    where ``*XXXX`` is an asterisk plus the process id modulo 10000 (four digits).
     """
 
     def __init__(
@@ -118,15 +134,13 @@ def __init__(
         datefmt: str | None = None,
         style: Literal["%", "{", "$"] = "%",
     ) -> None:
-        # Set default format if none provided - compact level, env tag, and PID
         if fmt is None:
-            fmt = "%(asctime)s [%(levelname)s] [%(env_tag)s] [pid=%(process)d] [stream_id=%(stream_id)s] %(name)s:%(lineno)d %(message)s"
+            fmt = "%(asctime)s [%(levelname)s] [pid=%(pid_short)s] %(name)s:%(lineno)d %(message)s"
         super().__init__(fmt, datefmt, style=style)
 
     def format(self, record: logging.LogRecord) -> str:
-        """Populate optional logging fields used by the global format."""
-        if not hasattr(record, "stream_id"):
-            record.stream_id = "-"
+        """Set ``pid_short`` on the record for the format string."""
+        record.pid_short = format_log_pid_short(getattr(record, "process", None))
         return super().format(record)
 
 
@@ -533,9 +547,8 @@ def install_environment_tagging() -> None:
         for handler in list(root.handlers):
             try:
                 handler.addFilter(filter_instance)
-                # Update formatter to include environment tag
+                # Normalize formatter to EnvironmentTaggingFormatter (pid_short, etc.)
                 if isinstance(handler.formatter, logging.Formatter):
-                    # Use the environment tagging formatter
                     new_formatter = EnvironmentTaggingFormatter(
                         fmt=handler.formatter._fmt, datefmt=handler.formatter.datefmt
                     )
@@ -560,19 +573,17 @@ def configure_logging_with_environment_tagging(
     use_colors: bool = False,
     console_stream: str = "stderr",
 ) -> None:
-    """Configure logging with environment tagging.
+    """Configure root logging, structlog, env-tag filter, and standard formatters.
 
     Args:
         level: Logging level
         log_format: Optional log format string
         log_file: Optional log file path
         use_colors: Whether to enable colored output
     """
-    # Use default format with environment tag if none provided - compact level, env tag, and PID
     if log_format is None:
-        log_format = "%(asctime)s [%(levelname)s] [%(env_tag)s] [pid=%(process)d] [stream_id=%(stream_id)s] %(name)s:%(lineno)d %(message)s"
+        log_format = "%(asctime)s [%(levelname)s] [pid=%(pid_short)s] %(name)s:%(lineno)d %(message)s"
 
-    # Create formatter with environment tag support
     formatter = EnvironmentTaggingFormatter(fmt=log_format)
 
     # Create handlers
@@ -588,9 +599,8 @@ def configure_logging_with_environment_tagging(
             from rich.logging import RichHandler
 
             # Use RichHandler for colored output
-            # Define a simplified format for Rich that excludes time/level (Rich handles them)
-            # but includes the environment tag and location info
-            rich_fmt = "[%(env_tag)s] %(name)s:%(lineno)d %(message)s"
+            # Simplified format for Rich (time/level come from Rich); keep pid + location
+            rich_fmt = "[pid=%(pid_short)s] %(name)s:%(lineno)d %(message)s"
             rich_formatter = EnvironmentTaggingFormatter(fmt=rich_fmt)
 
             console_handler = RichHandler(

src/core/common/uvicorn_logging.py

@@ -3,14 +3,14 @@
 import logging
 from typing import Any
 
-from src.core.common.logging_utils import get_environment_tag
+from src.core.common.logging_utils import format_log_pid_short
 
 
 class UvicornEnvironmentTaggingFormatter(logging.Formatter):
-    """Custom formatter for Uvicorn that adds environment tags like the main app.
+    """Custom formatter for Uvicorn aligned with the main app log layout.
 
-    This ensures Uvicorn log messages match the format of the rest of the application:
-    YYYY-MM-DD HH:MM:SS,mmm [LEVEL] [env] [pid=XXX] name:lineno message
+    Format matches :class:`EnvironmentTaggingFormatter` defaults:
+    ``YYYY-MM-DD HH:MM:SS,mmm [LEVEL] [pid=*XXXX] name:lineno message``.
     """
 
     def __init__(
@@ -19,16 +19,14 @@ def __init__(
         datefmt: str | None = None,
         use_colors: bool = False,
     ) -> None:
-        # Use project-standard format if none provided - compact level, env tag, and PID
         if fmt is None:
-            fmt = "%(asctime)s [%(levelname)s] [%(env_tag)s] [pid=%(process)d] %(name)s:%(lineno)d %(message)s"
+            fmt = "%(asctime)s [%(levelname)s] [pid=%(pid_short)s] %(name)s:%(lineno)d %(message)s"
         super().__init__(fmt, datefmt)
-        self._env_tag = get_environment_tag()
         self._use_colors = use_colors
 
     def format(self, record: logging.LogRecord) -> str:
-        """Add environment tag to the log record before formatting."""
-        record.env_tag = self._env_tag
+        """Set ``pid_short`` and optional Uvicorn access fields before formatting."""
+        record.pid_short = format_log_pid_short(getattr(record, "process", None))
         if not hasattr(record, "client_addr"):
             self._maybe_populate_access_fields(record)
         return super().format(record)
@@ -67,12 +65,9 @@ def get_uvicorn_logging_config(
     Returns:
         Uvicorn logging configuration dictionary.
     """
-    # Use project-standard log format matching EnvironmentTaggingFormatter in logging_utils.py
-    # Compact level (no padding), env tag, and PID
-    standard_fmt = "%(asctime)s [%(levelname)s] [%(env_tag)s] [pid=%(process)d] %(name)s:%(lineno)d %(message)s"
-    # For access logs, include client address and request info
+    standard_fmt = "%(asctime)s [%(levelname)s] [pid=%(pid_short)s] %(name)s:%(lineno)d %(message)s"
     access_fmt = (
-        "%(asctime)s [%(levelname)s] [%(env_tag)s] [pid=%(process)d] %(name)s:%(lineno)d "
+        "%(asctime)s [%(levelname)s] [pid=%(pid_short)s] %(name)s:%(lineno)d "
         '%(client_addr)s - "%(request_line)s" %(status_code)s'
     )
 

tests/unit/core/test_core_logging_utils.py

@@ -11,7 +11,9 @@
 from src.core.common.logging_utils import (
     CompatibleBoundLogger,
     EnvironmentTaggingFilter,
+    EnvironmentTaggingFormatter,
     LogContext,
+    format_log_pid_short,
     get_logger,
     log_async_call,
     log_call,
@@ -244,6 +246,30 @@ def test_environment_tagging_marks_pytest(
         assert hasattr(record, "env_tag")
         assert record.env_tag == "test"
 
+    def test_format_log_pid_short(self) -> None:
+        assert format_log_pid_short(440852) == "*0852"
+        assert format_log_pid_short(852) == "*0852"
+        assert format_log_pid_short(5) == "*0005"
+        assert format_log_pid_short(None) == "*----"
+
+    def test_environment_tagging_formatter_default_line(self) -> None:
+        record = logging.LogRecord(
+            name="nm",
+            level=logging.INFO,
+            pathname=__file__,
+            lineno=7,
+            msg="hi",
+            args=(),
+            exc_info=None,
+        )
+        record.process = 440852
+        line = EnvironmentTaggingFormatter().format(record)
+        assert "[pid=*0852]" in line
+        assert "[INFO]" in line
+        assert "[prod]" not in line
+        assert "[test]" not in line
+        assert "nm:7 hi" in line
+
     def test_log_context(self) -> None:
         """Test LogContext class."""
         mock_logger = MagicMock()