Skip to content

cortex.utils.logging

logging

Shared logging configuration for Cortex.

Provides colored console logging with consistent formatting across all modules.

Classes

ColoredFormatter

Bases: Formatter

Custom formatter with colors for different log levels and message types.

Source code in src/cortex/utils/logging.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class ColoredFormatter(logging.Formatter):
    """
    Custom formatter with colors for different log levels and message types.
    """

    LEVEL_COLORS = {
        "DEBUG": CYAN,
        "INFO": GREEN,
        "WARNING": YELLOW,
        "ERROR": RED,
        "CRITICAL": BRIGHT_RED,
    }

    def format(self, record: logging.LogRecord) -> str:
        # Color the level name
        levelname = record.levelname
        if levelname in self.LEVEL_COLORS:
            record.levelname = f"{self.LEVEL_COLORS[levelname]}{levelname:<5}{RESET}"

        # Format the message first
        formatted = super().format(record)

        # Restore original levelname for potential reuse
        record.levelname = levelname

        # Apply message-specific colors
        msg = record.getMessage()

        # Blue separators
        if msg.startswith("-") or msg.startswith("="):
            return self._colorize_line(formatted, BLUE)

        return formatted

    def _colorize_line(self, line: str, color: str, bold: bool = False) -> str:
        """Apply color to the message portion of the log line."""
        # Find the last | separator and colorize everything after it
        parts = line.rsplit("|", 1)
        if len(parts) == 2:
            prefix, message = parts
            if bold:
                return f"{prefix}|{color}{BOLD}{message}{RESET}"
            return f"{prefix}|{color}{message}{RESET}"
        if bold:
            return f"{color}{BOLD}{line}{RESET}"
        return f"{color}{line}{RESET}"

Functions

get_logger 

get_logger(
    name: str, level: int = logging.INFO
) -> logging.Logger

Get a configured logger with colored output.

Parameters:

Name Type Description Default
name str

Logger name (e.g., "cortex.discovery")

 required
level int

Logging level (default: INFO)

 INFO

Returns:

Type Description
Logger

Configured logger instance
Source code in src/cortex/utils/logging.py 
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
def get_logger(name: str, level: int = logging.INFO) -> logging.Logger:
    """
    Get a configured logger with colored output.

    Args:
        name: Logger name (e.g., "cortex.discovery")
        level: Logging level (default: INFO)

    Returns:
        Configured logger instance
    """
    logger = logging.getLogger(name)

    # Avoid adding duplicate handlers
    if logger.handlers:
        return logger

    logger.setLevel(level)
    logger.propagate = False

    # Create console handler with colored formatter
    handler = logging.StreamHandler(sys.stdout)
    handler.setLevel(level)
    handler.setFormatter(
        ColoredFormatter(
            fmt="%(asctime)s | %(levelname)s | %(message)s",
            datefmt="%H:%M:%S",
        )
    )

    logger.addHandler(handler)

    return logger

set_log_level 

set_log_level(logger: Logger, level: str) -> None

Set the log level for a logger and its handlers.

Parameters:

Name Type Description Default
logger Logger

The logger to configure

 required
level str

Log level name ("DEBUG", "INFO", "WARNING", "ERROR")

 required
Source code in src/cortex/utils/logging.py 
116
117
118
119
120
121
122
123
124
125
126
127
def set_log_level(logger: logging.Logger, level: str) -> None:
    """
    Set the log level for a logger and its handlers.

    Args:
        logger: The logger to configure
        level: Log level name ("DEBUG", "INFO", "WARNING", "ERROR")
    """
    log_level = getattr(logging, level.upper(), logging.INFO)
    logger.setLevel(log_level)
    for handler in logger.handlers:
        handler.setLevel(log_level)