// Send a log message manually
// Wrapper for (*Logger).Log
549111
func Log(lvl Level, source, message string) {
	Global.Log(lvl, source, message)
}
1171014
func (s *InternalSender) Send(m message.Composer) {
	s.output <- &InternalMessage{
		Message:  m,
		Priority: m.Priority(),
		Rendered: m.String(),
		Logged:   s.Level().ShouldLog(m),
	}
}
860828
func (c *C) log(args ...interface{}) {
	c.writeLog([]byte(fmt.Sprint(args...) + "\n"))
}
823510
func (l *Logger) makeLog(msg interface{}, lvl Level, data []interface{}) {
	log := Log{
		Time:    time.Now().UTC(),
		Message: l.toString(msg),
		Level:   lvl,
		Data:    data,
		Logger:  l,
		Pid:     os.Getpid(),
		Ctx:     l.ctx,
	}

	for _, appender := range l.appenders {
		appender.Append(log)
	}
}
84852
func (h *Handler) HandleLog(e *log.Entry) error {
	switch e.Level {
	case log.DebugLevel:
		return h.logger.Dbgm(e.Fields, e.Message)
	case log.InfoLevel:
		return h.logger.Infom(e.Fields, e.Message)
	case log.WarnLevel:
		return h.logger.Warnm(e.Fields, e.Message)
	case log.ErrorLevel:
		return h.logger.Errm(e.Fields, e.Message)
	case log.FatalLevel:
		return h.logger.Critm(e.Fields, e.Message)
	}

	return nil
}
1091222
func (k *LoggerKit) Log(keyvals ...interface{}) error {
	k.LogTo.Log(keyvals...)
	return nil
}
1374502
func Log(a ...interface{}) {
	format := ""

	for range a {
		format += "%v "
	}

	format = format[:len(format)-1]
	Logger(format, a...)
}
269233
func (l *Logger) Warn(msg interface{}, data ...interface{}) {
	if l.shouldAppend(WARN) {
		l.makeLog(msg, WARN, data)
	}
}
378085
func (l *Logger) Log(level Level, format string, a ...interface{}) {
	if level > l.MaxLevel || !l.open {
		return
	}
	message := format
	if len(a) > 0 {
		message = fmt.Sprintf(format, a...)
	}
	entry := &Entry{
		Category: l.Category,
		Level:    level,
		Message:  message,
		Time:     time.Now(),
	}
	if l.CallStackDepth > 0 {
		entry.CallStack = GetCallStack(3, l.CallStackDepth, l.CallStackFilter)
	}
	entry.FormattedMessage = l.Formatter(l, entry)
	l.entries <- entry
}
1199330
func log(msg string, parts ...interface{}) string {
	return fmt.Sprintf(fmt.Sprintf("%s: %s", CSIPluginName, msg), parts...)
}
1362208
func Log(serviceName string, methodName string, request proto.Message, response proto.Message, err error, duration time.Duration) {
	if err != nil {
		Error(serviceName, methodName, request, response, err, duration)
	} else {
		Info(serviceName, methodName, request, response, err, duration)
	}
}
73193
func (l *LogSender) SendAppLog(appID, message, sourceType, sourceInstance string) error {
	metrics.BatchIncrementCounter("logSenderTotalMessagesRead")
	return l.eventEmitter.Emit(makeLogMessage(appID, message, sourceType, sourceInstance, events.LogMessage_OUT))
}
566024
func (logger *StreamLogger) Send(message interface{}) {
	logger.mu.Lock()
	defer logger.mu.Unlock()

	for ch, name := range logger.subscribed {
		select {
		case ch <- message:
			deliveredCount.Add([]string{logger.name, name}, 1)
		default:
			deliveryDropCount.Add([]string{logger.name, name}, 1)
		}
	}
	sendCount.Add(logger.name, 1)
}
1276703
func (e *EmptyService) Log(ctx context.Context, follow bool) error {
	return nil
}
67714
func (a *LBClient) SendLogMessage(serviceLogInfo ServiceLogInfo, _ *struct{}) error {
	glog.V(4).Infof("ControlCenterAgent.SendLogMessage()")
	return a.rpcClient.Call("ControlCenterAgent.SendLogMessage", serviceLogInfo, nil, 0)
}
438799
func Log(handler http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s %s", r.RemoteAddr, r.Method, r.URL)
		handler.ServeHTTP(w, r)
	})
}
654957
func (log Logger) Log(lvl level, source, message string) {
	log.intLogNamef(logName(lvl), lvl, message)
}