msg.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326
  1. """
  2. BitBake 'msg' implementation
  3. Message handling infrastructure for bitbake
  4. """
  5. # Copyright (C) 2006 Richard Purdie
  6. #
  7. # SPDX-License-Identifier: GPL-2.0-only
  8. #
  9. import sys
  10. import copy
  11. import logging
  12. import logging.config
  13. from itertools import groupby
  14. import bb
  15. import bb.event
  16. class BBLogFormatter(logging.Formatter):
  17. """Formatter which ensures that our 'plain' messages (logging.INFO + 1) are used as is"""
  18. DEBUG3 = logging.DEBUG - 2
  19. DEBUG2 = logging.DEBUG - 1
  20. DEBUG = logging.DEBUG
  21. VERBOSE = logging.INFO - 1
  22. NOTE = logging.INFO
  23. PLAIN = logging.INFO + 1
  24. VERBNOTE = logging.INFO + 2
  25. ERROR = logging.ERROR
  26. WARNING = logging.WARNING
  27. CRITICAL = logging.CRITICAL
  28. levelnames = {
  29. DEBUG3 : 'DEBUG',
  30. DEBUG2 : 'DEBUG',
  31. DEBUG : 'DEBUG',
  32. VERBOSE: 'NOTE',
  33. NOTE : 'NOTE',
  34. PLAIN : '',
  35. VERBNOTE: 'NOTE',
  36. WARNING : 'WARNING',
  37. ERROR : 'ERROR',
  38. CRITICAL: 'ERROR',
  39. }
  40. color_enabled = False
  41. BASECOLOR, BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = list(range(29,38))
  42. COLORS = {
  43. DEBUG3 : CYAN,
  44. DEBUG2 : CYAN,
  45. DEBUG : CYAN,
  46. VERBOSE : BASECOLOR,
  47. NOTE : BASECOLOR,
  48. PLAIN : BASECOLOR,
  49. VERBNOTE: BASECOLOR,
  50. WARNING : YELLOW,
  51. ERROR : RED,
  52. CRITICAL: RED,
  53. }
  54. BLD = '\033[1;%dm'
  55. STD = '\033[%dm'
  56. RST = '\033[0m'
  57. def getLevelName(self, levelno):
  58. try:
  59. return self.levelnames[levelno]
  60. except KeyError:
  61. self.levelnames[levelno] = value = 'Level %d' % levelno
  62. return value
  63. def format(self, record):
  64. record.levelname = self.getLevelName(record.levelno)
  65. if record.levelno == self.PLAIN:
  66. msg = record.getMessage()
  67. else:
  68. if self.color_enabled:
  69. record = self.colorize(record)
  70. msg = logging.Formatter.format(self, record)
  71. if hasattr(record, 'bb_exc_formatted'):
  72. msg += '\n' + ''.join(record.bb_exc_formatted)
  73. elif hasattr(record, 'bb_exc_info'):
  74. etype, value, tb = record.bb_exc_info
  75. formatted = bb.exceptions.format_exception(etype, value, tb, limit=5)
  76. msg += '\n' + ''.join(formatted)
  77. return msg
  78. def colorize(self, record):
  79. color = self.COLORS[record.levelno]
  80. if self.color_enabled and color is not None:
  81. record = copy.copy(record)
  82. record.levelname = "".join([self.BLD % color, record.levelname, self.RST])
  83. record.msg = "".join([self.STD % color, record.msg, self.RST])
  84. return record
  85. def enable_color(self):
  86. self.color_enabled = True
  87. def __repr__(self):
  88. return "%s fmt='%s' color=%s" % (self.__class__.__name__, self._fmt, "True" if self.color_enabled else "False")
  89. class BBLogFilter(object):
  90. def __init__(self, handler, level, debug_domains):
  91. self.stdlevel = level
  92. self.debug_domains = debug_domains
  93. loglevel = level
  94. for domain in debug_domains:
  95. if debug_domains[domain] < loglevel:
  96. loglevel = debug_domains[domain]
  97. handler.setLevel(loglevel)
  98. handler.addFilter(self)
  99. def filter(self, record):
  100. if record.levelno >= self.stdlevel:
  101. return True
  102. if record.name in self.debug_domains and record.levelno >= self.debug_domains[record.name]:
  103. return True
  104. return False
  105. class LogFilterGEQLevel(logging.Filter):
  106. def __init__(self, level):
  107. self.strlevel = str(level)
  108. self.level = stringToLevel(level)
  109. def __repr__(self):
  110. return "%s level >= %s (%d)" % (self.__class__.__name__, self.strlevel, self.level)
  111. def filter(self, record):
  112. return (record.levelno >= self.level)
  113. class LogFilterLTLevel(logging.Filter):
  114. def __init__(self, level):
  115. self.strlevel = str(level)
  116. self.level = stringToLevel(level)
  117. def __repr__(self):
  118. return "%s level < %s (%d)" % (self.__class__.__name__, self.strlevel, self.level)
  119. def filter(self, record):
  120. return (record.levelno < self.level)
  121. # Message control functions
  122. #
  123. loggerDefaultLogLevel = BBLogFormatter.NOTE
  124. loggerDefaultDomains = {}
  125. def init_msgconfig(verbose, debug, debug_domains=None):
  126. """
  127. Set default verbosity and debug levels config the logger
  128. """
  129. if debug:
  130. bb.msg.loggerDefaultLogLevel = BBLogFormatter.DEBUG - debug + 1
  131. elif verbose:
  132. bb.msg.loggerDefaultLogLevel = BBLogFormatter.VERBOSE
  133. else:
  134. bb.msg.loggerDefaultLogLevel = BBLogFormatter.NOTE
  135. bb.msg.loggerDefaultDomains = {}
  136. if debug_domains:
  137. for (domainarg, iterator) in groupby(debug_domains):
  138. dlevel = len(tuple(iterator))
  139. bb.msg.loggerDefaultDomains["BitBake.%s" % domainarg] = logging.DEBUG - dlevel + 1
  140. def constructLogOptions():
  141. return loggerDefaultLogLevel, loggerDefaultDomains
  142. def addDefaultlogFilter(handler, cls = BBLogFilter, forcelevel=None):
  143. level, debug_domains = constructLogOptions()
  144. if forcelevel is not None:
  145. level = forcelevel
  146. cls(handler, level, debug_domains)
  147. def stringToLevel(level):
  148. try:
  149. return int(level)
  150. except ValueError:
  151. pass
  152. try:
  153. return getattr(logging, level)
  154. except AttributeError:
  155. pass
  156. return getattr(BBLogFormatter, level)
  157. #
  158. # Message handling functions
  159. #
  160. def fatal(msgdomain, msg):
  161. if msgdomain:
  162. logger = logging.getLogger("BitBake.%s" % msgdomain)
  163. else:
  164. logger = logging.getLogger("BitBake")
  165. logger.critical(msg)
  166. sys.exit(1)
  167. def logger_create(name, output=sys.stderr, level=logging.INFO, preserve_handlers=False, color='auto'):
  168. """Standalone logger creation function"""
  169. logger = logging.getLogger(name)
  170. console = logging.StreamHandler(output)
  171. format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
  172. if color == 'always' or (color == 'auto' and output.isatty()):
  173. format.enable_color()
  174. console.setFormatter(format)
  175. if preserve_handlers:
  176. logger.addHandler(console)
  177. else:
  178. logger.handlers = [console]
  179. logger.setLevel(level)
  180. return logger
  181. def has_console_handler(logger):
  182. for handler in logger.handlers:
  183. if isinstance(handler, logging.StreamHandler):
  184. if handler.stream in [sys.stderr, sys.stdout]:
  185. return True
  186. return False
  187. def mergeLoggingConfig(logconfig, userconfig):
  188. logconfig = copy.deepcopy(logconfig)
  189. userconfig = copy.deepcopy(userconfig)
  190. # Merge config with the default config
  191. if userconfig.get('version') != logconfig['version']:
  192. raise BaseException("Bad user configuration version. Expected %r, got %r" % (logconfig['version'], userconfig.get('version')))
  193. # Set some defaults to make merging easier
  194. userconfig.setdefault("loggers", {})
  195. # If a handler, formatter, or filter is defined in the user
  196. # config, it will replace an existing one in the default config
  197. for k in ("handlers", "formatters", "filters"):
  198. logconfig.setdefault(k, {}).update(userconfig.get(k, {}))
  199. seen_loggers = set()
  200. for name, l in logconfig["loggers"].items():
  201. # If the merge option is set, merge the handlers and
  202. # filters. Otherwise, if it is False, this logger won't get
  203. # add to the set of seen loggers and will replace the
  204. # existing one
  205. if l.get('bitbake_merge', True):
  206. ulogger = userconfig["loggers"].setdefault(name, {})
  207. ulogger.setdefault("handlers", [])
  208. ulogger.setdefault("filters", [])
  209. # Merge lists
  210. l.setdefault("handlers", []).extend(ulogger["handlers"])
  211. l.setdefault("filters", []).extend(ulogger["filters"])
  212. # Replace other properties if present
  213. if "level" in ulogger:
  214. l["level"] = ulogger["level"]
  215. if "propagate" in ulogger:
  216. l["propagate"] = ulogger["propagate"]
  217. seen_loggers.add(name)
  218. # Add all loggers present in the user config, but not any that
  219. # have already been processed
  220. for name in set(userconfig["loggers"].keys()) - seen_loggers:
  221. logconfig["loggers"][name] = userconfig["loggers"][name]
  222. return logconfig
  223. def setLoggingConfig(defaultconfig, userconfigfile=None):
  224. logconfig = copy.deepcopy(defaultconfig)
  225. if userconfigfile:
  226. with open(os.path.normpath(userconfigfile), 'r') as f:
  227. if userconfigfile.endswith('.yml') or userconfigfile.endswith('.yaml'):
  228. import yaml
  229. userconfig = yaml.load(f)
  230. elif userconfigfile.endswith('.json') or userconfigfile.endswith('.cfg'):
  231. import json
  232. userconfig = json.load(f)
  233. else:
  234. raise BaseException("Unrecognized file format: %s" % userconfigfile)
  235. if userconfig.get('bitbake_merge', True):
  236. logconfig = mergeLoggingConfig(logconfig, userconfig)
  237. else:
  238. # Replace the entire default config
  239. logconfig = userconfig
  240. # Convert all level parameters to integers in case users want to use the
  241. # bitbake defined level names
  242. for h in logconfig["handlers"].values():
  243. if "level" in h:
  244. h["level"] = bb.msg.stringToLevel(h["level"])
  245. for l in logconfig["loggers"].values():
  246. if "level" in l:
  247. l["level"] = bb.msg.stringToLevel(l["level"])
  248. conf = logging.config.dictConfigClass(logconfig)
  249. conf.configure()
  250. # The user may have specified logging domains they want at a higher debug
  251. # level than the standard.
  252. for name, l in logconfig["loggers"].items():
  253. if not name.startswith("BitBake."):
  254. continue
  255. if not "level" in l:
  256. continue
  257. curlevel = bb.msg.loggerDefaultDomains.get(name)
  258. # Note: level parameter should already be a int because of conversion
  259. # above
  260. newlevel = int(l["level"])
  261. if curlevel is None or newlevel < curlevel:
  262. bb.msg.loggerDefaultDomains[name] = newlevel
  263. # TODO: I don't think that setting the global log level should be necessary
  264. #if newlevel < bb.msg.loggerDefaultLogLevel:
  265. # bb.msg.loggerDefaultLogLevel = newlevel
  266. return conf