def _dequeue(self, parent): self._ttl_timeout = gevent.Timeout.start_new(timeout=self._ttl, exception=ActorTTLError) self._max_idle_timeout = gevent.Timeout.start_new(timeout=self._max_idle, exception=ActorMaxIdleError) self._stopped = False self._crashed = False try: while True: try: for task in self._mailbox: gevent.idle() self._max_idle_timeout.close() if self._max_idle: self._logger.trace("{me} has canceled timeout of {max_idle} seconds".format(me=self, max_idle=self._max_idle)) if isinstance(task, Task) and not task.canceled: self._logger.trace("{me} took {task} from mailbox".format(me=self, task=task)) self._handle(task) elif task is self._poisoned_pill: self._logger.trace("{me} is processing the poisoned pill.".format(me=self)) raise ActorStoppedError elif task is self._ping_pill: self._logger.debug("{me} is processing a ping.".format(me=self)) elif isinstance(task, Task) and task.canceled: self._logger.trace("{me} took canceled {task} from mailbox, dismissing".format(me=self, task=task)) continue self._max_idle_timeout = gevent.Timeout.start_new(timeout=self._max_idle, exception=ActorMaxIdleError) except ActorMaxIdleError as e: self._logger.trace("{me} has reached max_idle timeout of {sec} seconds.".format(me=self, sec=self._max_idle)) self.stop(wait=False) # FIXME!!!! except ActorTTLError as e: self._logger.trace("{me} has reached ttl timeout of {sec} seconds.".format(me=self, sec=self._ttl)) self.stop(wait=False) # FIXME!!!! except ActorStoppedError as e: self._stopped = True except Exception as e: self._stopped = True self._crashed = True formatted_exc = "".join(better_exceptions.format_exception(*sys.exc_info())) self._logger.error(("{me} crashed with:\n{exc}").format(me=self, exc=formatted_exc)) finally: self._logger.trace("{me} is executing on_stop() handler".format(me=self)) try: self.on_stop() except Exception as err: self._crashed = True formatted_exc = "".join(better_exceptions.format_exception(*sys.exc_info())) self._logger.error(("{me} crashed while executing on_stop() handler with:\n{exc}").format(me=self, exc=formatted_exc)) self._logger.trace("{me} has finished on_stop() handler".format(me=self)) self._ttl_timeout.close() self._max_idle_timeout.close() if hasattr(self, "_parent"): self._parent._handle_child(self, "crashed" if self._crashed else "stopped")
def exception_thunk( self, exc_tuple: Tuple[Any, ...] = None, filename: Optional[str] = None, tb_offset: Optional[int] = None, exception_only: bool = False, **kwargs: Any ): notuple = False if exc_tuple is None: notuple = True exc_tuple = sys.exc_info() etype, value, tb = self._get_exc_info(exc_tuple) use_better = not any( [filename, tb_offset, exception_only, issubclass(etype, SyntaxError)] ) if use_better: return print(*better_exceptions.format_exception(etype, value, tb), sep="") return old_show_tb( None if notuple else exc_tuple, filename, tb_offset, exception_only, **kwargs )
def patched_handle_exception(self, e): """ a new handler for ptpython repl exceptions it will call excepthook after ommitting all this framework's calls from traceback for the original, see ptpython.repl.PythonInput._handle_exception """ output = self.app.output t, v, tb = sys.exc_info() # Required for pdb.post_mortem() to work. sys.last_type, sys.last_value, sys.last_traceback = t, v, tb # loop until getting actual traceback last_stdin_tb = tb while tb: if tb.tb_frame.f_code.co_filename == "<stdin>": last_stdin_tb = tb tb = tb.tb_next # except hook does not work as expected sys.excepthook(t, v, last_stdin_tb) # just print formatted exception for now formatted = better_exceptions.format_exception(t, v, last_stdin_tb) print_formatted_text(ANSI(formatted)) output.write("%s\n" % e) output.flush()
def _get_stack(exception, engine="better_exceptions"): assert engine in ["stackprinter", "better_exceptions"] if engine == "better_exceptions": return "".join(better_exceptions.format_exception(*exception)) elif engine == "stackprinter": return stackprinter.format(exception)
def main(argv: Optional[List[str]] = None) -> int: parser = argument_parser() args = parser.parse_args(argv) try: query = parse(args.query, "fasta") reference = parse(args.reference, "fasta") print(orthoani(query, reference, threads=args.jobs)) return 0 except KeyboardInterrupt: print("Interrupted.", file=sys.stderr) return -signal.SIGINT except Exception as e: if args.traceback: print( "".join( better_exceptions.format_exception(type(e), e, e.__traceback__)), file=sys.stderr, ) else: print(e, file=sys.stderr) return typing.cast(int, getattr(e, "errno", 1))
def get_logger(name, path="", log_level="DEBUG", is_write_to_file=False, is_write_to_stdout=True): """ @summary: 获取log --------- @param name: log名 @param path: log文件存储路径 如 D://xxx.log @param log_level: log等级 CRITICAL/ERROR/WARNING/INFO/DEBUG @param is_write_to_file: 是否写入到文件 默认否 --------- @result: """ name = name.split(os.sep)[-1].split(".")[0] # 取文件名 logger = logging.getLogger(name) logger.setLevel(log_level) formatter = logging.Formatter(LOG_FORMAT) if PRINT_EXCEPTION_DETAILS: formatter.formatException = lambda exc_info: format_exception(*exc_info ) # 定义一个RotatingFileHandler,最多备份5个日志文件,每个日志文件最大10M if is_write_to_file: if path and not os.path.exists(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) rf_handler = RotatingFileHandler(path, mode="w", maxBytes=10 * 1024 * 1024, backupCount=20, encoding="utf8") rf_handler.setFormatter(formatter) logger.addHandler(rf_handler) if is_write_to_stdout: stream_handler = logging.StreamHandler() stream_handler.stream = sys.stdout stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) _handler_list = [] _handler_name_list = [] # 检查是否存在重复handler for _handler in logger.handlers: if str(_handler) not in _handler_name_list: _handler_name_list.append(str(_handler)) _handler_list.append(_handler) logger.handlers = _handler_list return logger
def build_exception_details(): import sys import better_exceptions et, ev, tb = sys.exc_info() return ExceptionDetails( **{ 'errorType': et.__name__, 'errorMessage': str(ev), 'message': "An unexpected exception has occurred", 'help': "\n".join(better_exceptions.format_exception(*sys.exc_info())) })
def _execute(self, method, args, kwargs): response = {} try: response["result"] = method(*args, **kwargs) except TypeError as e: response["error"] = str(e) response["error_type"] = GedisErrorTypes.BAD_REQUEST.value except: ttype, tvalue, tb = sys.exc_info() response["error"] = better_exceptions.format_exception( ttype, tvalue, tb) response["error_type"] = GedisErrorTypes.ACTOR_ERROR.value return response
def spawn_child(self, target, name=None, msg=None): if not name: name = "{tpl}-{target}".format(tpl=self._worker_name_tpl or str(self._worker_cls), target=target) try: kwargs = self._worker_args_func( msg) if msg and self._worker_args_func else {} child = self._worker_cls(name=name, target=target, **kwargs) except Exception as err: formatted_exc = better_exceptions.format_exception(*sys.exc_info()) self._logger.error( "Spawning child failed with {e}".format(e=formatted_exc)) raise SpawningChildFailedError(err) child._target = target self.register_child(child, target) return child
def patch(): import logging from better_exceptions import format_exception logging_format_exception = lambda exc_info: format_exception(*exc_info) if hasattr(logging, '_defaultFormatter'): logging._defaultFormatter.format_exception = logging_format_exception patchables = [ handler() for handler in logging._handlerList if isinstance(handler(), StreamHandler) ] patchables = [ handler for handler in patchables if handler.stream == sys.stderr ] patchables = [ handler for handler in patchables if handler.formatter is not None ] for handler in patchables: handler.formatter.formatException = logging_format_exception
def formatException(self, ei): return format_exception(*ei)
def get_logger( name=None, path=None, log_level=None, is_write_to_console=None, is_write_to_file=None, color=None, mode=None, max_bytes=None, backup_count=None, encoding=None, ): """ @summary: 获取log --------- @param name: log名 @param path: log文件存储路径 如 D://xxx.log @param log_level: log等级 CRITICAL/ERROR/WARNING/INFO/DEBUG @param is_write_to_console: 是否输出到控制台 @param is_write_to_file: 是否写入到文件 默认否 @param color:是否有颜色 @param mode:写文件模式 @param max_bytes: 每个日志文件的最大字节数 @param backup_count:日志文件保留数量 @param encoding:日志文件编码 --------- @result: """ # 加载setting里最新的值 name = name or setting.LOG_NAME path = path or setting.LOG_PATH log_level = log_level or setting.LOG_LEVEL is_write_to_console = (is_write_to_console if is_write_to_console is not None else setting.LOG_IS_WRITE_TO_CONSOLE) is_write_to_file = (is_write_to_file if is_write_to_file is not None else setting.LOG_IS_WRITE_TO_FILE) color = color if color is not None else setting.LOG_COLOR mode = mode or setting.LOG_MODE max_bytes = max_bytes or setting.LOG_MAX_BYTES backup_count = backup_count or setting.LOG_BACKUP_COUNT encoding = encoding or setting.LOG_ENCODING # logger 配置 name = name.split(os.sep)[-1].split(".")[0] # 取文件名 logger = logging.getLogger(name) logger.setLevel(log_level) formatter = logging.Formatter(setting.LOG_FORMAT) if setting.PRINT_EXCEPTION_DETAILS: formatter.formatException = lambda exc_info: format_exception(*exc_info ) # 定义一个RotatingFileHandler,最多备份5个日志文件,每个日志文件最大10M if is_write_to_file: if path and not os.path.exists(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) rf_handler = RotatingFileHandler( path, mode=mode, max_bytes=max_bytes, backup_count=backup_count, encoding=encoding, ) rf_handler.setFormatter(formatter) logger.addHandler(rf_handler) if color and is_write_to_console: loguru_handler = InterceptHandler() loguru_handler.setFormatter(formatter) # logging.basicConfig(handlers=[loguru_handler], level=0) logger.addHandler(loguru_handler) elif is_write_to_console: stream_handler = logging.StreamHandler() stream_handler.stream = sys.stdout stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) _handler_list = [] _handler_name_list = [] # 检查是否存在重复handler for _handler in logger.handlers: if str(_handler) not in _handler_name_list: _handler_name_list.append(str(_handler)) _handler_list.append(_handler) logger.handlers = _handler_list return logger
def get_traceback(): tb = format_exception(*sys.exc_info()) if isinstance(tb, list): tb = "".join(tb) return tb
def log_exception(args: threading.ExceptHookArgs): description = f"Failure in {args.thread.name}: {repr(args.exc_value)}" FAILURES.append(description) LOG.error(description + "\n" + "\n".join( better_exceptions.format_exception(args.exc_type, args.exc_value, args.exc_traceback)))
# -*- encoding: utf-8 -*- import logging import better_exceptions from better_exceptions import format_exception logger = logging.getLogger() formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') formatter.formatException = lambda exc_info: format_exception(*exc_info) stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.DEBUG) stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) file_handler = logging.FileHandler("test.log") file_handler.setLevel(logging.DEBUG) file_handler.setFormatter(formatter) logger.addHandler(file_handler) def get_student_infos(logs): student_infos = [] for log in logs: name, catgory, grade = log.split(' ') student_infos.append({ 'name': name,
def patch(self, err, test): lines = better_exceptions.format_exception(*err) if sys.version_info[0] == 2: return u"".join(lines).encode("utf-8") else: return u"".join(lines)