logging-format-interpolation for f-strings

[eddie-dunn]

Pylint will warn against using .format and % when logging. As the example below shows, I think it would be prudent to also output warnings when using f-strings.

Steps to reproduce

"""Docstring"""
import logging


def main():
    """Main"""
    url = 'http://example.com/%fe'
    # This works:
    logging.error(
        'url is %s | log method: %s', url, 'logging with parameters only')

    # This will crash the logger, but pylint will output
    # logging-format-interpolation:
    logging.error(
        'url is {} | log method: %s'.format(url), 'logging with .format')

    # This will also crash the logger, but pylint accepts it:
    logging.error(f'url is {url} | log method: %s', 'logging with f-string')


main()

Current behavior

Pylint does not warn against f-string interpolation in loggers.

Expected behavior

Pylint should warn against f-string interpolation in loggers, just as it warns against .format-interpolation.

pylint --version output

pylint 1.8.1, 
astroid 1.6.0
Python 3.6.2 (default, Sep 22 2017, 12:45:49) 
[GCC 6.3.0 20170516]

[PCManticore]

Thanks!

[sscherfke]

Please not! f-Strings are more readable and fast. We don't want to mix old-style and new-style formatting in our code (this is IMHO worse than not using logger.info('hello %s', name).

[sscherfke]

@PCManticore Or give it at least a different error message (e.g., logging-fstring-interpolation) so that this can be ignored (but not .format()) and users can keep using f-Strings.

[PCManticore]

A different message sounds good to me, if you can please create an issue with it, that would be great! Nevertheless, f-strings might be fast, but there's no need to compute them if there is no need to emit the logging message if its under the expected logging level.

[eddie-dunn]

@sscherfke as @PCManticore hinted at, the reason that pylint emits the logging-format-interpolation warning is because it is inefficient to compute the string for a log message that won't be logged. This also applies to f-strings, since even if they are faster than .format it is still slower to interpolate than not interpolate at all.

I share your opinion on the greatness of f-strings, but if you are using them with the logging module, you are using the logging module incorrectly/inefficiently.

[sscherfke]

Sometimes I just don care. Practicality beats purity. 😉

[zachliu]

I agree with @sscherfke. Code readability out weights the tiny efficiency increase.

[leahein]

Seconded. IMO mixing old-style formatting and f-strings throughout the application is less desirable than the cost of computing the string interpolation.

[PCManticore]

Commenting on this issue won't change anything, if you don't agree with the warning, feel free to disable it, but this is going to be the default in pylint.

[Steffan-Ennis]

Python not being my first nor preferred language. It does make it harder to quickly read and understand code.

I agree with the above sentiments. I thought the goal of linters was to make code consistent and easier to parse.