【Day 1】关于我是如何干掉Appium和RobotFramework这件事的——环境准备

file_level = logging.DEBUG

console_level = logging.INFO

# -*- coding: UTF-8 -*-

""" 自定义日志logger """

__LogPathName__ = "Report/Log"

import logging
import os
from datetime import datetime

from Engine import BASE_DIR

CUE_FILE_LOG = 'CueFileLog'
CUE_CONSOLE_LOG = 'CueConsoleLog'


class CueLog(object):
    ONLY_FILE = 1
    ONLY_CONSOLE = 2
    BOTH_FILE_CONSOLE = 3

    def __init__(self, **kwargs):
        """
        初始化日志对象。
        日志对象为单例，在初始化时可以对file_level、console_level设置不同的日志级别。
        Parameters
        ----------
        kwargs:
            file_level = logging.DEBUG
            console_level = logging.INFO
        """
        self.log_path = os.path.join(BASE_DIR, __LogPathName__)

        if not os.path.exists(self.log_path):
            os.makedirs(self.log_path)

        self._file_level = kwargs.get("file_level") if kwargs.get("file_level") else logging.DEBUG
        self._console_level = kwargs.get("console_level") if kwargs.get("console_level") else logging.INFO

        self.file_logger = logging.getLogger(CUE_FILE_LOG)
        self.console_logger = logging.getLogger(CUE_CONSOLE_LOG)
        self.formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        self.set_log_handler(self.file_logger, self._file_level)
        self.set_log_handler(self.console_logger, self._file_level)

    def set_log_handler(self, log_type, log_level):
        log_type.setLevel(log_level)
        self.file_logger.propagate = False
        if log_type.name == CUE_FILE_LOG:
            file_name = 'ClientTest_' + datetime.now().strftime('%Y%m%d') + '.log'
            file_path = os.path.join(self.log_path, file_name)
            handler = logging.FileHandler(file_path)
        else:
            handler = logging.StreamHandler()
        handler.setLevel(log_level)
        handler.setFormatter(self.formatter)
        log_type.addHandler(handler)

    def __new__(cls):
        """
        单例
        """
        if not hasattr(cls, 'instance'):
            cls.instance = super(CueLog, cls).__new__(cls)
        return cls.instance

    @staticmethod
    def make_log_msg(title, **kwargs):
        msg = ''
        if len(kwargs) > 0:
            msg = ':'
            for k, v in kwargs.items():
                msg += ' {0}={1};'.format(k, v)
        return title + msg

    def format_msg(self, msg):
        rv = self.find_call_stack()
        if isinstance(msg, bytes):
            msg = msg.decode()
        if (rv is not None) and (len(rv) > 0):
            filepath = rv[0]
            [_, filename] = os.path.split(filepath)
            return "[{}] {}:{}: ".format(filename, rv[2], rv[1]) + msg
        else:
            return msg

    def warning2(self, flag, msg, *args, **kwargs):
        if self._file_level <= logging.WARNING or self._console_level <= logging.WARNING:
            msg = self.format_msg(msg)
        if (self._file_level <= logging.WARNING) and ((flag & self.ONLY_FILE) != 0):
            self.file_logger.warning(msg, *args, **kwargs)
        if (self._console_level <= logging.WARNING) and ((flag & self.ONLY_CONSOLE) != 0):
            self.console_logger.warning(msg, *args, **kwargs)

    def error2(self, flag, msg, *args, **kwargs):
        if self._file_level <= logging.ERROR or self._console_level <= logging.ERROR:
            msg = self.format_msg(msg)
        if (self._file_level <= logging.ERROR) and ((flag & self.ONLY_FILE) != 0):
            self.file_logger.error(msg, *args, **kwargs)
        if (self._console_level <= logging.ERROR) and ((flag & self.ONLY_CONSOLE) != 0):
            self.console_logger.error(msg, *args, **kwargs)

    def debug2(self, flag, msg, *args, **kwargs):
        if self._file_level <= logging.DEBUG or self._console_level <= logging.DEBUG:
            msg = self.format_msg(msg)
        if (self._file_level <= logging.DEBUG) and ((flag & self.ONLY_FILE) != 0):
            self.file_logger.debug(msg, *args, **kwargs)
        if (self._console_level <= logging.DEBUG) and ((flag & self.ONLY_CONSOLE) != 0):
            self.console_logger.debug(msg, *args, **kwargs)

    def info2(self, flag, msg, *args, **kwargs):
        if self._file_level <= logging.INFO or self._console_level <= logging.INFO:
            msg = self.format_msg(msg)
        if (self._file_level <= logging.INFO) and ((flag & self.ONLY_FILE) != 0):
            self.file_logger.info(msg, *args, **kwargs)
        if (self._console_level <= logging.INFO) and ((flag & self.ONLY_CONSOLE) != 0):
            self.console_logger.info(msg, *args, **kwargs)

    def warning(self, msg, *args, **kwargs):
        self.warning2(self.BOTH_FILE_CONSOLE, msg, *args, **kwargs)

    def error(self, msg, *args, **kwargs):
        self.error2(self.BOTH_FILE_CONSOLE, msg, *args, **kwargs)

    def debug(self, msg, *args, **kwargs):
        self.debug2(self.BOTH_FILE_CONSOLE, msg, *args, **kwargs)

    def info(self, msg, *args, **kwargs):
        self.info2(self.BOTH_FILE_CONSOLE, msg, *args, **kwargs)

    @staticmethod
    def find_call_stack():
        """
        Find the stack frame of the caller so that we can note the source
        file name, line number and function name.
        """
        f = logging.currentframe()
        # On some versions of IronPython, currentframe() returns None if
        # IronPython isn't run with -X:Frames.
        if f is not None:
            f = f.f_back
        rv = "(unknown file)", 0, "(unknown function)", None
        while hasattr(f, "f_code"):
            co = f.f_code
            filename = os.path.normcase(co.co_filename)
            if filename == _srcfile:
                f = f.f_back
                continue
            rv = (co.co_filename, f.f_lineno, co.co_name)
            break
        return rv


logger = CueLog()
_srcfile = os.path.normcase(logger.error.__code__.co_filename)