Old method to set log level. It updates only the log level value. The rest of log settings remain unchanged.

@param logLevel the log level
@deprecated use {@link com.polidea.rxandroidble2.RxBleClient#updateLogOptions(LogOptions)}
186816
@Deprecated
    public static void setLogLevel(@LogLevel int logLevel) {
        LogOptions newLogOptions = new LogOptions.Builder().setLogLevel(logLevel).build();
        updateLogOptions(newLogOptions);
    }
759907
public function setErrorsLogLevel($errorsLogLevel)
    {
        if (!in_array($errorsLogLevel, $this->getAvailableErrorsLogLevel())) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Unsupported errors log level "%s". Use one of supported log levels: [%s].',
                    $errorsLogLevel,
                    implode(', ', $this->getAvailableErrorsLogLevel())
                )
            );
        }

        $this->errorsLogLevel = $errorsLogLevel;
    }
462582
func (s *UpdateChannelInput) SetLogLevel(v string) *UpdateChannelInput {
	s.LogLevel = &v
	return s
}
1318992
func SetLogLevel(logLevel string) {
	if logLevel != "" {
		lvl, err := logrus.ParseLevel(logLevel)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Unable to parse logging level: %s\n", logLevel)
			os.Exit(1)
		}
		logrus.SetLevel(lvl)
	} else {
		logrus.SetLevel(logrus.InfoLevel)
	}
}
742091
def set_log_level(self, level):
        
        self._log_level = level
        if self._python_logger:
            try:
                level = self.PYTHON_LEVEL.get(level)
            except ValueError as err:
                raise FailReply("Unknown logging level '%s'" % (level))
            self._python_logger.setLevel(level)
1371753
@Deprecated
    public void setMinLevel(String minLevel) {
        this.minLevel = minLevel != null ? Level.toLevel(minLevel) : null;
    }
386659
def _set_log_level(self):
        
        # set log level on logger
        log_level = "INFO"
        if hasattr(self._config, "level") and self._config.level.upper() in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
            log_level = self._config.level.upper()
        self._log_level = log_level
551621
def set_logging_level(level_name=None):
    
    can_logger = logging.getLogger('can')

    try:
        can_logger.setLevel(getattr(logging, level_name.upper()))
    except AttributeError:
        can_logger.setLevel(logging.DEBUG)
    log.debug("Logging set to {}".format(level_name))
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;
    }
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);
            }
        }
    }
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());
	}
624905
function setLevel(level) {
    opts.level = level;
    let logLevelIndex = levels.indexOf(opts.level.toUpperCase());

    levels.forEach((logLevel) => {
      let fn;
      if (logLevelIndex <= levels.indexOf(logLevel)) {
        fn = logWrap(logLevel);
      } else {
        fn = noop;
      }
      API[logLevel.toLowerCase()] = fn;
    });
  }
940138
func (s *MonitoringConfiguration) SetLogLevel(v string) *MonitoringConfiguration {
	s.LogLevel = &v
	return s
}
16404
func (s *StartChannelOutput) SetLogLevel(v string) *StartChannelOutput {
	s.LogLevel = &v
	return s
}
542098
public void setLoggingLevel(final String deviceName, final int loggingLevel) {
        System.out.println("set logging level " + deviceName + "-" + LoggingLevel.getLevelFromInt(loggingLevel));
        logger.debug("set logging level to {} on {}", LoggingLevel.getLevelFromInt(loggingLevel), deviceName);
        if (rootLoggingLevel < loggingLevel) {
            setRootLoggingLevel(loggingLevel);
        }
        // setLoggingLevel(loggingLevel);
        loggingLevels.put(deviceName, loggingLevel);
        for (final DeviceAppender appender : deviceAppenders.values()) {
            if (deviceName.equalsIgnoreCase(appender.getDeviceName())) {
                appender.setLevel(loggingLevel);
                break;
            }
        }
        for (final FileAppender appender : fileAppenders.values()) {
            if (deviceName.equalsIgnoreCase(appender.getDeviceName())) {
                appender.setLevel(loggingLevel);
                break;
            }
        }
    }
240295
func (s *MonitoringConfigurationDescription) SetLogLevel(v string) *MonitoringConfigurationDescription {
	s.LogLevel = &v
	return s
}
676346
public void changeLoglevel(LoglevelCommand loglevelCommand) {
        pubSubService.fire(LoglevelProperty.REDIS_KEY_PREFIX + "pubsub", Json.toJson(loglevelCommand, JsonFormat.compact()));
    }