Sets the minimum log level.

@param   logLevel
The log level
971621
public final void setLogLevel(LogLevel logLevel)
    {
        LogLevel updatedLogLevel=logLevel;
        if(updatedLogLevel==null)
        {
            updatedLogLevel=LogLevel.NONE;
        }
        
        this.logLevel=updatedLogLevel;
    }
201276
public void setLog( Log log )
    {
        this.mavenLogger = log;
        
        //Match the log level of the Java logger with that set in the Maven logger 
        if ( log.isDebugEnabled() ) 
        {
            javaLogger.setLevel( Level.FINE );
        } 
        else if ( log.isInfoEnabled() ) 
        {
            javaLogger.setLevel( Level.INFO );
        } 
        else if ( log.isWarnEnabled() ) 
        {
            javaLogger.setLevel( Level.WARNING );
        } 
        else 
        {
            javaLogger.setLevel( Level.SEVERE );
        }
    }
240295
func (s *MonitoringConfigurationDescription) SetLogLevel(v string) *MonitoringConfigurationDescription {
	s.LogLevel = &v
	return s
}
696898
public function setLogLevel($logLevel)
    {
        if (!is_string($logLevel) || '' === ($level = strtolower($logLevel)) || !isset($this->levelMap[$level]))
        {
            throw new \InvalidArgumentException(sprintf(
                '%s - Log level must be one of the following values: ["%s"].  %s seen.',
                get_called_class(),
                implode('", "', array_keys($this->levelMap)),
                is_string($logLevel) ? $logLevel : gettype($logLevel)
            ));
        }

        $this->level = $level;
    }
58339
func (s *LogTargetConfiguration) SetLogLevel(v string) *LogTargetConfiguration {
	s.LogLevel = &v
	return s
}
1109081
private void setRunLevel(int level) {

        if (m_instance != null) {
            if (m_instance.m_runLevel >= OpenCms.RUNLEVEL_1_CORE_OBJECT) {
                // otherwise the log is not available
                if (CmsLog.INIT.isInfoEnabled()) {
                    CmsLog.INIT.info(
                        Messages.get().getBundle().key(
                            Messages.INIT_RUNLEVEL_CHANGE_2,
                            new Integer(m_instance.m_runLevel),
                            new Integer(level)));
                }
            }
            m_instance.m_runLevel = level;
        }
    }
506526
public function setMinimalLogLevel($minLevel)
    {
        $this->logger->setMinLevel($minLevel);
        $this->commandHandler->setMinimalLogLevel($minLevel);
        $this->commandQueue->setMinimalLogLevel($minLevel);
    }
760457
public void setRootLoggingLevel(final int loggingLevel) {
        rootLoggingLevel = loggingLevel;
        if (rootLoggerBack != null) {
            rootLoggerBack.setLevel(LoggingLevel.getLevelFromInt(loggingLevel));
        }
    }
241984
public static void setLevel(Class<?> c, Level l) /* throws LoggerNotDefined */ {
		if (!loggers.containsKey(c)) tempLevels.put(c, l);
		else loggers.get(c).setLevel(l);
		//System.out.println("Set level " + l + " for logger " + loggers.get(c).getName());
	}
1207817
func SetLogLevel(ctx context.Context, lvl log.Level) {
	if logCtx, ok := ctx.(*lsc); ok {
		if lvl == logCtx.logger.Level {
			return
		}
		if logCtx.loggerInherited {
			parentLogger := logCtx.logger
			logCtx.logger = &log.Logger{
				Formatter: parentLogger.Formatter,
				Out:       parentLogger.Out,
				Hooks:     parentLogger.Hooks,
				Level:     lvl,
			}
			logCtx.loggerInherited = false
		}
	}
}
1371753
@Deprecated
    public void setMinLevel(String minLevel) {
        this.minLevel = minLevel != null ? Level.toLevel(minLevel) : null;
    }
566979
def set_log_level(self, level: str) -> None:
        """"""
        if level == 'info':
            to_set = logging.INFO
        if level == 'debug':
            to_set = logging.DEBUG
        if level == 'error':
            to_set = logging.ERROR
        self.log.setLevel(to_set)
1015616
public static void setStandaloneLogging(Level level) {
        LOGGER.setUseParentHandlers(false);
        for (Handler h : LOGGER.getHandlers()) {
            LOGGER.removeHandler(h);
        }
        StdoutHandler handler = new StdoutHandler();
        handler.setFormatter(new InlineFormatter());
        LOGGER.addHandler(handler);
        
        final UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();
        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            LOGGER.log(Level.SEVERE, "Uncaught Exception in thread " + t.getName(), e);
            if (ueh != null) {
                ueh.uncaughtException(t, e);
            }
        });
        
        setLogLevel(level);
    }
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;
        }
    }
849692
public void setLevel(@NonNull LogLevel level) {
        if (config == null) {
            throw new IllegalStateException("Cannot set logging level without a configuration");
        }

        if (logLevel.equals(level)) {
            return;
        }

        logLevel = level;
        C4Log.setBinaryFileLevel(level.getValue());
    }
373772
public function setMinimalLogLevel($minLevel)
    {
        $this->logger->setMinLevel($minLevel);
        $this->commandResolver->setMinimalLogLevel($minLevel);
        $this->commandQueue->setMinimalLogLevel($minLevel);
    }
517946
public void setLevel (Level level) {

		this.defaultLevel = level;
		logger.setLevel (level);
		for (Handler handler : logger.getHandlers ()) {
			handler.setLevel (level);
		}
	}