Mensagem PyLint: interpolação de formato de log

Para o seguinte código:

logger.debug('message: {}'.format('test'))

pylint produz o seguinte aviso:

interpolação de formato de log (W1202):

Use a formatação% nas funções de log e passe os parâmetros% como argumentos Utilizados quando uma instrução de log possui um formulário de chamada de “log. (Format_string.format (format_args ...))”. Essas chamadas devem usar% de formatação, mas deixar a interpolação para a função de log passando os parâmetros como argumentos.

Sei que posso desativar esse aviso, mas gostaria de entendê-lo. Eu assumi que usar format()é a maneira preferida de imprimir instruções no Python 3. Por que isso não é verdade para instruções do logger?

Isso não é verdadeiro para a declaração do criador de logs, porque conta com o formato "%" anterior, como string, para fornecer interpolação lenta dessa string usando argumentos extras fornecidos para a chamada do criador de logs. Por exemplo, em vez de fazer:

logger.error('oops caused by %s' % exc)

você deveria fazer

logger.error('oops caused by %s', exc)

portanto, a cadeia só será interpolada se a mensagem for realmente emitida.

Você não pode se beneficiar dessa funcionalidade ao usar .format().

De acordo com a seção Otimização dos loggingdocumentos:

A formatação dos argumentos da mensagem é adiada até que não possa ser evitada. No entanto, calcular os argumentos passados ​​para o método de registro também pode ser caro, e você pode evitar fazê-lo se o criador de logs simplesmente jogar fora seu evento.

Talvez desta vez as diferenças possam ajudá-lo.

A descrição a seguir não é a resposta para sua pergunta, mas pode ajudar as pessoas.

Para pylint 2.4: Existem 3 opções para login estilo no .pylintrcarquivo: old, new,fstr

fstropção adicionada em 2.4 e removida em 2.5

Descrição do .pylintrcarquivo (v2.4):

[LOGGING]

# Format style used to check logging format string. `old` means using %
# formatting, `new` is for `{}` formatting,and `fstr` is for f-strings.
logging-format-style=old

para old ( logging-format-style=old):

foo = "bar"
self.logger.info("foo: %s", foo)

para new ( logging-format-style=new):

foo = "bar"
self.logger.info("foo: {}", foo)
# OR
self.logger.info("foo: {foo}", foo=foo)

Nota : você não pode usar, .format()mesmo se você selecionar a newopção.

O pylint ainda dá o mesmo aviso para este código:

self.logger.info("foo: {}".format(foo))  # W1202
# OR
self.logger.info("foo: {foo}".format(foo=foo))  # W1202

para fstr ( logging-format-style=fstr):

foo = "bar"
self.logger.info(f"foo: {foo}")

Pessoalmente, prefiro a opção fstr por causa do PEP-0498 .

Na minha experiência, uma razão mais convincente do que a otimização (na maioria dos casos de uso) para a interpolação lenta é que ela funciona muito bem com agregadores de logs como o Sentry.

Considere uma mensagem de log 'usuário logado'. Se você interpolar o usuário na cadeia de formatação, você terá tantas mensagens de log distintas quanto os usuários. Se você usar uma interpolação lenta como essa, o agregador de log poderá interpretar isso mais razoavelmente como a mesma mensagem de log com várias instâncias diferentes.