// SetLogLevel backup gLoglevel and set gLogLevel to logLevel
553516
func SetLogLevel(logLevel int) {
	gLogLevelBackup = gLogLevel
	switch logLevel {
	case LInfo:
		gLogLevel = logLevel
	case LDebug:
		gLogLevel = logLevel
	case LCritical:
		gLogLevel = logLevel
	case LError:
		gLogLevel = logLevel
	default:
		gLogLevel = LInfo
	}
}
131784
func (d *lbdgpro2whDevice) SetLevel(level float32, zoneAddr string, w io.Writer) error {
	return sendString(fmt.Sprintf("#OUTPUT,%s,1,%.2f\r\n", zoneAddr, level), w)
}
1341365
func SetLevel(level LogLevel) LogLevel {
	logMux.Lock()
	defer logMux.Unlock()
	current := logLevel
	switch {
	case level <= LevelDebug:
		logLevel = LevelDebug
	case level >= LevelFatal:
		logLevel = LevelFatal
	default:
		logLevel = level
	}
	return current
}
961516
func (c *LoggerCollection) SetLevel(re *regexp.Regexp, level LogLevel) {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	if re == nil {
		c.level = level
	}
	for name, logger := range c.loggers {
		if re == nil || re.MatchString(name) {
			logger.setLevel(level)
		}
	}
}
914452
func SetGLogLevel(glogLevel int) {
	_ = flag.CommandLine.Parse([]string{})
	_ = flag.Lookup("logtostderr").Value.Set("true")
	_ = flag.Lookup("v").Value.Set(strconv.Itoa(glogLevel))
}
849056
func SetLevel(level Level) {
	l, err := parseLevel(level)
	if err != nil {
		fmt.Printf("%v", err)
	}

	std.mu.Lock()
	defer std.mu.Unlock()
	std.Level = l
}
31585
func (lr *logRegistry) SetLevel(logger, level string) error {
	lvl, err := logrus.ParseLevel(level)
	if err != nil {
		return err
	}
	if logger == "default" {
		lr.defaultLevel = lvl
		return nil
	}
	lr.logLevels[logger] = lvl
	logVal := lr.getLoggerFromMapping(logger)
	if logVal != nil {
		defaultLogger.Debugf("setting logger level: %v -> %v", logVal.GetName(), lvl.String())
		return setLevel(logVal, lvl)
	}
	return nil
}
981165
func (p *PackageLogger) SetLevel(l LogLevel) {
	logger.Lock()
	defer logger.Unlock()
	p.level = l
}
1108461
func (l *Logger) SetLevel(level Level) *Logger {
	l.mu.Lock()
	defer l.mu.Unlock()
	if level > DebugLevel {
		panic(gear.Err.WithMsg("invalid logger level"))
	}
	l.l = level
	return l
}
458263
func (opts *Options) SetInfoLogLevel(value InfoLogLevel) {
	C.rocksdb_options_set_info_log_level(opts.c, C.int(value))
}
374102
func (s *MethodSetting) SetLoggingLevel(v string) *MethodSetting {
	s.LoggingLevel = &v
	return s
}
807540
func (p *Plugin) setLoggerLogLevel(name string, level string) error {
	p.Log.Debugf("SetLogLevel name %q, level %q", name, level)

	return p.LogRegistry.SetLevel(name, level)
}
1282322
func (m *MMClient) SetLogLevel(level string) {
	l, err := logrus.ParseLevel(level)
	if err != nil {
		m.logger.Warnf("Failed to parse specified log-level '%s': %#v", level, err)
	} else {
		m.rootLogger.SetLevel(l)
	}
}
619271
func setLogLevel(level Level, loggerName string, logLevels *gorivets.SortedSlice) *logLevelSetting {
	if level < 0 {
		return nil
	}
	var lls *logLevelSetting = &logLevelSetting{loggerName, level}
	idx, found := logLevels.Find(lls)
	if found {
		lls = logLevels.At(idx).(*logLevelSetting)
		lls.level = level
	} else {
		logLevels.Add(lls)
	}
	return lls
}
1291196
func SetLoggingLevel(level LoggingLevel) {
	shimLoggingLevel = level
	logging.SetLevel(logging.Level(level), "shim")
}
1316900
func (c *ChaincodeLogger) SetLevel(level LoggingLevel) {
	logging.SetLevel(logging.Level(level), c.logger.Module)
}
1169939
func (writer *MultiWriter) SetLevel(level LevelType) {
	writer.level = level
	for _, fileWriter := range writer.writers {
		fileWriter.SetLevel(level)
	}
}