// SetupGlog makes --loglevel reflect in glog's -v flag
500598
func SetupGlog(flags *pflag.FlagSet) {

	from := flag.CommandLine
	if fflag := from.Lookup("v"); fflag != nil {
		level := fflag.Value.(*log.Level)
		loglevelPtr := (*int32)(level)
		flags.Int32Var(loglevelPtr, "loglevel", 0, "Set the level of log output (0-5)")
	}

	// FIXME currently glog has only option to redirect output to stderr
	// the preferred for S2I would be to redirect to stdout
	flag.CommandLine.Set("logtostderr", "true")
}
714861
func ConfigureLogger(l *log.Logger) {
	level := log.InfoLevel
	if LogVerbose {
		level = log.DebugLevel
	} else if LogVeryQuiet {
		level = log.ErrorLevel
	} else if LogQuiet {
		level = log.WarnLevel
	}
	l.SetLevel(level)
	if LogFile != "" {
		pathmap := make(lfshook.PathMap)
		for i := 0; i < 256; i++ {
			pathmap[log.Level(i)] = LogFile
		}
		hook := lfshook.NewHook(pathmap)
		hook.SetFormatter(newLogFormatter())
		l.AddHook(hook)
	}
}
1234870
func (s *VirtualNodeSpec) SetLogging(v *Logging) *VirtualNodeSpec {
	s.Logging = v
	return s
}
578167
func (l *Logger) SetFlags(flag int) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.flag = flag
	l.lg.SetFlags(flag & maskStdLogFlags)
}
241381
func SetupLoggingLong(lvl string) {
	SetLogger(log.New(os.Stderr, "", log.LstdFlags|log.Llongfile|log.Lmicroseconds), strings.ToLower(lvl))
}
240295
func (s *MonitoringConfigurationDescription) SetLogLevel(v string) *MonitoringConfigurationDescription {
	s.LogLevel = &v
	return s
}
1291196
func SetLoggingLevel(level LoggingLevel) {
	shimLoggingLevel = level
	logging.SetLevel(logging.Level(level), "shim")
}
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
}
862004
func (s *RouteSettings) SetLoggingLevel(v string) *RouteSettings {
	s.LoggingLevel = &v
	return s
}
940138
func (s *MonitoringConfiguration) SetLogLevel(v string) *MonitoringConfiguration {
	s.LogLevel = &v
	return s
}
462582
func (s *UpdateChannelInput) SetLogLevel(v string) *UpdateChannelInput {
	s.LogLevel = &v
	return s
}
327467
func GLog(flags *pflag.FlagSet) {
	from := flag.CommandLine
	if flag := from.Lookup("v"); flag != nil {
		level := flag.Value.(*klog.Level)
		levelPtr := (*int32)(level)
		flags.Int32Var(levelPtr, "loglevel", 0, "Set the level of log output (0-10)")
		if flags.Lookup("v") == nil {
			flags.Int32Var(levelPtr, "v", 0, "Set the level of log output (0-10)")
		}
	}
	if flag := from.Lookup("vmodule"); flag != nil {
		value := flag.Value
		flags.Var(pflagValue{value}, "logspec", "Set per module logging with file|pattern=LEVEL,...")
		if flags.Lookup("vmodule") == nil {
			flags.Var(pflagValue{value}, "vmodule", "Set per module logging with file|pattern=LEVEL,...")
		}
		flags.Lookup("vmodule").Hidden = true
	}
}
645523
func (s *SimulatedEnvironment) DebugLog(format string, args ...interface{}) {
	if s.OnDebugLog != nil {
		s.OnDebugLog(format, args...)
	}
}
1254107
func setupLogging() io.Closer {
	if *flagSyslog && runtime.GOOS == "windows" {
		exitf("-syslog not available on windows")
	}
	if fn := setupLoggingSyslog; fn != nil {
		if flusher := fn(); flusher != nil {
			return flusher
		}
	}
	if env.OnGCE() {
		lw, err := gce.LogWriter()
		if err != nil {
			log.Fatalf("Error setting up logging: %v", err)
		}
		log.SetOutput(lw)
		return lw
	}
	return maybeSetupGoogleCloudLogging()
}
67889
func (f *flexVolumeMounter) SetUp(fsGroup *int64) error {
	return f.SetUpAt(f.GetPath(), fsGroup)
}
1240814
func (l privLogger) SetLogLevel(logLevel string) error {
	if logger.IsValidLogLevel(logLevel) == true {
		*l.logLevel = logLevel
		return nil
	}
	return types.ErrNotFound{}
}
1110769
func (s *ChannelSummary) SetLogLevel(v string) *ChannelSummary {
	s.LogLevel = &v
	return s
}