accesslog

Documentation

Index

• Constants
• func NewSaveBackend(next http.Handler, backendName string) http.Handler
• func NewSaveFrontend(next http.Handler, frontendName string) http.Handler
• func NewSaveNegroniFrontend(next negroni.Handler, frontendName string) negroni.Handler
• type CommonLogFormatter
  • func (f *CommonLogFormatter) Format(entry *logrus.Entry) ([]byte, error)
• type CoreLogData
• type LogData
  • func GetLogDataTable(req *http.Request) *LogData
• type LogHandler
  • func NewLogHandler(config *types.AccessLog) (*LogHandler, error)
  • func (l *LogHandler) Close() error
  • func (l *LogHandler) Rotate() error
  • func (l *LogHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request, next http.HandlerFunc)
• type SaveBackend
  • func (sb *SaveBackend) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type SaveFrontend
  • func (sb *SaveFrontend) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type SaveNegroniFrontend
  • func (sb *SaveNegroniFrontend) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type SaveRetries
  • func (s *SaveRetries) Retried(req *http.Request, attempt int)

Constants

const (
	// StartUTC is the map key used for the time at which request processing started.
	StartUTC = "StartUTC"
	// StartLocal is the map key used for the local time at which request processing started.
	StartLocal = "StartLocal"
	// Duration is the map key used for the total time taken by processing the response, including the origin server's time but
	// not the log writing time.
	Duration = "Duration"
	// FrontendName is the map key used for the name of the Traefik frontend.
	FrontendName = "FrontendName"
	// BackendName is the map key used for the name of the Traefik backend.
	BackendName = "BackendName"
	// BackendURL is the map key used for the URL of the Traefik backend.
	BackendURL = "BackendURL"
	// BackendAddr is the map key used for the IP:port of the Traefik backend (extracted from BackendURL)
	BackendAddr = "BackendAddr"
	// ClientAddr is the map key used for the remote address in its original form (usually IP:port).
	ClientAddr = "ClientAddr"
	// ClientHost is the map key used for the remote IP address from which the client request was received.
	ClientHost = "ClientHost"
	// ClientPort is the map key used for the remote TCP port from which the client request was received.
	ClientPort = "ClientPort"
	// ClientUsername is the map key used for the username provided in the URL, if present.
	ClientUsername = "ClientUsername"
	// RequestAddr is the map key used for the HTTP Host header (usually IP:port). This is treated as not a header by the Go API.
	RequestAddr = "RequestAddr"
	// RequestHost is the map key used for the HTTP Host server name (not including port).
	RequestHost = "RequestHost"
	// RequestPort is the map key used for the TCP port from the HTTP Host.
	RequestPort = "RequestPort"
	// RequestMethod is the map key used for the HTTP method.
	RequestMethod = "RequestMethod"
	// RequestPath is the map key used for the HTTP request URI, not including the scheme, host or port.
	RequestPath = "RequestPath"
	// RequestProtocol is the map key used for the version of HTTP requested.
	RequestProtocol = "RequestProtocol"
	// RequestLine is the original request line
	RequestLine = "RequestLine"
	// RequestContentSize is the map key used for the number of bytes in the request entity (a.k.a. body) sent by the client.
	RequestContentSize = "RequestContentSize"
	// OriginDuration is the map key used for the time taken by the origin server ('upstream') to return its response.
	OriginDuration = "OriginDuration"
	// OriginContentSize is the map key used for the content length specified by the origin server, or 0 if unspecified.
	OriginContentSize = "OriginContentSize"
	// OriginStatus is the map key used for the HTTP status code returned by the origin server.
	// If the request was handled by this Traefik instance (e.g. with a redirect), then this value will be absent.
	OriginStatus = "OriginStatus"
	// OriginStatusLine is the map key used for the HTTP status code and corresponding descriptive string.
	// If the request was handled by this Traefik instance (e.g. with a redirect), then this value will be absent.
	// Note that the actual message string might be different to what is reported here, depending on server behaviour.
	OriginStatusLine = "OriginStatusLine"
	// DownstreamStatus is the map key used for the HTTP status code returned to the client.
	DownstreamStatus = "DownstreamStatus"
	// DownstreamStatusLine is the map key used for the HTTP status line returned to the client.
	DownstreamStatusLine = "DownstreamStatusLine"
	// DownstreamContentSize is the map key used for the number of bytes in the response entity returned to the client.
	// This is in addition to the "Content-Length" header, which may be present in the origin response.
	DownstreamContentSize = "DownstreamContentSize"
	// RequestCount is the map key used for the number of requests received since the Traefik instance started.
	RequestCount = "RequestCount"
	// GzipRatio is the map key used for the response body compression ratio achieved.
	GzipRatio = "GzipRatio"
	// Overhead is the map key used for the processing time overhead caused by Traefik.
	Overhead = "Overhead"
	// RetryAttempts is the map key used for the amount of attempts the request was retried.
	RetryAttempts = "RetryAttempts"
)

const (
	// DataTableKey is the key within the request context used to
	// store the Log Data Table
	DataTableKey key = "LogDataTable"

	// CommonFormat is the common logging format (CLF)
	CommonFormat = "common"

	// JSONFormat is the JSON logging format
	JSONFormat = "json"
)

Functions

func NewSaveBackend

func NewSaveBackend(next http.Handler, backendName string) http.Handler

NewSaveBackend creates a SaveBackend handler.

func NewSaveFrontend

func NewSaveFrontend(next http.Handler, frontendName string) http.Handler

NewSaveFrontend creates a SaveFrontend handler.

func NewSaveNegroniFrontend

func NewSaveNegroniFrontend(next negroni.Handler, frontendName string) negroni.Handler

NewSaveNegroniFrontend creates a SaveFrontend handler.

Types

type CommonLogFormatter

type CommonLogFormatter struct{}

CommonLogFormatter provides formatting in the Traefik common log format

func (*CommonLogFormatter) Format

func (f *CommonLogFormatter) Format(entry *logrus.Entry) ([]byte, error)

Format formats the log entry in the Traefik common log format

type CoreLogData

type CoreLogData map[string]interface{}

CoreLogData holds the fields computed from the request/response.

type LogData

type LogData struct {
	Core               CoreLogData
	Request            http.Header
	OriginResponse     http.Header
	DownstreamResponse http.Header
}

LogData is the data captured by the middleware so that it can be logged.

func GetLogDataTable

func GetLogDataTable(req *http.Request) *LogData

GetLogDataTable gets the request context object that contains logging data. This accretes data as the request passes through the middleware chain.

type LogHandler

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

LogHandler will write each request and its response to the access log.

func NewLogHandler

func NewLogHandler(config *types.AccessLog) (*LogHandler, error)

NewLogHandler creates a new LogHandler

func (*LogHandler) Close

func (l *LogHandler) Close() error

Close closes the Logger (i.e. the file etc).

func (*LogHandler) Rotate

func (l *LogHandler) Rotate() error

Rotate closes and reopens the log file to allow for rotation by an external source.

func (*LogHandler) ServeHTTP

func (l *LogHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request, next http.HandlerFunc)

type SaveBackend

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

SaveBackend sends the backend name to the logger. These are always used with a corresponding SaveFrontend handler.

func (*SaveBackend) ServeHTTP

func (sb *SaveBackend) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type SaveFrontend

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

SaveFrontend sends the frontend name to the logger. These are sometimes used with a corresponding SaveBackend handler, but not always. For example, redirected requests don't reach a backend.

func (*SaveFrontend) ServeHTTP

func (sb *SaveFrontend) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type SaveNegroniFrontend

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

SaveNegroniFrontend sends the frontend name to the logger. These are sometimes used with a corresponding SaveBackend handler, but not always. For example, redirected requests don't reach a backend.

func (*SaveNegroniFrontend) ServeHTTP

func (sb *SaveNegroniFrontend) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type SaveRetries

type SaveRetries struct{}

SaveRetries is an implementation of RetryListener that stores RetryAttempts in the LogDataTable.

func (*SaveRetries) Retried

func (s *SaveRetries) Retried(req *http.Request, attempt int)

Retried implements the RetryListener interface and will be called for each retry that happens.