// Crit produce a "Critical" log
325210
func (l *Logger) Crit(v interface{}) {
	if l.checkLogLevel(CritiLevel) {
		l.Output(time.Now(), CritiLevel, formatError(v))
	}
}
1139208
func (s *Syslog) Log(e log.Entry) {
	s.once.Do(func() {
		s.formatter = s.formatFunc(s)
	})
	line := string(s.formatter(e))

	switch e.Level {
	case log.DebugLevel:
		_ = s.writer.Debug(line)
	case log.InfoLevel:
		_ = s.writer.Info(line)
	case log.NoticeLevel:
		_ = s.writer.Notice(line)
	case log.WarnLevel:
		_ = s.writer.Warning(line)
	case log.ErrorLevel:
		_ = s.writer.Err(line)
	case log.PanicLevel, log.AlertLevel:
		_ = s.writer.Alert(line)
	case log.FatalLevel:
		_ = s.writer.Crit(line)
	}
}
116355
func (l *Logger) Critical(format string, a ...interface{}) {
	l.Log(LevelCritical, format, a...)
}
1243980
func Die(msg string, args ...interface{}) {
	Logger().Crit(msg, args...)
	panic(msg)
}
1264334
func (logs *Logs) Critical(v ...interface{}) {
	logs.CRITICAL().Output(2, fmt.Sprintln(v...))
}
1049179
func (d DefaultLogger) Log(level LogLevel, a ...interface{}) (n int, err error) {
	if level >= logThreshhold {
		fmt.Fprint(os.Stderr, prefix(level)+" ")
		return fmt.Fprintln(os.Stderr, a...)
	}
	return 0, nil
}
806147
func Crit(ctx context.Context, msg string, logCtx ...interface{}) {
	FromContext(ctx).Crit(msg, logCtx...)
}
1366398
func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{}) {
	l.writer.WriteString(t.Format(l.timeFormat))
	l.writer.WriteByte(' ')

	s, ok := _levelToBracket[level]
	if ok {
		l.writer.WriteString(s)
	} else {
		l.writer.WriteString("[?????]")
	}

	if l.caller {
		if _, file, line, ok := runtime.Caller(3); ok {
			l.writer.WriteByte(' ')
			l.writer.WriteString(trimCallerPath(file))
			l.writer.WriteByte(':')
			l.writer.WriteString(strconv.Itoa(line))
			l.writer.WriteByte(':')
		}
	}

	l.writer.WriteByte(' ')

	if l.name != "" {
		l.writer.WriteString(l.name)
		l.writer.WriteString(": ")
	}

	l.writer.WriteString(msg)

	args = append(l.implied, args...)

	var stacktrace CapturedStacktrace

	if args != nil && len(args) > 0 {
		if len(args)%2 != 0 {
			cs, ok := args[len(args)-1].(CapturedStacktrace)
			if ok {
				args = args[:len(args)-1]
				stacktrace = cs
			} else {
				args = append(args, "<unknown>")
			}
		}

		l.writer.WriteByte(':')

	FOR:
		for i := 0; i < len(args); i = i + 2 {
			var (
				val string
				raw bool
			)

			switch st := args[i+1].(type) {
			case string:
				val = st
			case int:
				val = strconv.FormatInt(int64(st), 10)
			case int64:
				val = strconv.FormatInt(int64(st), 10)
			case int32:
				val = strconv.FormatInt(int64(st), 10)
			case int16:
				val = strconv.FormatInt(int64(st), 10)
			case int8:
				val = strconv.FormatInt(int64(st), 10)
			case uint:
				val = strconv.FormatUint(uint64(st), 10)
			case uint64:
				val = strconv.FormatUint(uint64(st), 10)
			case uint32:
				val = strconv.FormatUint(uint64(st), 10)
			case uint16:
				val = strconv.FormatUint(uint64(st), 10)
			case uint8:
				val = strconv.FormatUint(uint64(st), 10)
			case CapturedStacktrace:
				stacktrace = st
				continue FOR
			case Format:
				val = fmt.Sprintf(st[0].(string), st[1:]...)
			default:
				v := reflect.ValueOf(st)
				if v.Kind() == reflect.Slice {
					val = l.renderSlice(v)
					raw = true
				} else {
					val = fmt.Sprintf("%v", st)
				}
			}

			l.writer.WriteByte(' ')
			l.writer.WriteString(args[i].(string))
			l.writer.WriteByte('=')

			if !raw && strings.ContainsAny(val, " \t\n\r") {
				l.writer.WriteByte('"')
				l.writer.WriteString(val)
				l.writer.WriteByte('"')
			} else {
				l.writer.WriteString(val)
			}
		}
	}

	l.writer.WriteString("\n")

	if stacktrace != "" {
		l.writer.WriteString(string(stacktrace))
	}
}
234261
func (logger *Logger) Log(level Level, v ...interface{}) {
	// Don't delete this calling. The calling is used to keep the same
	// calldepth for all the logging functions. The calldepth is used to
	// get runtime information such as line number, function name, etc.
	logger.log(level, v...)
}
926543
func (bl *BeeLogger) Critical(format string, v ...interface{}) {
	if LevelCritical > bl.level {
		return
	}
	msg := fmt.Sprintf("[C] "+format, v...)
	bl.writerMsg(LevelCritical, msg)
}
1308407
func Log(lvl level, source, message string) {
	Global.Log(lvl, source, message)
}
365955
func Critm(attrs map[string]interface{}, format string, va ...interface{}) error {
	return logDefaultMsg(attrs, LEVEL_CRIT, format, va...)
}
1165622
func (l *Logger) Critf(format string, va ...interface{}) error {
	return l.logMsg(nil, LEVEL_CRIT, format, va...)
}
721166
func (dl *ConsoleLogger) Critical(message interface{}, params ...interface{}) {
	dl.logger.Criticalf(fmt.Sprintf("%s %s", caller(), fmt.Sprint(message)), params...)
}
1121651
func Crit(msg string, ctx ...interface{}) {
	root.write(msg, LvlCrit, ctx, skipLevel)
	os.Exit(1)
}
603807
func Critical(msg string, fields map[string]interface{}) error {
	return defaultLogger.Log(LvCritical, msg, fields)
}
1313041
func (logger *Logger) Log(priority Priority, v ...interface{}) {
	fields := logger.fieldValues()
	fields["priority"] = priority
	fields["message"] = fmt.Sprint(v...)
	for _, sink := range logger.sinks {
		sink.Log(fields)
	}
}