homelab/traefik
1
0
Fork 0
Code Activity

New logger for the Traefik logs

Browse source
This commit is contained in:
Ludovic Fernandez 2022-11-21 18:36:05 +01:00 • committed by GitHub
parent 27c02b5a56
commit 56f7515ecd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
297 changed files with 2337 additions and 1934 deletions
Download patch file Download diff file Expand all files Collapse all files

7
pkg/middlewares/accesslog/field_middleware.go
View file

@ -4,9 +4,10 @@ import (
"net/http"
"time"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares/capture"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
)
// FieldApply function hook to add data in accesslog.
@ -57,7 +58,7 @@ func AddOriginFields(rw http.ResponseWriter, req *http.Request, next http.Handle
ctx := req.Context()
capt, err := capture.FromContext(ctx)
if err != nil {
log.FromContext(log.With(ctx, log.Str(log.MiddlewareType, "AccessLogs"))).Errorf("Could not get Capture: %v", err)
log.Ctx(ctx).Error().Err(err).Str(logs.MiddlewareType, "AccessLogs").Msg("Could not get Capture")
return
}

11
pkg/middlewares/accesslog/logger.go
View file

@ -16,9 +16,10 @@ import (
"time"
"github.com/containous/alice"
"github.com/rs/zerolog/log"
"github.com/sirupsen/logrus"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares/capture"
traefiktls "github.com/traefik/traefik/v2/pkg/tls"
"github.com/traefik/traefik/v2/pkg/types"
@ -94,7 +95,7 @@ func NewHandler(config *types.AccessLog) (*Handler, error) {
case JSONFormat:
formatter = new(logrus.JSONFormatter)
default:
log.WithoutContext().Errorf("unsupported access log format: %q, defaulting to common format instead.", config.Format)
log.Error().Msgf("Unsupported access log format: %q, defaulting to common format instead.", config.Format)
formatter = new(CommonLogFormatter)
}
@ -125,7 +126,7 @@ func NewHandler(config *types.AccessLog) (*Handler, error) {
if config.Filters != nil {
if httpCodeRanges, err := types.NewHTTPCodeRanges(config.Filters.StatusCodes); err != nil {
log.WithoutContext().Errorf("Failed to create new HTTP code ranges: %s", err)
log.Error().Err(err).Msg("Failed to create new HTTP code ranges")
} else {
logHandler.httpCodeRanges = httpCodeRanges
}
@ -233,9 +234,7 @@ func (h *Handler) ServeHTTP(rw http.ResponseWriter, req *http.Request, next http
ctx := req.Context()
capt, err := capture.FromContext(ctx)
if err != nil {
log.FromContext(log.With(ctx, log.Str(log.MiddlewareType, "AccessLogs"))).
WithError(err).
Errorf("Could not get Capture")
log.Ctx(ctx).Error().Err(err).Str(logs.MiddlewareType, "AccessLogs").Msg("Could not get Capture")
return
}

9
pkg/middlewares/addprefix/add_prefix.go
View file

@ -7,7 +7,6 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -25,7 +24,7 @@ type addPrefix struct {
// New creates a new handler.
func New(ctx context.Context, next http.Handler, config dynamic.AddPrefix, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
var result *addPrefix
if len(config.Prefix) > 0 {
@ -46,16 +45,16 @@ func (a *addPrefix) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (a *addPrefix) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := log.FromContext(middlewares.GetLoggerCtx(req.Context(), a.name, typeName))
logger := middlewares.GetLogger(req.Context(), a.name, typeName)
oldURLPath := req.URL.Path
req.URL.Path = ensureLeadingSlash(a.prefix + req.URL.Path)
logger.Debugf("URL.Path is now %s (was %s).", req.URL.Path, oldURLPath)
logger.Debug().Msgf("URL.Path is now %s (was %s).", req.URL.Path, oldURLPath)
if req.URL.RawPath != "" {
oldURLRawPath := req.URL.RawPath
req.URL.RawPath = ensureLeadingSlash(a.prefix + req.URL.RawPath)
logger.Debugf("URL.RawPath is now %s (was %s).", req.URL.RawPath, oldURLRawPath)
logger.Debug().Msgf("URL.RawPath is now %s (was %s).", req.URL.RawPath, oldURLRawPath)
}
req.RequestURI = req.URL.RequestURI()

12
pkg/middlewares/auth/basic_auth.go
View file

@ -10,7 +10,6 @@ import (
goauth "github.com/abbot/go-http-auth"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/accesslog"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -31,7 +30,8 @@ type basicAuth struct {
// NewBasic creates a basicAuth middleware.
func NewBasic(ctx context.Context, next http.Handler, authConfig dynamic.BasicAuth, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, basicTypeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, basicTypeName).Debug().Msg("Creating middleware")
users, err := getUsers(authConfig.UsersFile, authConfig.Users, basicUserParser)
if err != nil {
return nil, err
@ -60,7 +60,7 @@ func (b *basicAuth) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (b *basicAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := log.FromContext(middlewares.GetLoggerCtx(req.Context(), b.name, basicTypeName))
logger := middlewares.GetLogger(req.Context(), b.name, basicTypeName)
user, password, ok := req.BasicAuth()
if ok {
@ -76,14 +76,14 @@ func (b *basicAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
}
if !ok {
logger.Debug("Authentication failed")
logger.Debug().Msg("Authentication failed")
tracing.SetErrorWithEvent(req, "Authentication failed")
b.auth.RequireAuth(rw, req)
return
}
logger.Debug("Authentication succeeded")
logger.Debug().Msg("Authentication succeeded")
req.URL.User = url.User(user)
if b.headerField != "" {
@ -91,7 +91,7 @@ func (b *basicAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
}
if b.removeHeader {
logger.Debug("Removing authorization header")
logger.Debug().Msg("Removing authorization header")
req.Header.Del(authorizationHeader)
}
b.next.ServeHTTP(rw, req)

14
pkg/middlewares/auth/digest_auth.go
View file

@ -10,7 +10,6 @@ import (
goauth "github.com/abbot/go-http-auth"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/accesslog"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -31,7 +30,8 @@ type digestAuth struct {
// NewDigest creates a digest auth middleware.
func NewDigest(ctx context.Context, next http.Handler, authConfig dynamic.DigestAuth, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, digestTypeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, digestTypeName).Debug().Msg("Creating middleware")
users, err := getUsers(authConfig.UsersFile, authConfig.Users, digestUserParser)
if err != nil {
return nil, err
@ -59,7 +59,7 @@ func (d *digestAuth) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (d *digestAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := log.FromContext(middlewares.GetLoggerCtx(req.Context(), d.name, digestTypeName))
logger := middlewares.GetLogger(req.Context(), d.name, digestTypeName)
username, authinfo := d.auth.CheckAuth(req)
if username == "" {
@ -77,19 +77,19 @@ func (d *digestAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
}
if authinfo != nil && *authinfo == "stale" {
logger.Debug("Digest authentication failed, possibly because out of order requests")
logger.Debug().Msg("Digest authentication failed, possibly because out of order requests")
tracing.SetErrorWithEvent(req, "Digest authentication failed, possibly because out of order requests")
d.auth.RequireAuthStale(rw, req)
return
}
logger.Debug("Digest authentication failed")
logger.Debug().Msg("Digest authentication failed")
tracing.SetErrorWithEvent(req, "Digest authentication failed")
d.auth.RequireAuth(rw, req)
return
}
logger.Debug("Digest authentication succeeded")
logger.Debug().Msg("Digest authentication succeeded")
req.URL.User = url.User(username)
logData := accesslog.GetLogData(req)
@ -102,7 +102,7 @@ func (d *digestAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
}
if d.removeHeader {
logger.Debug("Removing the Authorization header")
logger.Debug().Msg("Removing the Authorization header")
req.Header.Del(authorizationHeader)
}
d.next.ServeHTTP(rw, req)

21
pkg/middlewares/auth/forward.go
View file

@ -13,12 +13,11 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/connectionheader"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/forward"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/forward"
"github.com/vulcand/oxy/v2/utils"
)
const (
@ -52,7 +51,7 @@ type forwardAuth struct {
// NewForward creates a forward auth middleware.
func NewForward(ctx context.Context, next http.Handler, config dynamic.ForwardAuth, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, forwardedTypeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, forwardedTypeName).Debug().Msg("Creating middleware")
fa := &forwardAuth{
address: config.Address,
@ -98,13 +97,13 @@ func (fa *forwardAuth) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := log.FromContext(middlewares.GetLoggerCtx(req.Context(), fa.name, forwardedTypeName))
logger := middlewares.GetLogger(req.Context(), fa.name, forwardedTypeName)
forwardReq, err := http.NewRequest(http.MethodGet, fa.address, nil)
tracing.LogRequest(tracing.GetSpan(req), forwardReq)
if err != nil {
logMessage := fmt.Sprintf("Error calling %s. Cause %s", fa.address, err)
logger.Debug(logMessage)
logger.Debug().Msg(logMessage)
tracing.SetErrorWithEvent(req, logMessage)
rw.WriteHeader(http.StatusInternalServerError)
@ -120,7 +119,7 @@ func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
forwardResponse, forwardErr := fa.client.Do(forwardReq)
if forwardErr != nil {
logMessage := fmt.Sprintf("Error calling %s. Cause: %s", fa.address, forwardErr)
logger.Debug(logMessage)
logger.Debug().Msg(logMessage)
tracing.SetErrorWithEvent(req, logMessage)
rw.WriteHeader(http.StatusInternalServerError)
@ -130,7 +129,7 @@ func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
body, readError := io.ReadAll(forwardResponse.Body)
if readError != nil {
logMessage := fmt.Sprintf("Error reading body %s. Cause: %s", fa.address, readError)
logger.Debug(logMessage)
logger.Debug().Msg(logMessage)
tracing.SetErrorWithEvent(req, logMessage)
rw.WriteHeader(http.StatusInternalServerError)
@ -141,7 +140,7 @@ func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
// Pass the forward response's body and selected headers if it
// didn't return a response within the range of [200, 300).
if forwardResponse.StatusCode < http.StatusOK || forwardResponse.StatusCode >= http.StatusMultipleChoices {
logger.Debugf("Remote error %s. StatusCode: %d", fa.address, forwardResponse.StatusCode)
logger.Debug().Msgf("Remote error %s. StatusCode: %d", fa.address, forwardResponse.StatusCode)
utils.CopyHeaders(rw.Header(), forwardResponse.Header)
utils.RemoveHeaders(rw.Header(), hopHeaders...)
@ -152,7 +151,7 @@ func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
if err != nil {
if !errors.Is(err, http.ErrNoLocation) {
logMessage := fmt.Sprintf("Error reading response location header %s. Cause: %s", fa.address, err)
logger.Debug(logMessage)
logger.Debug().Msg(logMessage)
tracing.SetErrorWithEvent(req, logMessage)
rw.WriteHeader(http.StatusInternalServerError)
@ -167,7 +166,7 @@ func (fa *forwardAuth) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
rw.WriteHeader(forwardResponse.StatusCode)
if _, err = rw.Write(body); err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
}
return
}

2
pkg/middlewares/auth/forward_test.go
View file

@ -16,7 +16,7 @@ import (
tracingMiddleware "github.com/traefik/traefik/v2/pkg/middlewares/tracing"
"github.com/traefik/traefik/v2/pkg/testhelpers"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/forward"
"github.com/vulcand/oxy/v2/forward"
)
func TestForwardAuthFail(t *testing.T) {

15
pkg/middlewares/buffering/buffering.go
View file

@ -5,11 +5,12 @@ import (
"net/http"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
oxybuffer "github.com/vulcand/oxy/buffer"
oxybuffer "github.com/vulcand/oxy/v2/buffer"
)
const (
@ -23,9 +24,9 @@ type buffer struct {
// New creates a buffering middleware.
func New(ctx context.Context, next http.Handler, config dynamic.Buffering, name string) (http.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
logger.Debug("Creating middleware")
logger.Debugf("Setting up buffering: request limits: %d (mem), %d (max), response limits: %d (mem), %d (max) with retry: '%s'",
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
logger.Debug().Msgf("Setting up buffering: request limits: %d (mem), %d (max), response limits: %d (mem), %d (max) with retry: '%s'",
config.MemRequestBodyBytes, config.MaxRequestBodyBytes, config.MemResponseBodyBytes, config.MaxResponseBodyBytes, config.RetryExpression)
oxyBuffer, err := oxybuffer.New(
@ -34,7 +35,9 @@ func New(ctx context.Context, next http.Handler, config dynamic.Buffering, name
oxybuffer.MaxRequestBodyBytes(config.MaxRequestBodyBytes),
oxybuffer.MemResponseBodyBytes(config.MemResponseBodyBytes),
oxybuffer.MaxResponseBodyBytes(config.MaxResponseBodyBytes),
oxybuffer.CondSetter(len(config.RetryExpression) > 0, oxybuffer.Retry(config.RetryExpression)),
oxybuffer.Logger(logs.NewOxyWrapper(*logger)),
oxybuffer.Verbose(logger.GetLevel() == zerolog.TraceLevel),
oxybuffer.Cond(len(config.RetryExpression) > 0, oxybuffer.Retry(config.RetryExpression)),
)
if err != nil {
return nil, err

3
pkg/middlewares/chain/chain.go
View file

@ -6,7 +6,6 @@ import (
"github.com/containous/alice"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
)
@ -20,7 +19,7 @@ type chainBuilder interface {
// New creates a chain middleware.
func New(ctx context.Context, next http.Handler, config dynamic.Chain, builder chainBuilder, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
middlewareChain := builder.BuildChain(ctx, config.Middlewares)
return middlewareChain.Then(next)

19
pkg/middlewares/circuitbreaker/circuit_breaker.go
View file

@ -6,11 +6,13 @@ import (
"time"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/cbreaker"
"github.com/vulcand/oxy/v2/cbreaker"
)
const typeName = "CircuitBreaker"
@ -24,19 +26,21 @@ type circuitBreaker struct {
func New(ctx context.Context, next http.Handler, confCircuitBreaker dynamic.CircuitBreaker, name string) (http.Handler, error) {
expression := confCircuitBreaker.Expression
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
logger.Debug("Creating middleware")
logger.Debugf("Setting up with expression: %s", expression)
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
logger.Debug().Msgf("Setting up with expression: %s", expression)
cbOpts := []cbreaker.CircuitBreakerOption{
cbOpts := []cbreaker.Option{
cbreaker.Fallback(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
tracing.SetErrorWithEvent(req, "blocked by circuit-breaker (%q)", expression)
rw.WriteHeader(http.StatusServiceUnavailable)
if _, err := rw.Write([]byte(http.StatusText(http.StatusServiceUnavailable))); err != nil {
log.FromContext(req.Context()).Error(err)
log.Ctx(req.Context()).Error().Err(err).Send()
}
})),
cbreaker.Logger(logs.NewOxyWrapper(*logger)),
cbreaker.Verbose(logger.GetLevel() == zerolog.TraceLevel),
}
if confCircuitBreaker.CheckPeriod > 0 {
@ -55,6 +59,7 @@ func New(ctx context.Context, next http.Handler, confCircuitBreaker dynamic.Circ
if err != nil {
return nil, err
}
return &circuitBreaker{
circuitBreaker: oxyCircuitBreaker,
name: name,

7
pkg/middlewares/compress/compress.go
View file

@ -10,7 +10,6 @@ import (
"github.com/klauspost/compress/gzhttp"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/compress/brotli"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -35,7 +34,7 @@ type compress struct {
// New creates a new compress middleware.
func New(ctx context.Context, next http.Handler, conf dynamic.Compress, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
excludes := []string{"application/grpc"}
for _, v := range conf.ExcludedContentTypes {
@ -74,7 +73,7 @@ func New(ctx context.Context, next http.Handler, conf dynamic.Compress, name str
}
func (c *compress) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := log.FromContext(middlewares.GetLoggerCtx(req.Context(), c.name, typeName))
logger := middlewares.GetLogger(req.Context(), c.name, typeName)
if req.Method == http.MethodHead {
c.next.ServeHTTP(rw, req)
@ -83,7 +82,7 @@ func (c *compress) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
mediaType, _, err := mime.ParseMediaType(req.Header.Get("Content-Type"))
if err != nil {
logger.WithError(err).Debug("Unable to parse MIME type")
logger.Debug().Err(err).Msg("Unable to parse MIME type")
}
// Notably for text/event-stream requests the response should not be compressed.

14
pkg/middlewares/customerrors/custom_errors.go
View file

@ -12,11 +12,10 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/traefik/traefik/v2/pkg/types"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
)
// Compile time validation that the response recorder implements http interfaces correctly.
@ -42,7 +41,7 @@ type customErrors struct {
// New creates a new custom error pages middleware.
func New(ctx context.Context, next http.Handler, config dynamic.ErrorPage, serviceBuilder serviceBuilder, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
httpCodeRanges, err := types.NewHTTPCodeRanges(config.Status)
if err != nil {
@ -68,11 +67,10 @@ func (c *customErrors) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (c *customErrors) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
ctx := middlewares.GetLoggerCtx(req.Context(), c.name, typeName)
logger := log.FromContext(ctx)
logger := middlewares.GetLogger(req.Context(), c.name, typeName)
if c.backendHandler == nil {
logger.Error("Error pages: no backend handler.")
logger.Error().Msg("Error pages: no backend handler.")
tracing.SetErrorWithEvent(req, "Error pages: no backend handler.")
c.next.ServeHTTP(rw, req)
return
@ -86,7 +84,7 @@ func (c *customErrors) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
// check the recorder code against the configured http status code ranges
code := catcher.getCode()
logger.Debugf("Caught HTTP Status Code %d, returning error page", code)
logger.Debug().Msgf("Caught HTTP Status Code %d, returning error page", code)
var query string
if len(c.backendQuery) > 0 {
@ -97,7 +95,7 @@ func (c *customErrors) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
pageReq, err := newRequest("http://" + req.Host + query)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
http.Error(rw, http.StatusText(code), code)
return
}

12
pkg/middlewares/extractor.go
View file

@ -6,9 +6,9 @@ import (
"fmt"
"net/http"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
)
// GetSourceExtractor returns the SourceExtractor function corresponding to the given sourceMatcher.
@ -35,26 +35,26 @@ func GetSourceExtractor(ctx context.Context, sourceMatcher *dynamic.SourceCriter
}
}
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if sourceMatcher.IPStrategy != nil {
strategy, err := sourceMatcher.IPStrategy.Get()
if err != nil {
return nil, err
}
logger.Debug("Using IPStrategy")
logger.Debug().Msg("Using IPStrategy")
return utils.ExtractorFunc(func(req *http.Request) (string, int64, error) {
return strategy.GetIP(req), 1, nil
}), nil
}
if sourceMatcher.RequestHeaderName != "" {
logger.Debug("Using RequestHeaderName")
logger.Debug().Msg("Using RequestHeaderName")
return utils.NewExtractor(fmt.Sprintf("request.header.%s", sourceMatcher.RequestHeaderName))
}
if sourceMatcher.RequestHost {
logger.Debug("Using RequestHost")
logger.Debug().Msg("Using RequestHost")
return utils.NewExtractor("request.host")
}

3
pkg/middlewares/grpcweb/grpcweb.go
View file

@ -6,7 +6,6 @@ import (
"github.com/improbable-eng/grpc-web/go/grpcweb"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
)
@ -14,7 +13,7 @@ const typeName = "grpc-web"
// New builds a new gRPC web request converter.
func New(ctx context.Context, next http.Handler, config dynamic.GrpcWeb, name string) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
return grpcweb.WrapHandler(next, grpcweb.WithCorsForRegisteredEndpointsOnly(false), grpcweb.WithOriginFunc(func(origin string) bool {
for _, originCfg := range config.AllowOrigins {

6
pkg/middlewares/headers/header.go
View file

@ -8,8 +8,9 @@ import (
"strconv"
"strings"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
)
// Header is a middleware that helps setup a few basic security features.
@ -28,7 +29,8 @@ func NewHeader(next http.Handler, cfg dynamic.Headers) (*Header, error) {
hasCustomHeaders := cfg.HasCustomHeadersDefined()
hasCorsHeaders := cfg.HasCorsHeadersDefined()
ctx := log.With(context.Background(), log.Str(log.MiddlewareType, typeName))
ctx := log.With().Str(logs.MiddlewareType, typeName).Logger().WithContext(context.Background())
handleDeprecation(ctx, &cfg)
regexes := make([]*regexp.Regexp, len(cfg.AccessControlAllowOriginListRegex))

25
pkg/middlewares/headers/headers.go
View file

@ -7,8 +7,8 @@ import (
"net/http"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/connectionheader"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -19,20 +19,22 @@ const (
)
func handleDeprecation(ctx context.Context, cfg *dynamic.Headers) {
logger := log.Ctx(ctx).Warn()
if cfg.SSLRedirect {
log.FromContext(ctx).Warn("SSLRedirect is deprecated, please use entrypoint redirection instead.")
logger.Msg("SSLRedirect is deprecated, please use entrypoint redirection instead.")
}
if cfg.SSLTemporaryRedirect {
log.FromContext(ctx).Warn("SSLTemporaryRedirect is deprecated, please use entrypoint redirection instead.")
logger.Msg("SSLTemporaryRedirect is deprecated, please use entrypoint redirection instead.")
}
if cfg.SSLHost != "" {
log.FromContext(ctx).Warn("SSLHost is deprecated, please use RedirectRegex middleware instead.")
logger.Msg("SSLHost is deprecated, please use RedirectRegex middleware instead.")
}
if cfg.SSLForceHost {
log.FromContext(ctx).Warn("SSLForceHost is deprecated, please use RedirectScheme middleware instead.")
logger.Msg("SSLForceHost is deprecated, please use RedirectScheme middleware instead.")
}
if cfg.FeaturePolicy != "" {
log.FromContext(ctx).Warn("FeaturePolicy is deprecated, please use PermissionsPolicy header instead.")
logger.Msg("FeaturePolicy is deprecated, please use PermissionsPolicy header instead.")
}
}
@ -44,9 +46,10 @@ type headers struct {
// New creates a Headers middleware.
func New(ctx context.Context, next http.Handler, cfg dynamic.Headers, name string) (http.Handler, error) {
// HeaderMiddleware -> SecureMiddleWare -> next
mCtx := middlewares.GetLoggerCtx(ctx, name, typeName)
logger := log.FromContext(mCtx)
logger.Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
mCtx := logger.WithContext(ctx)
handleDeprecation(mCtx, &cfg)
@ -62,13 +65,13 @@ func New(ctx context.Context, next http.Handler, cfg dynamic.Headers, name strin
nextHandler := next
if hasSecureHeaders {
logger.Debugf("Setting up secureHeaders from %v", cfg)
logger.Debug().Msgf("Setting up secureHeaders from %v", cfg)
handler = newSecure(next, cfg, name)
nextHandler = handler
}
if hasCustomHeaders || hasCorsHeaders {
logger.Debugf("Setting up customHeaders/Cors from %v", cfg)
logger.Debug().Msgf("Setting up customHeaders/Cors from %v", cfg)
h, err := NewHeader(nextHandler, cfg)
if err != nil {
return nil, err

4
pkg/middlewares/headers/responsewriter.go
View file

@ -6,7 +6,7 @@ import (
"net"
"net/http"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
)
type responseModifier struct {
@ -55,7 +55,7 @@ func (r *responseModifier) WriteHeader(code int) {
// we are propagating when we are called in Write, but we're logging anyway,
// because we could be called from another place which does not take care of
// checking w.modifierErr.
log.WithoutContext().Errorf("Error when applying response modifier: %v", err)
log.Error().Err(err).Msg("Error when applying response modifier")
r.rw.WriteHeader(http.StatusInternalServerError)
return
}

15
pkg/middlewares/inflightreq/inflight_req.go
View file

@ -6,11 +6,12 @@ import (
"net/http"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/connlimit"
"github.com/vulcand/oxy/v2/connlimit"
)
const (
@ -25,8 +26,10 @@ type inFlightReq struct {
// New creates a max request middleware.
// If no source criterion is provided in the config, it defaults to RequestHost.
func New(ctx context.Context, next http.Handler, config dynamic.InFlightReq, name string) (http.Handler, error) {
ctxLog := log.With(ctx, log.Str(log.MiddlewareName, name), log.Str(log.MiddlewareType, typeName))
log.FromContext(ctxLog).Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
ctxLog := logger.WithContext(ctx)
if config.SourceCriterion == nil ||
config.SourceCriterion.IPStrategy == nil &&
@ -41,7 +44,9 @@ func New(ctx context.Context, next http.Handler, config dynamic.InFlightReq, nam
return nil, fmt.Errorf("error creating requests limiter: %w", err)
}
handler, err := connlimit.New(next, sourceMatcher, config.Amount)
handler, err := connlimit.New(next, sourceMatcher, config.Amount,
connlimit.Logger(logs.NewOxyWrapper(*logger)),
connlimit.Verbose(logger.GetLevel() == zerolog.TraceLevel))
if err != nil {
return nil, fmt.Errorf("error creating connection limit: %w", err)
}

18
pkg/middlewares/ipallowlist/ip_allowlist.go
View file

@ -7,9 +7,9 @@ import (
"net/http"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/ip"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -28,8 +28,8 @@ type ipAllowLister struct {
// New builds a new IPAllowLister given a list of CIDR-Strings to allow.
func New(ctx context.Context, next http.Handler, config dynamic.IPAllowList, name string) (http.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
logger.Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
if len(config.SourceRange) == 0 {
return nil, errors.New("sourceRange is empty, IPAllowLister not created")
@ -45,7 +45,7 @@ func New(ctx context.Context, next http.Handler, config dynamic.IPAllowList, nam
return nil, err
}
logger.Debugf("Setting up IPAllowLister with sourceRange: %s", config.SourceRange)
logger.Debug().Msgf("Setting up IPAllowLister with sourceRange: %s", config.SourceRange)
return &ipAllowLister{
strategy: strategy,
@ -60,19 +60,19 @@ func (al *ipAllowLister) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (al *ipAllowLister) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
ctx := middlewares.GetLoggerCtx(req.Context(), al.name, typeName)
logger := log.FromContext(ctx)
logger := middlewares.GetLogger(req.Context(), al.name, typeName)
ctx := logger.WithContext(req.Context())
clientIP := al.strategy.GetIP(req)
err := al.allowLister.IsAuthorized(clientIP)
if err != nil {
msg := fmt.Sprintf("Rejecting IP %s: %v", clientIP, err)
logger.Debug(msg)
logger.Debug().Msg(msg)
tracing.SetErrorWithEvent(req, msg)
reject(ctx, rw)
return
}
logger.Debugf("Accepting IP %s", clientIP)
logger.Debug().Msgf("Accepting IP %s", clientIP)
al.next.ServeHTTP(rw, req)
}
@ -83,6 +83,6 @@ func reject(ctx context.Context, rw http.ResponseWriter) {
rw.WriteHeader(statusCode)
_, err := rw.Write([]byte(http.StatusText(statusCode)))
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
}
}

16
pkg/middlewares/metrics/metrics.go
View file

@ -10,7 +10,7 @@ import (
"github.com/containous/alice"
gokitmetrics "github.com/go-kit/kit/metrics"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/metrics"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/capture"
@ -44,7 +44,7 @@ type metricsMiddleware struct {
// NewEntryPointMiddleware creates a new metrics middleware for an Entrypoint.
func NewEntryPointMiddleware(ctx context.Context, next http.Handler, registry metrics.Registry, entryPointName string) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, nameEntrypoint, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, nameEntrypoint, typeName).Debug().Msg("Creating middleware")
return &metricsMiddleware{
next: next,
@ -60,7 +60,7 @@ func NewEntryPointMiddleware(ctx context.Context, next http.Handler, registry me
// NewRouterMiddleware creates a new metrics middleware for a Router.
func NewRouterMiddleware(ctx context.Context, next http.Handler, registry metrics.Registry, routerName string, serviceName string) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, nameRouter, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, nameRouter, typeName).Debug().Msg("Creating middleware")
return &metricsMiddleware{
next: next,
@ -76,7 +76,7 @@ func NewRouterMiddleware(ctx context.Context, next http.Handler, registry metric
// NewServiceMiddleware creates a new metrics middleware for a Service.
func NewServiceMiddleware(ctx context.Context, next http.Handler, registry metrics.Registry, serviceName string) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, nameService, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, nameService, typeName).Debug().Msg("Creating middleware")
return &metricsMiddleware{
next: next,
@ -129,10 +129,12 @@ func (m *metricsMiddleware) ServeHTTP(rw http.ResponseWriter, req *http.Request)
capt, err := capture.FromContext(ctx)
if err != nil {
with := log.Ctx(ctx).With()
for i := 0; i < len(m.baseLabels); i += 2 {
ctx = log.With(ctx, log.Str(m.baseLabels[i], m.baseLabels[i+1]))
with = with.Str(m.baseLabels[i], m.baseLabels[i+1])
}
log.FromContext(ctx).WithError(err).Errorf("Could not get Capture")
logger := with.Logger()
logger.Error().Err(err).Msg("Could not get Capture")
return
}
@ -223,7 +225,7 @@ func containsHeader(req *http.Request, name, value string) bool {
//nolint:usestdlibvars
func getMethod(r *http.Request) string {
if !utf8.ValidString(r.Method) {
log.WithoutContext().Warnf("Invalid HTTP method encoding: %s", r.Method)
log.Warn().Msgf("Invalid HTTP method encoding: %s", r.Method)
return "NON_UTF8_HTTP_METHOD"
}

15
pkg/middlewares/middleware.go
View file

@ -3,10 +3,17 @@ package middlewares
import (
"context"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/logs"
)
// GetLoggerCtx creates a logger context with the middleware fields.
func GetLoggerCtx(ctx context.Context, middleware, middlewareType string) context.Context {
return log.With(ctx, log.Str(log.MiddlewareName, middleware), log.Str(log.MiddlewareType, middlewareType))
// GetLogger creates a logger with the middleware fields.
func GetLogger(ctx context.Context, middleware, middlewareType string) *zerolog.Logger {
logger := log.Ctx(ctx).With().
Str(logs.MiddlewareName, middleware).
Str(logs.MiddlewareType, middlewareType).
Logger()
return &logger
}

16
pkg/middlewares/passtlsclientcert/pass_tls_client_cert.go
View file

@ -12,8 +12,8 @@ import (
"strings"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -130,7 +130,7 @@ type passTLSClientCert struct {
// New constructs a new PassTLSClientCert instance from supplied frontend header struct.
func New(ctx context.Context, next http.Handler, config dynamic.PassTLSClientCert, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
return &passTLSClientCert{
next: next,
@ -145,14 +145,14 @@ func (p *passTLSClientCert) GetTracingInformation() (string, ext.SpanKindEnum) {
}
func (p *passTLSClientCert) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
ctx := middlewares.GetLoggerCtx(req.Context(), p.name, typeName)
logger := log.FromContext(ctx)
logger := middlewares.GetLogger(req.Context(), p.name, typeName)
ctx := logger.WithContext(req.Context())
if p.pem {
if req.TLS != nil && len(req.TLS.PeerCertificates) > 0 {
req.Header.Set(xForwardedTLSClientCert, getCertificates(ctx, req.TLS.PeerCertificates))
} else {
logger.Warn("Tried to extract a certificate on a request without mutual TLS")
logger.Warn().Msg("Tried to extract a certificate on a request without mutual TLS")
}
}
@ -161,7 +161,7 @@ func (p *passTLSClientCert) ServeHTTP(rw http.ResponseWriter, req *http.Request)
headerContent := p.getCertInfo(ctx, req.TLS.PeerCertificates)
req.Header.Set(xForwardedTLSClientCertInfo, url.QueryEscape(headerContent))
} else {
logger.Warn("Tried to extract a certificate on a request without mutual TLS")
logger.Warn().Msg("Tried to extract a certificate on a request without mutual TLS")
}
}
@ -318,7 +318,7 @@ func writePart(ctx context.Context, content io.StringWriter, entry, prefix strin
if len(entry) > 0 {
_, err := content.WriteString(fmt.Sprintf("%s=%s%s", prefix, entry, subFieldSeparator))
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
}
}
}
@ -347,7 +347,7 @@ func getCertificates(ctx context.Context, certs []*x509.Certificate) string {
func extractCertificate(ctx context.Context, cert *x509.Certificate) string {
certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw})
if certPEM == nil {
log.FromContext(ctx).Error("Cannot extract the certificate content")
log.Ctx(ctx).Error().Msg("Cannot extract the certificate content")
return ""
}

36
pkg/middlewares/ratelimiter/rate_limiter.go
View file

@ -10,11 +10,11 @@ import (
"github.com/mailgun/ttlmap"
"github.com/opentracing/opentracing-go/ext"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
"golang.org/x/time/rate"
)
@ -45,8 +45,10 @@ type rateLimiter struct {
// New returns a rate limiter middleware.
func New(ctx context.Context, next http.Handler, config dynamic.RateLimit, name string) (http.Handler, error) {
ctxLog := log.With(ctx, log.Str(log.MiddlewareName, name), log.Str(log.MiddlewareType, typeName))
log.FromContext(ctxLog).Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
ctxLog := logger.WithContext(ctx)
if config.SourceCriterion == nil ||
config.SourceCriterion.IPStrategy == nil &&
@ -122,19 +124,19 @@ func (rl *rateLimiter) GetTracingInformation() (string, ext.SpanKindEnum) {
return rl.name, tracing.SpanKindNoneEnum
}
func (rl *rateLimiter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
ctx := middlewares.GetLoggerCtx(r.Context(), rl.name, typeName)
logger := log.FromContext(ctx)
func (rl *rateLimiter) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
logger := middlewares.GetLogger(req.Context(), rl.name, typeName)
ctx := logger.WithContext(req.Context())
source, amount, err := rl.sourceMatcher.Extract(r)
source, amount, err := rl.sourceMatcher.Extract(req)
if err != nil {
logger.Errorf("could not extract source of request: %v", err)
http.Error(w, "could not extract source of request", http.StatusInternalServerError)
logger.Error().Err(err).Msg("Could not extract source of request")
http.Error(rw, "could not extract source of request", http.StatusInternalServerError)
return
}
if amount != 1 {
logger.Infof("ignoring token bucket amount > 1: %d", amount)
logger.Info().Msgf("ignoring token bucket amount > 1: %d", amount)
}
var bucket *rate.Limiter
@ -148,8 +150,8 @@ func (rl *rateLimiter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// because we want to update the expiryTime everytime we get the source,
// as the expiryTime is supposed to reflect the activity (or lack thereof) on that source.
if err := rl.buckets.Set(source, bucket, rl.ttl); err != nil {
logger.Errorf("could not insert/update bucket: %v", err)
http.Error(w, "could not insert/update bucket", http.StatusInternalServerError)
logger.Error().Err(err).Msg("Could not insert/update bucket")
http.Error(rw, "could not insert/update bucket", http.StatusInternalServerError)
return
}
@ -159,19 +161,19 @@ func (rl *rateLimiter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// However, for now we take advantage of this behavior to provide the no-limit ratelimiter when config.Average is 0.
res := bucket.Reserve()
if !res.OK() {
http.Error(w, "No bursty traffic allowed", http.StatusTooManyRequests)
http.Error(rw, "No bursty traffic allowed", http.StatusTooManyRequests)
return
}
delay := res.Delay()
if delay > rl.maxDelay {
res.Cancel()
rl.serveDelayError(ctx, w, delay)
rl.serveDelayError(ctx, rw, delay)
return
}
time.Sleep(delay)
rl.next.ServeHTTP(w, r)
rl.next.ServeHTTP(rw, req)
}
func (rl *rateLimiter) serveDelayError(ctx context.Context, w http.ResponseWriter, delay time.Duration) {
@ -180,6 +182,6 @@ func (rl *rateLimiter) serveDelayError(ctx context.Context, w http.ResponseWrite
w.WriteHeader(http.StatusTooManyRequests)
if _, err := w.Write([]byte(http.StatusText(http.StatusTooManyRequests))); err != nil {
log.FromContext(ctx).Errorf("could not serve 429: %v", err)
log.Ctx(ctx).Error().Err(err).Msg("Could not serve 429")
}
}

2
pkg/middlewares/ratelimiter/rate_limiter_test.go
View file

@ -14,7 +14,7 @@ import (
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/testhelpers"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
)
func TestNewRateLimiter(t *testing.T) {

13
pkg/middlewares/recovery/recovery.go
View file

@ -5,7 +5,6 @@ import (
"net/http"
"runtime"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
)
@ -20,7 +19,7 @@ type recovery struct {
// New creates recovery middleware.
func New(ctx context.Context, next http.Handler) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, middlewareName, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, middlewareName, typeName).Debug().Msg("Creating middleware")
return &recovery{
next: next,
@ -32,19 +31,19 @@ func (re *recovery) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
re.next.ServeHTTP(rw, req)
}
func recoverFunc(rw http.ResponseWriter, r *http.Request) {
func recoverFunc(rw http.ResponseWriter, req *http.Request) {
if err := recover(); err != nil {
logger := log.FromContext(middlewares.GetLoggerCtx(r.Context(), middlewareName, typeName))
logger := middlewares.GetLogger(req.Context(), middlewareName, typeName)
if !shouldLogPanic(err) {
logger.Debugf("Request has been aborted [%s - %s]: %v", r.RemoteAddr, r.URL, err)
logger.Debug().Msgf("Request has been aborted [%s - %s]: %v", req.RemoteAddr, req.URL, err)
return
}
logger.Errorf("Recovered from panic in HTTP handler [%s - %s]: %+v", r.RemoteAddr, r.URL, err)
logger.Error().Msgf("Recovered from panic in HTTP handler [%s - %s]: %+v", req.RemoteAddr, req.URL, err)
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
logger.Errorf("Stack: %s", buf)
logger.Error().Msgf("Stack: %s", buf)
http.Error(rw, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}

2
pkg/middlewares/redirect/redirect.go
View file

@ -7,7 +7,7 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/tracing"
"github.com/vulcand/oxy/utils"
"github.com/vulcand/oxy/v2/utils"
)
const (

7
pkg/middlewares/redirect/redirect_regex.go
View file

@ -6,7 +6,6 @@ import (
"strings"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
)
@ -14,9 +13,9 @@ const typeRegexName = "RedirectRegex"
// NewRedirectRegex creates a redirect middleware.
func NewRedirectRegex(ctx context.Context, next http.Handler, conf dynamic.RedirectRegex, name string) (http.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeRegexName))
logger.Debug("Creating middleware")
logger.Debugf("Setting up redirection from %s to %s", conf.Regex, conf.Replacement)
logger := middlewares.GetLogger(ctx, name, typeRegexName)
logger.Debug().Msg("Creating middleware")
logger.Debug().Msgf("Setting up redirection from %s to %s", conf.Regex, conf.Replacement)
return newRedirect(next, conf.Regex, conf.Replacement, conf.Permanent, rawURL, name)
}

7
pkg/middlewares/redirect/redirect_scheme.go
View file

@ -8,7 +8,6 @@ import (
"strings"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
)
@ -20,9 +19,9 @@ const (
// NewRedirectScheme creates a new RedirectScheme middleware.
func NewRedirectScheme(ctx context.Context, next http.Handler, conf dynamic.RedirectScheme, name string) (http.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeSchemeName))
logger.Debug("Creating middleware")
logger.Debugf("Setting up redirection to %s %s", conf.Scheme, conf.Port)
logger := middlewares.GetLogger(ctx, name, typeSchemeName)
logger.Debug().Msg("Creating middleware")
logger.Debug().Msgf("Setting up redirection to %s %s", conf.Scheme, conf.Port)
if len(conf.Scheme) == 0 {
return nil, errors.New("you must provide a target scheme")

5
pkg/middlewares/replacepath/replace_path.go
View file

@ -7,7 +7,6 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -27,7 +26,7 @@ type replacePath struct {
// New creates a new replace path middleware.
func New(ctx context.Context, next http.Handler, config dynamic.ReplacePath, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
return &replacePath{
next: next,
@ -52,7 +51,7 @@ func (r *replacePath) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
var err error
req.URL.Path, err = url.PathUnescape(req.URL.RawPath)
if err != nil {
log.FromContext(middlewares.GetLoggerCtx(context.Background(), r.name, typeName)).Error(err)
middlewares.GetLogger(context.Background(), r.name, typeName).Error().Err(err).Send()
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}

5
pkg/middlewares/replacepathregex/replace_path_regex.go
View file

@ -10,7 +10,6 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/replacepath"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -28,7 +27,7 @@ type replacePathRegex struct {
// New creates a new replace path regex middleware.
func New(ctx context.Context, next http.Handler, config dynamic.ReplacePathRegex, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
exp, err := regexp.Compile(strings.TrimSpace(config.Regex))
if err != nil {
@ -63,7 +62,7 @@ func (rp *replacePathRegex) ServeHTTP(rw http.ResponseWriter, req *http.Request)
var err error
req.URL.Path, err = url.PathUnescape(req.URL.RawPath)
if err != nil {
log.FromContext(middlewares.GetLoggerCtx(context.Background(), rp.name, typeName)).Error(err)
middlewares.GetLogger(context.Background(), rp.name, typeName).Error().Err(err).Send()
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}

10
pkg/middlewares/requestdecorator/hostresolver.go
View file

@ -10,7 +10,7 @@ import (
"github.com/miekg/dns"
"github.com/patrickmn/go-cache"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
)
type cnameResolv struct {
@ -46,12 +46,12 @@ func (hr *Resolver) CNAMEFlatten(ctx context.Context, host string) string {
return value.(string)
}
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
cacheDuration := 0 * time.Second
for depth := 0; depth < hr.ResolvDepth; depth++ {
resolv, err := cnameResolve(ctx, request, hr.ResolvConfig)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
break
}
if resolv == nil {
@ -66,7 +66,7 @@ func (hr *Resolver) CNAMEFlatten(ctx context.Context, host string) string {
}
if err := hr.cache.Add(host, result, cacheDuration); err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
}
return result
@ -88,7 +88,7 @@ func cnameResolve(ctx context.Context, host, resolvPath string) (*cnameResolv, e
for _, server := range config.Servers {
tempRecord, err := getRecord(client, m, server, config.Port)
if err != nil {
log.FromContext(ctx).Errorf("Failed to resolve host %s: %v", host, err)
log.Ctx(ctx).Error().Err(err).Msgf("Failed to resolve host %s", host)
continue
}
result = append(result, tempRecord)

11
pkg/middlewares/retry/retry.go
View file

@ -14,7 +14,6 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -46,7 +45,7 @@ type retry struct {
// New returns a new retry middleware.
func New(ctx context.Context, next http.Handler, config dynamic.Retry, listener Listener, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
if config.Attempts <= 0 {
return nil, fmt.Errorf("incorrect (or empty) value for attempt (%d)", config.Attempts)
@ -106,19 +105,19 @@ func (r *retry) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
return fmt.Errorf("attempt %d failed", attempts-1)
}
logger := middlewares.GetLogger(req.Context(), r.name, typeName)
backOff := backoff.WithContext(r.newBackOff(), req.Context())
notify := func(err error, d time.Duration) {
log.FromContext(middlewares.GetLoggerCtx(req.Context(), r.name, typeName)).
Debugf("New attempt %d for request: %v", attempts, req.URL)
logger.Debug().Msgf("New attempt %d for request: %v", attempts, req.URL)
r.listener.Retried(req, attempts)
}
err := backoff.RetryNotify(operation, backOff, notify)
if err != nil {
log.FromContext(middlewares.GetLoggerCtx(req.Context(), r.name, typeName)).
Debugf("Final retry attempt failed: %v", err.Error())
logger.Debug().Err(err).Msg("Final retry attempt failed")
}
}

12
pkg/middlewares/snicheck/snicheck.go
View file

@ -5,7 +5,7 @@ import (
"net/http"
"strings"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/middlewares/requestdecorator"
traefiktls "github.com/traefik/traefik/v2/pkg/tls"
)
@ -36,11 +36,11 @@ func (s SNICheck) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
tlsOptionSNI := findTLSOptionName(s.tlsOptionsForHost, serverName, false)
if tlsOptionHeader != tlsOptionSNI {
log.WithoutContext().
WithField("host", host).
WithField("req.Host", req.Host).
WithField("req.TLS.ServerName", req.TLS.ServerName).
Debugf("TLS options difference: SNI:%s, Header:%s", tlsOptionSNI, tlsOptionHeader)
log.Debug().
Str("host", host).
Str("req.Host", req.Host).
Str("req.TLS.ServerName", req.TLS.ServerName).
Msgf("TLS options difference: SNI:%s, Header:%s", tlsOptionSNI, tlsOptionHeader)
http.Error(rw, http.StatusText(http.StatusMisdirectedRequest), http.StatusMisdirectedRequest)
return
}

3
pkg/middlewares/stripprefix/strip_prefix.go
View file

@ -7,7 +7,6 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -28,7 +27,7 @@ type stripPrefix struct {
// New creates a new strip prefix middleware.
func New(ctx context.Context, next http.Handler, config dynamic.StripPrefix, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
return &stripPrefix{
prefixes: config.Prefixes,
forceSlash: config.ForceSlash,

3
pkg/middlewares/stripprefixregex/strip_prefix_regex.go
View file

@ -8,7 +8,6 @@ import (
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/middlewares/stripprefix"
"github.com/traefik/traefik/v2/pkg/tracing"
@ -27,7 +26,7 @@ type stripPrefixRegex struct {
// New builds a new StripPrefixRegex middleware.
func New(ctx context.Context, next http.Handler, config dynamic.StripPrefixRegex, name string) (http.Handler, error) {
log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
stripPrefix := stripPrefixRegex{
next: next,

12
pkg/middlewares/tcp/inflightconn/inflight_conn.go
View file

@ -7,7 +7,6 @@ import (
"sync"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tcp"
)
@ -26,8 +25,8 @@ type inFlightConn struct {
// New creates a max connections middleware.
// The connections are identified and grouped by remote IP.
func New(ctx context.Context, next tcp.Handler, config dynamic.TCPInFlightConn, name string) (tcp.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
logger.Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
return &inFlightConn{
name: name,
@ -39,18 +38,17 @@ func New(ctx context.Context, next tcp.Handler, config dynamic.TCPInFlightConn,
// ServeTCP serves the given TCP connection.
func (i *inFlightConn) ServeTCP(conn tcp.WriteCloser) {
ctx := middlewares.GetLoggerCtx(context.Background(), i.name, typeName)
logger := log.FromContext(ctx)
logger := middlewares.GetLogger(context.Background(), i.name, typeName)
ip, _, err := net.SplitHostPort(conn.RemoteAddr().String())
if err != nil {
logger.Errorf("Cannot parse IP from remote addr: %v", err)
logger.Error().Err(err).Msg("Cannot parse IP from remote addr")
conn.Close()
return
}
if err = i.increment(ip); err != nil {
logger.Errorf("Connection rejected: %v", err)
logger.Error().Err(err).Msg("Connection rejected")
conn.Close()
return
}

14
pkg/middlewares/tcp/ipallowlist/ip_allowlist.go
View file

@ -7,7 +7,6 @@ import (
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/ip"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tcp"
)
@ -25,8 +24,8 @@ type ipAllowLister struct {
// New builds a new TCP IPAllowLister given a list of CIDR-Strings to allow.
func New(ctx context.Context, next tcp.Handler, config dynamic.TCPIPAllowList, name string) (tcp.Handler, error) {
logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
logger.Debug("Creating middleware")
logger := middlewares.GetLogger(ctx, name, typeName)
logger.Debug().Msg("Creating middleware")
if len(config.SourceRange) == 0 {
return nil, errors.New("sourceRange is empty, IPAllowLister not created")
@ -37,7 +36,7 @@ func New(ctx context.Context, next tcp.Handler, config dynamic.TCPIPAllowList, n
return nil, fmt.Errorf("cannot parse CIDRs %s: %w", config.SourceRange, err)
}
logger.Debugf("Setting up IPAllowLister with sourceRange: %s", config.SourceRange)
logger.Debug().Msgf("Setting up IPAllowLister with sourceRange: %s", config.SourceRange)
return &ipAllowLister{
allowLister: checker,
@ -47,19 +46,18 @@ func New(ctx context.Context, next tcp.Handler, config dynamic.TCPIPAllowList, n
}
func (al *ipAllowLister) ServeTCP(conn tcp.WriteCloser) {
ctx := middlewares.GetLoggerCtx(context.Background(), al.name, typeName)
logger := log.FromContext(ctx)
logger := middlewares.GetLogger(context.Background(), al.name, typeName)
addr := conn.RemoteAddr().String()
err := al.allowLister.IsAuthorized(addr)
if err != nil {
logger.Errorf("Connection from %s rejected: %v", addr, err)
logger.Error().Err(err).Msgf("Connection from %s rejected", addr)
conn.Close()
return
}
logger.Debugf("Connection from %s accepted", addr)
logger.Debug().Msgf("Connection from %s accepted", addr)
al.next.ServeTCP(conn)
}

7
pkg/middlewares/tracing/entrypoint.go
View file

@ -7,7 +7,6 @@ import (
"github.com/containous/alice"
"github.com/opentracing/opentracing-go"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -18,7 +17,7 @@ const (
// NewEntryPoint creates a new middleware that the incoming request.
func NewEntryPoint(ctx context.Context, t *tracing.Tracing, entryPointName string, next http.Handler) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, "tracing", entryPointTypeName)).Debug("Creating middleware")
middlewares.GetLogger(ctx, "tracing", entryPointTypeName).Debug().Msg("Creating middleware")
return &entryPointMiddleware{
entryPoint: entryPointName,
@ -36,8 +35,8 @@ type entryPointMiddleware struct {
func (e *entryPointMiddleware) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
spanCtx, err := e.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
if err != nil {
log.FromContext(middlewares.GetLoggerCtx(req.Context(), "tracing", entryPointTypeName)).
Debugf("Failed to extract the context: %v", err)
middlewares.GetLogger(req.Context(), "tracing", entryPointTypeName).
Debug().Err(err).Msg("Failed to extract the context")
}
span, req, finish := e.StartSpanf(req, ext.SpanKindRPCServerEnum, "EntryPoint", []string{e.entryPoint, req.Host}, " ", ext.RPCServerOption(spanCtx))

6
pkg/middlewares/tracing/forwarder.go
View file

@ -5,7 +5,7 @@ import (
"net/http"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/middlewares"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -22,8 +22,8 @@ type forwarderMiddleware struct {
// NewForwarder creates a new forwarder middleware that traces the outgoing request.
func NewForwarder(ctx context.Context, router, service string, next http.Handler) http.Handler {
log.FromContext(middlewares.GetLoggerCtx(ctx, "tracing", forwarderTypeName)).
Debugf("Added outgoing tracing middleware %s", service)
middlewares.GetLogger(ctx, "tracing", forwarderTypeName).
Debug().Str(logs.ServiceName, service).Msg("Added outgoing tracing middleware")
return &forwarderMiddleware{
router: router,

5
pkg/middlewares/tracing/wrapper.go
View file

@ -6,7 +6,8 @@ import (
"github.com/containous/alice"
"github.com/opentracing/opentracing-go/ext"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/tracing"
)
@ -28,7 +29,7 @@ func Wrap(ctx context.Context, constructor alice.Constructor) alice.Constructor
if traceableHandler, ok := handler.(Traceable); ok {
name, spanKind := traceableHandler.GetTracingInformation()
log.FromContext(ctx).WithField(log.MiddlewareName, name).Debug("Adding tracing to middleware")
log.Ctx(ctx).Debug().Str(logs.MiddlewareName, name).Msg("Adding tracing to middleware")
return NewWrapper(handler, name, spanKind), nil
}
return handler, nil