// defaultLogLevels is the default configuration for all Ringpop named loggers.
16357
func defaultLogLevels(r *Ringpop) error {
	return LogLevels(map[string]logging.Level{
		"damping":       logging.Error,
		"dissemination": logging.Error,
		"gossip":        logging.Error,
		"join":          logging.Warn,
		"membership":    logging.Error,
		"ring":          logging.Error,
		"suspicion":     logging.Error,
	})(r)
}
86871
func (c *ConfigLocal) SetVLogLevel(levelString string) {
	c.lock.Lock()
	defer c.lock.Unlock()
	c.vdebugSetting = levelString
	for _, vlog := range c.vlogs {
		vlog.Configure(levelString)
	}
}
442020
func (l *LoggerLevels) DefaultLevel() zapcore.Level {
	l.mutex.RLock()
	lvl := l.defaultLevel
	l.mutex.RUnlock()
	return lvl
}
1240814
func (l privLogger) SetLogLevel(logLevel string) error {
	if logger.IsValidLogLevel(logLevel) == true {
		*l.logLevel = logLevel
		return nil
	}
	return types.ErrNotFound{}
}
411389
func InitializeDefaultLogger() *logrus.Logger {
	logger := logrus.New()
	logger.Formatter = setupFormatter()
	return logger
}
388326
func ResetDefaultLogLevel(classes ...LogClass) {
	// Combine the output classes into just one
	class := NONE
	for _, c := range classes {
		class |= c
	}

	defaultOutputMutex.Lock()
	for _, o := range defaultOutputs {
		o.Class = class
	}
	defaultOutputMutex.Unlock()
}
917944
func (hook *MailHook) Levels() []logrus.Level {
	return []logrus.Level{
		logrus.PanicLevel,
		logrus.FatalLevel,
		logrus.ErrorLevel,
	}
}
200999
func LogLevel(levelString string) (LoggingLevel, error) {
	l, err := logging.LogLevel(levelString)
	level := LoggingLevel(l)
	if err != nil {
		level = LogError
	}
	return level, err
}
770148
func (s *SetV2LoggingLevelInput) SetLogLevel(v string) *SetV2LoggingLevelInput {
	s.LogLevel = &v
	return s
}
632947
func (s *DescribeChannelOutput) SetLogLevel(v string) *DescribeChannelOutput {
	s.LogLevel = &v
	return s
}
38650
func (s *StopChannelOutput) SetLogLevel(v string) *StopChannelOutput {
	s.LogLevel = &v
	return s
}
440273
func ParseLogLevel(configuration *viper.Viper, defaultLevel logrus.Level) (
	logrus.Level, error) {

	logStr := configuration.GetString("logging.level")
	if logStr == "" {
		return defaultLevel, nil
	}
	return logrus.ParseLevel(logStr)
}
216273
func LogLevel(level string) (Level, error) {
	l, err := metadata.ParseLevel(level)
	return Level(l), err
}
1320200
func SetLogLevel(log *logrus.Logger, levelString string) error {
	level, err := logrus.ParseLevel(levelString)

	if err != nil {
		return err
	}

	log.Level = level

	return nil
}
592419
func (l *Logger) logAll(opt *levelOptions, s string) {
	// Skip everything if logger is disabled
	if !l.Active {
		return
	}
	// Log to all receivers
	for _, r := range l.Receivers {
		r.log(opt, s)
	}
}
282150
func (config *Config) LogLevel() int {
	if config.ENV.CFLogLevel != "" {
		envVal, err := strconv.ParseInt(config.ENV.CFLogLevel, 10, 32)
		if err == nil {
			return int(envVal)
		}

		switch strings.ToLower(config.ENV.CFLogLevel) {
		case "fatal":
			return 1
		case "error":
			return 2
		case "warn":
			return 3
		case "info":
			return 4
		case "debug":
			return 5
		}
	}

	return 0
}
557873
func FormatLogLevel(x LogLevel) string {
	var level string
	switch x {
	case DEBUG:
		level = "DEBUG"
	case INFO:
		level = "INFO"
	case WARN:
		level = "WARN"
	case ERROR:
		level = "ERROR"
	case FATAL:
		level = "FATAL"
	}
	return level
}