123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295 |
- # -*- coding: utf-8 -*-
- # Copyright (c) 2009-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
- # Copyright (c) 2009, 2012, 2014 Google, Inc.
- # Copyright (c) 2012 Mike Bryant <leachim@leachim.info>
- # Copyright (c) 2014 Brett Cannon <brett@python.org>
- # Copyright (c) 2014 Arun Persaud <arun@nubati.net>
- # Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
- # Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
- # Copyright (c) 2016 Chris Murray <chris@chrismurray.scot>
- # Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
- # Copyright (c) 2017 guillaume2 <guillaume.peillex@gmail.col>
- # Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
- # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
- # For details: https://github.com/PyCQA/pylint/blob/master/COPYING
-
- """checker for use of Python logging
- """
- import string
-
- import six
-
- import astroid
-
- from pylint import checkers
- from pylint import interfaces
- from pylint.checkers import utils
- from pylint.checkers.utils import check_messages
-
-
-
- MSGS = {
- 'W1201': ('Specify string format arguments as logging function parameters',
- 'logging-not-lazy',
- 'Used when a logging statement has a call form of '
- '"logging.<logging method>(format_string % (format_args...))". '
- 'Such calls should leave string interpolation to the logging '
- 'method itself and be written '
- '"logging.<logging method>(format_string, format_args...)" '
- 'so that the program may avoid incurring the cost of the '
- 'interpolation in those cases in which no message will be '
- 'logged. For more, see '
- 'http://www.python.org/dev/peps/pep-0282/.'),
- 'W1202': ('Use % formatting in logging functions and pass the % '
- 'parameters as arguments',
- 'logging-format-interpolation',
- 'Used when a logging statement has a call form of '
- '"logging.<logging method>(format_string.format(format_args...))"'
- '. Such calls should use % formatting instead, but leave '
- 'interpolation to the logging function by passing the parameters '
- 'as arguments.'),
- 'E1200': ('Unsupported logging format character %r (%#02x) at index %d',
- 'logging-unsupported-format',
- 'Used when an unsupported format character is used in a logging\
- statement format string.'),
- 'E1201': ('Logging format string ends in middle of conversion specifier',
- 'logging-format-truncated',
- 'Used when a logging statement format string terminates before\
- the end of a conversion specifier.'),
- 'E1205': ('Too many arguments for logging format string',
- 'logging-too-many-args',
- 'Used when a logging format string is given too many arguments.'),
- 'E1206': ('Not enough arguments for logging format string',
- 'logging-too-few-args',
- 'Used when a logging format string is given too few arguments.'),
- }
-
-
- CHECKED_CONVENIENCE_FUNCTIONS = {
- 'critical', 'debug', 'error', 'exception', 'fatal', 'info', 'warn', 'warning'
- }
-
-
- def is_method_call(func, types=(), methods=()):
- """Determines if a BoundMethod node represents a method call.
-
- Args:
- func (astroid.BoundMethod): The BoundMethod AST node to check.
- types (Optional[String]): Optional sequence of caller type names to restrict check.
- methods (Optional[String]): Optional sequence of method names to restrict check.
-
- Returns:
- bool: true if the node represents a method call for the given type and
- method names, False otherwise.
- """
- return (isinstance(func, astroid.BoundMethod)
- and isinstance(func.bound, astroid.Instance)
- and (func.bound.name in types if types else True)
- and (func.name in methods if methods else True))
-
-
- class LoggingChecker(checkers.BaseChecker):
- """Checks use of the logging module."""
-
- __implements__ = interfaces.IAstroidChecker
- name = 'logging'
- msgs = MSGS
-
- options = (('logging-modules',
- {'default': ('logging',),
- 'type': 'csv',
- 'metavar': '<comma separated list>',
- 'help': 'Logging modules to check that the string format '
- 'arguments are in logging function parameter format'}
- ),
- )
-
- def visit_module(self, node): # pylint: disable=unused-argument
- """Clears any state left in this checker from last module checked."""
- # The code being checked can just as easily "import logging as foo",
- # so it is necessary to process the imports and store in this field
- # what name the logging module is actually given.
- self._logging_names = set()
- logging_mods = self.config.logging_modules
-
- self._logging_modules = set(logging_mods)
- self._from_imports = {}
- for logging_mod in logging_mods:
- parts = logging_mod.rsplit('.', 1)
- if len(parts) > 1:
- self._from_imports[parts[0]] = parts[1]
-
- def visit_importfrom(self, node):
- """Checks to see if a module uses a non-Python logging module."""
- try:
- logging_name = self._from_imports[node.modname]
- for module, as_name in node.names:
- if module == logging_name:
- self._logging_names.add(as_name or module)
- except KeyError:
- pass
-
- def visit_import(self, node):
- """Checks to see if this module uses Python's built-in logging."""
- for module, as_name in node.names:
- if module in self._logging_modules:
- self._logging_names.add(as_name or module)
-
- @check_messages(*(MSGS.keys()))
- def visit_call(self, node):
- """Checks calls to logging methods."""
- def is_logging_name():
- return (isinstance(node.func, astroid.Attribute) and
- isinstance(node.func.expr, astroid.Name) and
- node.func.expr.name in self._logging_names)
-
- def is_logger_class():
- try:
- for inferred in node.func.infer():
- if isinstance(inferred, astroid.BoundMethod):
- parent = inferred._proxied.parent
- if (isinstance(parent, astroid.ClassDef) and
- (parent.qname() == 'logging.Logger' or
- any(ancestor.qname() == 'logging.Logger'
- for ancestor in parent.ancestors()))):
- return True, inferred._proxied.name
- except astroid.exceptions.InferenceError:
- pass
- return False, None
-
- if is_logging_name():
- name = node.func.attrname
- else:
- result, name = is_logger_class()
- if not result:
- return
- self._check_log_method(node, name)
-
- def _check_log_method(self, node, name):
- """Checks calls to logging.log(level, format, *format_args)."""
- if name == 'log':
- if node.starargs or node.kwargs or len(node.args) < 2:
- # Either a malformed call, star args, or double-star args. Beyond
- # the scope of this checker.
- return
- format_pos = 1
- elif name in CHECKED_CONVENIENCE_FUNCTIONS:
- if node.starargs or node.kwargs or not node.args:
- # Either no args, star args, or double-star args. Beyond the
- # scope of this checker.
- return
- format_pos = 0
- else:
- return
-
- if isinstance(node.args[format_pos], astroid.BinOp):
- binop = node.args[format_pos]
- if (binop.op == '%' or binop.op == '+' and
- len([_operand for _operand in (binop.left, binop.right)
- if self._is_operand_literal_str(_operand)]) == 1):
- self.add_message('logging-not-lazy', node=node)
- elif isinstance(node.args[format_pos], astroid.Call):
- self._check_call_func(node.args[format_pos])
- elif isinstance(node.args[format_pos], astroid.Const):
- self._check_format_string(node, format_pos)
-
- @staticmethod
- def _is_operand_literal_str(operand):
- """
- Return True if the operand in argument is a literal string
- """
- return isinstance(operand, astroid.Const) and operand.name == 'str'
-
- def _check_call_func(self, node):
- """Checks that function call is not format_string.format().
-
- Args:
- node (astroid.node_classes.Call):
- Call AST node to be checked.
- """
- func = utils.safe_infer(node.func)
- types = ('str', 'unicode')
- methods = ('format',)
- if is_method_call(func, types, methods) and not is_complex_format_str(func.bound):
- self.add_message('logging-format-interpolation', node=node)
-
- def _check_format_string(self, node, format_arg):
- """Checks that format string tokens match the supplied arguments.
-
- Args:
- node (astroid.node_classes.NodeNG): AST node to be checked.
- format_arg (int): Index of the format string in the node arguments.
- """
- num_args = _count_supplied_tokens(node.args[format_arg + 1:])
- if not num_args:
- # If no args were supplied, then all format strings are valid -
- # don't check any further.
- return
- format_string = node.args[format_arg].value
- if not isinstance(format_string, six.string_types):
- # If the log format is constant non-string (e.g. logging.debug(5)),
- # ensure there are no arguments.
- required_num_args = 0
- else:
- try:
- keyword_args, required_num_args = \
- utils.parse_format_string(format_string)
- if keyword_args:
- # Keyword checking on logging strings is complicated by
- # special keywords - out of scope.
- return
- except utils.UnsupportedFormatCharacter as ex:
- char = format_string[ex.index]
- self.add_message('logging-unsupported-format', node=node,
- args=(char, ord(char), ex.index))
- return
- except utils.IncompleteFormatString:
- self.add_message('logging-format-truncated', node=node)
- return
- if num_args > required_num_args:
- self.add_message('logging-too-many-args', node=node)
- elif num_args < required_num_args:
- self.add_message('logging-too-few-args', node=node)
-
-
- def is_complex_format_str(node):
- """Checks if node represents a string with complex formatting specs.
-
- Args:
- node (astroid.node_classes.NodeNG): AST node to check
- Returns:
- bool: True if inferred string uses complex formatting, False otherwise
- """
- inferred = utils.safe_infer(node)
- if inferred is None or not isinstance(inferred.value, six.string_types):
- return True
- try:
- parsed = list(string.Formatter().parse(inferred.value))
- except ValueError:
- # This format string is invalid
- return False
- for _, _, format_spec, _ in parsed:
- if format_spec:
- return True
- return False
-
-
- def _count_supplied_tokens(args):
- """Counts the number of tokens in an args list.
-
- The Python log functions allow for special keyword arguments: func,
- exc_info and extra. To handle these cases correctly, we only count
- arguments that aren't keywords.
-
- Args:
- args (list): AST nodes that are arguments for a log format string.
-
- Returns:
- int: Number of AST nodes that aren't keywords.
- """
- return sum(1 for arg in args if not isinstance(arg, astroid.Keyword))
-
-
- def register(linter):
- """Required method to auto-register this checker."""
- linter.register_checker(LoggingChecker(linter))
|