// Log a message at LEVEL_INFO with 'format' populated with values from 'va' on the default logger
18980
func Infof(format string, va ...interface{}) error {
	return logDefaultMsg(nil, LEVEL_INFO, format, va...)
}
1168779
func (l *Logger) Log(level Level, v ...interface{}) {
	l.print(level, fmt.Sprint(v...), l.NewLine)
}
820574
func (l *Logger) Infom(attrs map[string]interface{}, format string, va ...interface{}) error {
	return l.logMsg(attrs, LEVEL_INFO, format, va...)
}
1076153
func (l *logger) Info(v ...interface{}) {
	f := extractFields(&v)
	l.send(LevelInfo, 2, fmt.Sprint(v...), f)
}
14211
func (logger *Logger) Infof(format string, args ...interface{}) {
	if logger.std.Level >= lg.InfoLevel {
		logger.header(1).Infof(format, args...)
	}
}
1262342
func (logger *Logger) log(level Level, v ...interface{}) {
	if int32(level) >= atomic.LoadInt32((*int32)(&logger.level)) {
		if logger.runtime || logger.sync {
			message := fmt.Sprint(v...)
			message = logger.genLog(level, message)
			logger.flushMsg(message)
		} else {
			r := new(request)
			r.level = level
			r.v = v
			logger.request <- *r
		}
	}
}
8140
func (l *Logger) Info(msg string, fields map[string]interface{}) error {
	return l.Log(LvInfo, msg, fields)
}
884327
func (l *Logger) Info(format string, v ...interface{}) {
	fmt.Fprint(l.stderr, addColor(InfoPrefix+" ", Green))
	fmt.Fprintf(l.stdout, appendNewLine(format), v...)
}
493689
func Logf(level Level, format string, args ...interface{}) {
	Default.Logf(level, format, args...)
}
836986
func (d DefaultLogger) Logf(level LogLevel, format string, a ...interface{}) (n int, err error) {
	if level >= logThreshhold {
		return fmt.Fprintf(os.Stderr, prefix(level)+" "+format+"\n", a...)
	}

	return 0, nil
}
732117
func (po *PolicyOptions) Log(level LogLevel, msg string) {
	if !po.ShouldLog(level) {
		return // Short circuit message formatting if we're not logging it
	}

	// We are logging it, ensure trailing newline
	if len(msg) == 0 || msg[len(msg)-1] != '\n' {
		msg += "\n" // Ensure trailing newline
	}
	po.pipeline.options.Log.Log(level, msg)

	// If logger doesn't handle fatal/panic, we'll do it here.
	if level == LogFatal {
		os.Exit(1)
	} else if level == LogPanic {
		panic(msg)
	}
}
50804
func (l *Log) Info(eid uint32, msg string) error {
	return l.report(winapi.EVENTLOG_INFORMATION_TYPE, eid, msg)
}
677272
func LogLevel() string {
	envLevel := os.Getenv(EnvLog)
	if envLevel == "" {
		return ""
	}

	logLevel := "TRACE"
	if isValidLogLevel(envLevel) {
		// allow following for better ux: info, Info or INFO
		logLevel = strings.ToUpper(envLevel)
	} else {
		log.Printf("[WARN] Invalid log level: %q. Defaulting to level: TRACE. Valid levels are: %+v",
			envLevel, ValidLevels)
	}

	return logLevel
}
781420
func (c *context) Info(format string, args ...interface{}) {
	c.logger.Info(c.prefixFormat()+format, args...)
}
154647
func (dl *ConsoleLogger) Info(message interface{}, params ...interface{}) {
	dl.logger.Infof(fmt.Sprintf("%s %s", caller(), fmt.Sprint(message)), params...)
}
953168
func (l *Logger) Info(msg string, v ...interface{}) {
	l.Log("INFO", msg, v)
}
806877
func Info(v ...interface{}) {
	if std.Level >= InfoLevel {
		std.Logger.Print(InfoLevel.String() + fmt.Sprint(v...))
	}
}