python类FileHandler()的实例源码

def get_logger(name, filename, level=logging.DEBUG, fmt=None):
    logger = logging.Logger(name)

    fmt = fmt or '%(asctime)s-%(name)s-%(levelname)-10s%(message)s'
    formatter = logging.Formatter(fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')

    stream_handler = logging.StreamHandler()
    stream_handler.setFormatter(formatter)

    file_handler = logging.FileHandler(filename)
    file_handler.setFormatter(formatter)

    logger.addHandler(stream_handler)
    logger.addHandler(file_handler)

    logger.setLevel(level)

    return logger

def EnableTestLogger(testLogFileName, parentLoggerHandler=LOGGER, formatting=formatter):
    """
    Start logging for given parent logger handler and test log-file name. Possible, you can use logger formatter.
    Function return new open Logger handler.
    """
    testCaseLogHandler = logging.FileHandler(testLogFileName)  # log handler

    if formatting:
        testCaseLogHandler.setFormatter(formatting)  # set given log formatting

    else:
        testCaseLogHandler.setFormatter(formatter)  # set default log formatting

    parentLoggerHandler.addHandler(testCaseLogHandler)  # init test log

    return testCaseLogHandler

def setup(config=None):
    root_logger = logging.getLogger()
    log_path = config.get_safe('global', '--log-path', '.')
    if not os.path.exists(log_path):
        raise RuntimeError('configured ``--log-path`` value does not exist: %s' % log_path)
    date = datetime.strftime(datetime.utcnow(), '%Y-%m-%d')
    log_file = os.path.join(log_path, 'ceph-medic-%s.log' % date)

    root_logger.setLevel(logging.DEBUG)

    # File Logger
    fh = logging.FileHandler(log_file)
    fh.setLevel(logging.DEBUG)
    fh.setFormatter(logging.Formatter(FILE_FORMAT))

    root_logger.addHandler(fh)

def CreateLogging(app = None):
    app = app or CreateApp()
    if not app.config['LOGGING']:
        loggHandler = logging.StreamHandler(sys.stdout)
    else:
        if app.config['LOGGING_TYPE'] == 'local':
            loggHandler = logging.FileHandler(app.config['LOGGING_NAME'])
        elif app.config['LOGGING_TYPE'] == 'syslog':
            loggHandler = logging.handler.\
                    SysLogHandler(address = (app.config['LOGGING_SERVER'],
                                             int(app.config['LOGGING_PORT'])))
    level = NodeDefender.config.logging.level()
    if level:
        loggHandler.setLevel(level.upper())
    else:
        loggHandler.setLevel("DEBUG")

    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    loggHandler.setFormatter(formatter)

    logger = logging.getLogger("NodeDefender")
    logger.setLevel(logging.INFO)
    logger.addHandler(loggHandler)
    return logger, loggHandler

def create_logger(app_name, logfilename=None, level=logging.INFO,
                  console=False, syslog=False):
    """ Build and return a custom logger. Accepts the application name,
    log filename, loglevel and console logging toggle and syslog toggle """

    log=logging.getLogger(app_name)
    log.setLevel(logging.DEBUG)
    # Add file handler
    if logfilename != None:
        log.addHandler(logging.FileHandler(logfilename))

    if syslog:
        log.addHandler(logging.handlers.SysLogHandler(address='/dev/log'))

    if console:
        log.addHandler(logging.StreamHandler())

    # Add formatter
    for handle in log.handlers:
        formatter = logging.Formatter('%(asctime)s : %(levelname)-8s - %(message)s',
                                      datefmt='%Y-%m-%d %H:%M:%S')
        handle.setFormatter(formatter)

    return log

def update_logging_settings(self, file_path=None, level=None, format=None):
        """
        Update global logging. If None is set to the arguments, it will keep the previous setting.

        Args:
            file_path (str): It is Initialized to 'log.log'.
            level (str): It can be 'error', 'warning' or 'info'. It is Initialized to 'error'.
            format (str): It is Initialized to '%(asctime)s %(levelname)s %(message)s'.
        """

        LOGGING_STRING_MAP = {'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR}
        if file_path is not None:
            self._logger_config['file_path'] = self._get_abs_path(file_path)
        if level is not None:
            self._logger_config['level'] = level
        if format is not None:
            self._logger_config['format'] = format

        logger = logging.getLogger(Configuration.LOGGER_NAME)
        log_file = logging.FileHandler(self._logger_config['file_path'])
        logger.addHandler(log_file)
        log_file.setFormatter(logging.Formatter(self._logger_config['format']))
        logger.setLevel(LOGGING_STRING_MAP[self._logger_config['level']])
        self._logger = logger

def __init__(self):
        TFModel.__init__(self)
        PrepareData.__init__(self)
        EarlyStopMonitor.__init__(self)
        self.num_steps = 30000
        self.batch_size = 128
        self.early_stopping_rounds = None
        self.summaries_dir = './logs/didi'
        self.dropout= 0.9
        self.usedFeatures = [101,102,103,104,105,     #106,107, 
                             201, 204, #205,206, 203,
                             301,
                             401,402,
                             501,502,503,      #504,505,506,507,
                            601,602,603,604,605,606,
                             8801,8802
                             ]
        self.train_validation_foldid = -2 #0.415
#         self.train_validation_foldid = -1 #0.425
#         self.train_validation_foldid = -3 #0.430
        logging.getLogger().addHandler(logging.FileHandler('logs/didnerual.log', mode='w'))
        return

def __init__(self):
        root = logging.getLogger()
        root.setLevel(logging.DEBUG)
        root.addHandler(logging.StreamHandler(sys.stdout))
        root.addHandler(logging.FileHandler('logs/forwardfeatureselection_knn.log', mode='w'))
        clfDict = {1: GrientBoostingModel, 2:KNNModel, 3: DidiXGBoostModel}
        self.clf =  clfDict[2]()
#         self.result = []
#         self.featureList = [101,102, 201,502]
        self.featureList =  [101,102,103,104,105,106,107, 
                             201, 203,204,205,206,
                             301,
                             401,402,
                             501,502,503,504,505,506,507,
                             601,602,603,604,605,606,
                             8801,8802
                             ]

        return

def emit(self, record):
        """
        Emit a record.

        Output the record to the file, catering for rollover as described
        in setRollover().
        """
        if self.maxBytes > 0:                   # are we rolling over?
            msg = "%s\n" % self.format(record)
            try:
                self.stream.seek(0, 2)  #due to non-posix-compliant Windows feature
                if self.stream.tell() + len(msg) >= self.maxBytes:
                    self.doRollover()

            except ValueError:
                # on Windows we get "ValueError: I/O operation on closed file"
                # when a second copy of workbench is run
                self.doRollover()

        logging.FileHandler.emit(self, record)

def init_logger(logPath, fileName, logLvl, consoleLog, fileLog):

        logger = logging.getLogger()
        logger.setLevel(logLvl)
        formatter = logging.Formatter('%(asctime)s [%(levelname)-5.5s]  %(message)s')

        consoleHandler = logging.StreamHandler(sys.stdout)

        consoleHandler.setFormatter(formatter)
        logger.addHandler(consoleHandler)

        if consoleLog is False:
            consoleHandler.setLevel(logLvl)
        else:
            consoleHandler.setLevel(100)

        if fileLog is False:
            fileHandler = logging.FileHandler("{0}/{1}.log".format(logPath, fileName))
            fileHandler.setFormatter(formatter)
            fileHandler.setLevel(logLvl)
            logger.addHandler(fileHandler)

def __init__(self, type=types.TYPE_USIM, logLevel=logging.INFO):
        dir = os.path.dirname(__file__)
        resultFile = dir + "/../sim_soft.log"
        FORMATTER = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt='%H:%M:%S')
        fileHndl = logging.FileHandler(resultFile, mode='w')
        fileHndl.setFormatter(FORMATTER)
        fileHndl.setLevel(logLevel)
        logger = logging.getLogger("sim_soft")
        #dont't propagate to root logger
        logger.propagate=False
        logger.handlers = []
        logger.setLevel(logLevel)
        logger.addHandler(fileHndl)
        self.logging = logger
        self.readers = []
        self.simType = type

def setup_logger(log_file_path):
  """
  Setup a logger that simultaneously output to a file and stdout
  ARGS
    log_file_path: string, path to the logging file
  """
  # logging settings
  log_formatter = logging.Formatter("%(asctime)s [%(levelname)-5.5s]  %(message)s")
  root_logger = logging.getLogger()
  root_logger.setLevel(logging.DEBUG)
  # file handler
  log_file_handler = logging.FileHandler(log_file_path)
  log_file_handler.setFormatter(log_formatter)
  root_logger.addHandler(log_file_handler)
  # stdout handler
  log_stream_handler = logging.StreamHandler(sys.stdout)
  log_stream_handler.setFormatter(log_formatter)
  root_logger.addHandler(log_stream_handler)

  logging.info('Log file is %s' % log_file_path)

def set_logger_handler(app):
    """
    ????handler
    :param app:
    :return:
    """
    import logging
    from logging import Formatter
    from logging import FileHandler
    filehandler = FileHandler('/tmp/py.log', 'a+')
    filehandler.setLevel(logging.DEBUG)
    filehandler.setFormatter(Formatter(
        '%(asctime)s %(levelname)s: %(message)s '
        '[in %(pathname)s:%(lineno)d]'
    ))
    app.logger.addHandler(filehandler)

def __init__(self, debug=False, logfile=None):
        logging.Logger.__init__(self, 'VirtualBMC')
        try:
            if logfile is not None:
                self.handler = logging.FileHandler(logfile)
            else:
                self.handler = logging.StreamHandler()

            formatter = logging.Formatter(DEFAULT_LOG_FORMAT)
            self.handler.setFormatter(formatter)
            self.addHandler(self.handler)

            if debug:
                self.setLevel(logging.DEBUG)
            else:
                self.setLevel(logging.INFO)

        except IOError as e:
            if e.errno == errno.EACCES:
                pass

def setup_logging(debugging):
    """ configures logging """

    # configure logging
    formatting = '%(asctime)s | %(levelname)s |  %(funcName)s | %(message)s'
    log_file = 'logs/{0}.log'.format(time.strftime("%d.%m.%Y %H-%M"))
    logging.basicConfig(level=logging.DEBUG, format=formatting)

    # disable all non-error messages if not debugging
    if not debugging:
        logging.disable(logging.DEBUG)

    # setup output streams
    rootLogger = logging.getLogger()

    # file output
    logFormatter = logging.Formatter(formatting)
    fileHandler = logging.FileHandler("{0}".format(log_file))
    fileHandler.setFormatter(logFormatter)
    rootLogger.addHandler(fileHandler)

    # terminal output
    # consoleHandler = logging.StreamHandler()
    # consoleHandler.setFormatter(logFormatter)
    # rootLogger.addHandler(consoleHandler)

def init_logger():
    """ Instantiates and sets up the logger, if it's not already set up.
    """

    if _logger.ready:
        return

    log_fmt = logging.Formatter(
        fmt='[{asctime}][{levelname:^7}] {message}',
        datefmt='%m/%d | %H:%M:%S', style='{')

    file_handler = logging.FileHandler(filename='pomodorobot.log',
                                       encoding='utf8', mode='w')
    term_handler = logging.StreamHandler(sys.stdout)

    file_handler.setFormatter(log_fmt)
    term_handler.setFormatter(log_fmt)
    _logger.logger.addHandler(file_handler)
    _logger.logger.addHandler(term_handler)

    _logger.logger.setLevel(logging.INFO)

    _logger.ready = True

def create_logger(log_file=None):
    """
    Initialize global logger and return it.

    :param log_file: log to this file, or to standard output if None
    :return: created logger
    """
    formatter = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt='%m/%d %H:%M:%S')
    if log_file is not None:
        os.makedirs(os.path.dirname(log_file), exist_ok=True)
        handler = logging.FileHandler(log_file)
        handler.setFormatter(formatter)
        logger = logging.getLogger(__name__)
        logger.addHandler(handler)

    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    logger = logging.getLogger(__name__)
    logger.addHandler(handler)
    return logger

def get_log(program):
        Utils.source_provisioner_env()

        log = logging.getLogger(os.path.basename(program))
        log.setLevel(logging.INFO)
        # create handlers
        file_handler    = logging.FileHandler(os.environ['PROVISIONING_LOG_FILE'])
        file_handler.setLevel(logging.INFO)
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setLevel(logging.INFO)
        # create loggin format:
        formatter = logging.Formatter("[@:%(created)f]:[%(name)s]: %(message)s")
        # set formatter
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        # add handlers
        log.addHandler(file_handler)
        log.addHandler(console_handler)
        # return the log
        return log

def log_to_both_file_and_console():
    root_logger = logging.getLogger()
    root_logger.setLevel(logging.DEBUG)

    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')

    # Set up log for file.
    file_handler = logging.FileHandler('log_info.txt')
    file_handler.setLevel(logging.DEBUG)
    file_handler.setFormatter(formatter)
    root_logger.addHandler(file_handler)

    # Set up log for terminal.
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.DEBUG)
    console_handler.setFormatter(formatter)
    root_logger.addHandler(console_handler)

    root_logger.debug('This is a log_debug message in the program.')
    root_logger.error('This is a log_error message in the  program.')

# ------ Log to different logging levels. ------

def __init__(self, name):
        self.logger_id = str(uuid4())
        self.filename = os.path.join(self.BASE_DIR, "{}.log".format(name))
        if not os.path.isdir(self.BASE_DIR):
            os.mkdir(self.BASE_DIR)

        self.console_formatter = ColorizedFormatter(self.DEFAULT_FORMAT, use_color=True)
        self.syslog = logging.StreamHandler(sys.stdout)
        self.syslog.setFormatter(self.console_formatter)
        self.syslog.setLevel(self.DEFAULT_LEVEL)

        self.file_formatter = ColorizedFormatter(self.DEFAULT_FORMAT, use_color=False)
        self.file_handler = logging.FileHandler(self.filename, encoding="utf8")
        self.file_handler.setFormatter(self.file_formatter)
        self.file_handler.setLevel(self.DEFAULT_LEVEL)

        self.logger = logging.getLogger("{}-{}".format(self.logger_id, self.filename))
        self.logger.setLevel(self.DEFAULT_LEVEL)
        self.logger.addHandler(self.syslog)
        self.logger.addHandler(self.file_handler)