Logs the inputed message for the given level.  This will update
        both the feedback label and the details widget.
        
        :param      level   | <int>
                    message | <str>
333506
def showMessage(self, level, message):
        
        self.uiFeedbackLBL.setText(message)
        self.uiLoggerEDIT.log(level, message)
682703
def _log_message(self, level, process_name, timeperiod, msg):
        
        self.timetable.add_log_entry(process_name, timeperiod, msg)
        self.logger.log(level, msg)
65868
public static void print(ConsoleLevel level, String message) {
		if (level.compareTo(_level) <= 0) {
			if (_printLogLevel) {
				level.getStream().println(level.name() + ": " + message);
			}
			else {
				level.getStream().println(message);
			}
			level.getStream().flush();
		}
	}
218130
def setLoggerLevel(self, logger, level):
        
        if level == logging.NOTSET:
            self.removeLogger(logger)
            self.handler().setLoggerLevel(logger, level)
            return
            
        if isinstance(logger, logging.Logger):
            logger = logger.name
        
        if not logger in self._loggers:
            self.addLogger(logger, level)
        else:
            self.handler().setLoggerLevel(logger, level)
1326150
public void log(final String _message,
                    final int _level)
    {
        switch (_level)  {
            case 4:
                if (IvyOverSLF4JLogger.LOG.isDebugEnabled())  {
                    IvyOverSLF4JLogger.LOG.debug(_message);
                }
                break;
            case 3:
                if (IvyOverSLF4JLogger.LOG.isWarnEnabled())  {
                    IvyOverSLF4JLogger.LOG.warn(_message);
                }
                break;
            case 2:
                if (IvyOverSLF4JLogger.LOG.isInfoEnabled())  {
                    IvyOverSLF4JLogger.LOG.info(_message);
                }
                break;
            case 1:
                if (IvyOverSLF4JLogger.LOG.isErrorEnabled())  {
                    IvyOverSLF4JLogger.LOG.error(_message);
                }
                break;
            default:
                IvyOverSLF4JLogger.LOG.error("unknown log level " + _level);
                IvyOverSLF4JLogger.LOG.error(_message);
        }
    }
579809
def log_init(level):
    
    log = logging.getLogger()
    hdlr = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    log.addHandler(hdlr)
    log.setLevel(level)
591922
def log(self, level, msg=None, *args, **kwargs):
        """"""

        return self._log(level, msg, args, kwargs)
583814
def log(self, message, level=logging.INFO, *args, **kwargs):
        
        msg = "{}.{}: {}[{}]: {}".format(
            self.__class__.__name__, self.status, self.__class__.path,
            self.uuid, message
        )
        extra = kwargs.pop("extra", dict())
        extra.update(dict(kmsg=Message(
            self.uuid, entrypoint=self.__class__.path, params=self.params,
            metadata=self.metadata
        ).dump()))

        return logger.log(
            level=level, msg=msg, extra=extra, *args, **kwargs
        )
1059493
public function log ($level, $message, array $context = [])
  {
    $levelName = isset(self::$LEVELS[$level]) ? self::$LEVELS[$level] : $level;
    $message   = Debug::interpolate ($message, $context);
    $this->write ("<#log><#i><span class=__alert>$levelName</span> $message</#i></#log>");
  }
618465
public void log(Level level, Object message) {
        doLog(level, FQCN, message, null, null);
    }
745458
def debug(message, level=1):
    
    if level <= debug_level:
        logging.debug(' ' * (level - 1) * 2 + str(message))
929833
void log(Level level, String msg, Exception e) {
        if (e != null)
            logger.log(level, msg, e);
    }
518523
public void debug(final String message, final int level) {
        messages.add(new LogMessage(message, LogMessage.Type.DEBUG, level));
        log.debug(message);
    }
439153
def set_level(self, level):
        
        args = {
            'level': level,
        }
        self._level_chk.check(args)

        return self._client.json('logger.set_level', args)
65312
def set_level(cls, level):
        
        level = (
            level
            if not is_str(level)
            else int(LOGGING_LEVELS.get(level.upper(), level))
        )

        for handler in root.handlers:
            handler.setLevel(level)

        root.setLevel(level)
820100
def set_log_level(self, level):
        """"""
        if level == 'info':
            level = logging.INFO
        if level == 'debug':
            level = logging.DEBUG
        if level == 'error':
            level = logging.ERROR
        self._log.setLevel(level)
1236928
public static void log(final Level level, final String message) {
		System.err.println("LOGGER " + level + ": " + message);
	}