msg.py 10 KB

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