// Critical formats a given message according to given params to log with level Critical and produces to a given Kafka topic.
170501
func (k *KafkaLogEmitter) Critical(message interface{}, params ...interface{}) {
	k.Emit(newLogLine(k.config.Source, CriticalLogTypeId, fmt.Sprintf(fmt.Sprint(message), params), k.config.Tags))
}
365932
func (l *Logger) CriticalD(title string, data map[string]interface{}) {
	data["title"] = title
	l.logWithLevel(Critical, data)
}
531424
func (k *KafkaLogEmitter) Info(message string, params ...interface{}) {
	k.Emit(newLogLine(k.config.Source, InfoLogTypeId, fmt.Sprintf(message, params), k.config.Tags))
}
534617
func (e *Errors) Crit(format string, a ...interface{}) error {
	return e.add(Critical, format, a...)
}
553191
func (l *Logger) Criticalf(format string, v ...interface{}) {
	l.Fprint(l.flags, LEVEL_CRITICAL, 2, fmt.Sprintf(format, v...), nil)
}
232295
func (sl *SysLogger) Critical(info, msg string) {
	sl.writer.Crit(info + " " + msg)
}
404196
func Criticalf(format string, i ...interface{}) {
	if gLogLevel <= LCritical {
		logMessage("CRITICAL - ", fmt.Sprintf(format, i...))
	}
}
1226220
func (l *kafkaLogRecord) log(verdict accesslog.FlowVerdict, code int, info string) {
	l.ApplyTags(logger.LogTags.Verdict(verdict, info))
	l.Kafka.ErrorCode = code

	// Log multiple entries for multiple Kafka topics in a single request.
	for _, t := range l.topics {
		l.Kafka.Topic.Topic = t
		l.Log()
	}

	// Update stats for the endpoint.
	// Count only one request.
	ingress := l.ObservationPoint == accesslog.Ingress
	var port uint16
	if ingress {
		port = l.DestinationEndpoint.Port
	} else {
		port = l.SourceEndpoint.Port
	}
	if port == 0 {
		// Something went wrong when identifying the endpoints.
		// Ignore in order to avoid polluting the stats.
		return
	}
	request := l.Type == accesslog.TypeRequest
	l.localEndpoint.UpdateProxyStatistics("kafka", port, ingress, request, l.Verdict)

}
340682
func (l *BeeLogger) Fatal(message string) {
	l.mustLog(levelFatal, message)
	os.Exit(255)
}
788245
func (g *GroupComposer) Priority() level.Priority {
	var highest level.Priority

	for _, m := range g.messages {
		if m == nil {
			continue
		}
		pri := m.Priority()
		if pri > highest {
			highest = pri
		}
	}

	return highest
}
412645
func (l *Logger) Critical(msg string, fields map[string]interface{}) error {
	return l.Log(LvCritical, msg, fields)
}
365955
func Critm(attrs map[string]interface{}, format string, va ...interface{}) error {
	return logDefaultMsg(attrs, LEVEL_CRIT, format, va...)
}
806147
func Crit(ctx context.Context, msg string, logCtx ...interface{}) {
	FromContext(ctx).Crit(msg, logCtx...)
}
941354
func Critf(format string, va ...interface{}) error {
	return logDefaultMsg(nil, LEVEL_CRIT, format, va...)
}
988565
func (l *Logger) Crit(v ...interface{}) {
	if l.getLevel() <= Critical {
		l.getHandler().Log(l.name, Critical, fmt.Sprint(v...), 1)
	}
}
465839
func Critical(format string, values ...interface{}) {
	mu.Lock()
	logger.Logf("[CRITICAL] "+format, values...)
	mu.Unlock()
}
434199
func Critical(v ...interface{}) {
	std.Fprint(std.flags, LEVEL_CRITICAL, 2, fmt.Sprint(v...), nil)
}