// SetLevel sets the log level of ALL receivers
19460
func (l *Logger) SetLevel(lvl Level) {
	for _, r := range l.Receivers {
		r.Level = lvl
	}
}
477378
func setLogLevel(subsystemID string, logLevel string) {
	// Ignore invalid subsystems.
	logger, ok := subsystemLoggers[subsystemID]
	if !ok {
		return
	}

	// Defaults to info if the log level is invalid.
	level, _ := btclog.LevelFromString(logLevel)
	logger.SetLevel(level)
}
632947
func (s *DescribeChannelOutput) SetLogLevel(v string) *DescribeChannelOutput {
	s.LogLevel = &v
	return s
}
1373680
func (l *Slog) SetLevel(level Level) *Slog {
	l = l.copy()
	l.Level = level
	return l
}
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
	}
}
998188
func (s *Permission) SetLevel(v string) *Permission {
	s.Level = &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)
}
319387
func SetLevel(levelStr string) {
	switch strings.ToLower(levelStr) {
	case "trace":
		level = TraceLevel
	case "info":
		level = InfoLevel
	case "error":
		level = ErrorLevel
	default:
		level = NoneLevel
	}
}
336581
func setLogLevel(backend core.ConfigBackend) {
	loggingLevelString, _ := backend.Lookup("client.logging.level")
	logLevel := logging.INFO
	if loggingLevelString != nil {
		var err error
		logLevel, err = logging.LogLevel(loggingLevelString.(string))
		if err != nil {
			panic(err)
		}
	}

	// TODO: allow separate settings for each
	for _, logModule := range logModules {
		logging.SetLevel(logModule, logLevel)
	}
}
398696
func SetLevel(module string, level Level) {
	modlog.SetLevel(module, api.Level(level))
}
945954
func (l *logger) SetLogLevel(level LogLevel) {
	for _, itf := range l.sinks {
		if s, ok := itf.(*writerSink); ok && s.name != "file" {
			continue
		}
		if s, ok := itf.(*ReconfigurableSink); ok {
			s.SetMinLevel(level)
		}
	}
}
1286860
func (s *Logger) SetLevel(v string) *Logger {
	s.Level = &v
	return s
}
1360478
func (writer *ConsoleWriter) SetLevel(level LevelType) {
	writer.lock.Lock()
	defer writer.lock.Unlock()

	writer.blog.SetLevel(level)
}
1312867
func (s *HierarchyStructure) SetLevelOne(v *HierarchyLevel) *HierarchyStructure {
	s.LevelOne = v
	return s
}
1309715
func (eg *EngineGroup) SetLogLevel(level core.LogLevel) {
	eg.Engine.SetLogLevel(level)
	for i := 0; i < len(eg.slaves); i++ {
		eg.slaves[i].SetLogLevel(level)
	}
}
621798
func SetLogLevel(name, level string) error {
	lvl, err := logging.LogLevel(level)
	if err != nil {
		return err
	}

	// wildcard, change all
	if name == "*" {
		SetAllLoggers(lvl)
		return nil
	}

	loggerMutex.RLock()
	defer loggerMutex.RUnlock()

	// Check if we have a logger by that name
	if _, ok := loggers[name]; !ok {
		return ErrNoSuchLogger
	}

	logging.SetLevel(lvl, name)

	return nil
}
418359
func (cl *CoLog) SetMinLevel(l Level) {
	cl.mu.Lock()
	defer cl.mu.Unlock()

	cl.minLevel = l
}