From bf6a3cc4b25229607e01779ea947d3825630db63 Mon Sep 17 00:00:00 2001 From: Ronak Yadav Date: Sun, 15 Nov 2026 21:39:44 +0530 Subject: [PATCH 1/2] fix(logger): handle case-insensitive and integer log levels Lowercase log levels crashed with TypeError when AWS_LAMBDA_LOG_LEVEL was configured due to comparing int with str returned by logging.getLevelName(). Custom integer log levels crashed with ValueError when logging.getLevelName(int) returned "Level " which failed stdlib setLevel(). Normalize string level names case-insensitively, preserve integer levels, and compare numeric logging levels. Add regression test matrix. Closes #8823 --- aws_lambda_powertools/logging/logger.py | 56 ++++++++++--- .../required_dependencies/test_logger.py | 81 +++++++++++++++++++ 2 files changed, 124 insertions(+), 13 deletions(-) diff --git a/aws_lambda_powertools/logging/logger.py b/aws_lambda_powertools/logging/logger.py index 5d2a515d516..276d3d90c2f 100644 --- a/aws_lambda_powertools/logging/logger.py +++ b/aws_lambda_powertools/logging/logger.py @@ -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: ----------- @@ -1015,7 +1040,7 @@ 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 @@ -1023,11 +1048,16 @@ def _get_powertools_log_level(self, level: str | int | None) -> str | None: 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): + 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. @@ -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: @@ -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.", @@ -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. " @@ -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 diff --git a/tests/functional/logger/required_dependencies/test_logger.py b/tests/functional/logger/required_dependencies/test_logger.py index afc16b6cbfb..9b5d8fa750c 100644 --- a/tests/functional/logger/required_dependencies/test_logger.py +++ b/tests/functional/logger/required_dependencies/test_logger.py @@ -1284,6 +1284,87 @@ 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), + ], +) +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. From 02b114784429fc4889c61276aa01fccc2c912522 Mon Sep 17 00:00:00 2001 From: Ronak Yadav Date: Wed, 18 Nov 2026 14:46:39 +0530 Subject: [PATCH 2/2] fix(logger): preserve empty level fallback --- aws_lambda_powertools/logging/logger.py | 2 +- tests/functional/logger/required_dependencies/test_logger.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/aws_lambda_powertools/logging/logger.py b/aws_lambda_powertools/logging/logger.py index 276d3d90c2f..886de63da26 100644 --- a/aws_lambda_powertools/logging/logger.py +++ b/aws_lambda_powertools/logging/logger.py @@ -1048,7 +1048,7 @@ def _get_powertools_log_level(self, level: str | int | None) -> str | int | None log_level_env = os.getenv(constants.POWERTOOLS_LOG_LEVEL_ENV) or os.getenv( constants.POWERTOOLS_LOG_LEVEL_LEGACY_ENV, ) - if isinstance(level, str): + if isinstance(level, str) and level: return level.upper() if isinstance(level, int) and not isinstance(level, bool): diff --git a/tests/functional/logger/required_dependencies/test_logger.py b/tests/functional/logger/required_dependencies/test_logger.py index 9b5d8fa750c..6ac5c79b305 100644 --- a/tests/functional/logger/required_dependencies/test_logger.py +++ b/tests/functional/logger/required_dependencies/test_logger.py @@ -1294,6 +1294,7 @@ def test_log_level_advanced_logging_controler_warning_different_log_levels_using ("critical", logging.CRITICAL), (15, 15), (logging.INFO, logging.INFO), + ("", logging.INFO), ], ) def test_logger_level_case_insensitive_and_integer_without_alc(stdout, service_name, level_input, expected_level):