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

10
pkg/server/service/loadbalancer/failover/failover.go
View file

@ -6,8 +6,8 @@ import (
"net/http"
"sync"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
)
// Failover is an http.Handler that can forward requests to the fallback handler
@ -90,11 +90,11 @@ func (f *Failover) SetHandlerStatus(ctx context.Context, up bool) {
if up == f.handlerStatus {
// We're still with the same status, no need to propagate.
log.FromContext(ctx).Debugf("Still %s, no need to propagate", status)
log.Ctx(ctx).Debug().Msgf("Still %s, no need to propagate", status)
return
}
log.FromContext(ctx).Debugf("Propagating new %s status", status)
log.Ctx(ctx).Debug().Msgf("Propagating new %s status", status)
f.handlerStatus = up
for _, fn := range f.updaters {
@ -125,11 +125,11 @@ func (f *Failover) SetFallbackHandlerStatus(ctx context.Context, up bool) {
if up == f.fallbackStatus {
// We're still with the same status, no need to propagate.
log.FromContext(ctx).Debugf("Still %s, no need to propagate", status)
log.Ctx(ctx).Debug().Msgf("Still %s, no need to propagate", status)
return
}
log.FromContext(ctx).Debugf("Propagating new %s status", status)
log.Ctx(ctx).Debug().Msgf("Propagating new %s status", status)
f.fallbackStatus = up
for _, fn := range f.updaters {

14
pkg/server/service/loadbalancer/mirror/mirror.go
View file

@ -11,9 +11,9 @@ import (
"net/http"
"sync"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/healthcheck"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/middlewares/accesslog"
"github.com/traefik/traefik/v2/pkg/safe"
)
@ -82,18 +82,18 @@ func (m *Mirroring) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
return
}
logger := log.FromContext(req.Context())
logger := log.Ctx(req.Context())
rr, bytesRead, err := newReusableRequest(req, m.maxBodySize)
if err != nil && !errors.Is(err, errBodyTooLarge) {
http.Error(rw, http.StatusText(http.StatusInternalServerError)+
fmt.Sprintf("error creating reusable request: %v", err), http.StatusInternalServerError)
http.Error(rw, fmt.Sprintf("%s: creating reusable request: %v",
http.StatusText(http.StatusInternalServerError), err), http.StatusInternalServerError)
return
}
if errors.Is(err, errBodyTooLarge) {
req.Body = io.NopCloser(io.MultiReader(bytes.NewReader(bytesRead), req.Body))
m.handler.ServeHTTP(rw, req)
logger.Debug("no mirroring, request body larger than allowed size")
logger.Debug().Msg("No mirroring, request body larger than allowed size")
return
}
@ -102,7 +102,7 @@ func (m *Mirroring) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
select {
case <-req.Context().Done():
// No mirroring if request has been canceled during main handler ServeHTTP
logger.Warn("no mirroring, request has been canceled during main handler ServeHTTP")
logger.Warn().Msg("No mirroring, request has been canceled during main handler ServeHTTP")
return
default:
}
@ -179,7 +179,7 @@ func (b blackHoleResponseWriter) Write(data []byte) (int, error) {
return len(data), nil
}
func (b blackHoleResponseWriter) WriteHeader(statusCode int) {}
func (b blackHoleResponseWriter) WriteHeader(_ int) {}
type contextStopPropagation struct {
context.Context

14
pkg/server/service/loadbalancer/wrr/wrr.go
View file

@ -7,8 +7,8 @@ import (
"net/http"
"sync"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
)
type namedHandler struct {
@ -105,7 +105,9 @@ func (b *Balancer) SetStatus(ctx context.Context, childName string, up bool) {
if up {
status = "UP"
}
log.FromContext(ctx).Debugf("Setting status of %s to %v", childName, status)
log.Ctx(ctx).Debug().Msgf("Setting status of %s to %v", childName, status)
if up {
b.status[childName] = struct{}{}
} else {
@ -121,12 +123,12 @@ func (b *Balancer) SetStatus(ctx context.Context, childName string, up bool) {
// No Status Change
if upBefore == upAfter {
// We're still with the same status, no need to propagate
log.FromContext(ctx).Debugf("Still %s, no need to propagate", status)
log.Ctx(ctx).Debug().Msgf("Still %s, no need to propagate", status)
return
}
// Status Change
log.FromContext(ctx).Debugf("Propagating new %s status", status)
log.Ctx(ctx).Debug().Msgf("Propagating new %s status", status)
for _, fn := range b.updaters {
fn(upAfter)
}
@ -168,7 +170,7 @@ func (b *Balancer) nextServer() (*namedHandler, error) {
}
}
log.WithoutContext().Debugf("Service selected by WRR: %s", handler.name)
log.Debug().Msgf("Service selected by WRR: %s", handler.name)
return handler, nil
}
@ -177,7 +179,7 @@ func (b *Balancer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
cookie, err := req.Cookie(b.stickyCookie.name)
if err != nil && !errors.Is(err, http.ErrNoCookie) {
log.WithoutContext().Warnf("Error while reading cookie: %v", err)
log.Warn().Err(err).Msg("Error while reading cookie")
}
if err == nil && cookie != nil {

8
pkg/server/service/proxy.go
View file

@ -11,7 +11,7 @@ import (
"strings"
"time"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"golang.org/x/net/http/httpguts"
)
@ -115,12 +115,12 @@ func errorHandler(w http.ResponseWriter, req *http.Request, err error) {
}
}
logger := log.FromContext(req.Context())
logger.Debugf("'%d %s' caused by: %v", statusCode, statusText(statusCode), err)
logger := log.Ctx(req.Context())
logger.Debug().Err(err).Msgf("%d %s", statusCode, statusText(statusCode))
w.WriteHeader(statusCode)
if _, werr := w.Write([]byte(statusText(statusCode))); werr != nil {
logger.Debugf("Error while writing status code", werr)
logger.Debug().Err(werr).Msg("Error while writing status code")
}
}

10
pkg/server/service/roundtripper.go
View file

@ -11,12 +11,12 @@ import (
"sync"
"time"
"github.com/rs/zerolog/log"
"github.com/spiffe/go-spiffe/v2/bundle/x509bundle"
"github.com/spiffe/go-spiffe/v2/spiffeid"
"github.com/spiffe/go-spiffe/v2/spiffetls/tlsconfig"
"github.com/spiffe/go-spiffe/v2/svid/x509svid"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
traefiktls "github.com/traefik/traefik/v2/pkg/tls"
"golang.org/x/net/http2"
)
@ -74,7 +74,7 @@ func (r *RoundTripperManager) Update(newConfigs map[string]*dynamic.ServersTrans
var err error
r.roundTrippers[configName], err = r.createRoundTripper(newConfig)
if err != nil {
log.WithoutContext().Errorf("Could not configure HTTP Transport %s, fallback on default transport: %v", configName, err)
log.Error().Err(err).Msgf("Could not configure HTTP Transport %s, fallback on default transport", configName)
r.roundTrippers[configName] = http.DefaultTransport
}
}
@ -87,7 +87,7 @@ func (r *RoundTripperManager) Update(newConfigs map[string]*dynamic.ServersTrans
var err error
r.roundTrippers[newConfigName], err = r.createRoundTripper(newConfig)
if err != nil {
log.WithoutContext().Errorf("Could not configure HTTP Transport %s, fallback on default transport: %v", newConfigName, err)
log.Error().Err(err).Msgf("Could not configure HTTP Transport %s, fallback on default transport", newConfigName)
r.roundTrippers[newConfigName] = http.DefaultTransport
}
}
@ -95,7 +95,7 @@ func (r *RoundTripperManager) Update(newConfigs map[string]*dynamic.ServersTrans
r.configs = newConfigs
}
// Get get a roundtripper by name.
// Get gets a roundtripper by name.
func (r *RoundTripperManager) Get(name string) (http.RoundTripper, error) {
if len(name) == 0 {
name = "default@internal"
@ -195,7 +195,7 @@ func createRootCACertPool(rootCAs []traefiktls.FileOrContent) *x509.CertPool {
for _, cert := range rootCAs {
certContent, err := cert.Read()
if err != nil {
log.WithoutContext().Error("Error while read RootCAs", err)
log.Error().Err(err).Msg("Error while read RootCAs")
continue
}
roots.AppendCertsFromPEM(certContent)

23
pkg/server/service/service.go
View file

@ -13,10 +13,11 @@ import (
"strings"
"time"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/runtime"
"github.com/traefik/traefik/v2/pkg/healthcheck"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/metrics"
"github.com/traefik/traefik/v2/pkg/middlewares/accesslog"
metricsMiddle "github.com/traefik/traefik/v2/pkg/middlewares/metrics"
@ -64,10 +65,10 @@ func NewManager(configs map[string]*runtime.ServiceInfo, metricsRegistry metrics
// BuildHTTP Creates a http.Handler for a service configuration.
func (m *Manager) BuildHTTP(rootCtx context.Context, serviceName string) (http.Handler, error) {
ctx := log.With(rootCtx, log.Str(log.ServiceName, serviceName))
serviceName = provider.GetQualifiedName(rootCtx, serviceName)
serviceName = provider.GetQualifiedName(ctx, serviceName)
ctx = provider.AddInContext(ctx, serviceName)
ctx := log.Ctx(rootCtx).With().Str(logs.ServiceName, serviceName).Logger().
WithContext(provider.AddInContext(rootCtx, serviceName))
handler, ok := m.services[serviceName]
if ok {
@ -241,7 +242,8 @@ func (m *Manager) getWRRServiceHandler(ctx context.Context, serviceName string,
return nil, fmt.Errorf("cannot register %v as updater for %v: %w", childName, serviceName, err)
}
log.FromContext(ctx).Debugf("Child service %v will update parent %v on status change", childName, serviceName)
log.Ctx(ctx).Debug().Str("parent", serviceName).Str("child", childName).
Msg("Child service will update parent on status change")
}
return balancer, nil
@ -250,8 +252,8 @@ func (m *Manager) getWRRServiceHandler(ctx context.Context, serviceName string,
func (m *Manager) getLoadBalancerServiceHandler(ctx context.Context, serviceName string, info *runtime.ServiceInfo) (http.Handler, error) {
service := info.LoadBalancer
logger := log.FromContext(ctx)
logger.Debug("Creating load-balancer")
logger := log.Ctx(ctx)
logger.Debug().Msg("Creating load-balancer")
// TODO: should we keep this config value as Go is now handling stream response correctly?
flushInterval := dynamic.DefaultFlushInterval
@ -292,7 +294,8 @@ func (m *Manager) getLoadBalancerServiceHandler(ctx context.Context, serviceName
return nil, fmt.Errorf("error parsing server URL %s: %w", server.URL, err)
}
logger.WithField(log.ServerName, proxyName).Debugf("Creating server %s", target)
logger.Debug().Str(logs.ServerName, proxyName).Stringer("target", target).
Msg("Creating server")
proxy := buildSingleHostProxy(target, passHostHeader, time.Duration(flushInterval), roundTripper, m.bufferPool)
@ -330,8 +333,8 @@ func (m *Manager) getLoadBalancerServiceHandler(ctx context.Context, serviceName
// LaunchHealthCheck launches the health checks.
func (m *Manager) LaunchHealthCheck(ctx context.Context) {
for serviceName, hc := range m.healthCheckers {
ctx = log.With(ctx, log.Str(log.ServiceName, serviceName))
go hc.Launch(ctx)
logger := log.Ctx(ctx).With().Str(logs.ServiceName, serviceName).Logger()
go hc.Launch(logger.WithContext(ctx))
}
}

28
pkg/server/service/tcp/service.go
View file

@ -8,8 +8,9 @@ import (
"net"
"time"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/runtime"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/server/provider"
"github.com/traefik/traefik/v2/pkg/tcp"
)
@ -31,8 +32,9 @@ func NewManager(conf *runtime.Configuration) *Manager {
// BuildTCP Creates a tcp.Handler for a service configuration.
func (m *Manager) BuildTCP(rootCtx context.Context, serviceName string) (tcp.Handler, error) {
serviceQualifiedName := provider.GetQualifiedName(rootCtx, serviceName)
logger := log.Ctx(rootCtx).With().Str(logs.ServiceName, serviceQualifiedName).Logger()
ctx := provider.AddInContext(rootCtx, serviceQualifiedName)
ctx = log.With(ctx, log.Str(log.ServiceName, serviceName))
conf, ok := m.configs[serviceQualifiedName]
if !ok {
@ -45,7 +47,6 @@ func (m *Manager) BuildTCP(rootCtx context.Context, serviceName string) (tcp.Han
return nil, err
}
logger := log.FromContext(ctx)
switch {
case conf.LoadBalancer != nil:
loadBalancer := tcp.NewWRRLoadBalancer()
@ -56,34 +57,43 @@ func (m *Manager) BuildTCP(rootCtx context.Context, serviceName string) (tcp.Han
}
duration := time.Duration(*conf.LoadBalancer.TerminationDelay) * time.Millisecond
for name, server := range shuffle(conf.LoadBalancer.Servers, m.rand) {
for index, server := range shuffle(conf.LoadBalancer.Servers, m.rand) {
srvLogger := logger.With().
Int(logs.ServerIndex, index).
Str("serverAddress", server.Address).Logger()
if _, _, err := net.SplitHostPort(server.Address); err != nil {
logger.Errorf("In service %q: %v", serviceQualifiedName, err)
srvLogger.Error().Err(err).Msg("Failed to split host port")
continue
}
handler, err := tcp.NewProxy(server.Address, duration, conf.LoadBalancer.ProxyProtocol)
if err != nil {
logger.Errorf("In service %q server %q: %v", serviceQualifiedName, server.Address, err)
srvLogger.Error().Err(err).Msg("Failed to create server")
continue
}
loadBalancer.AddServer(handler)
logger.WithField(log.ServerName, name).Debugf("Creating TCP server %d at %s", name, server.Address)
logger.Debug().Msg("Creating TCP server")
}
return loadBalancer, nil
case conf.Weighted != nil:
loadBalancer := tcp.NewWRRLoadBalancer()
for _, service := range shuffle(conf.Weighted.Services, m.rand) {
handler, err := m.BuildTCP(rootCtx, service.Name)
handler, err := m.BuildTCP(ctx, service.Name)
if err != nil {
logger.Errorf("In service %q: %v", serviceQualifiedName, err)
logger.Error().Err(err).Msg("Failed to build TCP handler")
return nil, err
}
loadBalancer.AddWeightServer(handler, service.Weight)
}
return loadBalancer, nil
default:
err := fmt.Errorf("the service %q does not have any type defined", serviceQualifiedName)
conf.AddError(err, true)

32
pkg/server/service/udp/service.go
View file

@ -8,8 +8,9 @@ import (
"net"
"time"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/runtime"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/server/provider"
"github.com/traefik/traefik/v2/pkg/udp"
)
@ -31,12 +32,13 @@ func NewManager(conf *runtime.Configuration) *Manager {
// BuildUDP creates the UDP handler for the given service name.
func (m *Manager) BuildUDP(rootCtx context.Context, serviceName string) (udp.Handler, error) {
serviceQualifiedName := provider.GetQualifiedName(rootCtx, serviceName)
logger := log.Ctx(rootCtx).With().Str(logs.ServiceName, serviceQualifiedName).Logger()
ctx := provider.AddInContext(rootCtx, serviceQualifiedName)
ctx = log.With(ctx, log.Str(log.ServiceName, serviceName))
conf, ok := m.configs[serviceQualifiedName]
if !ok {
return nil, fmt.Errorf("the udp service %q does not exist", serviceQualifiedName)
return nil, fmt.Errorf("the UDP service %q does not exist", serviceQualifiedName)
}
if conf.LoadBalancer != nil && conf.Weighted != nil {
@ -45,41 +47,49 @@ func (m *Manager) BuildUDP(rootCtx context.Context, serviceName string) (udp.Han
return nil, err
}
logger := log.FromContext(ctx)
switch {
case conf.LoadBalancer != nil:
loadBalancer := udp.NewWRRLoadBalancer()
for name, server := range shuffle(conf.LoadBalancer.Servers, m.rand) {
for index, server := range shuffle(conf.LoadBalancer.Servers, m.rand) {
srvLogger := logger.With().
Int(logs.ServerIndex, index).
Str("serverAddress", server.Address).Logger()
if _, _, err := net.SplitHostPort(server.Address); err != nil {
logger.Errorf("In udp service %q: %v", serviceQualifiedName, err)
srvLogger.Error().Err(err).Msg("Failed to split host port")
continue
}
handler, err := udp.NewProxy(server.Address)
if err != nil {
logger.Errorf("In udp service %q server %q: %v", serviceQualifiedName, server.Address, err)
srvLogger.Error().Err(err).Msg("Failed to create server")
continue
}
loadBalancer.AddServer(handler)
logger.WithField(log.ServerName, name).Debugf("Creating UDP server %d at %s", name, server.Address)
srvLogger.Debug().Msg("Creating UDP server")
}
return loadBalancer, nil
case conf.Weighted != nil:
loadBalancer := udp.NewWRRLoadBalancer()
for _, service := range shuffle(conf.Weighted.Services, m.rand) {
handler, err := m.BuildUDP(rootCtx, service.Name)
handler, err := m.BuildUDP(ctx, service.Name)
if err != nil {
logger.Errorf("In udp service %q: %v", serviceQualifiedName, err)
logger.Error().Err(err).Msg("Failed to build UDP handler")
return nil, err
}
loadBalancer.AddWeightedServer(handler, service.Weight)
}
return loadBalancer, nil
default:
err := fmt.Errorf("the udp service %q does not have any type defined", serviceQualifiedName)
err := fmt.Errorf("the UDP service %q does not have any type defined", serviceQualifiedName)
conf.AddError(err, true)
return nil, err
}

4
pkg/server/service/udp/service_test.go
View file

@ -23,7 +23,7 @@ func TestManager_BuildUDP(t *testing.T) {
desc: "without configuration",
serviceName: "test",
configs: nil,
expectedError: `the udp service "test" does not exist`,
expectedError: `the UDP service "test" does not exist`,
},
{
desc: "missing lb configuration",
@ -33,7 +33,7 @@ func TestManager_BuildUDP(t *testing.T) {
UDPService: &dynamic.UDPService{},
},
},
expectedError: `the udp service "test" does not have any type defined`,
expectedError: `the UDP service "test" does not have any type defined`,
},
{
desc: "no such host, server is skipped, error is logged",