Enables console logging amd console error logging

@param level Level of log
@param verbose if verbose should be set
14758
public void enableConsoleLog(Level level, boolean verbose) {
        InstallLogUtils.enableConsoleLogging(level, verbose);
        InstallLogUtils.enableConsoleErrorLogging(verbose);
    }
515473
public void log(int logLevel, String format, Object... args) {
    println(logLevel, format, args);
  }
187366
def _verbose(self, msg, level=log.debug):
        '''
        
        '''
        if self.opts.get('verbose', False) is True:
            self.ui.status(msg)
        level(msg)
599957
public void setLoggerLevel(String level) {
        if ("TRACE".equalsIgnoreCase(level)) {
            this.level = TRACE;
        } else if ("DEBUG".equalsIgnoreCase(level)) {
            this.level = DEBUG;
        } else if ("INFO".equalsIgnoreCase(level)) {
            this.level = INFO;
        } else if ("WARN".equalsIgnoreCase(level)) {
            this.level = WARN;
        } else if ("ERROR".equalsIgnoreCase(level)) {
            this.level = ERROR;
        }
    }
270383
def enable_logging(log_level):
    # type: (typing.Union[None, int]) -> None
    
    root_logger = logging.getLogger()
    root_logger.setLevel(logging.DEBUG)
    logfile_handler = logging.StreamHandler(_LOGFILE_STREAM)
    logfile_handler.setLevel(logging.DEBUG)
    logfile_handler.setFormatter(logging.Formatter(
        '%(levelname)s [%(asctime)s][%(name)s] %(message)s'))
    root_logger.addHandler(logfile_handler)
    if signal.getsignal(signal.SIGTERM) == signal.SIG_DFL:
        signal.signal(signal.SIGTERM, _logfile_sigterm_handler)
    if log_level:
        handler = logging.StreamHandler()
        handler.setFormatter(_LogColorFormatter())
        root_logger.setLevel(log_level)
        root_logger.addHandler(handler)
812671
func (l *Logger) Verbose(args ...interface{}) {
	l.logf(l.app, logLevelVerbose, "", true, args...)
}
143488
def process_verbosity_param
      return unless @options[:verbose]
      log_levels = %w[debug info warn error fatal unknown]
      @logger.level = log_levels.index(@options[:verbose])
    end
93846
def configure_logging(verbose, logger):
    """"""
    if not verbose:
        log_level = logging.WARNING
    elif verbose == 1:
        log_level = logging.INFO
    else:
        log_level = logging.DEBUG
    logger.setLevel(log_level)
    ch = colorlog.StreamHandler()
    ch.setLevel(log_level)
    formatter = colorlog.ColoredFormatter(
        '%(log_color)s%(asctime)s %(name)s %(levelname)s: %(message)s')
    ch.setFormatter(formatter)
    logger.addHandler(ch)
1229197
@Override
  public void _log (final int nLevel, @Nonnull final Object aMsg, @Nullable final Throwable aThrowable)
  {
    // >= 7
    if (nLevel >= ERROR)
    {
      if (m_aLogger.isErrorEnabled ())
      {
        if (aMsg != null)
          m_aLogger.error ("{}", aMsg, aThrowable);
        else
          m_aLogger.error (BLA, aThrowable);
      }
    }
    else
      // >= 5
      if (nLevel >= WARN)
      {
        if (m_aLogger.isWarnEnabled ())
        {
          if (aMsg != null)
            m_aLogger.warn ("{}", aMsg, aThrowable);
          else
            m_aLogger.warn (BLA, aThrowable);
        }
      }
      else
        // >= 3
        if (nLevel >= INFO)
        {
          if (m_aLogger.isInfoEnabled ())
          {
            if (aMsg != null)
              m_aLogger.info ("{}", aMsg, aThrowable);
            else
              m_aLogger.info (BLA, aThrowable);
          }
        }
        else
          // >= 1
          if (nLevel >= DEBUG)
          {
            if (m_aLogger.isDebugEnabled ())
            {
              if (aMsg != null)
                m_aLogger.debug ("{}", aMsg, aThrowable);
              else
                m_aLogger.debug (BLA, aThrowable);
            }
          }
          else
          {
            // < 1
            if (m_aLogger.isTraceEnabled ())
            {
              if (aMsg != null)
                m_aLogger.trace ("{}", aMsg, aThrowable);
              else
                m_aLogger.trace (BLA, aThrowable);
            }
          }
  }
1312554
public static void setLoggingLevel(final Level level) {
    final Handler[] handlers = Logger.getLogger("").getHandlers();
    ConsoleHandler ch = null;
    for (final Handler h : handlers) {
      if (h instanceof ConsoleHandler) {
        ch = (ConsoleHandler) h;
        break;
      }
    }
    if (ch == null) {
      ch = new ConsoleHandler();
      Logger.getLogger("").addHandler(ch);
    }
    ch.setLevel(level);
    Logger.getLogger("").setLevel(level);
  }
1083681
function consoleHandler(logData) {
    'use strict';
    var consoleArgs = logData.hasOwnProperty('args') ? logData.args : logData.hasOwnProperty('logEntry') ? [logData.logEntry] : arguments;

    switch (logData.level) {
        case messageLevel.ERROR:
            origConErr.apply(console, consoleArgs);
            break;
        case messageLevel.WARN:
            origConWarn.apply(console, consoleArgs);
            break;
        case messageLevel.INFO:
            origConInfo.apply(console, consoleArgs);
            break;
        default:
            throw new Error('Invalid log level defined');
    }
}
358309
@Override
	public void log(com.silentgo.utils.log.level.Level level, String format, Object... arguments) {
		log(level, null, format, arguments);
	}
500784
public static void setVerbose(java.util.logging.Level verbose) {
    if(verbose.intValue() <= Level.VERBOSE.intValue()) {
      // decrease to VERBOSE if it was higher, otherwise further to
      // VERYVERBOSE
      if(LOGGER_GLOBAL_TOP.getLevel() == null || LOGGER_GLOBAL_TOP.getLevel().intValue() > verbose.intValue()) {
        LOGGER_GLOBAL_TOP.setLevel(verbose);
      }
      if(LOGGER_ELKI_TOP.getLevel() == null || LOGGER_ELKI_TOP.getLevel().intValue() > verbose.intValue()) {
        LOGGER_ELKI_TOP.setLevel(verbose);
      }
    }
    else {
      // re-increase to given level if it was verbose or "very verbose".
      if(LOGGER_GLOBAL_TOP.getLevel() != null && (//
      Level.VERBOSE.equals(LOGGER_GLOBAL_TOP.getLevel()) || //
          Level.VERYVERBOSE.equals(LOGGER_GLOBAL_TOP.getLevel()) //
      )) {
        LOGGER_GLOBAL_TOP.setLevel(verbose);
      }
      if(LOGGER_ELKI_TOP.getLevel() != null && (//
      Level.VERBOSE.equals(LOGGER_ELKI_TOP.getLevel()) || //
          Level.VERYVERBOSE.equals(LOGGER_ELKI_TOP.getLevel()) //
      )) {
        LOGGER_ELKI_TOP.setLevel(verbose);
      }
    }
  }
1117238
public boolean print(boolean verbose) {

		String errors = formatErrors();

		if (errors != null) {
			System.err.println(errors);
		}

		if (verbose) {
			System.out.println(formatStats());
		}

		return (errors != null);
	}
1367485
public static void log(Level level, String message) {
        Logger.getLogger("LEX4J").log(level, message);
    }
922622
public void log(Throwable error, Level level) {
    log(error, null, null, level);
  }
149263
function verbose() {
  var args = [LEVELS.VERBOSE].concat(slice.apply(arguments));
  return this.log.apply(this, args);
}