Documentation

Overview

    Package logger defines interfaces that logger drivers implement to log messages.

    The other half of a logger driver is the implementation of the factory, which holds the contextual instance information that allows multiple loggers of the same type to perform different actions, such as logging to different locations.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func AddBuiltinLogOpts

    func AddBuiltinLogOpts(opts map[string]bool)

      AddBuiltinLogOpts updates the list of built-in log opts. This allows other packages to supplement additional log options without having to register an actual log driver. This is used by things that are more proxy log drivers and should not be exposed as a usable log driver to the API. This should only be called on package initialization.

      func ListDrivers

      func ListDrivers() []string

        ListDrivers gets the list of registered log driver names

        func PutMessage

        func PutMessage(msg *Message)

          PutMessage puts the specified message back n the message pool. The message fields are reset before putting into the pool.

          func RegisterExternalValidator

          func RegisterExternalValidator(v LogOptValidator)

            RegisterExternalValidator adds the validator to the list of external validators. External validators are used by packages outside this package that need to add their own validation logic. This should only be called on package initialization.

            func RegisterLogDriver

            func RegisterLogDriver(name string, c Creator) error

              RegisterLogDriver registers the given logging driver builder with given logging driver name.

              func RegisterLogOptValidator

              func RegisterLogOptValidator(name string, l LogOptValidator) error

                RegisterLogOptValidator registers the logging option validator with the given logging driver name.

                func RegisterPluginGetter

                func RegisterPluginGetter(plugingetter getter.PluginGetter)

                  RegisterPluginGetter sets the plugingetter

                  func ValidateLogOpts

                  func ValidateLogOpts(name string, cfg map[string]string) error

                    ValidateLogOpts checks the options for the given log driver. The options supported are specific to the LogDriver implementation.

                    Types

                    type Capability

                    type Capability struct {
                    	// Determines if a log driver can read back logs
                    	ReadLogs bool
                    }

                      Capability defines the list of capabilities that a driver can implement These capabilities are not required to be a logging driver, however do determine how a logging driver can be used

                      type Copier

                      type Copier struct {
                      	// contains filtered or unexported fields
                      }

                        Copier can copy logs from specified sources to Logger and attach Timestamp. Writes are concurrent, so you need implement some sync in your logger.

                        func NewCopier

                        func NewCopier(srcs map[string]io.Reader, dst Logger) *Copier

                          NewCopier creates a new Copier

                          func (*Copier) Close

                          func (c *Copier) Close()

                            Close closes the copier

                            func (*Copier) Run

                            func (c *Copier) Run()

                              Run starts logs copying

                              func (*Copier) Wait

                              func (c *Copier) Wait()

                                Wait waits until all copying is done

                                type Creator

                                type Creator func(Info) (Logger, error)

                                  Creator builds a logging driver instance with given context.

                                  func GetLogDriver

                                  func GetLogDriver(name string) (Creator, error)

                                    GetLogDriver provides the logging driver builder for a logging driver name.

                                    type ErrReadLogsNotSupported

                                    type ErrReadLogsNotSupported struct{}

                                      ErrReadLogsNotSupported is returned when the underlying log driver does not support reading

                                      func (ErrReadLogsNotSupported) Error

                                      func (ErrReadLogsNotSupported) NotImplemented

                                      func (ErrReadLogsNotSupported) NotImplemented()

                                        NotImplemented makes this error implement the `NotImplemented` interface from api/errdefs

                                        type Info

                                        type Info struct {
                                        	Config              map[string]string
                                        	ContainerID         string
                                        	ContainerName       string
                                        	ContainerEntrypoint string
                                        	ContainerArgs       []string
                                        	ContainerImageID    string
                                        	ContainerImageName  string
                                        	ContainerCreated    time.Time
                                        	ContainerEnv        []string
                                        	ContainerLabels     map[string]string
                                        	LogPath             string
                                        	DaemonName          string
                                        }

                                          Info provides enough information for a logging driver to do its function.

                                          func (*Info) Command

                                          func (info *Info) Command() string

                                            Command returns the command that the container being logged was started with. The Entrypoint is prepended to the container arguments.

                                            func (*Info) ExtraAttributes

                                            func (info *Info) ExtraAttributes(keyMod func(string) string) (map[string]string, error)

                                              ExtraAttributes returns the user-defined extra attributes (labels, environment variables) in key-value format. This can be used by log drivers that support metadata to add more context to a log.

                                              func (*Info) FullID

                                              func (info *Info) FullID() string

                                                FullID is an alias of ContainerID.

                                                func (*Info) Hostname

                                                func (info *Info) Hostname() (string, error)

                                                  Hostname returns the hostname from the underlying OS.

                                                  func (*Info) ID

                                                  func (info *Info) ID() string

                                                    ID Returns the Container ID shortened to 12 characters.

                                                    func (*Info) ImageFullID

                                                    func (info *Info) ImageFullID() string

                                                      ImageFullID is an alias of ContainerImageID.

                                                      func (*Info) ImageID

                                                      func (info *Info) ImageID() string

                                                        ImageID returns the ContainerImageID shortened to 12 characters.

                                                        func (*Info) ImageName

                                                        func (info *Info) ImageName() string

                                                          ImageName is an alias of ContainerImageName

                                                          func (*Info) Name

                                                          func (info *Info) Name() string

                                                            Name returns the ContainerName without a preceding '/'.

                                                            type LogOptValidator

                                                            type LogOptValidator func(cfg map[string]string) error

                                                              LogOptValidator checks the options specific to the underlying logging implementation.

                                                              type LogReader

                                                              type LogReader interface {
                                                              	// Read logs from underlying logging backend
                                                              	ReadLogs(ReadConfig) *LogWatcher
                                                              }

                                                                LogReader is the interface for reading log messages for loggers that support reading.

                                                                type LogWatcher

                                                                type LogWatcher struct {
                                                                	// For sending log messages to a reader.
                                                                	Msg chan *Message
                                                                	// For sending error messages that occur while reading logs.
                                                                	Err chan error
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  LogWatcher is used when consuming logs read from the LogReader interface.

                                                                  func NewLogWatcher

                                                                  func NewLogWatcher() *LogWatcher

                                                                    NewLogWatcher returns a new LogWatcher.

                                                                    func (*LogWatcher) ConsumerGone

                                                                    func (w *LogWatcher) ConsumerGone()

                                                                      ConsumerGone notifies that the logs consumer is gone.

                                                                      func (*LogWatcher) ProducerGone

                                                                      func (w *LogWatcher) ProducerGone()

                                                                        ProducerGone notifies the underlying log reader that the logs producer (a container) is gone.

                                                                        func (*LogWatcher) WatchConsumerGone

                                                                        func (w *LogWatcher) WatchConsumerGone() <-chan struct{}

                                                                          WatchConsumerGone returns a channel receiver that receives notification when the log watcher consumer is gone.

                                                                          func (*LogWatcher) WatchProducerGone

                                                                          func (w *LogWatcher) WatchProducerGone() <-chan struct{}

                                                                            WatchProducerGone returns a channel receiver that receives notification once the logs producer (a container) is gone.

                                                                            type Logger

                                                                            type Logger interface {
                                                                            	Log(*Message) error
                                                                            	Name() string
                                                                            	Close() error
                                                                            }

                                                                              Logger is the interface for docker logging drivers.

                                                                              func NewRingLogger

                                                                              func NewRingLogger(driver Logger, logInfo Info, maxSize int64) Logger

                                                                                NewRingLogger creates a new Logger that is implemented as a RingBuffer wrapping the passed in logger.

                                                                                type MarshalFunc

                                                                                type MarshalFunc func(*Message) ([]byte, error)

                                                                                  MarshalFunc is a func that marshals a message into an arbitrary format

                                                                                  type Message

                                                                                  type Message backend.LogMessage

                                                                                    Message is data structure that represents piece of output produced by some container. The Line member is a slice of an array whose contents can be changed after a log driver's Log() method returns.

                                                                                    Message is subtyped from backend.LogMessage because there is a lot of internal complexity around the Message type that should not be exposed to any package not explicitly importing the logger type.

                                                                                    Any changes made to this struct must also be updated in the `reset` function

                                                                                    func NewMessage

                                                                                    func NewMessage() *Message

                                                                                      NewMessage returns a new message from the message sync.Pool

                                                                                      func (*Message) AsLogMessage

                                                                                      func (m *Message) AsLogMessage() *backend.LogMessage

                                                                                        AsLogMessage returns a pointer to the message as a pointer to backend.LogMessage, which is an identical type with a different purpose

                                                                                        type ReadConfig

                                                                                        type ReadConfig struct {
                                                                                        	Since  time.Time
                                                                                        	Until  time.Time
                                                                                        	Tail   int
                                                                                        	Follow bool
                                                                                        }

                                                                                          ReadConfig is the configuration passed into ReadLogs.

                                                                                          type RingLogger

                                                                                          type RingLogger struct {
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            RingLogger is a ring buffer that implements the Logger interface. This is used when lossy logging is OK.

                                                                                            func (*RingLogger) BufSize

                                                                                            func (r *RingLogger) BufSize() int

                                                                                              BufSize returns the buffer size of the underlying logger. Returns -1 if the logger doesn't match SizedLogger interface.

                                                                                              func (*RingLogger) Close

                                                                                              func (r *RingLogger) Close() error

                                                                                                Close closes the logger

                                                                                                func (*RingLogger) Log

                                                                                                func (r *RingLogger) Log(msg *Message) error

                                                                                                  Log queues messages into the ring buffer

                                                                                                  func (*RingLogger) Name

                                                                                                  func (r *RingLogger) Name() string

                                                                                                    Name returns the name of the underlying logger

                                                                                                    type SizedLogger

                                                                                                    type SizedLogger interface {
                                                                                                    	Logger
                                                                                                    	BufSize() int
                                                                                                    }

                                                                                                      SizedLogger is the interface for logging drivers that can control the size of buffer used for their messages.

                                                                                                      Directories

                                                                                                      Path Synopsis
                                                                                                      Package awslogs provides the logdriver for forwarding container logs to Amazon CloudWatch Logs
                                                                                                      Package awslogs provides the logdriver for forwarding container logs to Amazon CloudWatch Logs
                                                                                                      Package etwlogs provides a log driver for forwarding container logs as ETW events.(ETW stands for Event Tracing for Windows) A client can then create an ETW listener to listen for events that are sent by the ETW provider that we register, using the provider's GUID "a3693192-9ed6-46d2-a981-f8226c8363bd".
                                                                                                      Package etwlogs provides a log driver for forwarding container logs as ETW events.(ETW stands for Event Tracing for Windows) A client can then create an ETW listener to listen for events that are sent by the ETW provider that we register, using the provider's GUID "a3693192-9ed6-46d2-a981-f8226c8363bd".
                                                                                                      Package fluentd provides the log driver for forwarding server logs to fluentd endpoints.
                                                                                                      Package fluentd provides the log driver for forwarding server logs to fluentd endpoints.
                                                                                                      Package gelf provides the log driver for forwarding server logs to endpoints that support the Graylog Extended Log Format.
                                                                                                      Package gelf provides the log driver for forwarding server logs to endpoints that support the Graylog Extended Log Format.
                                                                                                      Package journald provides the log driver for forwarding server logs to endpoints that receive the systemd format.
                                                                                                      Package journald provides the log driver for forwarding server logs to endpoints that receive the systemd format.
                                                                                                      Package jsonfilelog provides the default Logger implementation for Docker logging.
                                                                                                      Package jsonfilelog provides the default Logger implementation for Docker logging.
                                                                                                      Package local provides a logger implementation that stores logs on disk.
                                                                                                      Package local provides a logger implementation that stores logs on disk.
                                                                                                      Package logentries provides the log driver for forwarding server logs to logentries endpoints.
                                                                                                      Package logentries provides the log driver for forwarding server logs to logentries endpoints.
                                                                                                      Package splunk provides the log driver for forwarding server logs to Splunk HTTP Event Collector endpoint.
                                                                                                      Package splunk provides the log driver for forwarding server logs to Splunk HTTP Event Collector endpoint.
                                                                                                      Package syslog provides the logdriver for forwarding server logs to syslog endpoints.
                                                                                                      Package syslog provides the logdriver for forwarding server logs to syslog endpoints.