// getLogger returns a logrus object with EndpointID, ContainerID and the Endpoint
// revision fields.
549890
func (e *Endpoint) getLogger() *logrus.Entry {
	v := atomic.LoadPointer(&e.logger)
	return (*logrus.Entry)(v)
}
1360882
func (logger *Logger) GetHandler(name string) Handler {
	logger.mutex.RLock()
	handlerSpec := logger.eventHandlerMap[name]
	logger.mutex.RUnlock()

	if handlerSpec == nil {
		return nil
	}
	return handlerSpec.handler
}
992047
func Logger(l *log.Logger) optSetter {
	return func(b *Buffer) error {
		b.log = l
		return nil
	}
}
900482
func (r *raftLog) GetLog(idx uint64, log *raft.Log) error {
	r.RLock()
	tx, err := r.conn.Begin(false)
	if err != nil {
		r.RUnlock()
		return err
	}
	var key [8]byte
	binary.BigEndian.PutUint64(key[:], idx)
	bucket := tx.Bucket(logsBucket)
	val := bucket.Get(key[:])
	if val == nil {
		err = raft.ErrLogNotFound
	} else {
		err = r.decodeRaftLog(val, log)
	}
	tx.Rollback()
	r.RUnlock()
	return err
}
677120
func (e *Kex2Provisionee) GetLogFactory() rpc.LogFactory {
	return rpc.NewSimpleLogFactory(e.G().Log, nil)
}
432405
func (service *Service) GetWebuser(r *http.Request, w http.ResponseWriter) (username string, err error) {
	username, err = service.sessionService.GetLoggedInUser(r, w)
	return
}
685048
func (d *DeploymentStatusRequest) GetLogURL() string {
	if d == nil || d.LogURL == nil {
		return ""
	}
	return *d.LogURL
}
289134
func getLogLevel() (loglevel string) {
	loglevel = os.Getenv(LogLevelEnvVarName)
	if len(loglevel) == 0 {
		// If no env is set, return the default
		loglevel = LogLevelDefault
	}
	return
}
788471
func NewGetEndpointIDLog(ctx *middleware.Context, handler GetEndpointIDLogHandler) *GetEndpointIDLog {
	return &GetEndpointIDLog{Context: ctx, Handler: handler}
}
404522
func Logger(logger *log.Logger) ReporterOption {
	return func(c *kafkaReporter) {
		c.logger = logger
	}
}
1328180
func UsingLogger(logger Logger) Option {
	return func(api *API) error {
		api.logger = logger
		return nil
	}
}
932227
func (s *Logging) Logger(name string) *FabricLogger {
	zl := s.ZapLogger(name)
	return NewFabricLogger(zl)
}
1234114
func DefaultLogger() *Logger {
	// The *Logger object is not created or intialized until after the first call to this function. This is because each Logger starts a goroutine, and we don't want to start a goroutine simply because the package was imported.
	var logger *Logger

	loggerValue := defaultLoggerValue.Load()
	if loggerValue == nil {
		defaultLoggerMutex.Lock()
		loggerValue = defaultLoggerValue.Load()
		if loggerValue == nil {
			logger = NewLogger()
			logger.InitStdStreams()
			defaultLoggerValue.Store(logger)
		}
		defaultLoggerMutex.Unlock()
		loggerValue = defaultLoggerValue.Load()
	}

	logger = loggerValue.(*Logger)

	return logger
}
104331
func (options) Logger(logger jaeger.Logger) Option {
	return func(o *options) {
		o.logger = logger
	}
}
831656
func GetLevelLogger(inj inject.Injector) LevelLogger {
	if loggerType := inj.Get(inject.InterfaceOf((*LevelLogger)(nil))); loggerType.IsValid() {
		logger := loggerType.Interface().(LevelLogger)
		return logger
	}
	return DefaultLogger
}
11012
func Logger(logger *zap.Logger) TransportOption {
	return func(t *transportOptions) {
		t.logger = logger
	}
}
567092
func GetLogger(name string) *Logger {
	logger, ok := loggers[name]
	if !ok {
		logger = &Logger{
			Name:  name,
			Level: DEBUG,
			ctx:   Ctx{},
		}

		logger.Enable(StdoutAppender())
		logger.normalizeName()

		// recalculate names
		curnamelen = len(logger.Name)
		for _, _logger := range loggers {
			_logger.normalizeName()
		}

		loggers[name] = logger
	}

	return logger
}