Disables logging statements in these lines whose logging level falls
    between the specified minimum and maximum levels.
434896
def disable_logging(lines, min_level_value, max_level_value):
    """"""
    output = ''
    while lines:
        line = lines[0]
        ret = RE_LOGGING_START.match(line)
        if not ret:
            # no logging statement here, so just leave the line as-is and keep going
            output += line
            lines = lines[1:]
        else:
            # a logging call has started: find all the lines it includes and those it does not
            logging_lines, remaining_lines = split_call(lines)
            lines = remaining_lines
            logging_stmt = ''.join(logging_lines)

            # replace the logging statement if its level falls b/w min and max
            if not check_level(logging_stmt, False, min_level_value, max_level_value):
                output += logging_stmt
            else:
                # comment out this logging statement and replace it with pass
                prefix_ws = ret.group(1)
                pass_stmt = prefix_ws + PASS_LINE_CONTENTS
                commented_out_logging_lines = comment_lines(logging_lines)
                new_lines = pass_stmt + commented_out_logging_lines
                logging.info('replacing:\n%s\nwith this:\n%s' % (logging_stmt.rstrip(), new_lines.rstrip()))
                output += new_lines
    return output
576585
def set_log_level(self):
        

        if self.options.debug:
            self.logger.setLevel(logging.DEBUG)
        elif self.options.quiet:
            self.logger.setLevel(logging.ERROR)
        else:
            self.logger.setLevel(logging.INFO)
        self.logger.addHandler(logging.StreamHandler())
        return self.logger
1268009
def suppress_logging() -> None:
    
    from wdom import options
    options.root_logger.removeHandler(options._log_handler)
    options.root_logger.addHandler(logging.NullHandler())
877686
void forceLoggingViaChildLogger(LogRecord record) {
    // Assume that nobody else will configure or manipulate loggers with this "secret" name.
    Logger forcingLogger = getForcingLogger(logger);

    // This logger can be garbage collected at any time, so we must always reset any configuration.
    // This code is subject to a bunch of unlikely race conditions if the logger is manipulated
    // while these checks are being made, but there is nothing we can really do about this (the
    // setting of log levels is not protected by synchronizing the logger instance).
    try {
      forcingLogger.setLevel(Level.ALL);
    } catch (SecurityException e) {
      // If we're blocked from changing logging configuration then we cannot log "forced" log
      // statements via the forcingLogger. Fall back to publishing them directly to the handlers
      // (which may bypass logic present in an overridden log(LogRecord) method).
      cannotUseForcingLogger = true;
      // Log to the root logger to bypass any configuration that might drop this message.
      Logger.getLogger("").log(Level.SEVERE,
          "Forcing log statements with Flogger has been partially disabled.\n"
          + "The Flogger library cannot modify logger log levels, which is necessary to force"
          + " log statements. This is likely due to an installed SecurityManager.\n"
          + "Forced log statements will still be published directly to log handlers, but will"
          + " not be visible to the 'log(LogRecord)' method of Logger sub-classes.\n");
      publish(logger, record);
      return;
    }
    // Assume any custom behaviour in our logger instance also exists for a child logger.
    forcingLogger.log(record);
  }
142280
@Override
    public void stop() {

        // Make sure to return the system streams to the state they were in
        // before we mucked with them
        restoreSystemStreams();

        unregisterLoggerHandlerSingleton();

        // Close writers, however they were allocated
        LoggingFileUtils.tryToClose(messagesLog);
        LoggingFileUtils.tryToClose(traceLog);
    }
293713
def set_verbose_logging(verbose: bool) -> None:
    """"""
    if verbose:
        set_loglevel(logging.DEBUG)
    else:
        set_loglevel(logging.INFO)
186816
@Deprecated
    public static void setLogLevel(@LogLevel int logLevel) {
        LogOptions newLogOptions = new LogOptions.Builder().setLogLevel(logLevel).build();
        updateLogOptions(newLogOptions);
    }
1235523
public void stop()
    {
        try{if (_writer!=null)_writer.flush();} catch (IOException e){LogSupport.ignore(log,e);}
        if (_out!=null && _closeOut)
            try{_out.close();}catch(IOException e){LogSupport.ignore(log,e);}
        _out=null;
        _fileOut=null;
        _closeOut=false;
        _logDateCache=null;
        _writer=null;
    }
820792
public static void ignore(Log log,Throwable th)
    {
        if (log.isTraceEnabled()) log.trace(IGNORED,th);
    }
952091
synchronized private void setLevelsOnExistingLoggers() {
        Enumeration<?> enm = props.keys();
        while (enm.hasMoreElements()) {
            String key = (String) enm.nextElement();
            if (!key.endsWith(".level")) {
                // Not a level definition.
                continue;
            }
            int ix = key.length() - 6;
            String name = key.substring(0, ix);
            Level level = getLevelProperty(key, null);
            if (level == null) {
                System.err.println("Bad level value for property: " + key);
                continue;
            }
            for (LoggerContext cx : contexts()) {
                Logger l = cx.findLogger(name);
                if (l == null) {
                    continue;
                }
                l.setLevel(level);
            }
        }
    }
1048006
def stop(self):
		
		if WAppsGlobals.log is not None and WLogApp.__log_handler__ is not None:
			WAppsGlobals.log.removeHandler(WLogApp.__log_handler__)

		WLogApp.__log_handler__ = None
		WAppsGlobals.log = None
696034
private String preventLogForging(String logMsg) {

    String result = logMsg;
    // use precompiled pattern for performance reasons
    result = LINEBREAK_PATTERN.matcher(logMsg).replaceAll(SingleLinePatternLayout.LINE_SEP);
    return result;
  }
416354
def sanitize_config_loglevel(level):
    '''
    
    '''
    if sys.version_info[:2] != (2, 6) or isinstance(level, (int, long)):
        return level
    lvl = None
    if isinstance(level, basestring):
        lvl = logging._levelNames.get(level)
    if not lvl:
        raise ValueError('Invalid log level, %s' % level)
    return lvl
1226226
def _suppress_distutils_logs():
    
    f = distutils.log.Log._log

    def _log(log, level, msg, args):
        if level >= distutils.log.ERROR:
            f(log, level, msg, args)

    distutils.log.Log._log = _log
    yield
    distutils.log.Log._log = f
939167
public static void stop() {
    final ILoggerFactory loggerFactory = org.slf4j.LoggerFactory.getILoggerFactory();
    if (loggerFactory instanceof LoggerContext) {
      final LoggerContext context = (LoggerContext) loggerFactory;
      context.stop();
    }
    setup.getAndSet(false);
  }
931255
private void skipToEndOfLine()
  {
    while (pos < limit) {
      char c = in.charAt(pos++);
      if (c == '\n') {
        lineNumber++;
        lineStart = pos;
        break;
      } else if (c == '\r') {
        break;
      }
    }
  }
1309469
public void stop_logging () {
   		Vector dl = Util.instance().get_device_list("*");
        for (Object aDl : dl) {
            ((DeviceImpl) aDl).stop_logging();
        }
    }