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

56
pkg/server/router/tcp/manager.go
View file

@ -7,8 +7,9 @@ import (
"fmt"
"net/http"
"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/middlewares/snicheck"
httpmuxer "github.com/traefik/traefik/v2/pkg/muxer/http"
tcpmuxer "github.com/traefik/traefik/v2/pkg/muxer/tcp"
@ -77,11 +78,12 @@ func (m *Manager) BuildHandlers(rootCtx context.Context, entryPoints []string) m
routers := entryPointsRouters[entryPointName]
ctx := log.With(rootCtx, log.Str(log.EntryPointName, entryPointName))
logger := log.Ctx(rootCtx).With().Str(logs.EntryPointName, entryPointName).Logger()
ctx := logger.WithContext(rootCtx)
handler, err := m.buildEntryPointHandler(ctx, routers, entryPointsRoutersHTTP[entryPointName], m.httpHandlers[entryPointName], m.httpsHandlers[entryPointName])
if err != nil {
log.FromContext(ctx).Error(err)
logger.Error().Err(err).Send()
continue
}
entryPointHandlers[entryPointName] = handler
@ -105,7 +107,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
defaultTLSConf, err := m.tlsManager.Get(traefiktls.DefaultTLSStoreName, traefiktls.DefaultTLSConfigName)
if err != nil {
log.FromContext(ctx).Errorf("Error during the build of the default TLS configuration: %v", err)
log.Ctx(ctx).Error().Err(err).Msg("Error during the build of the default TLS configuration")
}
// Keyed by domain. The source of truth for doing SNI checking, and for what TLS
@ -125,8 +127,8 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
continue
}
ctxRouter := log.With(provider.AddInContext(ctx, routerHTTPName), log.Str(log.RouterName, routerHTTPName))
logger := log.FromContext(ctxRouter)
logger := log.Ctx(ctx).With().Str(logs.RouterName, routerHTTPName).Logger()
ctxRouter := logger.WithContext(provider.AddInContext(ctx, routerHTTPName))
tlsOptionsName := traefiktls.DefaultTLSConfigName
if len(routerHTTPConfig.TLS.Options) > 0 && routerHTTPConfig.TLS.Options != traefiktls.DefaultTLSConfigName {
@ -137,7 +139,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
if err != nil {
routerErr := fmt.Errorf("invalid rule %s, error: %w", routerHTTPConfig.Rule, err)
routerHTTPConfig.AddError(routerErr, true)
logger.Error(routerErr)
logger.Error().Err(routerErr).Send()
continue
}
@ -173,13 +175,13 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
// # When a request for "/foo" comes, even though it won't be routed by
// httpRouter2, if its SNI is set to foo.com, myTLSOptions will be used for the TLS
// connection. Otherwise, it will fallback to the default TLS config.
logger.Warnf("No domain found in rule %v, the TLS options applied for this router will depend on the SNI of each request", routerHTTPConfig.Rule)
logger.Warn().Msgf("No domain found in rule %v, the TLS options applied for this router will depend on the SNI of each request", routerHTTPConfig.Rule)
}
tlsConf, err := m.tlsManager.Get(traefiktls.DefaultTLSStoreName, tlsOptionsName)
if err != nil {
routerHTTPConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -206,7 +208,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
router.SetHTTPSHandler(sniCheck, defaultTLSConf)
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
for hostSNI, tlsConfigs := range tlsOptionsForHostSNI {
if len(tlsConfigs) == 1 {
var optionsName string
@ -217,7 +219,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
break
}
logger.Debugf("Adding route for %s with TLS options %s", hostSNI, optionsName)
logger.Debug().Msgf("Adding route for %s with TLS options %s", hostSNI, optionsName)
router.AddHTTPTLSConfig(hostSNI, config)
} else {
@ -227,34 +229,34 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
routers = append(routers, v.routerName)
}
logger.Warnf("Found different TLS options for routers on the same host %v, so using the default TLS options instead for these routers: %#v", hostSNI, routers)
logger.Warn().Msgf("Found different TLS options for routers on the same host %v, so using the default TLS options instead for these routers: %#v", hostSNI, routers)
router.AddHTTPTLSConfig(hostSNI, defaultTLSConf)
}
}
for routerName, routerConfig := range configs {
ctxRouter := log.With(provider.AddInContext(ctx, routerName), log.Str(log.RouterName, routerName))
logger := log.FromContext(ctxRouter)
logger := log.Ctx(ctx).With().Str(logs.RouterName, routerName).Logger()
ctxRouter := logger.WithContext(provider.AddInContext(ctx, routerName))
if routerConfig.Service == "" {
err := errors.New("the service is missing on the router")
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
if routerConfig.Rule == "" {
err := errors.New("router has no rule")
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
handler, err := m.buildTCPHandler(ctxRouter, routerConfig)
if err != nil {
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -262,7 +264,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
if err != nil {
routerErr := fmt.Errorf("invalid rule: %q , %w", routerConfig.Rule, err)
routerConfig.AddError(routerErr, true)
logger.Error(routerErr)
logger.Error().Err(routerErr).Send()
continue
}
@ -271,23 +273,23 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
if len(domains) > 0 && routerConfig.TLS == nil && domains[0] != "*" {
routerErr := fmt.Errorf("invalid rule: %q , has HostSNI matcher, but no TLS on router", routerConfig.Rule)
routerConfig.AddError(routerErr, true)
logger.Error(routerErr)
logger.Error().Err(routerErr).Send()
}
if routerConfig.TLS == nil {
logger.Debugf("Adding route for %q", routerConfig.Rule)
logger.Debug().Msgf("Adding route for %q", routerConfig.Rule)
if err := router.AddRoute(routerConfig.Rule, routerConfig.Priority, handler); err != nil {
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
}
continue
}
if routerConfig.TLS.Passthrough {
logger.Debugf("Adding Passthrough route for %q", routerConfig.Rule)
logger.Debug().Msgf("Adding Passthrough route for %q", routerConfig.Rule)
if err := router.AddRouteTLS(routerConfig.Rule, routerConfig.Priority, handler, nil); err != nil {
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
}
continue
}
@ -299,7 +301,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
asciiError := fmt.Errorf("invalid domain name value %q, non-ASCII characters are not allowed", domain)
routerConfig.AddError(asciiError, true)
logger.Error(asciiError)
logger.Error().Err(asciiError).Send()
}
tlsOptionsName := routerConfig.TLS.Options
@ -315,7 +317,7 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
tlsConf, err := m.tlsManager.Get(traefiktls.DefaultTLSStoreName, tlsOptionsName)
if err != nil {
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -333,10 +335,10 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
// it's all good. Otherwise, we would have to do as for HTTPS, i.e. disallow
// different TLS configs for the same HostSNIs.
logger.Debugf("Adding TLS route for %q", routerConfig.Rule)
logger.Debug().Msgf("Adding TLS route for %q", routerConfig.Rule)
if err := router.AddRouteTLS(routerConfig.Rule, routerConfig.Priority, handler, tlsConf); err != nil {
routerConfig.AddError(err, true)
logger.Error(err)
logger.Error().Err(err).Send()
}
}

6
pkg/server/router/tcp/postgres.go
View file

@ -6,7 +6,7 @@ import (
"errors"
"sync"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
tcpmuxer "github.com/traefik/traefik/v2/pkg/muxer/tcp"
"github.com/traefik/traefik/v2/pkg/tcp"
)
@ -25,7 +25,7 @@ func isPostgres(br *bufio.Reader) (bool, error) {
for i := 1; i < len(PostgresStartTLSMsg)+1; i++ {
peeked, err := br.Peek(i)
if err != nil {
log.WithoutContext().Errorf("Error while Peeking first bytes: %s", err)
log.Error().Err(err).Msg("Error while Peeking first bytes")
return false, err
}
@ -67,7 +67,7 @@ func (r *Router) servePostgres(conn tcp.WriteCloser) {
connData, err := tcpmuxer.NewConnData(hello.serverName, conn, hello.protos)
if err != nil {
log.WithoutContext().Errorf("Error while reading TCP connection data: %v", err)
log.Error().Err(err).Msg("Error while reading TCP connection data")
conn.Close()
return
}

20
pkg/server/router/tcp/router.go
View file

@ -10,7 +10,7 @@ import (
"net/http"
"time"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
tcpmuxer "github.com/traefik/traefik/v2/pkg/muxer/tcp"
"github.com/traefik/traefik/v2/pkg/tcp"
)
@ -88,7 +88,7 @@ func (r *Router) ServeTCP(conn tcp.WriteCloser) {
if r.muxerTCP.HasRoutes() && !r.muxerTCPTLS.HasRoutes() && !r.muxerHTTPS.HasRoutes() {
connData, err := tcpmuxer.NewConnData("", conn, nil)
if err != nil {
log.WithoutContext().Errorf("Error while reading TCP connection data: %v", err)
log.Error().Err(err).Msg("Error while reading TCP connection data")
conn.Close()
return
}
@ -128,17 +128,17 @@ func (r *Router) ServeTCP(conn tcp.WriteCloser) {
// Remove read/write deadline and delegate this to underlying tcp server (for now only handled by HTTP Server)
err = conn.SetReadDeadline(time.Time{})
if err != nil {
log.WithoutContext().Errorf("Error while setting read deadline: %v", err)
log.Error().Err(err).Msg("Error while setting read deadline")
}
err = conn.SetWriteDeadline(time.Time{})
if err != nil {
log.WithoutContext().Errorf("Error while setting write deadline: %v", err)
log.Error().Err(err).Msg("Error while setting write deadline")
}
connData, err := tcpmuxer.NewConnData(hello.serverName, conn, hello.protos)
if err != nil {
log.WithoutContext().Errorf("Error while reading TCP connection data: %v", err)
log.Error().Err(err).Msg("Error while reading TCP connection data")
conn.Close()
return
}
@ -263,7 +263,7 @@ func (r *Router) SetHTTPSForwarder(handler tcp.Handler) {
Config: tlsConf,
})
if err != nil {
log.WithoutContext().Errorf("Error while adding route for host: %v", err)
log.Error().Err(err).Msg("Error while adding route for host")
}
}
@ -326,7 +326,7 @@ func clientHelloInfo(br *bufio.Reader) (*clientHello, error) {
if err != nil {
var opErr *net.OpError
if !errors.Is(err, io.EOF) && (!errors.As(err, &opErr) || opErr.Timeout()) {
log.WithoutContext().Errorf("Error while Peeking first byte: %s", err)
log.Error().Err(err).Msg("Error while Peeking first byte")
}
return nil, err
}
@ -353,7 +353,7 @@ func clientHelloInfo(br *bufio.Reader) (*clientHello, error) {
const recordHeaderLen = 5
hdr, err = br.Peek(recordHeaderLen)
if err != nil {
log.Errorf("Error while Peeking hello: %s", err)
log.Error().Err(err).Msg("Error while Peeking hello")
return &clientHello{
peeked: getPeeked(br),
}, nil
@ -367,7 +367,7 @@ func clientHelloInfo(br *bufio.Reader) (*clientHello, error) {
helloBytes, err := br.Peek(recordHeaderLen + recLen)
if err != nil {
log.Errorf("Error while Hello: %s", err)
log.Error().Err(err).Msg("Error while Hello")
return &clientHello{
isTLS: true,
peeked: getPeeked(br),
@ -396,7 +396,7 @@ func clientHelloInfo(br *bufio.Reader) (*clientHello, error) {
func getPeeked(br *bufio.Reader) string {
peeked, err := br.Peek(br.Buffered())
if err != nil {
log.Errorf("Could not get anything: %s", err)
log.Error().Err(err).Msg("Could not get anything")
return ""
}
return string(peeked)