Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 43 additions & 13 deletions aws_lambda_powertools/logging/logger.py
Original file line number Diff line number Diff line change
Expand Up @@ -999,9 +999,34 @@ def _get_aws_lambda_log_level(self) -> str | None:

return constants.LAMBDA_ADVANCED_LOGGING_LEVELS.get(os.getenv(constants.LAMBDA_LOG_LEVEL_ENV))

def _get_powertools_log_level(self, level: str | int | None) -> str | None:
def _to_numeric_log_level(self, level: str | int) -> int:
"""Convert a log level name or integer to its numeric value."""
if isinstance(level, str):
name = level.upper()
mapping = (
logging.getLevelNamesMapping() if hasattr(logging, "getLevelNamesMapping") else logging._nameToLevel
)
if name in mapping:
return mapping[name]

val = logging.getLevelName(name)
if isinstance(val, int):
return val

if hasattr(logging, "_checkLevel"):
return logging._checkLevel(name)

raise ValueError(f"Unknown level: {level!r}")

if isinstance(level, int) and not isinstance(level, bool):
return level

raise TypeError(f"Level not an integer or a valid string: {level!r}")

def _get_powertools_log_level(self, level: str | int | None) -> str | int | None:
"""Retrieve the log level for Powertools from the environment variable or level parameter.
If log level is an integer, we convert to its respective string level `logging.getLevelName()`.
If log level is an integer, we return it directly as an integer.
If log level is a string, we normalize it to uppercase.
If no log level is provided, we check env vars for the log level: POWERTOOLS_LOG_LEVEL_ENV and POWERTOOLS_LOG_LEVEL_LEGACY_ENV.
Parameters:
-----------
Expand All @@ -1015,19 +1040,24 @@ def _get_powertools_log_level(self, level: str | int | None) -> str | None:
log level (e.g: INFO, DEBUG, WARNING, ERROR, CRITICAL)
Returns:
--------
str | None:
str | int | None:
The corresponding logging level. Returns None if the log level is not explicitly specified.
""" # noqa E501

# Extract log level from Powertools Logger env vars
log_level_env = os.getenv(constants.POWERTOOLS_LOG_LEVEL_ENV) or os.getenv(
constants.POWERTOOLS_LOG_LEVEL_LEGACY_ENV,
)
# If level is an int (logging.INFO), return its respective string ("INFO")
if isinstance(level, int):
return logging.getLevelName(level)
if isinstance(level, str) and level:
return level.upper()

if isinstance(level, int) and not isinstance(level, bool):
return level

return level or log_level_env
if log_level_env is not None:
return log_level_env.upper()

return None

def _determine_log_level(self, level: str | int | None) -> str | int:
"""Determine the effective log level considering Lambda and Powertools preferences.
Expand All @@ -1038,7 +1068,7 @@ def _determine_log_level(self, level: str | int | None) -> str | int:
The specified log level as a string, integer, or None.
Returns:
----------
str | int: The effective logging level.
str | int: The effective logging level.
"""

# This function consider the following order of precedence:
Expand All @@ -1051,9 +1081,9 @@ def _determine_log_level(self, level: str | int | None) -> str | int:
lambda_log_level = self._get_aws_lambda_log_level()
powertools_log_level = self._get_powertools_log_level(level)

if powertools_log_level and lambda_log_level:
if powertools_log_level is not None and lambda_log_level:
# If Powertools log level is set and higher than AWS Lambda Advanced Logging Controls, emit a warning
if logging.getLevelName(lambda_log_level) > logging.getLevelName(powertools_log_level):
if self._to_numeric_log_level(lambda_log_level) > self._to_numeric_log_level(powertools_log_level):
warnings.warn(
f"Current log level ({powertools_log_level}) does not match AWS Lambda Advanced Logging Controls "
f"minimum log level ({lambda_log_level}). This can lead to data loss, consider adjusting them.",
Expand All @@ -1065,8 +1095,8 @@ def _determine_log_level(self, level: str | int | None) -> str | int:
if (
hasattr(self, "_buffer_config")
and self._buffer_config
and logging.getLevelName(lambda_log_level)
> logging.getLevelName(self._buffer_config.buffer_at_verbosity)
and self._to_numeric_log_level(lambda_log_level)
> self._to_numeric_log_level(self._buffer_config.buffer_at_verbosity)
):
warnings.warn(
"Advanced Logging Controls (ALC) Log Level is less verbose than Log Buffering Log Level. "
Expand All @@ -1085,7 +1115,7 @@ def _determine_log_level(self, level: str | int | None) -> str | int:
return logging.INFO

# Powertools log level is set, we use this
return powertools_log_level.upper()
return powertools_log_level

# FUNCTIONS for Buffering log

Expand Down
82 changes: 82 additions & 0 deletions tests/functional/logger/required_dependencies/test_logger.py
Original file line number Diff line number Diff line change
Expand Up @@ -1284,6 +1284,88 @@ def test_log_level_advanced_logging_controler_warning_different_log_levels_using
assert logger.log_level == logging.INFO


@pytest.mark.parametrize(
"level_input, expected_level",
[
("debug", logging.DEBUG),
("info", logging.INFO),
("warning", logging.WARNING),
("error", logging.ERROR),
("critical", logging.CRITICAL),
(15, 15),
(logging.INFO, logging.INFO),

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

A row for the empty string. It fails on this branch without the change above and passes with it.

Suggested change
(logging.INFO, logging.INFO),
(logging.INFO, logging.INFO),
("", logging.INFO),

("", logging.INFO),
],
)
def test_logger_level_case_insensitive_and_integer_without_alc(stdout, service_name, level_input, expected_level):
# GIVEN no ALC environment variable
# WHEN Logger is initialized with lowercase string or integer level
logger = Logger(service=service_name, stream=stdout, level=level_input)

# THEN the log level matches the expected numeric level
assert logger.log_level == expected_level

# AND setLevel also accepts lowercase and custom integer
logger.setLevel(level=level_input)
assert logger.log_level == expected_level


@pytest.mark.parametrize(
"level_input, alc_level, should_warn, expected_effective_level",
[
("debug", "INFO", True, logging.INFO),
("info", "INFO", False, logging.INFO),
("warning", "INFO", False, logging.INFO),
(15, "INFO", True, logging.INFO),
(15, "DEBUG", False, logging.DEBUG),
(25, "INFO", False, logging.INFO),
],
)
def test_logger_level_case_insensitive_and_integer_with_alc(
monkeypatch,
stdout,
service_name,
level_input,
alc_level,
should_warn,
expected_effective_level,
):
# GIVEN ALC is configured
monkeypatch.setenv(constants.LAMBDA_LOG_LEVEL_ENV, alc_level)

# WHEN Logger is initialized with lowercase string or integer level
if should_warn:
with pytest.warns(UserWarning):
logger = Logger(service=service_name, stream=stdout, level=level_input)
else:
logger = Logger(service=service_name, stream=stdout, level=level_input)

# THEN ALC takes precedence
assert logger.log_level == expected_effective_level


@pytest.mark.parametrize("env_var", [constants.POWERTOOLS_LOG_LEVEL_ENV, constants.POWERTOOLS_LOG_LEVEL_LEGACY_ENV])
@pytest.mark.parametrize(
"env_value, expected_level",
[
("debug", logging.DEBUG),
("info", logging.INFO),
("warning", logging.WARNING),
("error", logging.ERROR),
("critical", logging.CRITICAL),
],
)
def test_logger_env_var_case_insensitive(monkeypatch, stdout, service_name, env_var, env_value, expected_level):
# GIVEN POWERTOOLS_LOG_LEVEL or LOG_LEVEL is set with lowercase string
monkeypatch.setenv(env_var, env_value)

# WHEN Logger is initialized without explicit level
logger = Logger(service=service_name, stream=stdout)

# THEN Logger normalizes the level case-insensitively
assert logger.log_level == expected_level


def test_logger_add_remove_filter(stdout, service_name):
# GIVEN a Logger with a custom logging filter
class ApiKeyFilter(logging.Filter): # NOSONAR # need filter to test actual impl.
Expand Down