Colors not rendering in Apache WSGI logs (hashtag1026)

[vikramsubramanian]

I integrated loguru with a django application with this handler.

    dict(
        sink=sys.stderr,
        format="<g>{time:YYYY ddd MMM DD HH:mm:ss.SSSSSSZZ}</g>",
        colorize=True,
        backtrace=False, 
        diagnose=True,  
        catch=True, 
    ),

When I try to use django's inbuilt webserver to serve the application, the colors are shown just fine but for production environment, I use Apache WSGI to serve django application, the logs print fine in apache logs, but the colors are shown as codes instead of the actual color.

\x1b[32m2023 Sun Nov 26 23:44:55.622738+0000\x1b[0m - Apache Logs

![image]( - Django Development Server logs

I tested Apache Logs both on gitbash and command prompt

)

[mayil-ai]

Possible Solution

• Set colorize=False in the handler configuration to disable ANSI color codes when logs are being written to Apache WSGI logs.
• Ensure that the colorize parameter is set based on the output stream's ability to handle ANSI color codes. Use the should_colorize function from _colorama.py to determine if the output stream supports colorization.
• Modify the add method in _logger.py to conditionally set colorize based on the output stream:

  if colorize is None:
      colorize = _colorama.should_colorize(sink)

• If Apache WSGI does not support color codes, consider using a different logging configuration for production that does not rely on ANSI color codes.

Code snippets to check

loguru → _colorama.py

This snippet contains the logic to determine if the output should be colorized, which is directly related to the issue of colors not rendering properly in Apache WSGI logs.

loguru/loguru/_colorama.py

Lines 1 to 67 in 871de74

	import builtins
	import os
	import sys
	def should_colorize(stream):
	if stream is None:
	return False
	if getattr(builtins, "__IPYTHON__", False) and (stream is sys.stdout or stream is sys.stderr):
	try:
	import ipykernel
	import IPython
	ipython = IPython.get_ipython()
	is_jupyter_stream = isinstance(stream, ipykernel.iostream.OutStream)
	is_jupyter_shell = isinstance(ipython, ipykernel.zmqshell.ZMQInteractiveShell)
	except Exception:
	pass
	else:
	if is_jupyter_stream and is_jupyter_shell:
	return True
	if stream is sys.__stdout__ or stream is sys.__stderr__:
	if "CI" in os.environ and any(
	ci in os.environ
	for ci in ["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS"]
	):
	return True
	if "PYCHARM_HOSTED" in os.environ:
	return True
	if os.name == "nt" and "TERM" in os.environ:
	return True
	try:
	return stream.isatty()
	except Exception:
	return False
	def should_wrap(stream):
	if os.name != "nt":
	return False
	if stream is not sys.__stdout__ and stream is not sys.__stderr__:
	return False
	from colorama.win32 import winapi_test
	if not winapi_test():
	return False
	try:
	from colorama.winterm import enable_vt_processing
	except ImportError:
	return True
	try:
	return not enable_vt_processing(stream.fileno())
	except Exception:
	return True
	def wrap(stream):
	from colorama import AnsiToWin32
	return AnsiToWin32(stream, convert=True, strip=True, autoreset=False).stream

loguru → _colorizer.py

This snippet contains the logic for substituting color tags with ANSI codes, which is relevant to the issue since the colors are shown as codes instead of the actual color in Apache logs.

loguru/loguru/_colorizer.py

Lines 274 to 309 in 871de74

	def _get_ansicode(self, tag):
	style = self._style
	foreground = self._foreground
	background = self._background
	# Substitute on a direct match.
	if tag in style:
	return style[tag]
	if tag in foreground:
	return foreground[tag]
	if tag in background:
	return background[tag]
	# An alternative syntax for setting the color (e.g. <fg red>, <bg red>).
	if tag.startswith("fg ") or tag.startswith("bg "):
	st, color = tag[:2], tag[3:]
	code = "38" if st == "fg" else "48"
	if st == "fg" and color.lower() in foreground:
	return foreground[color.lower()]
	if st == "bg" and color.upper() in background:
	return background[color.upper()]
	if color.isdigit() and int(color) <= 255:
	return "\033[%s;5;%sm" % (code, color)
	if re.match(r"#(?:[a-fA-F0-9]{3}){1,2}$", color):
	hex_color = color[1:]
	if len(hex_color) == 3:
	hex_color *= 2
	rgb = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
	return "\033[%s;2;%s;%s;%sm" % ((code,) + rgb)
	if color.count(",") == 2:
	colors = tuple(color.split(","))
	if all(x.isdigit() and int(x) <= 255 for x in colors):
	return "\033[%s;2;%s;%s;%sm" % ((code,) + colors)
	return None

This snippet deals with the colorization of messages and may be relevant to understand how the colorization process is applied to log messages.

loguru/loguru/_colorizer.py

Lines 312 to 350 in 871de74

	class ColoringMessage(str):
	__fields__ = ("_messages",)
	def __format__(self, spec):
	return next(self._messages).__format__(spec)
	class ColoredMessage:
	def __init__(self, tokens):
	self.tokens = tokens
	self.stripped = AnsiParser.strip(tokens)
	def colorize(self, ansi_level):
	return AnsiParser.colorize(self.tokens, ansi_level)
	class ColoredFormat:
	def __init__(self, tokens, messages_color_tokens):
	self._tokens = tokens
	self._messages_color_tokens = messages_color_tokens
	def strip(self):
	return AnsiParser.strip(self._tokens)
	def colorize(self, ansi_level):
	return AnsiParser.colorize(self._tokens, ansi_level)
	def make_coloring_message(self, message, *, ansi_level, colored_message):
	messages = [
	message
	if color_tokens is None
	else AnsiParser.wrap(
	colored_message.tokens, ansi_level=ansi_level, color_tokens=color_tokens
	)
	for color_tokens in self._messages_color_tokens
	]
	coloring = ColoringMessage(message)
	coloring._messages = iter(messages)
	return coloring

This snippet defines background color codes and may be relevant to the issue if the problem is related to the background color rendering.

loguru/loguru/_colorizer.py

Lines 132 to 214 in 871de74

	_background = ansi_escape(
	{
	"K": Back.BLACK,
	"R": Back.RED,
	"G": Back.GREEN,
	"Y": Back.YELLOW,
	"E": Back.BLUE,
	"M": Back.MAGENTA,
	"C": Back.CYAN,
	"W": Back.WHITE,
	"LK": Back.LIGHTBLACK_EX,
	"LR": Back.LIGHTRED_EX,
	"LG": Back.LIGHTGREEN_EX,
	"LY": Back.LIGHTYELLOW_EX,
	"LE": Back.LIGHTBLUE_EX,
	"LM": Back.LIGHTMAGENTA_EX,
	"LC": Back.LIGHTCYAN_EX,
	"LW": Back.LIGHTWHITE_EX,
	"BLACK": Back.BLACK,
	"RED": Back.RED,
	"GREEN": Back.GREEN,
	"YELLOW": Back.YELLOW,
	"BLUE": Back.BLUE,
	"MAGENTA": Back.MAGENTA,
	"CYAN": Back.CYAN,
	"WHITE": Back.WHITE,
	"LIGHT-BLACK": Back.LIGHTBLACK_EX,
	"LIGHT-RED": Back.LIGHTRED_EX,
	"LIGHT-GREEN": Back.LIGHTGREEN_EX,
	"LIGHT-YELLOW": Back.LIGHTYELLOW_EX,
	"LIGHT-BLUE": Back.LIGHTBLUE_EX,
	"LIGHT-MAGENTA": Back.LIGHTMAGENTA_EX,
	"LIGHT-CYAN": Back.LIGHTCYAN_EX,
	"LIGHT-WHITE": Back.LIGHTWHITE_EX,
	}
	)
	_regex_tag = re.compile(r"\\?</?((?:[fb]g\s)?[^<>\s]*)>")
	def __init__(self):
	self._tokens = []
	self._tags = []
	self._color_tokens = []
	@staticmethod
	def strip(tokens):
	output = ""
	for type_, value in tokens:
	if type_ == TokenType.TEXT:
	output += value
	return output
	@staticmethod
	def colorize(tokens, ansi_level):
	output = ""
	for type_, value in tokens:
	if type_ == TokenType.LEVEL:
	if ansi_level is None:
	raise ValueError(
	"The '<level>' color tag is not allowed in this context, "
	"it has not yet been associated to any color value."
	)
	value = ansi_level
	output += value
	return output
	@staticmethod
	def wrap(tokens, *, ansi_level, color_tokens):
	output = ""
	for type_, value in tokens:
	if type_ == TokenType.LEVEL:
	value = ansi_level
	output += value
	if type_ == TokenType.CLOSING:
	for subtype, subvalue in color_tokens:
	if subtype == TokenType.LEVEL:
	subvalue = ansi_level
	output += subvalue
	return output

loguru → _better_exceptions.py

This snippet includes default color themes and initialization of colorization settings, which could be relevant to the issue if default settings are affecting the color output in Apache WSGI logs.

loguru/loguru/_better_exceptions.py

Lines 122 to 190 in 871de74

	_default_theme = {
	"introduction": "\x1b[33m\x1b[1m{}\x1b[0m",
	"cause": "\x1b[1m{}\x1b[0m",
	"context": "\x1b[1m{}\x1b[0m",
	"dirname": "\x1b[32m{}\x1b[0m",
	"basename": "\x1b[32m\x1b[1m{}\x1b[0m",
	"line": "\x1b[33m{}\x1b[0m",
	"function": "\x1b[35m{}\x1b[0m",
	"exception_type": "\x1b[31m\x1b[1m{}\x1b[0m",
	"exception_value": "\x1b[1m{}\x1b[0m",
	"arrows": "\x1b[36m{}\x1b[0m",
	"value": "\x1b[36m\x1b[1m{}\x1b[0m",
	}
	def __init__(
	self,
	colorize=False,
	backtrace=False,
	diagnose=True,
	theme=None,
	style=None,
	max_length=128,
	encoding="ascii",
	hidden_frames_filename=None,
	prefix="",
	):
	self._colorize = colorize
	self._diagnose = diagnose
	self._theme = theme or self._default_theme
	self._backtrace = backtrace
	self._syntax_highlighter = SyntaxHighlighter(style)
	self._max_length = max_length
	self._encoding = encoding
	self._hidden_frames_filename = hidden_frames_filename
	self._prefix = prefix
	self._lib_dirs = self._get_lib_dirs()
	self._pipe_char = self._get_char("\u2502", "|")
	self._cap_char = self._get_char("\u2514", "->")
	self._catch_point_identifier = " <Loguru catch point here>"
	@staticmethod
	def _get_lib_dirs():
	schemes = sysconfig.get_scheme_names()
	names = ["stdlib", "platstdlib", "platlib", "purelib"]
	paths = {sysconfig.get_path(name, scheme) for scheme in schemes for name in names}
	return [os.path.abspath(path).lower() + os.sep for path in paths if path in sys.path]
	@staticmethod
	def _indent(text, count, *, prefix="| "):
	if count == 0:
	yield text
	return
	for line in text.splitlines(True):
	indented = " " * count + prefix + line
	yield indented.rstrip() + "\n"
	def _get_char(self, char, default):
	try:
	char.encode(self._encoding)
	except (UnicodeEncodeError, LookupError):
	return default
	else:
	return char
	def _is_file_mine(self, file):
	filepath = os.path.abspath(file).lower()
	if not filepath.endswith(".py"):
	return False
	return not any(filepath.startswith(d) for d in self._lib_dirs)