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

13
pkg/provider/acme/account.go
View file

@ -9,7 +9,8 @@ import (
"github.com/go-acme/lego/v4/certcrypto"
"github.com/go-acme/lego/v4/registration"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/logs"
)
// Account is used to store lets encrypt registration info.
@ -56,8 +57,8 @@ func (a *Account) GetRegistration() *registration.Resource {
func (a *Account) GetPrivateKey() crypto.PrivateKey {
privateKey, err := x509.ParsePKCS1PrivateKey(a.PrivateKey)
if err != nil {
log.WithoutContext().WithField(log.ProviderName, "acme").
Errorf("Cannot unmarshal private key %+v: %v", a.PrivateKey, err)
log.Error().Str(logs.ProviderName, "acme").
Err(err).Msgf("Cannot unmarshal private key %+v", a.PrivateKey)
return nil
}
@ -66,7 +67,7 @@ func (a *Account) GetPrivateKey() crypto.PrivateKey {
// GetKeyType used to determine which algo to used.
func GetKeyType(ctx context.Context, value string) certcrypto.KeyType {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
switch value {
case "EC256":
@ -80,10 +81,10 @@ func GetKeyType(ctx context.Context, value string) certcrypto.KeyType {
case "RSA8192":
return certcrypto.RSA8192
case "":
logger.Infof("The key type is empty. Use default key type %v.", certcrypto.RSA4096)
logger.Info().Msgf("The key type is empty. Use default key type %v.", certcrypto.RSA4096)
return certcrypto.RSA4096
default:
logger.Infof("Unable to determine the key type value %q: falling back on %v.", value, certcrypto.RSA4096)
logger.Info().Msgf("Unable to determine the key type value %q: falling back on %v.", value, certcrypto.RSA4096)
return certcrypto.RSA4096
}
}

22
pkg/provider/acme/challenge_http.go
View file

@ -13,7 +13,8 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/go-acme/lego/v4/challenge/http01"
"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/safe"
)
@ -70,12 +71,11 @@ func (c *ChallengeHTTP) Timeout() (timeout, interval time.Duration) {
}
func (c *ChallengeHTTP) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
ctx := log.With(req.Context(), log.Str(log.ProviderName, "acme"))
logger := log.FromContext(ctx)
logger := log.Ctx(req.Context()).With().Str(logs.ProviderName, "acme").Logger()
token, err := getPathParam(req.URL)
if err != nil {
logger.Errorf("Unable to get token: %v.", err)
logger.Error().Err(err).Msg("Unable to get token")
rw.WriteHeader(http.StatusNotFound)
return
}
@ -83,16 +83,16 @@ func (c *ChallengeHTTP) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
if token != "" {
domain, _, err := net.SplitHostPort(req.Host)
if err != nil {
logger.Debugf("Unable to split host and port: %v. Fallback to request host.", err)
logger.Debug().Err(err).Msg("Unable to split host and port. Fallback to request host.")
domain = req.Host
}
tokenValue := c.getTokenValue(ctx, token, domain)
tokenValue := c.getTokenValue(logger.WithContext(req.Context()), token, domain)
if len(tokenValue) > 0 {
rw.WriteHeader(http.StatusOK)
_, err = rw.Write(tokenValue)
if err != nil {
logger.Errorf("Unable to write token: %v", err)
logger.Error().Err(err).Msg("Unable to write token")
}
return
}
@ -102,8 +102,8 @@ func (c *ChallengeHTTP) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
}
func (c *ChallengeHTTP) getTokenValue(ctx context.Context, token, domain string) []byte {
logger := log.FromContext(ctx)
logger.Debugf("Retrieving the ACME challenge for %s (token %q)...", domain, token)
logger := log.Ctx(ctx)
logger.Debug().Msgf("Retrieving the ACME challenge for %s (token %q)...", domain, token)
var result []byte
@ -125,14 +125,14 @@ func (c *ChallengeHTTP) getTokenValue(ctx context.Context, token, domain string)
}
notify := func(err error, time time.Duration) {
logger.Errorf("Error getting challenge for token retrying in %s", time)
logger.Error().Msgf("Error getting challenge for token retrying in %s", time)
}
ebo := backoff.NewExponentialBackOff()
ebo.MaxElapsedTime = 60 * time.Second
err := backoff.RetryNotify(safe.OperationWithRecover(operation), ebo, notify)
if err != nil {
logger.Errorf("Cannot retrieve the ACME challenge for %s (token %q): %v", domain, token, err)
logger.Error().Err(err).Msgf("Cannot retrieve the ACME challenge for %s (token %q)", domain, token)
return []byte{}
}

13
pkg/provider/acme/challenge_tls.go
View file

@ -6,8 +6,9 @@ import (
"time"
"github.com/go-acme/lego/v4/challenge/tlsalpn01"
"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/safe"
traefiktls "github.com/traefik/traefik/v2/pkg/tls"
"github.com/traefik/traefik/v2/pkg/types"
@ -36,8 +37,8 @@ func NewChallengeTLSALPN() *ChallengeTLSALPN {
// Present presents a challenge to obtain new ACME certificate.
func (c *ChallengeTLSALPN) Present(domain, _, keyAuth string) error {
logger := log.WithoutContext().WithField(log.ProviderName, providerNameALPN)
logger.Debugf("TLS Challenge Present temp certificate for %s", domain)
logger := log.With().Str(logs.ProviderName, providerNameALPN).Logger()
logger.Debug().Msgf("TLS Challenge Present temp certificate for %s", domain)
certPEMBlock, keyPEMBlock, err := tlsalpn01.ChallengeBlocks(domain, keyAuth)
if err != nil {
@ -71,7 +72,7 @@ func (c *ChallengeTLSALPN) Present(domain, _, keyAuth string) error {
err = c.CleanUp(domain, "", keyAuth)
if err != nil {
logger.Errorf("Failed to clean up TLS challenge: %v", err)
logger.Error().Err(err).Msg("Failed to clean up TLS challenge")
}
return fmt.Errorf("timeout %s", t)
@ -83,8 +84,8 @@ func (c *ChallengeTLSALPN) Present(domain, _, keyAuth string) error {
// CleanUp cleans the challenges when certificate is obtained.
func (c *ChallengeTLSALPN) CleanUp(domain, _, keyAuth string) error {
log.WithoutContext().WithField(log.ProviderName, providerNameALPN).
Debugf("TLS Challenge CleanUp temp certificate for %s", domain)
log.Debug().Str(logs.ProviderName, providerNameALPN).
Msgf("TLS Challenge CleanUp temp certificate for %s", domain)
c.muCerts.Lock()
delete(c.certs, keyAuth)

13
pkg/provider/acme/local_store.go
View file

@ -6,7 +6,8 @@ import (
"os"
"sync"
"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/safe"
)
@ -52,7 +53,7 @@ func (s *LocalStore) get(resolverName string) (*StoredData, error) {
}
if hasData {
logger := log.WithoutContext().WithField(log.ProviderName, "acme")
logger := log.With().Str(logs.ProviderName, "acme").Logger()
f, err := os.Open(s.filename)
if err != nil {
@ -76,7 +77,7 @@ func (s *LocalStore) get(resolverName string) (*StoredData, error) {
for _, storedData := range s.storedData {
for _, certificate := range storedData.Certificates {
if len(certificate.Certificate.Certificate) == 0 || len(certificate.Key) == 0 {
logger.Debugf("Deleting empty certificate %v for %v", certificate, certificate.Domain.ToStrArray())
logger.Debug().Msgf("Deleting empty certificate %v for %v", certificate, certificate.Domain.ToStrArray())
continue
}
certificates = append(certificates, certificate)
@ -101,16 +102,16 @@ func (s *LocalStore) get(resolverName string) (*StoredData, error) {
// listenSaveAction listens to a chan to store ACME data in json format into `LocalStore.filename`.
func (s *LocalStore) listenSaveAction() {
safe.Go(func() {
logger := log.WithoutContext().WithField(log.ProviderName, "acme")
logger := log.With().Str(logs.ProviderName, "acme").Logger()
for object := range s.saveDataChan {
data, err := json.MarshalIndent(object, "", " ")
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
}
err = os.WriteFile(s.filename, data, 0o600)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
}
}
})

152
pkg/provider/acme/provider.go
View file

@ -19,9 +19,10 @@ import (
"github.com/go-acme/lego/v4/lego"
"github.com/go-acme/lego/v4/providers/dns"
"github.com/go-acme/lego/v4/registration"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
httpmuxer "github.com/traefik/traefik/v2/pkg/muxer/http"
tcpmuxer "github.com/traefik/traefik/v2/pkg/muxer/tcp"
"github.com/traefik/traefik/v2/pkg/safe"
@ -131,8 +132,7 @@ func (p *Provider) ListenConfiguration(config dynamic.Configuration) {
// Init for compatibility reason the BaseProvider implements an empty Init.
func (p *Provider) Init() error {
ctx := log.With(context.Background(), log.Str(log.ProviderName, p.ResolverName+".acme"))
logger := log.FromContext(ctx)
logger := log.With().Str(logs.ProviderName, p.ResolverName+".acme").Logger()
if len(p.Configuration.Storage) == 0 {
return errors.New("unable to initialize ACME provider with no storage location for the certificates")
@ -149,8 +149,8 @@ func (p *Provider) Init() error {
}
// Reset Account if caServer changed, thus registration URI can be updated
if p.account != nil && p.account.Registration != nil && !isAccountMatchingCaServer(ctx, p.account.Registration.URI, p.CAServer) {
logger.Info("Account URI does not match the current CAServer. The account will be reset.")
if p.account != nil && p.account.Registration != nil && !isAccountMatchingCaServer(logger.WithContext(context.Background()), p.account.Registration.URI, p.CAServer) {
logger.Info().Msg("Account URI does not match the current CAServer. The account will be reset.")
p.account = nil
}
@ -169,17 +169,17 @@ func (p *Provider) Init() error {
}
func isAccountMatchingCaServer(ctx context.Context, accountURI, serverURI string) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
aru, err := url.Parse(accountURI)
if err != nil {
logger.Infof("Unable to parse account.Registration URL: %v", err)
logger.Info().Err(err).Str("registrationURL", accountURI).Msg("Unable to parse account.Registration URL")
return false
}
cau, err := url.Parse(serverURI)
if err != nil {
logger.Infof("Unable to parse CAServer URL: %v", err)
logger.Info().Err(err).Str("caServerURL", serverURI).Msg("Unable to parse CAServer URL")
return false
}
@ -194,9 +194,9 @@ func (p *Provider) ThrottleDuration() time.Duration {
// Provide allows the file provider to provide configurations to traefik
// using the given Configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctx := log.With(context.Background(),
log.Str(log.ProviderName, p.ResolverName+".acme"),
log.Str("ACME CA", p.Configuration.CAServer))
logger := log.With().Str(logs.ProviderName, p.ResolverName+".acme").Str("acmeCA", p.Configuration.CAServer).
Logger()
ctx := logger.WithContext(context.Background())
p.pool = pool
@ -211,7 +211,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
p.configurationChan <- msg
renewPeriod, renewInterval := getCertificateRenewDurations(p.CertificatesDuration)
log.FromContext(ctx).Debugf("Attempt to renew certificates %q before expiry and check every %q",
logger.Debug().Msgf("Attempt to renew certificates %q before expiry and check every %q",
renewPeriod, renewInterval)
p.renewCertificates(ctx, renewPeriod)
@ -236,8 +236,9 @@ func (p *Provider) getClient() (*lego.Client, error) {
p.clientMutex.Lock()
defer p.clientMutex.Unlock()
ctx := log.With(context.Background(), log.Str(log.ProviderName, p.ResolverName+".acme"))
logger := log.FromContext(ctx)
logger := log.With().Str(logs.ProviderName, p.ResolverName+".acme").Logger()
ctx := logger.WithContext(context.Background())
if p.client != nil {
return p.client, nil
@ -248,13 +249,13 @@ func (p *Provider) getClient() (*lego.Client, error) {
return nil, err
}
logger.Debug("Building ACME client...")
logger.Debug().Msg("Building ACME client...")
caServer := lego.LEDirectoryProduction
if len(p.CAServer) > 0 {
caServer = p.CAServer
}
logger.Debug(caServer)
logger.Debug().Msg(caServer)
config := lego.NewConfig(account)
config.CADirURL = caServer
@ -290,7 +291,7 @@ func (p *Provider) getClient() (*lego.Client, error) {
}
if p.DNSChallenge != nil && len(p.DNSChallenge.Provider) > 0 {
logger.Debugf("Using DNS Challenge provider: %s", p.DNSChallenge.Provider)
logger.Debug().Msgf("Using DNS Challenge provider: %s", p.DNSChallenge.Provider)
var provider challenge.Provider
provider, err = dns.NewDNSChallengeProviderByName(p.DNSChallenge.Provider)
@ -302,7 +303,7 @@ func (p *Provider) getClient() (*lego.Client, error) {
dns01.CondOption(len(p.DNSChallenge.Resolvers) > 0, dns01.AddRecursiveNameservers(p.DNSChallenge.Resolvers)),
dns01.WrapPreCheck(func(domain, fqdn, value string, check dns01.PreCheckFunc) (bool, error) {
if p.DNSChallenge.DelayBeforeCheck > 0 {
logger.Debugf("Delaying %d rather than validating DNS propagation now.", p.DNSChallenge.DelayBeforeCheck)
logger.Debug().Msgf("Delaying %d rather than validating DNS propagation now.", p.DNSChallenge.DelayBeforeCheck)
time.Sleep(time.Duration(p.DNSChallenge.DelayBeforeCheck))
}
@ -319,7 +320,7 @@ func (p *Provider) getClient() (*lego.Client, error) {
}
if p.HTTPChallenge != nil && len(p.HTTPChallenge.EntryPoint) > 0 {
logger.Debug("Using HTTP Challenge provider.")
logger.Debug().Msg("Using HTTP Challenge provider.")
err = client.Challenge.SetHTTP01Provider(p.HTTPChallengeProvider)
if err != nil {
@ -328,7 +329,7 @@ func (p *Provider) getClient() (*lego.Client, error) {
}
if p.TLSChallenge != nil {
logger.Debug("Using TLS Challenge provider.")
logger.Debug().Msg("Using TLS Challenge provider.")
err = client.Challenge.SetTLSALPN01Provider(p.TLSChallengeProvider)
if err != nil {
@ -358,30 +359,30 @@ func (p *Provider) initAccount(ctx context.Context) (*Account, error) {
}
func (p *Provider) register(ctx context.Context, client *lego.Client) (*registration.Resource, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if p.EAB != nil {
logger.Info("Register with external account binding...")
logger.Info().Msg("Register with external account binding...")
eabOptions := registration.RegisterEABOptions{TermsOfServiceAgreed: true, Kid: p.EAB.Kid, HmacEncoded: p.EAB.HmacEncoded}
return client.Registration.RegisterWithExternalAccountBinding(eabOptions)
}
logger.Info("Register...")
logger.Info().Msg("Register...")
return client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true})
}
func (p *Provider) resolveDomains(ctx context.Context, domains []string, tlsStore string) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if len(domains) == 0 {
logger.Debug("No domain parsed in provider ACME")
logger.Debug().Msg("No domain parsed in provider ACME")
return
}
logger.Debugf("Trying to challenge certificate for domain %v found in HostSNI rule", domains)
logger.Debug().Msgf("Trying to challenge certificate for domain %v found in HostSNI rule", domains)
var domain types.Domain
if len(domains) > 0 {
@ -393,20 +394,22 @@ func (p *Provider) resolveDomains(ctx context.Context, domains []string, tlsStor
safe.Go(func() {
dom, cert, err := p.resolveCertificate(ctx, domain, tlsStore)
if err != nil {
logger.Errorf("Unable to obtain ACME certificate for domains %q: %v", strings.Join(domains, ","), err)
logger.Error().Err(err).Strs("domains", domains).Msg("Unable to obtain ACME certificate for domains")
return
}
err = p.addCertificateForDomain(dom, cert, tlsStore)
if err != nil {
logger.WithError(err).Error("Error adding certificate for domain")
logger.Error().Err(err).Strs("domains", dom.ToStrArray()).Msg("Error adding certificate for domains")
}
})
}
}
func (p *Provider) watchNewDomains(ctx context.Context) {
ctx = log.With(ctx, log.Str(log.ProviderName, p.ResolverName+".acme"))
rootLogger := log.Ctx(ctx).With().Str(logs.ProviderName, p.ResolverName+".acme").Logger()
ctx = rootLogger.WithContext(ctx)
p.pool.GoCtx(func(ctxPool context.Context) {
for {
select {
@ -417,8 +420,8 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
continue
}
ctxRouter := log.With(ctx, log.Str(log.RouterName, routerName), log.Str(log.Rule, route.Rule))
logger := log.FromContext(ctxRouter)
logger := rootLogger.With().Str(logs.RouterName, routerName).Str(logs.Rule, route.Rule).Logger()
ctxRouter := logger.WithContext(ctx)
if len(route.TLS.Domains) > 0 {
domains := deleteUnnecessaryDomains(ctxRouter, route.TLS.Domains)
@ -427,20 +430,20 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
safe.Go(func() {
dom, cert, err := p.resolveCertificate(ctx, domain, traefiktls.DefaultTLSStoreName)
if err != nil {
logger.WithError(err).Errorf("Unable to obtain ACME certificate for domains %q", strings.Join(domain.ToStrArray(), ","))
logger.Error().Err(err).Strs("domains", domain.ToStrArray()).Msg("Unable to obtain ACME certificate for domains")
return
}
err = p.addCertificateForDomain(dom, cert, traefiktls.DefaultTLSStoreName)
if err != nil {
logger.WithError(err).Error("Error adding certificate for domain")
logger.Error().Err(err).Strs("domains", dom.ToStrArray()).Msg("Error adding certificate for domains")
}
})
}
} else {
domains, err := tcpmuxer.ParseHostSNI(route.Rule)
if err != nil {
logger.WithError(err).Errorf("Error parsing domains in provider ACME")
logger.Error().Err(err).Msg("Error parsing domains in provider ACME")
continue
}
p.resolveDomains(ctxRouter, domains, traefiktls.DefaultTLSStoreName)
@ -454,8 +457,8 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
continue
}
ctxRouter := log.With(ctx, log.Str(log.RouterName, routerName), log.Str(log.Rule, route.Rule))
logger := log.FromContext(ctxRouter)
logger := rootLogger.With().Str(logs.RouterName, routerName).Str(logs.Rule, route.Rule).Logger()
ctxRouter := logger.WithContext(ctx)
if len(route.TLS.Domains) > 0 {
domains := deleteUnnecessaryDomains(ctxRouter, route.TLS.Domains)
@ -464,20 +467,20 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
safe.Go(func() {
dom, cert, err := p.resolveCertificate(ctx, domain, traefiktls.DefaultTLSStoreName)
if err != nil {
logger.WithError(err).Errorf("Unable to obtain ACME certificate for domains %q", strings.Join(domain.ToStrArray(), ","))
logger.Error().Err(err).Strs("domains", domain.ToStrArray()).Msg("Unable to obtain ACME certificate for domains")
return
}
err = p.addCertificateForDomain(dom, cert, traefiktls.DefaultTLSStoreName)
if err != nil {
logger.WithError(err).Error("Error adding certificate for domain")
logger.Error().Err(err).Strs("domains", dom.ToStrArray()).Msg("Error adding certificate for domain")
}
})
}
} else {
domains, err := httpmuxer.ParseDomains(route.Rule)
if err != nil {
logger.WithError(err).Errorf("Error parsing domains in provider ACME")
logger.Error().Err(err).Msg("Error parsing domains in provider ACME")
continue
}
p.resolveDomains(ctxRouter, domains, traefiktls.DefaultTLSStoreName)
@ -490,11 +493,10 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
}
for tlsStoreName, tlsStore := range config.TLS.Stores {
ctxTLSStore := log.With(ctx, log.Str(log.TLSStoreName, tlsStoreName))
logger := log.FromContext(ctxTLSStore)
logger := rootLogger.With().Str(logs.TLSStoreName, tlsStoreName).Logger()
if tlsStore.DefaultCertificate != nil && tlsStore.DefaultGeneratedCert != nil {
logger.Warn("defaultCertificate and defaultGeneratedCert cannot be defined at the same time.")
logger.Warn().Msg("defaultCertificate and defaultGeneratedCert cannot be defined at the same time.")
}
// Gives precedence to the user defined default certificate.
@ -503,7 +505,7 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
}
if tlsStore.DefaultGeneratedCert.Domain == nil || tlsStore.DefaultGeneratedCert.Resolver == "" {
logger.Warn("default generated certificate domain or resolver is missing.")
logger.Warn().Msg("default generated certificate domain or resolver is missing.")
continue
}
@ -513,18 +515,18 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
validDomains, err := p.sanitizeDomains(ctx, *tlsStore.DefaultGeneratedCert.Domain)
if err != nil {
logger.WithError(err).Errorf("domains validation: %s", strings.Join(tlsStore.DefaultGeneratedCert.Domain.ToStrArray(), ","))
logger.Error().Err(err).Strs("domains", tlsStore.DefaultGeneratedCert.Domain.ToStrArray()).Msg("domains validation")
}
if p.certExists(validDomains) {
logger.Debug("Default ACME certificate generation is not required.")
logger.Debug().Msg("Default ACME certificate generation is not required.")
continue
}
safe.Go(func() {
cert, err := p.resolveDefaultCertificate(ctx, validDomains)
if err != nil {
logger.WithError(err).Errorf("Unable to obtain ACME certificate for domain %q", strings.Join(validDomains, ","))
logger.Error().Err(err).Strs("domains", validDomains).Msgf("Unable to obtain ACME certificate for domain")
return
}
@ -537,7 +539,7 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
err = p.addCertificateForDomain(domain, cert, traefiktls.DefaultTLSStoreName)
if err != nil {
logger.WithError(err).Error("Error adding certificate for domain")
logger.Error().Err(err).Msg("Error adding certificate for domain")
}
})
}
@ -549,7 +551,7 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
}
func (p *Provider) resolveDefaultCertificate(ctx context.Context, domains []string) (*certificate.Resource, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
p.resolvingDomainsMutex.Lock()
@ -571,7 +573,7 @@ func (p *Provider) resolveDefaultCertificate(ctx context.Context, domains []stri
defer p.removeResolvingDomains(append(domains, domainKey))
logger.Debugf("Loading ACME certificates %+v...", domains)
logger.Debug().Msgf("Loading ACME certificates %+v...", domains)
client, err := p.getClient()
if err != nil {
@ -596,7 +598,7 @@ func (p *Provider) resolveDefaultCertificate(ctx context.Context, domains []stri
return nil, fmt.Errorf("certificate for domains %v is empty: %v", domains, cert)
}
logger.Debugf("Default certificate obtained for domains %+v", domains)
logger.Debug().Msgf("Default certificate obtained for domains %+v", domains)
return cert, nil
}
@ -615,8 +617,8 @@ func (p *Provider) resolveCertificate(ctx context.Context, domain types.Domain,
defer p.removeResolvingDomains(uncheckedDomains)
logger := log.FromContext(ctx)
logger.Debugf("Loading ACME certificates %+v...", uncheckedDomains)
logger := log.Ctx(ctx)
logger.Debug().Msgf("Loading ACME certificates %+v...", uncheckedDomains)
client, err := p.getClient()
if err != nil {
@ -641,7 +643,7 @@ func (p *Provider) resolveCertificate(ctx context.Context, domain types.Domain,
return types.Domain{}, nil, fmt.Errorf("certificate for domains %v is empty: %v", uncheckedDomains, cert)
}
logger.Debugf("Certificates obtained for domains %+v", uncheckedDomains)
logger.Debug().Msgf("Certificates obtained for domains %+v", uncheckedDomains)
domain = types.Domain{Main: uncheckedDomains[0]}
if len(uncheckedDomains) > 1 {
@ -712,7 +714,7 @@ func getCertificateRenewDurations(certificatesDuration int) (time.Duration, time
func deleteUnnecessaryDomains(ctx context.Context, domains []types.Domain) []types.Domain {
var newDomains []types.Domain
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
for idxDomainToCheck, domainToCheck := range domains {
keepDomain := true
@ -724,7 +726,7 @@ func deleteUnnecessaryDomains(ctx context.Context, domains []types.Domain) []typ
if reflect.DeepEqual(domain, domainToCheck) {
if idxDomainToCheck > idxDomain {
logger.Warnf("The domain %v is duplicated in the configuration but will be process by ACME provider only once.", domainToCheck)
logger.Warn().Msgf("The domain %v is duplicated in the configuration but will be process by ACME provider only once.", domainToCheck)
keepDomain = false
}
break
@ -736,11 +738,11 @@ func deleteUnnecessaryDomains(ctx context.Context, domains []types.Domain) []typ
for _, domainProcessed := range domainToCheck.ToStrArray() {
if idxDomain < idxDomainToCheck && isDomainAlreadyChecked(domainProcessed, domain.ToStrArray()) {
// The domain is duplicated in a CN
logger.Warnf("Domain %q is duplicated in the configuration or validated by the domain %v. It will be processed once.", domainProcessed, domain)
logger.Warn().Msgf("Domain %q is duplicated in the configuration or validated by the domain %v. It will be processed once.", domainProcessed, domain)
continue
} else if domain.Main != domainProcessed && strings.HasPrefix(domain.Main, "*") && isDomainAlreadyChecked(domainProcessed, []string{domain.Main}) {
// Check if a wildcard can validate the domain
logger.Warnf("Domain %q will not be processed by ACME provider because it is validated by the wildcard %q", domainProcessed, domain.Main)
logger.Warn().Msgf("Domain %q will not be processed by ACME provider because it is validated by the wildcard %q", domainProcessed, domain.Main)
continue
}
newDomainsToCheck = append(newDomainsToCheck, domainProcessed)
@ -791,9 +793,9 @@ func (p *Provider) buildMessage() dynamic.Message {
}
func (p *Provider) renewCertificates(ctx context.Context, renewPeriod time.Duration) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
logger.Info("Testing certificate renew...")
logger.Info().Msg("Testing certificate renew...")
p.certificatesMu.RLock()
@ -811,11 +813,11 @@ func (p *Provider) renewCertificates(ctx context.Context, renewPeriod time.Durat
for _, cert := range certificates {
client, err := p.getClient()
if err != nil {
logger.WithError(err).Infof("Error renewing certificate from LE : %+v", cert.Domain)
logger.Info().Err(err).Msgf("Error renewing certificate from LE : %+v", cert.Domain)
continue
}
logger.Infof("Renewing certificate from LE : %+v", cert.Domain)
logger.Info().Msgf("Renewing certificate from LE : %+v", cert.Domain)
renewedCert, err := client.Certificate.Renew(certificate.Resource{
Domain: cert.Domain.Main,
@ -823,18 +825,18 @@ func (p *Provider) renewCertificates(ctx context.Context, renewPeriod time.Durat
Certificate: cert.Certificate.Certificate,
}, true, ocspMustStaple, p.PreferredChain)
if err != nil {
logger.WithError(err).Errorf("Error renewing certificate from LE: %v", cert.Domain)
logger.Error().Err(err).Msgf("Error renewing certificate from LE: %v", cert.Domain)
continue
}
if len(renewedCert.Certificate) == 0 || len(renewedCert.PrivateKey) == 0 {
logger.Errorf("domains %v renew certificate with no value: %v", cert.Domain.ToStrArray(), cert)
logger.Error().Msgf("domains %v renew certificate with no value: %v", cert.Domain.ToStrArray(), cert)
continue
}
err = p.addCertificateForDomain(cert.Domain, renewedCert, cert.Store)
if err != nil {
logger.WithError(err).Error("Error adding certificate for domain")
logger.Error().Err(err).Msg("Error adding certificate for domain")
}
}
}
@ -842,7 +844,7 @@ func (p *Provider) renewCertificates(ctx context.Context, renewPeriod time.Durat
// Get provided certificate which check a domains list (Main and SANs)
// from static and dynamic provided certificates.
func (p *Provider) getUncheckedDomains(ctx context.Context, domainsToCheck []string, tlsStore string) []string {
log.FromContext(ctx).Debugf("Looking for provided certificate(s) to validate %q...", domainsToCheck)
log.Ctx(ctx).Debug().Msgf("Looking for provided certificate(s) to validate %q...", domainsToCheck)
var allDomains []string
store := p.tlsManager.GetStore(tlsStore)
@ -884,21 +886,24 @@ func searchUncheckedDomains(ctx context.Context, domainsToCheck, existentDomains
}
}
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if len(uncheckedDomains) == 0 {
logger.Debugf("No ACME certificate generation required for domains %q.", domainsToCheck)
logger.Debug().Strs("domains", domainsToCheck).Msg("No ACME certificate generation required for domains")
} else {
logger.Debugf("Domains %q need ACME certificates generation for domains %q.", domainsToCheck, strings.Join(uncheckedDomains, ","))
logger.Debug().Strs("domains", domainsToCheck).Msgf("Domains need ACME certificates generation for domains %q.", strings.Join(uncheckedDomains, ","))
}
return uncheckedDomains
}
func getX509Certificate(ctx context.Context, cert *Certificate) (*x509.Certificate, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
tlsCert, err := tls.X509KeyPair(cert.Certificate, cert.Key)
if err != nil {
logger.WithError(err).Errorf("Failed to load TLS key pair from ACME certificate for domain %q (SAN : %q), certificate will be renewed", cert.Domain.Main, strings.Join(cert.Domain.SANs, ","))
logger.Error().Err(err).
Str("domain", cert.Domain.Main).
Strs("SANs", cert.Domain.SANs).
Msg("Failed to load TLS key pair from ACME certificate for domain, certificate will be renewed")
return nil, err
}
@ -906,7 +911,10 @@ func getX509Certificate(ctx context.Context, cert *Certificate) (*x509.Certifica
if crt == nil {
crt, err = x509.ParseCertificate(tlsCert.Certificate[0])
if err != nil {
logger.WithError(err).Errorf("Failed to parse TLS key pair from ACME certificate for domain %q (SAN : %q), certificate will be renewed", cert.Domain.Main, strings.Join(cert.Domain.SANs, ","))
logger.Error().Err(err).
Str("domain", cert.Domain.Main).
Strs("SANs", cert.Domain.SANs).
Msg("Failed to parse TLS key pair from ACME certificate for domain, certificate will be renewed")
}
}
@ -935,7 +943,7 @@ func (p *Provider) sanitizeDomains(ctx context.Context, domain types.Domain) ([]
canonicalDomain := types.CanonicalDomain(dom)
cleanDomain := dns01.UnFqdn(canonicalDomain)
if canonicalDomain != cleanDomain {
log.FromContext(ctx).Warnf("FQDN detected, please remove the trailing dot: %s", canonicalDomain)
log.Ctx(ctx).Warn().Msgf("FQDN detected, please remove the trailing dot: %s", canonicalDomain)
}
cleanDomains = append(cleanDomains, cleanDomain)

12
pkg/provider/aggregator/aggregator.go
View file

@ -4,9 +4,9 @@ import (
"context"
"time"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/static"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/file"
"github.com/traefik/traefik/v2/pkg/provider/traefik"
@ -148,7 +148,7 @@ func NewProviderAggregator(conf static.Providers) ProviderAggregator {
func (p *ProviderAggregator) quietAddProvider(provider provider.Provider) {
err := p.AddProvider(provider)
if err != nil {
log.WithoutContext().Errorf("Error while initializing provider %T: %v", provider, err)
log.Error().Err(err).Msgf("Error while initializing provider %T", provider)
}
}
@ -201,14 +201,14 @@ func (p ProviderAggregator) Provide(configurationChan chan<- dynamic.Message, po
func (p ProviderAggregator) launchProvider(configurationChan chan<- dynamic.Message, pool *safe.Pool, prd provider.Provider) {
jsonConf, err := redactor.RemoveCredentials(prd)
if err != nil {
log.WithoutContext().Debugf("Cannot marshal the provider configuration %T: %v", prd, err)
log.Debug().Err(err).Msgf("Cannot marshal the provider configuration %T", prd)
}
log.WithoutContext().Infof("Starting provider %T", prd)
log.WithoutContext().Debugf("%T provider configuration: %s", prd, jsonConf)
log.Info().Msgf("Starting provider %T", prd)
log.Debug().RawJSON("config", []byte(jsonConf)).Msgf("%T provider configuration", prd)
if err := maybeThrottledProvide(prd, p.providersThrottleDuration)(configurationChan, pool); err != nil {
log.WithoutContext().Errorf("Cannot start the provider %T: %v", prd, err)
log.Error().Err(err).Msgf("Cannot start the provider %T", prd)
return
}
}

68
pkg/provider/configuration.go
View file

@ -10,13 +10,14 @@ import (
"unicode"
"github.com/Masterminds/sprig/v3"
"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"
)
// Merge Merges multiple configurations.
func Merge(ctx context.Context, configurations map[string]*dynamic.Configuration) *dynamic.Configuration {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
configuration := &dynamic.Configuration{
HTTP: &dynamic.HTTPConfiguration{
@ -136,56 +137,56 @@ func Merge(ctx context.Context, configurations map[string]*dynamic.Configuration
}
for serviceName := range servicesToDelete {
logger.WithField(log.ServiceName, serviceName).
Errorf("Service defined multiple times with different configurations in %v", services[serviceName])
logger.Error().Str(logs.ServiceName, serviceName).
Msgf("Service defined multiple times with different configurations in %v", services[serviceName])
delete(configuration.HTTP.Services, serviceName)
}
for routerName := range routersToDelete {
logger.WithField(log.RouterName, routerName).
Errorf("Router defined multiple times with different configurations in %v", routers[routerName])
logger.Error().Str(logs.RouterName, routerName).
Msgf("Router defined multiple times with different configurations in %v", routers[routerName])
delete(configuration.HTTP.Routers, routerName)
}
for transportName := range transportsToDelete {
logger.WithField(log.ServersTransportName, transportName).
Errorf("ServersTransport defined multiple times with different configurations in %v", transports[transportName])
logger.Error().Str(logs.ServersTransportName, transportName).
Msgf("ServersTransport defined multiple times with different configurations in %v", transports[transportName])
delete(configuration.HTTP.ServersTransports, transportName)
}
for serviceName := range servicesTCPToDelete {
logger.WithField(log.ServiceName, serviceName).
Errorf("Service TCP defined multiple times with different configurations in %v", servicesTCP[serviceName])
logger.Error().Str(logs.ServiceName, serviceName).
Msgf("Service TCP defined multiple times with different configurations in %v", servicesTCP[serviceName])
delete(configuration.TCP.Services, serviceName)
}
for routerName := range routersTCPToDelete {
logger.WithField(log.RouterName, routerName).
Errorf("Router TCP defined multiple times with different configurations in %v", routersTCP[routerName])
logger.Error().Str(logs.RouterName, routerName).
Msgf("Router TCP defined multiple times with different configurations in %v", routersTCP[routerName])
delete(configuration.TCP.Routers, routerName)
}
for serviceName := range servicesUDPToDelete {
logger.WithField(log.ServiceName, serviceName).
Errorf("UDP service defined multiple times with different configurations in %v", servicesUDP[serviceName])
logger.Error().Str(logs.ServiceName, serviceName).
Msgf("UDP service defined multiple times with different configurations in %v", servicesUDP[serviceName])
delete(configuration.UDP.Services, serviceName)
}
for routerName := range routersUDPToDelete {
logger.WithField(log.RouterName, routerName).
Errorf("UDP router defined multiple times with different configurations in %v", routersUDP[routerName])
logger.Error().Str(logs.RouterName, routerName).
Msgf("UDP router defined multiple times with different configurations in %v", routersUDP[routerName])
delete(configuration.UDP.Routers, routerName)
}
for middlewareName := range middlewaresToDelete {
logger.WithField(log.MiddlewareName, middlewareName).
Errorf("Middleware defined multiple times with different configurations in %v", middlewares[middlewareName])
logger.Error().Str(logs.MiddlewareName, middlewareName).
Msgf("Middleware defined multiple times with different configurations in %v", middlewares[middlewareName])
delete(configuration.HTTP.Middlewares, middlewareName)
}
for middlewareName := range middlewaresTCPToDelete {
logger.WithField(log.MiddlewareName, middlewareName).
Errorf("TCP Middleware defined multiple times with different configurations in %v", middlewaresTCP[middlewareName])
logger.Error().Str(logs.MiddlewareName, middlewareName).
Msgf("TCP Middleware defined multiple times with different configurations in %v", middlewaresTCP[middlewareName])
delete(configuration.TCP.Middlewares, middlewareName)
}
@ -342,18 +343,19 @@ func MakeDefaultRuleTemplate(defaultRule string, funcMap template.FuncMap) (*tem
// BuildTCPRouterConfiguration Builds a router configuration.
func BuildTCPRouterConfiguration(ctx context.Context, configuration *dynamic.TCPConfiguration) {
for routerName, router := range configuration.Routers {
loggerRouter := log.FromContext(ctx).WithField(log.RouterName, routerName)
loggerRouter := log.Ctx(ctx).With().Str(logs.RouterName, routerName).Logger()
if len(router.Rule) == 0 {
delete(configuration.Routers, routerName)
loggerRouter.Errorf("Empty rule")
loggerRouter.Error().Msg("Empty rule")
continue
}
if len(router.Service) == 0 {
if len(configuration.Services) > 1 {
delete(configuration.Routers, routerName)
loggerRouter.
Error("Could not define the service name for the router: too many services")
loggerRouter.Error().
Msg("Could not define the service name for the router: too many services")
continue
}
@ -367,7 +369,8 @@ func BuildTCPRouterConfiguration(ctx context.Context, configuration *dynamic.TCP
// BuildUDPRouterConfiguration Builds a router configuration.
func BuildUDPRouterConfiguration(ctx context.Context, configuration *dynamic.UDPConfiguration) {
for routerName, router := range configuration.Routers {
loggerRouter := log.FromContext(ctx).WithField(log.RouterName, routerName)
loggerRouter := log.Ctx(ctx).With().Str(logs.RouterName, routerName).Logger()
if len(router.Service) > 0 {
continue
}
@ -375,7 +378,7 @@ func BuildUDPRouterConfiguration(ctx context.Context, configuration *dynamic.UDP
if len(configuration.Services) > 1 {
delete(configuration.Routers, routerName)
loggerRouter.
Error("Could not define the service name for the router: too many services")
Error().Msg("Could not define the service name for the router: too many services")
continue
}
@ -390,7 +393,7 @@ func BuildUDPRouterConfiguration(ctx context.Context, configuration *dynamic.UDP
func BuildRouterConfiguration(ctx context.Context, configuration *dynamic.HTTPConfiguration, defaultRouterName string, defaultRuleTpl *template.Template, model interface{}) {
if len(configuration.Routers) == 0 {
if len(configuration.Services) > 1 {
log.FromContext(ctx).Info("Could not create a router for the container: too many services")
log.Ctx(ctx).Info().Msg("Could not create a router for the container: too many services")
} else {
configuration.Routers = make(map[string]*dynamic.Router)
configuration.Routers[defaultRouterName] = &dynamic.Router{}
@ -398,18 +401,19 @@ func BuildRouterConfiguration(ctx context.Context, configuration *dynamic.HTTPCo
}
for routerName, router := range configuration.Routers {
loggerRouter := log.FromContext(ctx).WithField(log.RouterName, routerName)
loggerRouter := log.Ctx(ctx).With().Str(logs.RouterName, routerName).Logger()
if len(router.Rule) == 0 {
writer := &bytes.Buffer{}
if err := defaultRuleTpl.Execute(writer, model); err != nil {
loggerRouter.Errorf("Error while parsing default rule: %v", err)
loggerRouter.Error().Err(err).Msg("Error while parsing default rule")
delete(configuration.Routers, routerName)
continue
}
router.Rule = writer.String()
if len(router.Rule) == 0 {
loggerRouter.Error("Undefined rule")
loggerRouter.Error().Msg("Undefined rule")
delete(configuration.Routers, routerName)
continue
}
@ -418,8 +422,8 @@ func BuildRouterConfiguration(ctx context.Context, configuration *dynamic.HTTPCo
if len(router.Service) == 0 {
if len(configuration.Services) > 1 {
delete(configuration.Routers, routerName)
loggerRouter.
Error("Could not define the service name for the router: too many services")
loggerRouter.Error().
Msg("Could not define the service name for the router: too many services")
continue
}

29
pkg/provider/consulcatalog/config.go
View file

@ -10,9 +10,10 @@ import (
"strings"
"github.com/hashicorp/consul/api"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -22,17 +23,17 @@ func (p *Provider) buildConfiguration(ctx context.Context, items []itemData, cer
for _, item := range items {
svcName := provider.Normalize(item.Node + "-" + item.Name + "-" + item.ID)
ctxSvc := log.With(ctx, log.Str(log.ServiceName, svcName))
logger := log.Ctx(ctx).With().Str(logs.ServiceName, svcName).Logger()
ctxSvc := logger.WithContext(ctx)
if !p.keepContainer(ctxSvc, item) {
continue
}
logger := log.FromContext(ctxSvc)
confFromLabel, err := label.DecodeConfiguration(item.Labels)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -41,7 +42,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, items []itemData, cer
tcpOrUDP = true
if err := p.buildTCPServiceConfiguration(item, confFromLabel.TCP); err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -52,7 +53,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, items []itemData, cer
tcpOrUDP = true
if err := p.buildUDPServiceConfiguration(item, confFromLabel.UDP); err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildUDPRouterConfiguration(ctxSvc, confFromLabel.UDP)
@ -77,7 +78,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, items []itemData, cer
}
if err = p.buildServiceConfiguration(item, confFromLabel.HTTP); err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -98,30 +99,30 @@ func (p *Provider) buildConfiguration(ctx context.Context, items []itemData, cer
}
func (p *Provider) keepContainer(ctx context.Context, item itemData) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if !item.ExtraConf.Enable {
logger.Debug("Filtering disabled item")
logger.Debug().Msg("Filtering disabled item")
return false
}
if !p.ConnectAware && item.ExtraConf.ConsulCatalog.Connect {
logger.Debugf("Filtering out Connect aware item, Connect support is not enabled")
logger.Debug().Msg("Filtering out Connect aware item, Connect support is not enabled")
return false
}
matches, err := constraints.MatchTags(item.Tags, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expressions: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expressions")
return false
}
if !matches {
logger.Debugf("Container pruned by constraint expressions: %q", p.Constraints)
logger.Debug().Msgf("Container pruned by constraint expressions: %q", p.Constraints)
return false
}
if item.Status != api.HealthPassing && item.Status != api.HealthWarning {
logger.Debug("Filtering unhealthy or starting item")
logger.Debug().Msg("Filtering unhealthy or starting item")
return false
}

47
pkg/provider/consulcatalog/consul_catalog.go
View file

@ -11,11 +11,12 @@ import (
"github.com/hashicorp/consul/api"
"github.com/hashicorp/consul/api/watch"
"github.com/hashicorp/go-hclog"
"github.com/sirupsen/logrus"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
"github.com/traefik/traefik/v2/pkg/safe"
@ -58,7 +59,7 @@ func (p *ProviderBuilder) BuildProviders() []*Provider {
// We can warn about that, because we've already made sure before that
// Namespace and Namespaces are mutually exclusive.
if p.Namespace != "" {
log.WithoutContext().Warnf("Namespace option is deprecated, please use the Namespaces option instead.")
log.Warn().Msg("Namespace option is deprecated, please use the Namespaces option instead.")
}
if len(p.Namespaces) == 0 {
@ -166,8 +167,8 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, p.name))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, p.name).Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
ctx, cancel := context.WithCancel(ctxLog)
@ -194,7 +195,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
// that gets resolved before the certificates are available
// will cause an error condition.
if p.ConnectAware && !certInfo.isReady() {
logger.Infof("Waiting for Connect certificate before building first configuration")
logger.Info().Msg("Waiting for Connect certificate before building first configuration")
select {
case <-ctx.Done():
return nil
@ -242,12 +243,12 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxLog), notify)
if err != nil {
logger.Errorf("Cannot connect to consul catalog server %+v", err)
logger.Error().Err(err).Msg("Cannot connect to consul catalog server")
}
})
@ -281,32 +282,32 @@ func (p *Provider) getConsulServicesData(ctx context.Context) ([]itemData, error
var data []itemData
for name, tags := range serviceNames {
logger := log.FromContext(log.With(ctx, log.Str("serviceName", name)))
logger := log.Ctx(ctx).With().Str("serviceName", name).Logger()
extraConf, err := p.getExtraConf(tagsToNeutralLabels(tags, p.Prefix))
if err != nil {
logger.Errorf("Skip service: %v", err)
logger.Error().Err(err).Msg("Skip service")
continue
}
if !extraConf.Enable {
logger.Debug("Filtering disabled item")
logger.Debug().Msg("Filtering disabled item")
continue
}
matches, err := constraints.MatchTags(tags, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expressions: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expressions")
continue
}
if !matches {
logger.Debugf("Container pruned by constraint expressions: %q", p.Constraints)
logger.Debug().Msgf("Container pruned by constraint expressions: %q", p.Constraints)
continue
}
if !p.ConnectAware && extraConf.ConsulCatalog.Connect {
logger.Debugf("Filtering out Connect aware item, Connect support is not enabled")
logger.Debug().Msg("Filtering out Connect aware item, Connect support is not enabled")
continue
}
@ -346,7 +347,7 @@ func (p *Provider) getConsulServicesData(ctx context.Context) ([]itemData, error
extraConf, err := p.getExtraConf(item.Labels)
if err != nil {
log.FromContext(ctx).Errorf("Skip item %s: %v", item.Name, err)
log.Ctx(ctx).Error().Err(err).Msgf("Skip item %s", item.Name)
continue
}
item.ExtraConf = extraConf
@ -424,8 +425,9 @@ func (p *Provider) watchServices(ctx context.Context) error {
logger := hclog.New(&hclog.LoggerOptions{
Name: "consulcatalog",
Level: hclog.LevelFromString(logrus.GetLevel().String()),
Level: hclog.LevelFromString(log.Logger.GetLevel().String()),
JSONFormat: true,
Output: logs.NoLevel(log.Logger, zerolog.DebugLevel),
})
errChan := make(chan error, 2)
@ -455,13 +457,13 @@ func (p *Provider) watchServices(ctx context.Context) error {
func rootsWatchHandler(ctx context.Context, dest chan<- []string) func(watch.BlockingParamVal, interface{}) {
return func(_ watch.BlockingParamVal, raw interface{}) {
if raw == nil {
log.FromContext(ctx).Errorf("Root certificate watcher called with nil")
log.Ctx(ctx).Error().Msg("Root certificate watcher called with nil")
return
}
v, ok := raw.(*api.CARootList)
if !ok || v == nil {
log.FromContext(ctx).Errorf("Invalid result for root certificate watcher")
log.Ctx(ctx).Error().Msg("Invalid result for root certificate watcher")
return
}
@ -485,13 +487,13 @@ type keyPair struct {
func leafWatcherHandler(ctx context.Context, dest chan<- keyPair) func(watch.BlockingParamVal, interface{}) {
return func(_ watch.BlockingParamVal, raw interface{}) {
if raw == nil {
log.FromContext(ctx).Errorf("Leaf certificate watcher called with nil")
log.Ctx(ctx).Error().Msg("Leaf certificate watcher called with nil")
return
}
v, ok := raw.(*api.LeafCert)
if !ok || v == nil {
log.FromContext(ctx).Errorf("Invalid result for leaf certificate watcher")
log.Ctx(ctx).Error().Msg("Invalid result for leaf certificate watcher")
return
}
@ -531,8 +533,9 @@ func (p *Provider) watchConnectTLS(ctx context.Context) error {
hclogger := hclog.New(&hclog.LoggerOptions{
Name: "consulcatalog",
Level: hclog.LevelFromString(logrus.GetLevel().String()),
Level: hclog.LevelFromString(log.Logger.GetLevel().String()),
JSONFormat: true,
Output: logs.NoLevel(log.Logger, zerolog.DebugLevel),
})
errChan := make(chan error, 2)
@ -573,7 +576,7 @@ func (p *Provider) watchConnectTLS(ctx context.Context) error {
leaf: leafCerts,
}
if newCertInfo.isReady() && !newCertInfo.equals(certInfo) {
log.FromContext(ctx).Debugf("Updating connect certs for service %s", p.ServiceName)
log.Ctx(ctx).Debug().Msgf("Updating connect certs for service %s", p.ServiceName)
certInfo = newCertInfo

51
pkg/provider/docker/config.go
View file

@ -9,9 +9,10 @@ import (
dockertypes "github.com/docker/docker/api/types"
"github.com/docker/go-connections/nat"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -21,17 +22,17 @@ func (p *Provider) buildConfiguration(ctx context.Context, containersInspected [
for _, container := range containersInspected {
containerName := getServiceName(container) + "-" + container.ID
ctxContainer := log.With(ctx, log.Str("container", containerName))
logger := log.Ctx(ctx).With().Str("container", containerName).Logger()
ctxContainer := logger.WithContext(ctx)
if !p.keepContainer(ctxContainer, container) {
continue
}
logger := log.FromContext(ctxContainer)
confFromLabel, err := label.DecodeConfiguration(container.Labels)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -41,7 +42,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, containersInspected [
err := p.buildTCPServiceConfiguration(ctxContainer, container, confFromLabel.TCP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildTCPRouterConfiguration(ctxContainer, confFromLabel.TCP)
@ -52,7 +53,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, containersInspected [
err := p.buildUDPServiceConfiguration(ctxContainer, container, confFromLabel.UDP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildUDPRouterConfiguration(ctxContainer, confFromLabel.UDP)
@ -67,7 +68,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, containersInspected [
err = p.buildServiceConfiguration(ctxContainer, container, confFromLabel.HTTP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -106,7 +107,7 @@ func (p *Provider) buildTCPServiceConfiguration(ctx context.Context, container d
}
for name, service := range configuration.Services {
ctx := log.With(ctx, log.Str(log.ServiceName, name))
ctx := log.Ctx(ctx).With().Str(logs.ServiceName, name).Logger().WithContext(ctx)
if err := p.addServerTCP(ctx, container, service.LoadBalancer); err != nil {
return fmt.Errorf("service %q error: %w", name, err)
}
@ -130,7 +131,7 @@ func (p *Provider) buildUDPServiceConfiguration(ctx context.Context, container d
}
for name, service := range configuration.Services {
ctx := log.With(ctx, log.Str(log.ServiceName, name))
ctx := log.Ctx(ctx).With().Str(logs.ServiceName, name).Logger().WithContext(ctx)
if err := p.addServerUDP(ctx, container, service.LoadBalancer); err != nil {
return fmt.Errorf("service %q error: %w", name, err)
}
@ -156,7 +157,7 @@ func (p *Provider) buildServiceConfiguration(ctx context.Context, container dock
}
for name, service := range configuration.Services {
ctx := log.With(ctx, log.Str(log.ServiceName, name))
ctx := log.Ctx(ctx).With().Str(logs.ServiceName, name).Logger().WithContext(ctx)
if err := p.addServer(ctx, container, service.LoadBalancer); err != nil {
return fmt.Errorf("service %q error: %w", name, err)
}
@ -166,25 +167,25 @@ func (p *Provider) buildServiceConfiguration(ctx context.Context, container dock
}
func (p *Provider) keepContainer(ctx context.Context, container dockerData) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if !container.ExtraConf.Enable {
logger.Debug("Filtering disabled container")
logger.Debug().Msg("Filtering disabled container")
return false
}
matches, err := constraints.MatchLabels(container.Labels, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraints expression: %v", err)
logger.Error().Err(err).Msg("Error matching constraints expression")
return false
}
if !matches {
logger.Debugf("Container pruned by constraint expression: %q", p.Constraints)
logger.Debug().Msgf("Container pruned by constraint expression: %q", p.Constraints)
return false
}
if !p.AllowEmptyServices && container.Health != "" && container.Health != dockertypes.Healthy {
logger.Debug("Filtering unhealthy or starting container")
logger.Debug().Msg("Filtering unhealthy or starting container")
return false
}
@ -274,7 +275,7 @@ func (p *Provider) addServer(ctx context.Context, container dockerData, loadBala
}
func (p *Provider) getIPPort(ctx context.Context, container dockerData, serverPort string) (string, string, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
var ip, port string
usedBound := false
@ -283,9 +284,9 @@ func (p *Provider) getIPPort(ctx context.Context, container dockerData, serverPo
portBinding, err := p.getPortBinding(container, serverPort)
switch {
case err != nil:
logger.Infof("Unable to find a binding for container %q, falling back on its internal IP/Port.", container.Name)
logger.Info().Msgf("Unable to find a binding for container %q, falling back on its internal IP/Port.", container.Name)
case portBinding.HostIP == "0.0.0.0" || len(portBinding.HostIP) == 0:
logger.Infof("Cannot determine the IP address (got %q) for %q's binding, falling back on its internal IP/Port.", portBinding.HostIP, container.Name)
logger.Info().Msgf("Cannot determine the IP address (got %q) for %q's binding, falling back on its internal IP/Port.", portBinding.HostIP, container.Name)
default:
ip = portBinding.HostIP
port = portBinding.HostPort
@ -306,7 +307,7 @@ func (p *Provider) getIPPort(ctx context.Context, container dockerData, serverPo
}
func (p Provider) getIPAddress(ctx context.Context, container dockerData) string {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if container.ExtraConf.Docker.Network != "" {
settings := container.NetworkSettings
@ -316,7 +317,7 @@ func (p Provider) getIPAddress(ctx context.Context, container dockerData) string
return network.Addr
}
logger.Warnf("Could not find network named '%s' for container '%s'! Maybe you're missing the project's prefix in the label? Defaulting to first available network.", container.ExtraConf.Docker.Network, container.Name)
logger.Warn().Msgf("Could not find network named '%s' for container '%s'! Maybe you're missing the project's prefix in the label? Defaulting to first available network.", container.ExtraConf.Docker.Network, container.Name)
}
}
@ -336,14 +337,14 @@ func (p Provider) getIPAddress(ctx context.Context, container dockerData) string
if container.NetworkSettings.NetworkMode.IsContainer() {
dockerClient, err := p.createClient()
if err != nil {
logger.Warnf("Unable to get IP address: %s", err)
logger.Warn().Err(err).Msg("Unable to get IP address")
return ""
}
connectedContainer := container.NetworkSettings.NetworkMode.ConnectedContainer()
containerInspected, err := dockerClient.ContainerInspect(context.Background(), connectedContainer)
if err != nil {
logger.Warnf("Unable to get IP address for container %s : Failed to inspect container ID %s, error: %s", container.Name, connectedContainer, err)
logger.Warn().Err(err).Msgf("Unable to get IP address for container %s: failed to inspect container ID %s", container.Name, connectedContainer)
return ""
}
@ -352,7 +353,7 @@ func (p Provider) getIPAddress(ctx context.Context, container dockerData) string
containerParsed := parseContainer(containerInspected)
extraConf, err := p.getConfiguration(containerParsed)
if err != nil {
logger.Warnf("Unable to get IP address for container %s : failed to get extra configuration for container %s: %s", container.Name, containerInspected.Name, err)
logger.Warn().Err(err).Msgf("Unable to get IP address for container %s : failed to get extra configuration for container %s", container.Name, containerInspected.Name)
return ""
}
@ -368,7 +369,7 @@ func (p Provider) getIPAddress(ctx context.Context, container dockerData) string
return network.Addr
}
logger.Warn("Unable to find the IP address.")
logger.Warn().Msg("Unable to find the IP address.")
return ""
}

62
pkg/provider/docker/docker.go
View file

@ -23,10 +23,11 @@ import (
"github.com/docker/docker/client"
"github.com/docker/go-connections/nat"
"github.com/docker/go-connections/sockets"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/types"
@ -162,7 +163,7 @@ func (p *Provider) getClientOpts() ([]client.Opt, error) {
}
if p.TLS != nil {
ctx := log.With(context.Background(), log.Str(log.ProviderName, "docker"))
ctx := log.With().Str(logs.ProviderName, "docker").Logger().WithContext(context.Background())
conf, err := p.TLS.CreateTLSConfig(ctx)
if err != nil {
@ -191,40 +192,41 @@ func (p *Provider) getClientOpts() ([]client.Opt, error) {
// Provide allows the docker provider to provide configurations to traefik using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, "docker"))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, "docker").Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
var err error
ctx, cancel := context.WithCancel(ctxLog)
defer cancel()
ctx = log.With(ctx, log.Str(log.ProviderName, "docker"))
ctx = log.Ctx(ctx).With().Str(logs.ProviderName, "docker").Logger().WithContext(ctx)
dockerClient, err := p.createClient()
if err != nil {
logger.Errorf("Failed to create a client for docker, error: %s", err)
logger.Error().Err(err).Msg("Failed to create a client for docker, error")
return err
}
defer dockerClient.Close()
serverVersion, err := dockerClient.ServerVersion(ctx)
if err != nil {
logger.Errorf("Failed to retrieve information of the docker client and server host: %s", err)
logger.Error().Err(err).Msg("Failed to retrieve information of the docker client and server host")
return err
}
logger.Debugf("Provider connection established with docker %s (API %s)", serverVersion.Version, serverVersion.APIVersion)
logger.Debug().Msgf("Provider connection established with docker %s (API %s)", serverVersion.Version, serverVersion.APIVersion)
var dockerDataList []dockerData
if p.SwarmMode {
dockerDataList, err = p.listServices(ctx, dockerClient)
if err != nil {
logger.Errorf("Failed to list services for docker swarm mode, error %s", err)
logger.Error().Err(err).Msg("Failed to list services for docker swarm mode")
return err
}
} else {
dockerDataList, err = p.listContainers(ctx, dockerClient)
if err != nil {
logger.Errorf("Failed to list containers for docker, error %s", err)
logger.Error().Err(err).Msg("Failed to list containers for docker")
return err
}
}
@ -242,8 +244,8 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
ticker := time.NewTicker(time.Duration(p.SwarmModeRefreshSeconds))
pool.GoCtx(func(ctx context.Context) {
ctx = log.With(ctx, log.Str(log.ProviderName, "docker"))
logger := log.FromContext(ctx)
logger := log.Ctx(ctx).With().Str(logs.ProviderName, "docker").Logger()
ctx = logger.WithContext(ctx)
defer close(errChan)
for {
@ -251,7 +253,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
case <-ticker.C:
services, err := p.listServices(ctx, dockerClient)
if err != nil {
logger.Errorf("Failed to list services for docker swarm mode, error %s", err)
logger.Error().Err(err).Msg("Failed to list services for docker swarm mode")
errChan <- err
return
}
@ -282,10 +284,10 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
startStopHandle := func(m eventtypes.Message) {
logger.Debugf("Provider event received %+v", m)
logger.Debug().Msgf("Provider event received %+v", m)
containers, err := p.listContainers(ctx, dockerClient)
if err != nil {
logger.Errorf("Failed to list containers for docker, error %s", err)
logger.Error().Err(err).Msg("Failed to list containers for docker")
// Call cancel to get out of the monitor
return
}
@ -314,7 +316,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
case err := <-errc:
if errors.Is(err, io.EOF) {
logger.Debug("Provider event stream closed")
logger.Debug().Msg("Provider event stream closed")
}
return err
case <-ctx.Done():
@ -327,11 +329,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxLog), notify)
if err != nil {
logger.Errorf("Cannot connect to docker server %+v", err)
logger.Error().Err(err).Msg("Cannot connect to docker server")
}
})
@ -354,7 +356,7 @@ func (p *Provider) listContainers(ctx context.Context, dockerClient client.Conta
extraConf, err := p.getConfiguration(dData)
if err != nil {
log.FromContext(ctx).Errorf("Skip container %s: %v", getServiceName(dData), err)
log.Ctx(ctx).Error().Err(err).Msgf("Skip container %s", getServiceName(dData))
continue
}
dData.ExtraConf = extraConf
@ -367,7 +369,7 @@ func (p *Provider) listContainers(ctx context.Context, dockerClient client.Conta
func inspectContainers(ctx context.Context, dockerClient client.ContainerAPIClient, containerID string) dockerData {
containerInspected, err := dockerClient.ContainerInspect(ctx, containerID)
if err != nil {
log.FromContext(ctx).Warnf("Failed to inspect container %s, error: %s", containerID, err)
log.Ctx(ctx).Warn().Err(err).Msgf("Failed to inspect container %s", containerID)
return dockerData{}
}
@ -428,7 +430,7 @@ func parseContainer(container dockertypes.ContainerJSON) dockerData {
}
func (p *Provider) listServices(ctx context.Context, dockerClient client.APIClient) ([]dockerData, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
serviceList, err := dockerClient.ServiceList(ctx, dockertypes.ServiceListOptions{})
if err != nil {
@ -450,7 +452,7 @@ func (p *Provider) listServices(ctx context.Context, dockerClient client.APIClie
networkList, err := dockerClient.NetworkList(ctx, dockertypes.NetworkListOptions{Filters: networkListArgs})
if err != nil {
logger.Debugf("Failed to network inspect on client for docker, error: %s", err)
logger.Debug().Err(err).Msg("Failed to network inspect on client for docker")
return nil, err
}
@ -466,7 +468,7 @@ func (p *Provider) listServices(ctx context.Context, dockerClient client.APIClie
for _, service := range serviceList {
dData, err := p.parseService(ctx, service, networkMap)
if err != nil {
logger.Errorf("Skip container %s: %v", getServiceName(dData), err)
logger.Error().Err(err).Msgf("Skip container %s", getServiceName(dData))
continue
}
@ -478,7 +480,7 @@ func (p *Provider) listServices(ctx context.Context, dockerClient client.APIClie
isGlobalSvc := service.Spec.Mode.Global != nil
dockerDataListTasks, err = listTasks(ctx, dockerClient, service.ID, dData, networkMap, isGlobalSvc)
if err != nil {
logger.Warn(err)
logger.Warn().Err(err).Send()
} else {
dockerDataList = append(dockerDataList, dockerDataListTasks...)
}
@ -488,7 +490,7 @@ func (p *Provider) listServices(ctx context.Context, dockerClient client.APIClie
}
func (p *Provider) parseService(ctx context.Context, service swarmtypes.Service, networkMap map[string]*dockertypes.NetworkResource) (dockerData, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
dData := dockerData{
ID: service.ID,
@ -507,7 +509,7 @@ func (p *Provider) parseService(ctx context.Context, service swarmtypes.Service,
if service.Spec.EndpointSpec != nil {
if service.Spec.EndpointSpec.Mode == swarmtypes.ResolutionModeDNSRR {
if dData.ExtraConf.Docker.LBSwarm {
logger.Warnf("Ignored %s endpoint-mode not supported, service name: %s. Fallback to Traefik load balancing", swarmtypes.ResolutionModeDNSRR, service.Spec.Annotations.Name)
logger.Warn().Msgf("Ignored %s endpoint-mode not supported, service name: %s. Fallback to Traefik load balancing", swarmtypes.ResolutionModeDNSRR, service.Spec.Annotations.Name)
}
} else if service.Spec.EndpointSpec.Mode == swarmtypes.ResolutionModeVIP {
dData.NetworkSettings.Networks = make(map[string]*networkData)
@ -523,10 +525,10 @@ func (p *Provider) parseService(ctx context.Context, service swarmtypes.Service,
}
dData.NetworkSettings.Networks[network.Name] = network
} else {
logger.Debugf("No virtual IPs found in network %s", virtualIP.NetworkID)
logger.Debug().Msgf("No virtual IPs found in network %s", virtualIP.NetworkID)
}
} else {
logger.Debugf("Network not found, id: %s", virtualIP.NetworkID)
logger.Debug().Msgf("Network not found, id: %s", virtualIP.NetworkID)
}
}
}
@ -591,7 +593,7 @@ func parseTasks(ctx context.Context, task swarmtypes.Task, serviceDockerData doc
dData.NetworkSettings.Networks[network.Name] = network
}
} else {
log.FromContext(ctx).Debugf("No IP addresses found for network %s", virtualIP.Network.ID)
log.Ctx(ctx).Debug().Msgf("No IP addresses found for network %s", virtualIP.Network.ID)
}
}
}

31
pkg/provider/ecs/config.go
View file

@ -10,9 +10,9 @@ import (
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/docker/go-connections/nat"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -22,17 +22,16 @@ func (p *Provider) buildConfiguration(ctx context.Context, instances []ecsInstan
for _, instance := range instances {
instanceName := getServiceName(instance) + "-" + instance.ID
ctxContainer := log.With(ctx, log.Str("ecs-instance", instanceName))
logger := log.Ctx(ctx).With().Str("ecs-instance", instanceName).Logger()
ctxContainer := logger.WithContext(ctx)
if !p.filterInstance(ctxContainer, instance) {
continue
}
logger := log.FromContext(ctxContainer)
confFromLabel, err := label.DecodeConfiguration(instance.Labels)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -42,7 +41,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, instances []ecsInstan
err := p.buildTCPServiceConfiguration(instance, confFromLabel.TCP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildTCPRouterConfiguration(ctxContainer, confFromLabel.TCP)
@ -53,7 +52,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, instances []ecsInstan
err := p.buildUDPServiceConfiguration(instance, confFromLabel.UDP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildUDPRouterConfiguration(ctxContainer, confFromLabel.UDP)
@ -68,7 +67,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, instances []ecsInstan
err = p.buildServiceConfiguration(ctxContainer, instance, confFromLabel.HTTP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -156,40 +155,40 @@ func (p *Provider) buildServiceConfiguration(_ context.Context, instance ecsInst
}
func (p *Provider) filterInstance(ctx context.Context, instance ecsInstance) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if instance.machine == nil {
logger.Debug("Filtering ecs instance with nil machine")
logger.Debug().Msg("Filtering ecs instance with nil machine")
return false
}
if strings.ToLower(instance.machine.state) != ec2.InstanceStateNameRunning {
logger.Debugf("Filtering ecs instance with an incorrect state %s (%s) (state = %s)", instance.Name, instance.ID, instance.machine.state)
logger.Debug().Msgf("Filtering ecs instance with an incorrect state %s (%s) (state = %s)", instance.Name, instance.ID, instance.machine.state)
return false
}
if instance.machine.healthStatus == "UNHEALTHY" {
logger.Debugf("Filtering unhealthy ecs instance %s (%s)", instance.Name, instance.ID)
logger.Debug().Msgf("Filtering unhealthy ecs instance %s (%s)", instance.Name, instance.ID)
return false
}
if len(instance.machine.privateIP) == 0 {
logger.Debugf("Filtering ecs instance without an ip address %s (%s)", instance.Name, instance.ID)
logger.Debug().Msgf("Filtering ecs instance without an ip address %s (%s)", instance.Name, instance.ID)
return false
}
if !instance.ExtraConf.Enable {
logger.Debugf("Filtering disabled ecs instance %s (%s)", instance.Name, instance.ID)
logger.Debug().Msgf("Filtering disabled ecs instance %s (%s)", instance.Name, instance.ID)
return false
}
matches, err := constraints.MatchLabels(instance.Labels, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expression: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expression")
return false
}
if !matches {
logger.Debugf("Container pruned by constraint expression: %q", p.Constraints)
logger.Debug().Msgf("Container pruned by constraint expression: %q", p.Constraints)
return false
}

38
pkg/provider/ecs/ecs.go
View file

@ -17,9 +17,11 @@ import (
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/cenkalti/backoff/v4"
"github.com/patrickmn/go-cache"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
)
@ -99,7 +101,7 @@ func (p *Provider) Init() error {
return nil
}
func (p *Provider) createClient(logger log.Logger) (*awsClient, error) {
func (p *Provider) createClient(logger zerolog.Logger) (*awsClient, error) {
sess, err := session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
})
@ -109,7 +111,7 @@ func (p *Provider) createClient(logger log.Logger) (*awsClient, error) {
ec2meta := ec2metadata.New(sess)
if p.Region == "" && ec2meta.Available() {
logger.Infoln("No region provided, querying instance metadata endpoint...")
logger.Info().Msg("No region provided, querying instance metadata endpoint...")
identity, err := ec2meta.GetInstanceIdentityDocument()
if err != nil {
return nil, err
@ -137,9 +139,7 @@ func (p *Provider) createClient(logger log.Logger) (*awsClient, error) {
cfg.Region = &p.Region
}
cfg.WithLogger(aws.LoggerFunc(func(args ...interface{}) {
logger.Debug(args...)
}))
cfg.WithLogger(logs.NewAWSWrapper(logger))
return &awsClient{
ecs.New(sess, cfg),
@ -151,8 +151,8 @@ func (p *Provider) createClient(logger log.Logger) (*awsClient, error) {
// Provide configuration to traefik from ECS.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, "ecs"))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, "ecs").Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
awsClient, err := p.createClient(logger)
@ -183,11 +183,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), routineCtx), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider api %+v", err)
logger.Error().Err(err).Msg("Cannot connect to Provider api")
}
})
@ -211,7 +211,7 @@ func (p *Provider) loadConfiguration(ctx context.Context, client *awsClient, con
// Find all running Provider tasks in a cluster, also collect the task definitions (for docker labels)
// and the EC2 instance data.
func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsInstance, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
var clustersArn []*string
var clusters []string
@ -242,7 +242,7 @@ func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsI
var instances []ecsInstance
logger.Debugf("ECS Clusters: %s", clusters)
logger.Debug().Msgf("ECS Clusters: %s", clusters)
for _, c := range clusters {
input := &ecs.ListTasksInput{
Cluster: &c,
@ -257,11 +257,11 @@ func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsI
Cluster: &c,
})
if err != nil {
logger.Errorf("Unable to describe tasks for %v", page.TaskArns)
logger.Error().Msgf("Unable to describe tasks for %v", page.TaskArns)
} else {
for _, t := range resp.Tasks {
if p.HealthyTasksOnly && aws.StringValue(t.HealthStatus) != ecs.HealthStatusHealthy {
logger.Debugf("Skipping unhealthy task %s", aws.StringValue(t.TaskArn))
logger.Debug().Msgf("Skipping unhealthy task %s", aws.StringValue(t.TaskArn))
continue
}
@ -314,7 +314,7 @@ func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsI
}
if containerDefinition == nil {
logger.Debugf("Unable to find container definition for %s", aws.StringValue(container.Name))
logger.Debug().Msgf("Unable to find container definition for %s", aws.StringValue(container.Name))
continue
}
@ -344,7 +344,7 @@ func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsI
} else {
miContainerInstance := miInstances[aws.StringValue(task.ContainerInstanceArn)]
if containerInstance == nil && miContainerInstance == nil {
logger.Errorf("Unable to find container instance information for %s", aws.StringValue(container.Name))
logger.Error().Msgf("Unable to find container instance information for %s", aws.StringValue(container.Name))
continue
}
@ -383,7 +383,7 @@ func (p *Provider) listInstances(ctx context.Context, client *awsClient) ([]ecsI
extraConf, err := p.getConfiguration(instance)
if err != nil {
log.FromContext(ctx).Errorf("Skip container %s: %w", getServiceName(instance), err)
logger.Error().Err(err).Msgf("Skip container %s", getServiceName(instance))
continue
}
instance.ExtraConf = extraConf
@ -525,13 +525,13 @@ func (p *Provider) lookupEc2Instances(ctx context.Context, client *awsClient, cl
}
func (p *Provider) lookupTaskDefinitions(ctx context.Context, client *awsClient, taskDefArns map[string]*ecs.Task) (map[string]*ecs.TaskDefinition, error) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
taskDef := make(map[string]*ecs.TaskDefinition)
for arn, task := range taskDefArns {
if definition, ok := existingTaskDefCache.Get(arn); ok {
taskDef[arn] = definition.(*ecs.TaskDefinition)
logger.Debugf("Found cached task definition for %s. Skipping the call", arn)
logger.Debug().Msgf("Found cached task definition for %s. Skipping the call", arn)
} else {
resp, err := client.ecs.DescribeTaskDefinitionWithContext(ctx, &ecs.DescribeTaskDefinitionInput{
TaskDefinition: task.TaskDefinitionArn,

65
pkg/provider/file/file.go
View file

@ -11,9 +11,10 @@ import (
"text/template"
"github.com/Masterminds/sprig/v3"
"github.com/rs/zerolog/log"
"github.com/traefik/paerser/file"
"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/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/tls"
@ -75,7 +76,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
// BuildConfiguration loads configuration either from file or a directory
// specified by 'Filename'/'Directory' and returns a 'Configuration' object.
func (p *Provider) BuildConfiguration() (*dynamic.Configuration, error) {
ctx := log.With(context.Background(), log.Str(log.ProviderName, providerName))
ctx := log.With().Str(logs.ProviderName, providerName).Logger().WithContext(context.Background())
if len(p.Directory) > 0 {
return p.loadFileConfigFromDirectory(ctx, p.Directory, nil)
@ -117,7 +118,7 @@ func (p *Provider) addWatcher(pool *safe.Pool, directory string, configurationCh
callback(configurationChan, evt)
}
case err := <-watcher.Errors:
log.WithoutContext().WithField(log.ProviderName, providerName).Errorf("Watcher event error: %s", err)
log.Error().Str(logs.ProviderName, providerName).Err(err).Msg("Watcher event error")
}
}
})
@ -130,16 +131,16 @@ func (p *Provider) watcherCallback(configurationChan chan<- dynamic.Message, eve
watchItem = p.Directory
}
logger := log.WithoutContext().WithField(log.ProviderName, providerName)
logger := log.With().Str(logs.ProviderName, providerName).Logger()
if _, err := os.Stat(watchItem); err != nil {
logger.Errorf("Unable to watch %s : %v", watchItem, err)
logger.Error().Err(err).Msgf("Unable to watch %s", watchItem)
return
}
configuration, err := p.BuildConfiguration()
if err != nil {
logger.Errorf("Error occurred during watcher callback: %s", err)
logger.Error().Err(err).Msg("Error occurred during watcher callback")
return
}
@ -176,7 +177,7 @@ func (p *Provider) loadFileConfig(ctx context.Context, filename string, parseTem
for _, caFile := range options.ClientAuth.CAFiles {
content, err := caFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
@ -197,14 +198,14 @@ func (p *Provider) loadFileConfig(ctx context.Context, filename string, parseTem
content, err := store.DefaultCertificate.CertFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
store.DefaultCertificate.CertFile = tls.FileOrContent(content)
content, err = store.DefaultCertificate.KeyFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
store.DefaultCertificate.KeyFile = tls.FileOrContent(content)
@ -221,14 +222,14 @@ func (p *Provider) loadFileConfig(ctx context.Context, filename string, parseTem
for _, cert := range st.Certificates {
content, err := cert.CertFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
cert.CertFile = tls.FileOrContent(content)
content, err = cert.KeyFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
cert.KeyFile = tls.FileOrContent(content)
@ -242,7 +243,7 @@ func (p *Provider) loadFileConfig(ctx context.Context, filename string, parseTem
for _, rootCA := range st.RootCAs {
content, err := rootCA.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
@ -261,14 +262,14 @@ func flattenCertificates(ctx context.Context, tlsConfig *dynamic.TLSConfiguratio
for _, cert := range tlsConfig.Certificates {
content, err := cert.Certificate.CertFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
cert.Certificate.CertFile = tls.FileOrContent(string(content))
content, err = cert.Certificate.KeyFile.Read()
if err != nil {
log.FromContext(ctx).Error(err)
log.Ctx(ctx).Error().Err(err).Send()
continue
}
cert.Certificate.KeyFile = tls.FileOrContent(string(content))
@ -312,10 +313,10 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
configTLSMaps := make(map[*tls.CertAndStores]struct{})
for _, item := range fileList {
logger := log.FromContext(log.With(ctx, log.Str("filename", item.Name())))
logger := log.Ctx(ctx).With().Str("filename", item.Name()).Logger()
if item.IsDir() {
configuration, err = p.loadFileConfigFromDirectory(ctx, filepath.Join(directory, item.Name()), configuration)
configuration, err = p.loadFileConfigFromDirectory(logger.WithContext(ctx), filepath.Join(directory, item.Name()), configuration)
if err != nil {
return configuration, fmt.Errorf("unable to load content configuration from subdirectory %s: %w", item, err)
}
@ -330,14 +331,14 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
}
var c *dynamic.Configuration
c, err = p.loadFileConfig(ctx, filepath.Join(directory, item.Name()), true)
c, err = p.loadFileConfig(logger.WithContext(ctx), filepath.Join(directory, item.Name()), true)
if err != nil {
return configuration, fmt.Errorf("%s: %w", filepath.Join(directory, item.Name()), err)
}
for name, conf := range c.HTTP.Routers {
if _, exists := configuration.HTTP.Routers[name]; exists {
logger.WithField(log.RouterName, name).Warn("HTTP router already configured, skipping")
logger.Warn().Str(logs.RouterName, name).Msg("HTTP router already configured, skipping")
} else {
configuration.HTTP.Routers[name] = conf
}
@ -345,7 +346,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.HTTP.Middlewares {
if _, exists := configuration.HTTP.Middlewares[name]; exists {
logger.WithField(log.MiddlewareName, name).Warn("HTTP middleware already configured, skipping")
logger.Warn().Str(logs.MiddlewareName, name).Msg("HTTP middleware already configured, skipping")
} else {
configuration.HTTP.Middlewares[name] = conf
}
@ -353,7 +354,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.HTTP.Services {
if _, exists := configuration.HTTP.Services[name]; exists {
logger.WithField(log.ServiceName, name).Warn("HTTP service already configured, skipping")
logger.Warn().Str(logs.ServiceName, name).Msg("HTTP service already configured, skipping")
} else {
configuration.HTTP.Services[name] = conf
}
@ -361,7 +362,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.HTTP.ServersTransports {
if _, exists := configuration.HTTP.ServersTransports[name]; exists {
logger.WithField(log.ServersTransportName, name).Warn("HTTP servers transport already configured, skipping")
logger.Warn().Str(logs.ServersTransportName, name).Msg("HTTP servers transport already configured, skipping")
} else {
configuration.HTTP.ServersTransports[name] = conf
}
@ -369,7 +370,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.TCP.Routers {
if _, exists := configuration.TCP.Routers[name]; exists {
logger.WithField(log.RouterName, name).Warn("TCP router already configured, skipping")
logger.Warn().Str(logs.RouterName, name).Msg("TCP router already configured, skipping")
} else {
configuration.TCP.Routers[name] = conf
}
@ -377,7 +378,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.TCP.Middlewares {
if _, exists := configuration.TCP.Middlewares[name]; exists {
logger.WithField(log.MiddlewareName, name).Warn("TCP middleware already configured, skipping")
logger.Warn().Str(logs.MiddlewareName, name).Msg("TCP middleware already configured, skipping")
} else {
configuration.TCP.Middlewares[name] = conf
}
@ -385,7 +386,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.TCP.Services {
if _, exists := configuration.TCP.Services[name]; exists {
logger.WithField(log.ServiceName, name).Warn("TCP service already configured, skipping")
logger.Warn().Str(logs.ServiceName, name).Msg("TCP service already configured, skipping")
} else {
configuration.TCP.Services[name] = conf
}
@ -393,7 +394,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.UDP.Routers {
if _, exists := configuration.UDP.Routers[name]; exists {
logger.WithField(log.RouterName, name).Warn("UDP router already configured, skipping")
logger.Warn().Str(logs.RouterName, name).Msg("UDP router already configured, skipping")
} else {
configuration.UDP.Routers[name] = conf
}
@ -401,7 +402,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.UDP.Services {
if _, exists := configuration.UDP.Services[name]; exists {
logger.WithField(log.ServiceName, name).Warn("UDP service already configured, skipping")
logger.Warn().Str(logs.ServiceName, name).Msg("UDP service already configured, skipping")
} else {
configuration.UDP.Services[name] = conf
}
@ -409,7 +410,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for _, conf := range c.TLS.Certificates {
if _, exists := configTLSMaps[conf]; exists {
logger.Warnf("TLS configuration %v already configured, skipping", conf)
logger.Warn().Msgf("TLS configuration %v already configured, skipping", conf)
} else {
configTLSMaps[conf] = struct{}{}
}
@ -417,7 +418,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.TLS.Options {
if _, exists := configuration.TLS.Options[name]; exists {
logger.Warnf("TLS options %v already configured, skipping", name)
logger.Warn().Msgf("TLS options %v already configured, skipping", name)
} else {
if configuration.TLS.Options == nil {
configuration.TLS.Options = map[string]tls.Options{}
@ -428,7 +429,7 @@ func (p *Provider) loadFileConfigFromDirectory(ctx context.Context, directory st
for name, conf := range c.TLS.Stores {
if _, exists := configuration.TLS.Stores[name]; exists {
logger.Warnf("TLS store %v already configured, skipping", name)
logger.Warn().Msgf("TLS store %v already configured, skipping", name)
} else {
if configuration.TLS.Stores == nil {
configuration.TLS.Stores = map[string]tls.Store{}
@ -478,9 +479,9 @@ func (p *Provider) CreateConfiguration(ctx context.Context, filename string, fun
renderedTemplate := buffer.String()
if p.DebugLogGeneratedTemplate {
logger := log.FromContext(ctx)
logger.Debugf("Template content: %s", tmplContent)
logger.Debugf("Rendering results: %s", renderedTemplate)
logger := log.Ctx(ctx)
logger.Debug().Msgf("Template content: %s", tmplContent)
logger.Debug().Msgf("Rendering results: %s", renderedTemplate)
}
return p.decodeConfiguration(filename, renderedTemplate)

11
pkg/provider/http/http.go
View file

@ -9,11 +9,12 @@ import (
"time"
"github.com/cenkalti/backoff/v4"
"github.com/rs/zerolog/log"
"github.com/traefik/paerser/file"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/tls"
@ -71,8 +72,8 @@ func (p *Provider) Init() error {
// Provide allows the provider to provide configurations to traefik using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, "http"))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, "http").Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
if err := p.updateConfiguration(configurationChan); err != nil {
@ -96,11 +97,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxLog), notify)
if err != nil {
logger.Errorf("Cannot connect to server endpoint %+v", err)
logger.Error().Err(err).Msg("Cannot connect to server endpoint")
}
})

10
pkg/provider/hub/handler.go
View file

@ -9,8 +9,8 @@ import (
"net/url"
"sync/atomic"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/log"
)
type handler struct {
@ -59,7 +59,7 @@ func (h *handler) handleConfig(rw http.ResponseWriter, req *http.Request) {
payload := &configRequest{Configuration: emptyDynamicConfiguration()}
if err := json.NewDecoder(req.Body).Decode(payload); err != nil {
err = fmt.Errorf("decoding config request: %w", err)
log.WithoutContext().Errorf("Handling config: %v", err)
log.Error().Err(err).Msg("Handling config")
http.Error(rw, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
@ -88,14 +88,14 @@ func (h *handler) handleDiscoverIP(rw http.ResponseWriter, req *http.Request) {
if err := h.doDiscoveryReq(req.Context(), xff, port, nonce); err != nil {
err = fmt.Errorf("doing discovery request: %w", err)
log.WithoutContext().Errorf("Handling IP discovery: %v", err)
log.Error().Err(err).Msg("Handling IP discovery")
http.Error(rw, http.StatusText(http.StatusBadGateway), http.StatusBadGateway)
return
}
if err := json.NewEncoder(rw).Encode(xff); err != nil {
err = fmt.Errorf("encoding discover ip response: %w", err)
log.WithoutContext().Errorf("Handling IP discovery: %v", err)
log.Error().Err(err).Msg("Handling IP discovery")
http.Error(rw, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
@ -136,7 +136,7 @@ func (h *handler) handleState(rw http.ResponseWriter, req *http.Request) {
}
if err := json.NewEncoder(rw).Encode(resp); err != nil {
err = fmt.Errorf("encoding last config received response: %w", err)
log.WithoutContext().Errorf("Handling state: %v", err)
log.Error().Err(err).Msg("Handling state")
http.Error(rw, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}

5
pkg/provider/hub/hub.go
View file

@ -8,8 +8,9 @@ import (
"net"
"net/http"
"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/provider"
"github.com/traefik/traefik/v2/pkg/safe"
ttls "github.com/traefik/traefik/v2/pkg/tls"
@ -67,7 +68,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, _ *safe.Poo
// if/when Provide lifecycle differs with Traefik lifecycle.
go func() {
if err = p.server.Serve(listener); err != nil {
log.WithoutContext().WithField(log.ProviderName, "hub").Errorf("Unexpected error while running server: %v", err)
log.Error().Str(logs.ProviderName, "hub").Err(err).Msg("Unexpected error while running server")
return
}
}()

22
pkg/provider/kubernetes/crd/client.go
View file

@ -8,7 +8,7 @@ import (
"runtime"
"time"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/generated/clientset/versioned"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/generated/informers/externalversions"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/traefik/v1alpha1"
@ -220,7 +220,7 @@ func (c *clientWrapper) GetIngressRoutes() []*v1alpha1.IngressRoute {
for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRoutes().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list ingress routes in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list ingress routes in namespace %s", ns)
}
result = append(result, ings...)
}
@ -234,7 +234,7 @@ func (c *clientWrapper) GetIngressRouteTCPs() []*v1alpha1.IngressRouteTCP {
for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRouteTCPs().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list tcp ingress routes in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list tcp ingress routes in namespace %s", ns)
}
result = append(result, ings...)
}
@ -248,7 +248,7 @@ func (c *clientWrapper) GetIngressRouteUDPs() []*v1alpha1.IngressRouteUDP {
for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRouteUDPs().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list udp ingress routes in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list udp ingress routes in namespace %s", ns)
}
result = append(result, ings...)
}
@ -262,7 +262,7 @@ func (c *clientWrapper) GetMiddlewares() []*v1alpha1.Middleware {
for ns, factory := range c.factoriesCrd {
middlewares, err := factory.Traefik().V1alpha1().Middlewares().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list middlewares in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list middlewares in namespace %s", ns)
}
result = append(result, middlewares...)
}
@ -276,7 +276,7 @@ func (c *clientWrapper) GetMiddlewareTCPs() []*v1alpha1.MiddlewareTCP {
for ns, factory := range c.factoriesCrd {
middlewares, err := factory.Traefik().V1alpha1().MiddlewareTCPs().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list TCP middlewares in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list TCP middlewares in namespace %s", ns)
}
result = append(result, middlewares...)
}
@ -302,7 +302,7 @@ func (c *clientWrapper) GetTraefikServices() []*v1alpha1.TraefikService {
for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().TraefikServices().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list Traefik services in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list Traefik services in namespace %s", ns)
}
result = append(result, ings...)
}
@ -310,14 +310,14 @@ func (c *clientWrapper) GetTraefikServices() []*v1alpha1.TraefikService {
return result
}
// GetServersTransport returns all ServersTransport.
// GetServersTransports returns all ServersTransport.
func (c *clientWrapper) GetServersTransports() []*v1alpha1.ServersTransport {
var result []*v1alpha1.ServersTransport
for ns, factory := range c.factoriesCrd {
serversTransports, err := factory.Traefik().V1alpha1().ServersTransports().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list servers transport in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list servers transport in namespace %s", ns)
}
result = append(result, serversTransports...)
}
@ -332,7 +332,7 @@ func (c *clientWrapper) GetTLSOptions() []*v1alpha1.TLSOption {
for ns, factory := range c.factoriesCrd {
options, err := factory.Traefik().V1alpha1().TLSOptions().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list tls options in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list tls options in namespace %s", ns)
}
result = append(result, options...)
}
@ -347,7 +347,7 @@ func (c *clientWrapper) GetTLSStores() []*v1alpha1.TLSStore {
for ns, factory := range c.factoriesCrd {
stores, err := factory.Traefik().V1alpha1().TLSStores().Lister().List(labels.Everything())
if err != nil {
log.Errorf("Failed to list tls stores in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list tls stores in namespace %s", ns)
}
result = append(result, stores...)
}

99
pkg/provider/kubernetes/crd/kubernetes.go
View file

@ -17,10 +17,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/mitchellh/hashstructure"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/traefik/v1alpha1"
"github.com/traefik/traefik/v2/pkg/safe"
@ -62,7 +63,7 @@ func (p *Provider) newK8sClient(ctx context.Context) (*clientWrapper, error) {
if err != nil {
return nil, fmt.Errorf("invalid label selector: %q", p.LabelSelector)
}
log.FromContext(ctx).Infof("label selector is: %q", p.LabelSelector)
log.Ctx(ctx).Info().Msgf("label selector is: %q", p.LabelSelector)
withEndpoint := ""
if p.Endpoint != "" {
@ -72,13 +73,13 @@ func (p *Provider) newK8sClient(ctx context.Context) (*clientWrapper, error) {
var client *clientWrapper
switch {
case os.Getenv("KUBERNETES_SERVICE_HOST") != "" && os.Getenv("KUBERNETES_SERVICE_PORT") != "":
log.FromContext(ctx).Infof("Creating in-cluster Provider client%s", withEndpoint)
log.Ctx(ctx).Info().Msgf("Creating in-cluster Provider client%s", withEndpoint)
client, err = newInClusterClient(p.Endpoint)
case os.Getenv("KUBECONFIG") != "":
log.FromContext(ctx).Infof("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
log.Ctx(ctx).Info().Msgf("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
client, err = newExternalClusterClientFromFile(os.Getenv("KUBECONFIG"))
default:
log.FromContext(ctx).Infof("Creating cluster-external Provider client%s", withEndpoint)
log.Ctx(ctx).Info().Msgf("Creating cluster-external Provider client%s", withEndpoint)
client, err = newExternalClusterClient(p.Endpoint, p.Token, p.CertAuthFilePath)
}
@ -98,8 +99,8 @@ func (p *Provider) Init() error {
// Provide allows the k8s provider to provide configurations to traefik
// using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctxLog := log.With(context.Background(), log.Str(log.ProviderName, providerName))
logger := log.FromContext(ctxLog)
logger := log.With().Str(logs.ProviderName, providerName).Logger()
ctxLog := logger.WithContext(context.Background())
k8sClient, err := p.newK8sClient(ctxLog)
if err != nil {
@ -107,18 +108,18 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
if p.AllowCrossNamespace {
logger.Warn("Cross-namespace reference between IngressRoutes and resources is enabled, please ensure that this is expected (see AllowCrossNamespace option)")
logger.Warn().Msg("Cross-namespace reference between IngressRoutes and resources is enabled, please ensure that this is expected (see AllowCrossNamespace option)")
}
if p.AllowExternalNameServices {
logger.Warn("ExternalName service loading is enabled, please ensure that this is expected (see AllowExternalNameServices option)")
logger.Warn().Msg("ExternalName service loading is enabled, please ensure that this is expected (see AllowExternalNameServices option)")
}
pool.GoCtx(func(ctxPool context.Context) {
operation := func() error {
eventsChan, err := k8sClient.WatchAll(p.Namespaces, ctxPool.Done())
if err != nil {
logger.Errorf("Error watching kubernetes events: %v", err)
logger.Error().Err(err).Msg("Error watching kubernetes events")
timer := time.NewTimer(1 * time.Second)
select {
case <-timer.C:
@ -147,9 +148,9 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
confHash, err := hashstructure.Hash(conf, nil)
switch {
case err != nil:
logger.Error("Unable to hash the configuration")
logger.Error().Err(err).Msg("Unable to hash the configuration")
case p.lastConfiguration.Get() == confHash:
logger.Debugf("Skipping Kubernetes event kind %T", event)
logger.Debug().Msgf("Skipping Kubernetes event kind %T", event)
default:
p.lastConfiguration.Set(confHash)
configurationChan <- dynamic.Message{
@ -167,11 +168,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error: %v; retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxPool), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider: %v", err)
logger.Error().Err(err).Msg("Cannot connect to Provider")
}
})
@ -200,29 +201,30 @@ func (p *Provider) loadConfigurationFromCRD(ctx context.Context, client Client)
for _, middleware := range client.GetMiddlewares() {
id := provider.Normalize(makeID(middleware.Namespace, middleware.Name))
ctxMid := log.With(ctx, log.Str(log.MiddlewareName, id))
logger := log.Ctx(ctx).With().Str(logs.MiddlewareName, id).Logger()
ctxMid := logger.WithContext(ctx)
basicAuth, err := createBasicAuthMiddleware(client, middleware.Namespace, middleware.Spec.BasicAuth)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading basic auth middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading basic auth middleware")
continue
}
digestAuth, err := createDigestAuthMiddleware(client, middleware.Namespace, middleware.Spec.DigestAuth)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading digest auth middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading digest auth middleware")
continue
}
forwardAuth, err := createForwardAuthMiddleware(client, middleware.Namespace, middleware.Spec.ForwardAuth)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading forward auth middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading forward auth middleware")
continue
}
errorPage, errorPageService, err := p.createErrorPageMiddleware(client, middleware.Namespace, middleware.Spec.Errors)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading error page middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading error page middleware")
continue
}
@ -234,25 +236,25 @@ func (p *Provider) loadConfigurationFromCRD(ctx context.Context, client Client)
plugin, err := createPluginMiddleware(client, middleware.Namespace, middleware.Spec.Plugin)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading plugins middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading plugins middleware")
continue
}
rateLimit, err := createRateLimitMiddleware(middleware.Spec.RateLimit)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading rateLimit middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading rateLimit middleware")
continue
}
retry, err := createRetryMiddleware(middleware.Spec.Retry)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading retry middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading retry middleware")
continue
}
circuitBreaker, err := createCircuitBreakerMiddleware(middleware.Spec.CircuitBreaker)
if err != nil {
log.FromContext(ctxMid).Errorf("Error while reading circuit breaker middleware: %v", err)
logger.Error().Err(err).Msg("Error while reading circuit breaker middleware")
continue
}
@ -298,20 +300,20 @@ func (p *Provider) loadConfigurationFromCRD(ctx context.Context, client Client)
for _, service := range client.GetTraefikServices() {
err := cb.buildTraefikService(ctx, service, conf.HTTP.Services)
if err != nil {
log.FromContext(ctx).WithField(log.ServiceName, service.Name).
Errorf("Error while building TraefikService: %v", err)
log.Ctx(ctx).Error().Str(logs.ServiceName, service.Name).Err(err).
Msg("Error while building TraefikService")
continue
}
}
for _, serversTransport := range client.GetServersTransports() {
logger := log.FromContext(ctx).WithField(log.ServersTransportName, serversTransport.Name)
logger := log.Ctx(ctx).With().Str(logs.ServersTransportName, serversTransport.Name).Logger()
var rootCAs []tls.FileOrContent
for _, secret := range serversTransport.Spec.RootCAsSecrets {
caSecret, err := loadCASecret(serversTransport.Namespace, secret, client)
if err != nil {
logger.Errorf("Error while loading rootCAs %s: %v", secret, err)
logger.Error().Err(err).Msgf("Error while loading rootCAs %s", secret)
continue
}
@ -322,7 +324,7 @@ func (p *Provider) loadConfigurationFromCRD(ctx context.Context, client Client)
for _, secret := range serversTransport.Spec.CertificatesSecrets {
tlsSecret, tlsKey, err := loadAuthTLSSecret(serversTransport.Namespace, secret, client)
if err != nil {
logger.Errorf("Error while loading certificates %s: %v", secret, err)
logger.Error().Err(err).Msgf("Error while loading certificates %s", secret)
continue
}
@ -339,35 +341,35 @@ func (p *Provider) loadConfigurationFromCRD(ctx context.Context, client Client)
if serversTransport.Spec.ForwardingTimeouts.DialTimeout != nil {
err := forwardingTimeout.DialTimeout.Set(serversTransport.Spec.ForwardingTimeouts.DialTimeout.String())
if err != nil {
logger.Errorf("Error while reading DialTimeout: %v", err)
logger.Error().Err(err).Msg("Error while reading DialTimeout")
}
}
if serversTransport.Spec.ForwardingTimeouts.ResponseHeaderTimeout != nil {
err := forwardingTimeout.ResponseHeaderTimeout.Set(serversTransport.Spec.ForwardingTimeouts.ResponseHeaderTimeout.String())
if err != nil {
logger.Errorf("Error while reading ResponseHeaderTimeout: %v", err)
logger.Error().Err(err).Msg("Error while reading ResponseHeaderTimeout")
}
}
if serversTransport.Spec.ForwardingTimeouts.IdleConnTimeout != nil {
err := forwardingTimeout.IdleConnTimeout.Set(serversTransport.Spec.ForwardingTimeouts.IdleConnTimeout.String())
if err != nil {
logger.Errorf("Error while reading IdleConnTimeout: %v", err)
logger.Error().Err(err).Msg("Error while reading IdleConnTimeout")
}
}
if serversTransport.Spec.ForwardingTimeouts.ReadIdleTimeout != nil {
err := forwardingTimeout.ReadIdleTimeout.Set(serversTransport.Spec.ForwardingTimeouts.ReadIdleTimeout.String())
if err != nil {
logger.Errorf("Error while reading ReadIdleTimeout: %v", err)
logger.Error().Err(err).Msg("Error while reading ReadIdleTimeout")
}
}
if serversTransport.Spec.ForwardingTimeouts.PingTimeout != nil {
err := forwardingTimeout.PingTimeout.Set(serversTransport.Spec.ForwardingTimeouts.PingTimeout.String())
if err != nil {
logger.Errorf("Error while reading PingTimeout: %v", err)
logger.Error().Err(err).Msg("Error while reading PingTimeout")
}
}
}
@ -414,8 +416,8 @@ func getServicePort(svc *corev1.Service, port intstr.IntOrString) (*corev1.Servi
}
if hasValidPort {
log.WithoutContext().
Warnf("The port %s from IngressRoute doesn't match with ports defined in the ExternalName service %s/%s.", port, svc.Namespace, svc.Name)
log.Warn().Msgf("The port %s from IngressRoute doesn't match with ports defined in the ExternalName service %s/%s.",
&port, svc.Namespace, svc.Name)
}
return &corev1.ServicePort{Port: port.IntVal}, nil
@ -811,8 +813,7 @@ func createChainMiddleware(ctx context.Context, namespace string, chain *v1alpha
for _, mi := range chain.Middlewares {
if strings.Contains(mi.Name, providerNamespaceSeparator) {
if len(mi.Namespace) > 0 {
log.FromContext(ctx).
Warnf("namespace %q is ignored in cross-provider context", mi.Namespace)
log.Ctx(ctx).Warn().Msgf("namespace %q is ignored in cross-provider context", mi.Namespace)
}
mds = append(mds, mi.Name)
continue
@ -838,24 +839,24 @@ func buildTLSOptions(ctx context.Context, client Client) map[string]tls.Options
var nsDefault []string
for _, tlsOption := range tlsOptionsCRD {
logger := log.FromContext(log.With(ctx, log.Str("tlsOption", tlsOption.Name), log.Str("namespace", tlsOption.Namespace)))
logger := log.Ctx(ctx).With().Str("tlsOption", tlsOption.Name).Str("namespace", tlsOption.Namespace).Logger()
var clientCAs []tls.FileOrContent
for _, secretName := range tlsOption.Spec.ClientAuth.SecretNames {
secret, exists, err := client.GetSecret(tlsOption.Namespace, secretName)
if err != nil {
logger.Errorf("Failed to fetch secret %s/%s: %v", tlsOption.Namespace, secretName, err)
logger.Error().Err(err).Msgf("Failed to fetch secret %s/%s", tlsOption.Namespace, secretName)
continue
}
if !exists {
logger.Warnf("Secret %s/%s does not exist", tlsOption.Namespace, secretName)
logger.Warn().Msgf("Secret %s/%s does not exist", tlsOption.Namespace, secretName)
continue
}
cert, err := getCABlocks(secret, tlsOption.Namespace, secretName)
if err != nil {
logger.Errorf("Failed to extract CA from secret %s/%s: %v", tlsOption.Namespace, secretName, err)
logger.Error().Err(err).Msgf("Failed to extract CA from secret %s/%s", tlsOption.Namespace, secretName)
continue
}
@ -890,7 +891,7 @@ func buildTLSOptions(ctx context.Context, client Client) map[string]tls.Options
if len(nsDefault) > 1 {
delete(tlsOptions, tls.DefaultTLSConfigName)
log.FromContext(ctx).Errorf("Default TLS Options defined in multiple namespaces: %v", nsDefault)
log.Ctx(ctx).Error().Msgf("Default TLS Options defined in multiple namespaces: %v", nsDefault)
}
return tlsOptions
@ -907,7 +908,7 @@ func buildTLSStores(ctx context.Context, client Client) (map[string]tls.Store, m
tlsConfigs := make(map[string]*tls.CertAndStores)
for _, t := range tlsStoreCRD {
logger := log.FromContext(log.With(ctx, log.Str("TLSStore", t.Name), log.Str("namespace", t.Namespace)))
logger := log.Ctx(ctx).With().Str("TLSStore", t.Name).Str("namespace", t.Namespace).Logger()
id := makeID(t.Namespace, t.Name)
@ -924,17 +925,17 @@ func buildTLSStores(ctx context.Context, client Client) (map[string]tls.Store, m
secret, exists, err := client.GetSecret(t.Namespace, secretName)
if err != nil {
logger.Errorf("Failed to fetch secret %s/%s: %v", t.Namespace, secretName, err)
logger.Error().Err(err).Msgf("Failed to fetch secret %s/%s", t.Namespace, secretName)
continue
}
if !exists {
logger.Errorf("Secret %s/%s does not exist", t.Namespace, secretName)
logger.Error().Msgf("Secret %s/%s does not exist", t.Namespace, secretName)
continue
}
cert, key, err := getCertificateBlocks(secret, t.Namespace, secretName)
if err != nil {
logger.Errorf("Could not get certificate blocks: %v", err)
logger.Error().Err(err).Msg("Could not get certificate blocks")
continue
}
@ -952,7 +953,7 @@ func buildTLSStores(ctx context.Context, client Client) (map[string]tls.Store, m
}
if err := buildCertificates(client, id, t.Namespace, t.Spec.Certificates, tlsConfigs); err != nil {
logger.Errorf("Failed to load certificates: %v", err)
logger.Error().Err(err).Msg("Failed to load certificates")
continue
}
@ -961,7 +962,7 @@ func buildTLSStores(ctx context.Context, client Client) (map[string]tls.Store, m
if len(nsDefault) > 1 {
delete(tlsStores, tls.DefaultTLSStoreName)
log.FromContext(ctx).Errorf("Default TLS Stores defined in multiple namespaces: %v", nsDefault)
log.Ctx(ctx).Error().Msgf("Default TLS Stores defined in multiple namespaces: %v", nsDefault)
}
return tlsStores, tlsConfigs
@ -1117,7 +1118,7 @@ func throttleEvents(ctx context.Context, throttleDuration time.Duration, pool *s
default:
// We already have an event in eventsChanBuffered, so we'll do a refresh as soon as our throttle allows us to.
// It's fine to drop the event and keep whatever's in the buffer -- we don't do different things for different events
log.FromContext(ctx).Debugf("Dropping event kind %T due to throttling", nextEvent)
log.Ctx(ctx).Debug().Msgf("Dropping event kind %T due to throttling", nextEvent)
}
}
}

38
pkg/provider/kubernetes/crd/kubernetes_http.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"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/traefik/v1alpha1"
"github.com/traefik/traefik/v2/pkg/tls"
@ -32,8 +33,7 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
}
for _, ingressRoute := range client.GetIngressRoutes() {
ctxRt := log.With(ctx, log.Str("ingress", ingressRoute.Name), log.Str("namespace", ingressRoute.Namespace))
logger := log.FromContext(ctxRt)
logger := log.Ctx(ctx).With().Str("ingress", ingressRoute.Name).Str("namespace", ingressRoute.Namespace).Logger()
// TODO keep the name ingressClass?
if !shouldProcessIngress(p.IngressClass, ingressRoute.Annotations[annotationKubernetesIngressClass]) {
@ -42,7 +42,7 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
err := getTLSHTTP(ctx, ingressRoute, client, tlsConfigs)
if err != nil {
logger.Errorf("Error configuring TLS: %v", err)
logger.Error().Err(err).Msg("Error configuring TLS")
}
ingressName := ingressRoute.Name
@ -59,24 +59,24 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
for _, route := range ingressRoute.Spec.Routes {
if route.Kind != "Rule" {
logger.Errorf("Unsupported match kind: %s. Only \"Rule\" is supported for now.", route.Kind)
logger.Error().Msgf("Unsupported match kind: %s. Only \"Rule\" is supported for now.", route.Kind)
continue
}
if len(route.Match) == 0 {
logger.Errorf("Empty match rule")
logger.Error().Msg("Empty match rule")
continue
}
serviceKey, err := makeServiceKey(route.Match, ingressName)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
mds, err := p.makeMiddlewareKeys(ctx, ingressRoute.Namespace, route.Middlewares)
if err != nil {
logger.Errorf("Failed to create middleware keys: %v", err)
logger.Error().Err(err).Msg("Failed to create middleware keys")
continue
}
@ -92,13 +92,13 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
errBuild := cb.buildServicesLB(ctx, ingressRoute.Namespace, spec, serviceName, conf.Services)
if errBuild != nil {
logger.Error(errBuild)
logger.Error().Err(errBuild).Send()
continue
}
} else if len(route.Services) == 1 {
fullName, serversLB, err := cb.nameAndService(ctx, ingressRoute.Namespace, route.Services[0].LoadBalancerSpec)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -134,12 +134,12 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
tlsOptionsName = makeID(ns, tlsOptionsName)
} else if len(ns) > 0 {
logger.
WithField("TLSOption", ingressRoute.Spec.TLS.Options.Name).
Warnf("Namespace %q is ignored in cross-provider context", ns)
Warn().Str("TLSOption", ingressRoute.Spec.TLS.Options.Name).
Msgf("Namespace %q is ignored in cross-provider context", ns)
}
if !isNamespaceAllowed(p.AllowCrossNamespace, ingressRoute.Namespace, ns) {
logger.Errorf("TLSOption %s/%s is not in the IngressRoute namespace %s",
logger.Error().Msgf("TLSOption %s/%s is not in the IngressRoute namespace %s",
ns, ingressRoute.Spec.TLS.Options.Name, ingressRoute.Namespace)
continue
}
@ -170,9 +170,9 @@ func (p *Provider) makeMiddlewareKeys(ctx context.Context, ingRouteNamespace str
if strings.Contains(name, providerNamespaceSeparator) {
if len(mi.Namespace) > 0 {
log.FromContext(ctx).
WithField(log.MiddlewareName, mi.Name).
Warnf("namespace %q is ignored in cross-provider context", mi.Namespace)
log.Ctx(ctx).
Warn().Str(logs.MiddlewareName, mi.Name).
Msgf("namespace %q is ignored in cross-provider context", mi.Namespace)
}
mds = append(mds, name)
@ -439,7 +439,7 @@ func (c configBuilder) loadServers(parentNamespace string, svc v1alpha1.LoadBala
// it generates and returns the configuration part for such a service,
// so that the caller can add it to the global config map.
func (c configBuilder) nameAndService(ctx context.Context, parentNamespace string, service v1alpha1.LoadBalancerSpec) (string, *dynamic.Service, error) {
svcCtx := log.With(ctx, log.Str(log.ServiceName, service.Name))
svcCtx := log.Ctx(ctx).With().Str(logs.ServiceName, service.Name).Logger().WithContext(ctx)
namespace := namespaceOrFallback(service, parentNamespace)
@ -488,7 +488,7 @@ func fullServiceName(ctx context.Context, namespace string, service v1alpha1.Loa
}
if service.Namespace != "" {
log.FromContext(ctx).Warnf("namespace %q is ignored in cross-provider context", service.Namespace)
log.Ctx(ctx).Warn().Msgf("namespace %q is ignored in cross-provider context", service.Namespace)
}
return provider.Normalize(name) + providerNamespaceSeparator + pName
@ -507,7 +507,7 @@ func getTLSHTTP(ctx context.Context, ingressRoute *v1alpha1.IngressRoute, k8sCli
return nil
}
if ingressRoute.Spec.TLS.SecretName == "" {
log.FromContext(ctx).Debugf("No secret name provided")
log.Ctx(ctx).Debug().Msg("No secret name provided")
return nil
}

38
pkg/provider/kubernetes/crd/kubernetes_tcp.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"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/traefik/v1alpha1"
"github.com/traefik/traefik/v2/pkg/tls"
@ -24,7 +25,7 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
}
for _, ingressRouteTCP := range client.GetIngressRouteTCPs() {
logger := log.FromContext(log.With(ctx, log.Str("ingress", ingressRouteTCP.Name), log.Str("namespace", ingressRouteTCP.Namespace)))
logger := log.Ctx(ctx).With().Str("ingress", ingressRouteTCP.Name).Str("namespace", ingressRouteTCP.Namespace).Logger()
if !shouldProcessIngress(p.IngressClass, ingressRouteTCP.Annotations[annotationKubernetesIngressClass]) {
continue
@ -33,7 +34,7 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
if ingressRouteTCP.Spec.TLS != nil && !ingressRouteTCP.Spec.TLS.Passthrough {
err := getTLSTCP(ctx, ingressRouteTCP, client, tlsConfigs)
if err != nil {
logger.Errorf("Error configuring TLS: %v", err)
logger.Error().Err(err).Msg("Error configuring TLS")
}
}
@ -44,19 +45,19 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
for _, route := range ingressRouteTCP.Spec.Routes {
if len(route.Match) == 0 {
logger.Errorf("Empty match rule")
logger.Error().Msg("Empty match rule")
continue
}
key, err := makeServiceKey(route.Match, ingressName)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
mds, err := p.makeMiddlewareTCPKeys(ctx, ingressRouteTCP.Namespace, route.Middlewares)
if err != nil {
logger.Errorf("Failed to create middleware keys: %v", err)
logger.Error().Err(err).Msg("Failed to create middleware keys")
continue
}
@ -65,10 +66,11 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
for _, service := range route.Services {
balancerServerTCP, err := p.createLoadBalancerServerTCP(client, ingressRouteTCP.Namespace, service)
if err != nil {
logger.
WithField("serviceName", service.Name).
WithField("servicePort", service.Port).
Errorf("Cannot create service: %v", err)
logger.Error().
Str("serviceName", service.Name).
Stringer("servicePort", &service.Port).
Err(err).
Msg("Cannot create service")
continue
}
@ -119,13 +121,13 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
}
tlsOptionsName = makeID(ns, tlsOptionsName)
} else if len(ns) > 0 {
logger.
WithField("TLSOption", ingressRouteTCP.Spec.TLS.Options.Name).
Warnf("Namespace %q is ignored in cross-provider context", ns)
logger.Warn().
Str("TLSOption", ingressRouteTCP.Spec.TLS.Options.Name).
Msgf("Namespace %q is ignored in cross-provider context", ns)
}
if !isNamespaceAllowed(p.AllowCrossNamespace, ingressRouteTCP.Namespace, ns) {
logger.Errorf("TLSOption %s/%s is not in the IngressRouteTCP namespace %s",
logger.Error().Msgf("TLSOption %s/%s is not in the IngressRouteTCP namespace %s",
ns, ingressRouteTCP.Spec.TLS.Options.Name, ingressRouteTCP.Namespace)
continue
}
@ -147,9 +149,9 @@ func (p *Provider) makeMiddlewareTCPKeys(ctx context.Context, ingRouteTCPNamespa
for _, mi := range middlewares {
if strings.Contains(mi.Name, providerNamespaceSeparator) {
if len(mi.Namespace) > 0 {
log.FromContext(ctx).
WithField(log.MiddlewareName, mi.Name).
Warnf("namespace %q is ignored in cross-provider context", mi.Namespace)
log.Ctx(ctx).Warn().
Str(logs.MiddlewareName, mi.Name).
Msgf("Namespace %q is ignored in cross-provider context", mi.Namespace)
}
mds = append(mds, mi.Name)
continue
@ -275,7 +277,7 @@ func getTLSTCP(ctx context.Context, ingressRoute *v1alpha1.IngressRouteTCP, k8sC
return nil
}
if ingressRoute.Spec.TLS.SecretName == "" {
log.FromContext(ctx).Debugf("No secret name provided")
log.Ctx(ctx).Debug().Msg("No secret name provided")
return nil
}

13
pkg/provider/kubernetes/crd/kubernetes_udp.go
View file

@ -7,8 +7,8 @@ import (
"net"
"strconv"
"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/provider/kubernetes/crd/traefik/v1alpha1"
corev1 "k8s.io/api/core/v1"
)
@ -20,7 +20,7 @@ func (p *Provider) loadIngressRouteUDPConfiguration(ctx context.Context, client
}
for _, ingressRouteUDP := range client.GetIngressRouteUDPs() {
logger := log.FromContext(log.With(ctx, log.Str("ingress", ingressRouteUDP.Name), log.Str("namespace", ingressRouteUDP.Namespace)))
logger := log.Ctx(ctx).With().Str("ingress", ingressRouteUDP.Name).Str("namespace", ingressRouteUDP.Namespace).Logger()
if !shouldProcessIngress(p.IngressClass, ingressRouteUDP.Annotations[annotationKubernetesIngressClass]) {
continue
@ -38,10 +38,11 @@ func (p *Provider) loadIngressRouteUDPConfiguration(ctx context.Context, client
for _, service := range route.Services {
balancerServerUDP, err := p.createLoadBalancerServerUDP(client, ingressRouteUDP.Namespace, service)
if err != nil {
logger.
WithField("serviceName", service.Name).
WithField("servicePort", service.Port).
Errorf("Cannot create service: %v", err)
logger.Error().
Str("serviceName", service.Name).
Stringer("servicePort", &service.Port).
Err(err).
Msg("Cannot create service")
continue
}

18
pkg/provider/kubernetes/gateway/client.go
View file

@ -7,7 +7,7 @@ import (
"os"
"time"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
corev1 "k8s.io/api/core/v1"
kubeerror "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -252,7 +252,7 @@ func (c *clientWrapper) GetNamespaces(selector labels.Selector) ([]string, error
var namespaces []string
for _, namespace := range ns {
if !c.isWatchedNamespace(namespace.Name) {
log.WithoutContext().Warnf("Namespace %q is not within watched namespaces", selector, namespace)
log.Warn().Msgf("Namespace %q is not within %q watched namespaces", selector, namespace)
continue
}
namespaces = append(namespaces, namespace.Name)
@ -264,7 +264,7 @@ func (c *clientWrapper) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRout
var httpRoutes []*v1alpha2.HTTPRoute
for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) {
log.WithoutContext().Warnf("Failed to get HTTPRoutes: %q is not within watched namespaces", namespace)
log.Warn().Msgf("Failed to get HTTPRoutes: %q is not within watched namespaces", namespace)
continue
}
@ -274,7 +274,7 @@ func (c *clientWrapper) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRout
}
if len(routes) == 0 {
log.WithoutContext().Debugf("No HTTPRoutes found in namespace %q", namespace)
log.Debug().Msgf("No HTTPRoutes found in namespace %q", namespace)
continue
}
@ -288,7 +288,7 @@ func (c *clientWrapper) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute,
var tcpRoutes []*v1alpha2.TCPRoute
for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) {
log.WithoutContext().Warnf("Failed to get TCPRoutes: %q is not within watched namespaces", namespace)
log.Warn().Msgf("Failed to get TCPRoutes: %q is not within watched namespaces", namespace)
continue
}
@ -298,7 +298,7 @@ func (c *clientWrapper) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute,
}
if len(routes) == 0 {
log.WithoutContext().Debugf("No TCPRoutes found in namespace %q", namespace)
log.Debug().Msgf("No TCPRoutes found in namespace %q", namespace)
continue
}
@ -311,7 +311,7 @@ func (c *clientWrapper) GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute,
var tlsRoutes []*v1alpha2.TLSRoute
for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) {
log.WithoutContext().Warnf("Failed to get TLSRoutes: %q is not within watched namespaces", namespace)
log.Warn().Msgf("Failed to get TLSRoutes: %q is not within watched namespaces", namespace)
continue
}
@ -321,7 +321,7 @@ func (c *clientWrapper) GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute,
}
if len(routes) == 0 {
log.WithoutContext().Debugf("No TLSRoutes found in namespace %q", namespace)
log.Debug().Msgf("No TLSRoutes found in namespace %q", namespace)
continue
}
@ -336,7 +336,7 @@ func (c *clientWrapper) GetGateways() []*v1alpha2.Gateway {
for ns, factory := range c.factoriesGateway {
gateways, err := factory.Gateway().V1alpha2().Gateways().Lister().List(labels.Everything())
if err != nil {
log.WithoutContext().Errorf("Failed to list Gateways in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list Gateways in namespace %s", ns)
continue
}
result = append(result, gateways...)

60
pkg/provider/kubernetes/gateway/kubernetes.go
View file

@ -15,10 +15,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/hashicorp/go-multierror"
"github.com/mitchellh/hashstructure"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
traefikv1alpha1 "github.com/traefik/traefik/v2/pkg/provider/kubernetes/crd/traefik/v1alpha1"
"github.com/traefik/traefik/v2/pkg/safe"
@ -67,24 +68,19 @@ func (p *Provider) newK8sClient(ctx context.Context) (*clientWrapper, error) {
return nil, fmt.Errorf("invalid label selector: %q", p.LabelSelector)
}
logger := log.FromContext(ctx)
logger.Infof("label selector is: %q", p.LabelSelector)
withEndpoint := ""
if p.Endpoint != "" {
withEndpoint = fmt.Sprintf(" with endpoint %s", p.Endpoint)
}
logger := log.Ctx(ctx)
logger.Info().Msgf("Label selector is: %q", p.LabelSelector)
var client *clientWrapper
switch {
case os.Getenv("KUBERNETES_SERVICE_HOST") != "" && os.Getenv("KUBERNETES_SERVICE_PORT") != "":
logger.Infof("Creating in-cluster Provider client%s", withEndpoint)
logger.Info().Str("endpoint", p.Endpoint).Msg("Creating in-cluster Provider client")
client, err = newInClusterClient(p.Endpoint)
case os.Getenv("KUBECONFIG") != "":
logger.Infof("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
logger.Info().Msgf("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
client, err = newExternalClusterClientFromFile(os.Getenv("KUBECONFIG"))
default:
logger.Infof("Creating cluster-external Provider client%s", withEndpoint)
logger.Info().Str("endpoint", p.Endpoint).Msg("Creating cluster-external Provider client")
client, err = newExternalClusterClient(p.Endpoint, p.Token, p.CertAuthFilePath)
}
@ -104,8 +100,8 @@ func (p *Provider) Init() error {
// Provide allows the k8s provider to provide configurations to traefik using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctxLog := log.With(context.Background(), log.Str(log.ProviderName, providerName))
logger := log.FromContext(ctxLog)
logger := log.With().Str(logs.ProviderName, providerName).Logger()
ctxLog := logger.WithContext(context.Background())
k8sClient, err := p.newK8sClient(ctxLog)
if err != nil {
@ -116,7 +112,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
operation := func() error {
eventsChan, err := k8sClient.WatchAll(p.Namespaces, ctxPool.Done())
if err != nil {
logger.Errorf("Error watching kubernetes events: %v", err)
logger.Error().Err(err).Msg("Error watching kubernetes events")
timer := time.NewTimer(1 * time.Second)
select {
case <-timer.C:
@ -145,9 +141,9 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
confHash, err := hashstructure.Hash(conf, nil)
switch {
case err != nil:
logger.Error("Unable to hash the configuration")
logger.Error().Msg("Unable to hash the configuration")
case p.lastConfiguration.Get() == confHash:
logger.Debugf("Skipping Kubernetes event kind %T", event)
logger.Debug().Msgf("Skipping Kubernetes event kind %T", event)
default:
p.lastConfiguration.Set(confHash)
configurationChan <- dynamic.Message{
@ -165,11 +161,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error: %v; retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxPool), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider: %v", err)
logger.Error().Err(err).Msg("Cannot connect to Provider")
}
})
@ -178,13 +174,13 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
// TODO Handle errors and update resources statuses (gatewayClass, gateway).
func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Client) *dynamic.Configuration {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
gatewayClassNames := map[string]struct{}{}
gatewayClasses, err := client.GetGatewayClasses()
if err != nil {
logger.Errorf("Cannot find GatewayClasses: %v", err)
logger.Error().Err(err).Msg("Cannot find GatewayClasses")
return &dynamic.Configuration{
UDP: &dynamic.UDPConfiguration{
Routers: map[string]*dynamic.UDPRouter{},
@ -215,7 +211,7 @@ func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Clie
LastTransitionTime: metav1.Now(),
})
if err != nil {
logger.Errorf("Failed to update %s condition: %v", v1alpha2.GatewayClassConditionStatusAccepted, err)
logger.Error().Err(err).Msgf("Failed to update %s condition", v1alpha2.GatewayClassConditionStatusAccepted)
}
}
}
@ -224,8 +220,8 @@ func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Clie
// TODO check if we can only use the default filtering mechanism
for _, gateway := range client.GetGateways() {
ctxLog := log.With(ctx, log.Str("gateway", gateway.Name), log.Str("namespace", gateway.Namespace))
logger := log.FromContext(ctxLog)
logger := log.Ctx(ctx).With().Str("gateway", gateway.Name).Str("namespace", gateway.Namespace).Logger()
ctxLog := logger.WithContext(ctx)
if _, ok := gatewayClassNames[string(gateway.Spec.GatewayClassName)]; !ok {
continue
@ -233,7 +229,7 @@ func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Clie
cfg, err := p.createGatewayConf(ctxLog, client, gateway)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -315,7 +311,7 @@ func (p *Provider) createGatewayConf(ctx context.Context, client Client, gateway
}
func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *v1alpha2.Gateway, conf *dynamic.Configuration, tlsConfigs map[string]*tls.CertAndStores) []v1alpha2.ListenerStatus {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
listenerStatuses := make([]v1alpha2.ListenerStatus, len(gateway.Spec.Listeners))
allocatedListeners := make(map[string]struct{})
@ -407,7 +403,7 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
if isTLSPassthrough && len(listener.TLS.CertificateRefs) > 0 {
// https://gateway-api.sigs.k8s.io/v1alpha2/references/spec/#gateway.networking.k8s.io/v1alpha2.GatewayTLSConfig
logger.Warnf("In case of Passthrough TLS mode, no TLS settings take effect as the TLS session from the client is NOT terminated at the Gateway")
logger.Warn().Msg("In case of Passthrough TLS mode, no TLS settings take effect as the TLS session from the client is NOT terminated at the Gateway")
}
// Allowed configurations:
@ -684,7 +680,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
}
if len(routes) == 0 {
log.FromContext(ctx).Debugf("No HTTPRoutes found")
log.Ctx(ctx).Debug().Msg("No HTTPRoutes found")
return nil
}
@ -825,7 +821,7 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
}
if len(routes) == 0 {
log.FromContext(ctx).Debugf("No TCPRoutes found")
log.Ctx(ctx).Debug().Msg("No TCPRoutes found")
return nil
}
@ -955,7 +951,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
}
if len(routes) == 0 {
log.FromContext(ctx).Debugf("No TLSRoutes found")
log.Ctx(ctx).Debug().Msg("No TLSRoutes found")
return nil
}
@ -1466,7 +1462,7 @@ func loadServices(client Client, namespace string, backendRefs []v1alpha2.HTTPBa
// "DroppedRoutes" reason. The gateway status for this route
// should be updated with a condition that describes the error
// more specifically.
log.WithoutContext().Errorf("A multiple ports Kubernetes Service cannot be used if unspecified backendRef.Port")
log.Error().Msg("A multiple ports Kubernetes Service cannot be used if unspecified backendRef.Port")
continue
}
@ -1587,7 +1583,7 @@ func loadTCPServices(client Client, namespace string, backendRefs []v1alpha2.Bac
// "DroppedRoutes" reason. The gateway status for this route
// should be updated with a condition that describes the error
// more specifically.
log.WithoutContext().Errorf("A multiple ports Kubernetes Service cannot be used if unspecified backendRef.Port")
log.Error().Msg("A multiple ports Kubernetes Service cannot be used if unspecified backendRef.Port")
continue
}
@ -1684,7 +1680,7 @@ func throttleEvents(ctx context.Context, throttleDuration time.Duration, pool *s
default:
// We already have an event in eventsChanBuffered, so we'll do a refresh as soon as our throttle allows us to.
// It's fine to drop the event and keep whatever's in the buffer -- we don't do different things for different events
log.FromContext(ctx).Debugf("Dropping event kind %T due to throttling", nextEvent)
log.Ctx(ctx).Debug().Msgf("Dropping event kind %T due to throttling", nextEvent)
}
}
}

22
pkg/provider/kubernetes/ingress/client.go
View file

@ -10,7 +10,7 @@ import (
"time"
"github.com/hashicorp/go-version"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/provider/kubernetes/k8s"
traefikversion "github.com/traefik/traefik/v2/pkg/version"
corev1 "k8s.io/api/core/v1"
@ -246,7 +246,7 @@ func (c *clientWrapper) GetIngresses() []*networkingv1.Ingress {
// networking
listNew, err := factory.Networking().V1().Ingresses().Lister().List(labels.Everything())
if err != nil {
log.WithoutContext().Errorf("Failed to list ingresses in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list ingresses in namespace %s", ns)
continue
}
@ -257,14 +257,14 @@ func (c *clientWrapper) GetIngresses() []*networkingv1.Ingress {
// networking beta
list, err := factory.Networking().V1beta1().Ingresses().Lister().List(labels.Everything())
if err != nil {
log.WithoutContext().Errorf("Failed to list ingresses in namespace %s: %v", ns, err)
log.Error().Err(err).Msgf("Failed to list ingresses in namespace %s", ns)
continue
}
for _, ing := range list {
n, err := toNetworkingV1(ing)
if err != nil {
log.WithoutContext().Errorf("Failed to convert ingress %s from networking/v1beta1 to networking/v1: %v", ns, err)
log.Error().Err(err).Msgf("Failed to convert ingress %s from networking/v1beta1 to networking/v1", ns)
continue
}
@ -366,10 +366,10 @@ func (c *clientWrapper) UpdateIngressStatus(src *networkingv1.Ingress, ingStatus
return fmt.Errorf("failed to get ingress %s/%s: %w", src.Namespace, src.Name, err)
}
logger := log.WithoutContext().WithField("namespace", ing.Namespace).WithField("ingress", ing.Name)
logger := log.With().Str("namespace", ing.Namespace).Str("ingress", ing.Name).Logger()
if isLoadBalancerIngressEquals(ing.Status.LoadBalancer.Ingress, ingStatus) {
logger.Debug("Skipping ingress status update")
logger.Debug().Msg("Skipping ingress status update")
return nil
}
@ -384,7 +384,7 @@ func (c *clientWrapper) UpdateIngressStatus(src *networkingv1.Ingress, ingStatus
return fmt.Errorf("failed to update ingress status %s/%s: %w", src.Namespace, src.Name, err)
}
logger.Info("Updated ingress status")
logger.Info().Msg("Updated ingress status")
return nil
}
@ -394,10 +394,10 @@ func (c *clientWrapper) updateIngressStatusOld(src *networkingv1.Ingress, ingSta
return fmt.Errorf("failed to get ingress %s/%s: %w", src.Namespace, src.Name, err)
}
logger := log.WithoutContext().WithField("namespace", ing.Namespace).WithField("ingress", ing.Name)
logger := log.With().Str("namespace", ing.Namespace).Str("ingress", ing.Name).Logger()
if isLoadBalancerIngressEquals(ing.Status.LoadBalancer.Ingress, ingStatus) {
logger.Debug("Skipping ingress status update")
logger.Debug().Msg("Skipping ingress status update")
return nil
}
@ -411,7 +411,7 @@ func (c *clientWrapper) updateIngressStatusOld(src *networkingv1.Ingress, ingSta
if err != nil {
return fmt.Errorf("failed to update ingress status %s/%s: %w", src.Namespace, src.Name, err)
}
logger.Info("Updated ingress status")
logger.Info().Msg("Updated ingress status")
return nil
}
@ -484,7 +484,7 @@ func (c *clientWrapper) GetIngressClasses() ([]*networkingv1.IngressClass, error
if ic.Spec.Controller == traefikDefaultIngressClassController {
icN, err := toNetworkingV1IngressClass(ic)
if err != nil {
log.WithoutContext().Errorf("Failed to convert ingress class %s from networking/v1beta1 to networking/v1: %v", ic.Name, err)
log.Error().Err(err).Msgf("Failed to convert ingress class %s from networking/v1beta1 to networking/v1", ic.Name)
continue
}
ics = append(ics, icN)

86
pkg/provider/kubernetes/ingress/kubernetes.go
View file

@ -15,10 +15,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/mitchellh/hashstructure"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/tls"
@ -62,9 +63,9 @@ func (p *Provider) newK8sClient(ctx context.Context) (*clientWrapper, error) {
return nil, fmt.Errorf("invalid ingress label selector: %q", p.LabelSelector)
}
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
logger.Infof("ingress label selector is: %q", p.LabelSelector)
logger.Info().Msgf("ingress label selector is: %q", p.LabelSelector)
withEndpoint := ""
if p.Endpoint != "" {
@ -74,13 +75,13 @@ func (p *Provider) newK8sClient(ctx context.Context) (*clientWrapper, error) {
var cl *clientWrapper
switch {
case os.Getenv("KUBERNETES_SERVICE_HOST") != "" && os.Getenv("KUBERNETES_SERVICE_PORT") != "":
logger.Infof("Creating in-cluster Provider client%s", withEndpoint)
logger.Info().Msgf("Creating in-cluster Provider client%s", withEndpoint)
cl, err = newInClusterClient(p.Endpoint)
case os.Getenv("KUBECONFIG") != "":
logger.Infof("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
logger.Info().Msgf("Creating cluster-external Provider client from KUBECONFIG %s", os.Getenv("KUBECONFIG"))
cl, err = newExternalClusterClientFromFile(os.Getenv("KUBECONFIG"))
default:
logger.Infof("Creating cluster-external Provider client%s", withEndpoint)
logger.Info().Msgf("Creating cluster-external Provider client%s", withEndpoint)
cl, err = newExternalClusterClient(p.Endpoint, p.Token, p.CertAuthFilePath)
}
@ -100,8 +101,8 @@ func (p *Provider) Init() error {
// Provide allows the k8s provider to provide configurations to traefik
// using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctxLog := log.With(context.Background(), log.Str(log.ProviderName, "kubernetes"))
logger := log.FromContext(ctxLog)
logger := log.With().Str(logs.ProviderName, "kubernetes").Logger()
ctxLog := logger.WithContext(context.Background())
k8sClient, err := p.newK8sClient(ctxLog)
if err != nil {
@ -109,14 +110,14 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
if p.AllowExternalNameServices {
logger.Warn("ExternalName service loading is enabled, please ensure that this is expected (see AllowExternalNameServices option)")
logger.Warn().Msg("ExternalName service loading is enabled, please ensure that this is expected (see AllowExternalNameServices option)")
}
pool.GoCtx(func(ctxPool context.Context) {
operation := func() error {
eventsChan, err := k8sClient.WatchAll(p.Namespaces, ctxPool.Done())
if err != nil {
logger.Errorf("Error watching kubernetes events: %v", err)
logger.Error().Err(err).Msg("Error watching kubernetes events")
timer := time.NewTimer(1 * time.Second)
select {
case <-timer.C:
@ -147,9 +148,9 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
confHash, err := hashstructure.Hash(conf, nil)
switch {
case err != nil:
logger.Error("Unable to hash the configuration")
logger.Error().Msg("Unable to hash the configuration")
case p.lastConfiguration.Get() == confHash:
logger.Debugf("Skipping Kubernetes event kind %T", event)
logger.Debug().Msgf("Skipping Kubernetes event kind %T", event)
default:
p.lastConfiguration.Set(confHash)
configurationChan <- dynamic.Message{
@ -167,12 +168,12 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error: %s; retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxPool), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider: %s", err)
logger.Error().Err(err).Msg("Cannot connect to Provider")
}
})
@ -196,7 +197,7 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
if supportsIngressClass(serverVersion) {
ics, err := client.GetIngressClasses()
if err != nil {
log.FromContext(ctx).Warnf("Failed to list ingress classes: %v", err)
log.Ctx(ctx).Warn().Err(err).Msg("Failed to list ingress classes")
}
if p.IngressClass != "" {
@ -210,7 +211,8 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
certConfigs := make(map[string]*tls.CertAndStores)
for _, ingress := range ingresses {
ctx = log.With(ctx, log.Str("ingress", ingress.Name), log.Str("namespace", ingress.Namespace))
logger := log.Ctx(ctx).With().Str("ingress", ingress.Name).Str("namespace", ingress.Namespace).Logger()
ctx = logger.WithContext(ctx)
if !p.shouldProcessIngress(ingress, ingressClasses) {
continue
@ -218,35 +220,36 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
rtConfig, err := parseRouterConfig(ingress.Annotations)
if err != nil {
log.FromContext(ctx).Errorf("Failed to parse annotations: %v", err)
logger.Error().Err(err).Msg("Failed to parse annotations")
continue
}
err = getCertificates(ctx, ingress, client, certConfigs)
if err != nil {
log.FromContext(ctx).Errorf("Error configuring TLS: %v", err)
logger.Error().Err(err).Msg("Error configuring TLS")
}
if len(ingress.Spec.Rules) == 0 && ingress.Spec.DefaultBackend != nil {
if _, ok := conf.HTTP.Services["default-backend"]; ok {
log.FromContext(ctx).Error("The default backend already exists.")
logger.Error().Msg("The default backend already exists.")
continue
}
service, err := p.loadService(client, ingress.Namespace, *ingress.Spec.DefaultBackend)
if err != nil {
log.FromContext(ctx).
WithField("serviceName", ingress.Spec.DefaultBackend.Service.Name).
WithField("servicePort", ingress.Spec.DefaultBackend.Service.Port.String()).
Errorf("Cannot create service: %v", err)
logger.Error().
Str("serviceName", ingress.Spec.DefaultBackend.Service.Name).
Str("servicePort", ingress.Spec.DefaultBackend.Service.Port.String()).
Err(err).
Msg("Cannot create service")
continue
}
if len(service.LoadBalancer.Servers) == 0 && !p.AllowEmptyServices {
log.FromContext(ctx).
WithField("serviceName", ingress.Spec.DefaultBackend.Service.Name).
WithField("servicePort", ingress.Spec.DefaultBackend.Service.Port.String()).
Errorf("Skipping service: no endpoints found")
logger.Error().
Str("serviceName", ingress.Spec.DefaultBackend.Service.Name).
Str("servicePort", ingress.Spec.DefaultBackend.Service.Port.String()).
Msg("Skipping service: no endpoints found")
continue
}
@ -270,7 +273,7 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
for _, rule := range ingress.Spec.Rules {
if err := p.updateIngressStatus(ingress, client); err != nil {
log.FromContext(ctx).Errorf("Error while updating ingress status: %v", err)
logger.Error().Err(err).Msg("Error while updating ingress status")
}
if rule.HTTP == nil {
@ -280,18 +283,19 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
for _, pa := range rule.HTTP.Paths {
service, err := p.loadService(client, ingress.Namespace, pa.Backend)
if err != nil {
log.FromContext(ctx).
WithField("serviceName", pa.Backend.Service.Name).
WithField("servicePort", pa.Backend.Service.Port.String()).
Errorf("Cannot create service: %v", err)
logger.Error().
Str("serviceName", pa.Backend.Service.Name).
Str("servicePort", pa.Backend.Service.Port.String()).
Err(err).
Msg("Cannot create service")
continue
}
if len(service.LoadBalancer.Servers) == 0 && !p.AllowEmptyServices {
log.FromContext(ctx).
WithField("serviceName", pa.Backend.Service.Name).
WithField("servicePort", pa.Backend.Service.Port.String()).
Errorf("Skipping service: no endpoints found")
logger.Error().
Str("serviceName", pa.Backend.Service.Name).
Str("servicePort", pa.Backend.Service.Port.String()).
Msg("Skipping service: no endpoints found")
continue
}
@ -315,12 +319,12 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
continue
}
log.FromContext(ctx).Debugf("Multiple routers are defined with the same key %q, generating hashes to avoid conflicts", routerKey)
logger.Debug().Msgf("Multiple routers are defined with the same key %q, generating hashes to avoid conflicts", routerKey)
for _, router := range conflictingRouters {
key, err := makeRouterKeyWithHash(routerKey, router.Rule)
if err != nil {
log.FromContext(ctx).Error(err)
logger.Error().Err(err).Send()
continue
}
@ -367,7 +371,7 @@ func (p *Provider) updateIngressStatus(ing *networkingv1.Ingress, k8sClient Clie
if exists && service.Status.LoadBalancer.Ingress == nil {
// service exists, but has no Load Balancer status
log.Debugf("Skipping updating Ingress %s/%s due to service %s having no status set", ing.Namespace, ing.Name, p.IngressEndpoint.PublishedService)
log.Debug().Msgf("Skipping updating Ingress %s/%s due to service %s having no status set", ing.Namespace, ing.Name, p.IngressEndpoint.PublishedService)
return nil
}
@ -405,7 +409,7 @@ func buildHostRule(host string) string {
func getCertificates(ctx context.Context, ingress *networkingv1.Ingress, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error {
for _, t := range ingress.Spec.TLS {
if t.SecretName == "" {
log.FromContext(ctx).Debugf("Skipping TLS sub-section: No secret name provided")
log.Ctx(ctx).Debug().Msg("Skipping TLS sub-section: No secret name provided")
continue
}
@ -673,7 +677,7 @@ func throttleEvents(ctx context.Context, throttleDuration time.Duration, pool *s
// do a refresh as soon as our throttle allows us to. It's fine
// to drop the event and keep whatever's in the buffer -- we
// don't do different things for different events.
log.FromContext(ctx).Debugf("Dropping event kind %T due to throttling", nextEvent)
log.Ctx(ctx).Debug().Msgf("Dropping event kind %T due to throttling", nextEvent)
}
}
}

4
pkg/provider/kubernetes/k8s/parser.go
View file

@ -5,7 +5,7 @@ import (
"regexp"
"strings"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/kubernetes/scheme"
)
@ -28,7 +28,7 @@ func MustParseYaml(content []byte) []runtime.Object {
}
if !acceptedK8sTypes.MatchString(groupVersionKind.Kind) {
log.WithoutContext().Debugf("The custom-roles configMap contained K8s object types which are not supported! Skipping object with type: %s", groupVersionKind.Kind)
log.Debug().Msgf("The custom-roles configMap contained K8s object types which are not supported! Skipping object with type: %s", groupVersionKind.Kind)
} else {
retVal = append(retVal, obj)
}

4
pkg/provider/kv/consul/consul.go
View file

@ -7,7 +7,7 @@ import (
"time"
"github.com/kvtools/consul"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/kv"
"github.com/traefik/traefik/v2/pkg/types"
@ -41,7 +41,7 @@ func (p *ProviderBuilder) BuildProviders() []*Provider {
// We can warn about that, because we've already made sure before that
// Namespace and Namespaces are mutually exclusive.
if p.Namespace != "" {
log.WithoutContext().Warnf("Namespace option is deprecated, please use the Namespaces option instead.")
log.Warn().Msg("Namespace option is deprecated, please use the Namespaces option instead.")
}
if len(p.Namespaces) == 0 {

20
pkg/provider/kv/kv.go
View file

@ -10,10 +10,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/kvtools/valkeyrie"
"github.com/kvtools/valkeyrie/store"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/kv"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/safe"
)
@ -34,7 +35,7 @@ func (p *Provider) SetDefaults() {
// Init the provider.
func (p *Provider) Init(storeType, name string, config valkeyrie.Config) error {
ctx := log.With(context.Background(), log.Str(log.ProviderName, name))
ctx := log.With().Str(logs.ProviderName, name).Logger().WithContext(context.Background())
p.name = name
@ -50,8 +51,8 @@ func (p *Provider) Init(storeType, name string, config valkeyrie.Config) error {
// Provide allows the docker provider to provide configurations to traefik using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctx := log.With(context.Background(), log.Str(log.ProviderName, p.name))
logger := log.FromContext(ctx)
logger := log.With().Str(logs.ProviderName, p.name).Logger()
ctx := logger.WithContext(context.Background())
operation := func() error {
if _, err := p.kvClient.Exists(ctx, path.Join(p.RootKey, "qmslkjdfmqlskdjfmqlksjazçueznbvbwzlkajzebvkwjdcqmlsfj"), nil); err != nil {
@ -61,8 +62,9 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("KV connection error: %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("KV connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctx), notify)
if err != nil {
return fmt.Errorf("cannot connect to KV server: %w", err)
@ -70,7 +72,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
configuration, err := p.buildConfiguration(ctx)
if err != nil {
logger.Errorf("Cannot build the configuration: %v", err)
logger.Error().Err(err).Msg("Cannot build the configuration")
} else {
configurationChan <- dynamic.Message{
ProviderName: p.name,
@ -79,11 +81,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
pool.GoCtx(func(ctxPool context.Context) {
ctxLog := log.With(ctxPool, log.Str(log.ProviderName, p.name))
ctxLog := logger.With().Str(logs.ProviderName, p.name).Logger().WithContext(ctxPool)
err := p.watchKv(ctxLog, configurationChan)
if err != nil {
logger.Errorf("Cannot watch KV store: %v", err)
logger.Error().Err(err).Msg("Cannot watch KV store")
}
})
@ -122,7 +124,7 @@ func (p *Provider) watchKv(ctx context.Context, configurationChan chan<- dynamic
}
notify := func(err error, time time.Duration) {
log.FromContext(ctx).Errorf("KV connection error: %+v, retrying in %s", err, time)
log.Ctx(ctx).Error().Err(err).Msgf("KV connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation),

26
pkg/provider/kv/storewrapper.go
View file

@ -4,7 +4,7 @@ import (
"context"
"github.com/kvtools/valkeyrie/store"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
)
type storeWrapper struct {
@ -12,7 +12,7 @@ type storeWrapper struct {
}
func (s *storeWrapper) Put(ctx context.Context, key string, value []byte, options *store.WriteOptions) error {
log.WithoutContext().Debugf("Put: %s", key, string(value))
log.Debug().Msgf("Put: %s %s", key, string(value))
if s.Store == nil {
return nil
@ -21,7 +21,7 @@ func (s *storeWrapper) Put(ctx context.Context, key string, value []byte, option
}
func (s *storeWrapper) Get(ctx context.Context, key string, options *store.ReadOptions) (*store.KVPair, error) {
log.WithoutContext().Debugf("Get: %s", key)
log.Debug().Msgf("Get: %s", key)
if s.Store == nil {
return nil, nil
@ -30,7 +30,7 @@ func (s *storeWrapper) Get(ctx context.Context, key string, options *store.ReadO
}
func (s *storeWrapper) Delete(ctx context.Context, key string) error {
log.WithoutContext().Debugf("Delete: %s", key)
log.Debug().Msgf("Delete: %s", key)
if s.Store == nil {
return nil
@ -39,7 +39,7 @@ func (s *storeWrapper) Delete(ctx context.Context, key string) error {
}
func (s *storeWrapper) Exists(ctx context.Context, key string, options *store.ReadOptions) (bool, error) {
log.WithoutContext().Debugf("Exists: %s", key)
log.Debug().Msgf("Exists: %s", key)
if s.Store == nil {
return true, nil
@ -48,7 +48,7 @@ func (s *storeWrapper) Exists(ctx context.Context, key string, options *store.Re
}
func (s *storeWrapper) Watch(ctx context.Context, key string, options *store.ReadOptions) (<-chan *store.KVPair, error) {
log.WithoutContext().Debugf("Watch: %s", key)
log.Debug().Msgf("Watch: %s", key)
if s.Store == nil {
return nil, nil
@ -57,7 +57,7 @@ func (s *storeWrapper) Watch(ctx context.Context, key string, options *store.Rea
}
func (s *storeWrapper) WatchTree(ctx context.Context, directory string, options *store.ReadOptions) (<-chan []*store.KVPair, error) {
log.WithoutContext().Debugf("WatchTree: %s", directory)
log.Debug().Msgf("WatchTree: %s", directory)
if s.Store == nil {
return nil, nil
@ -66,7 +66,7 @@ func (s *storeWrapper) WatchTree(ctx context.Context, directory string, options
}
func (s *storeWrapper) NewLock(ctx context.Context, key string, options *store.LockOptions) (store.Locker, error) {
log.WithoutContext().Debugf("NewLock: %s", key)
log.Debug().Msgf("NewLock: %s", key)
if s.Store == nil {
return nil, nil
@ -75,7 +75,7 @@ func (s *storeWrapper) NewLock(ctx context.Context, key string, options *store.L
}
func (s *storeWrapper) List(ctx context.Context, directory string, options *store.ReadOptions) ([]*store.KVPair, error) {
log.WithoutContext().Debugf("List: %s", directory)
log.Debug().Msgf("List: %s", directory)
if s.Store == nil {
return nil, nil
@ -84,7 +84,7 @@ func (s *storeWrapper) List(ctx context.Context, directory string, options *stor
}
func (s *storeWrapper) DeleteTree(ctx context.Context, directory string) error {
log.WithoutContext().Debugf("DeleteTree: %s", directory)
log.Debug().Msgf("DeleteTree: %s", directory)
if s.Store == nil {
return nil
@ -93,7 +93,7 @@ func (s *storeWrapper) DeleteTree(ctx context.Context, directory string) error {
}
func (s *storeWrapper) AtomicPut(ctx context.Context, key string, value []byte, previous *store.KVPair, options *store.WriteOptions) (bool, *store.KVPair, error) {
log.WithoutContext().Debugf("AtomicPut: %s", key, string(value), previous)
log.Debug().Msgf("AtomicPut: %s %s %v", key, string(value), previous)
if s.Store == nil {
return true, nil, nil
@ -102,7 +102,7 @@ func (s *storeWrapper) AtomicPut(ctx context.Context, key string, value []byte,
}
func (s *storeWrapper) AtomicDelete(ctx context.Context, key string, previous *store.KVPair) (bool, error) {
log.WithoutContext().Debugf("AtomicDelete: %s", key, previous)
log.Debug().Msgf("AtomicDelete: %s %v", key, previous)
if s.Store == nil {
return true, nil
@ -111,7 +111,7 @@ func (s *storeWrapper) AtomicDelete(ctx context.Context, key string, previous *s
}
func (s *storeWrapper) Close() error {
log.WithoutContext().Debugf("Close")
log.Debug().Msg("Close")
if s.Store == nil {
return nil

40
pkg/provider/marathon/config.go
View file

@ -10,9 +10,9 @@ import (
"strings"
"github.com/gambol99/go-marathon"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -21,12 +21,12 @@ func (p *Provider) buildConfiguration(ctx context.Context, applications *maratho
configurations := make(map[string]*dynamic.Configuration)
for _, app := range applications.Apps {
ctxApp := log.With(ctx, log.Str("applicationID", app.ID))
logger := log.FromContext(ctxApp)
logger := log.Ctx(ctx).With().Str("applicationID", app.ID).Logger()
ctxApp := logger.WithContext(ctx)
extraConf, err := p.getConfiguration(app)
if err != nil {
logger.Errorf("Skip application: %v", err)
logger.Error().Err(err).Msg("Skip application")
continue
}
@ -45,7 +45,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, applications *maratho
confFromLabel, err := label.DecodeConfiguration(labels)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -55,7 +55,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, applications *maratho
err := p.buildTCPServiceConfiguration(ctxApp, app, extraConf, confFromLabel.TCP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildTCPRouterConfiguration(ctxApp, confFromLabel.TCP)
@ -66,7 +66,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, applications *maratho
err := p.buildUDPServiceConfiguration(ctxApp, app, extraConf, confFromLabel.UDP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
} else {
provider.BuildUDPRouterConfiguration(ctxApp, confFromLabel.UDP)
}
@ -81,7 +81,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, applications *maratho
err = p.buildServiceConfiguration(ctxApp, app, extraConf, confFromLabel.HTTP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -109,7 +109,8 @@ func getServiceName(app marathon.Application) string {
func (p *Provider) buildServiceConfiguration(ctx context.Context, app marathon.Application, extraConf configuration, conf *dynamic.HTTPConfiguration) error {
appName := getServiceName(app)
appCtx := log.With(ctx, log.Str("ApplicationID", appName))
logger := log.Ctx(ctx).With().Str("applicationName", appName).Logger()
if len(conf.Services) == 0 {
conf.Services = make(map[string]*dynamic.Service)
@ -136,7 +137,7 @@ func (p *Provider) buildServiceConfiguration(ctx context.Context, app marathon.A
}
server, err := p.getServer(app, *task, extraConf, defaultServer)
if err != nil {
log.FromContext(appCtx).Errorf("Skip task: %v", err)
logger.Error().Err(err).Msg("Skip task")
continue
}
servers = append(servers, server)
@ -152,7 +153,8 @@ func (p *Provider) buildServiceConfiguration(ctx context.Context, app marathon.A
func (p *Provider) buildTCPServiceConfiguration(ctx context.Context, app marathon.Application, extraConf configuration, conf *dynamic.TCPConfiguration) error {
appName := getServiceName(app)
appCtx := log.With(ctx, log.Str("ApplicationID", appName))
logger := log.Ctx(ctx).With().Str("applicationName", appName).Logger()
if len(conf.Services) == 0 {
conf.Services = make(map[string]*dynamic.TCPService)
@ -176,7 +178,7 @@ func (p *Provider) buildTCPServiceConfiguration(ctx context.Context, app maratho
if p.taskFilter(ctx, *task, app) {
server, err := p.getTCPServer(app, *task, extraConf, defaultServer)
if err != nil {
log.FromContext(appCtx).Errorf("Skip task: %v", err)
logger.Error().Err(err).Msg("Skip task")
continue
}
servers = append(servers, server)
@ -193,7 +195,7 @@ func (p *Provider) buildTCPServiceConfiguration(ctx context.Context, app maratho
func (p *Provider) buildUDPServiceConfiguration(ctx context.Context, app marathon.Application, extraConf configuration, conf *dynamic.UDPConfiguration) error {
appName := getServiceName(app)
appCtx := log.With(ctx, log.Str("ApplicationID", appName))
logger := log.Ctx(ctx).With().Str("applicationName", appName).Logger()
if len(conf.Services) == 0 {
conf.Services = make(map[string]*dynamic.UDPService)
@ -217,7 +219,7 @@ func (p *Provider) buildUDPServiceConfiguration(ctx context.Context, app maratho
if p.taskFilter(ctx, *task, app) {
server, err := p.getUDPServer(app, *task, extraConf, defaultServer)
if err != nil {
log.FromContext(appCtx).Errorf("Skip task: %v", err)
logger.Error().Err(err).Msg("Skip task")
continue
}
servers = append(servers, server)
@ -233,22 +235,22 @@ func (p *Provider) buildUDPServiceConfiguration(ctx context.Context, app maratho
}
func (p *Provider) keepApplication(ctx context.Context, extraConf configuration, labels map[string]string) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
// Filter disabled application.
if !extraConf.Enable {
logger.Debug("Filtering disabled Marathon application")
logger.Debug().Msg("Filtering disabled Marathon application")
return false
}
// Filter by constraints.
matches, err := constraints.MatchLabels(labels, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraints expression: %v", err)
logger.Error().Err(err).Msg("Error matching constraints expression")
return false
}
if !matches {
logger.Debugf("Marathon application filtered by constraint expression: %q", p.Constraints)
logger.Debug().Msgf("Marathon application filtered by constraint expression: %q", p.Constraints)
return false
}
@ -261,7 +263,7 @@ func (p *Provider) taskFilter(ctx context.Context, task marathon.Task, applicati
}
if ready := p.readyChecker.Do(task, application); !ready {
log.FromContext(ctx).Infof("Filtering unready task %s from application %s", task.ID, application.ID)
log.Ctx(ctx).Info().Msgf("Filtering unready task %s from application %s", task.ID, application.ID)
return false
}

32
pkg/provider/marathon/marathon.go
View file

@ -11,11 +11,12 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/gambol99/go-marathon"
"github.com/sirupsen/logrus"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/types"
@ -23,9 +24,8 @@ import (
const (
// DefaultTemplateRule The default template for the default rule.
DefaultTemplateRule = "Host(`{{ normalize .Name }}`)"
traceMaxScanTokenSize = 1024 * 1024
marathonEventIDs = marathon.EventIDApplications |
DefaultTemplateRule = "Host(`{{ normalize .Name }}`)"
marathonEventIDs = marathon.EventIDApplications |
marathon.EventIDAddHealthCheck |
marathon.EventIDDeploymentSuccess |
marathon.EventIDDeploymentFailed |
@ -108,23 +108,25 @@ func (p *Provider) Init() error {
// Provide allows the marathon provider to provide configurations to traefik
// using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
ctx := log.With(context.Background(), log.Str(log.ProviderName, "marathon"))
logger := log.FromContext(ctx)
logger := log.With().Str(logs.ProviderName, "marathon").Logger()
ctx := logger.WithContext(context.Background())
operation := func() error {
confg := marathon.NewDefaultConfig()
confg.URL = p.Endpoint
confg.EventsTransport = marathon.EventsTransportSSE
if p.Trace {
confg.LogOutput = log.CustomWriterLevel(logrus.DebugLevel, traceMaxScanTokenSize)
confg.LogOutput = logs.NoLevel(logger, zerolog.DebugLevel)
}
if p.Basic != nil {
confg.HTTPBasicAuthUser = p.Basic.HTTPBasicAuthUser
confg.HTTPBasicPassword = p.Basic.HTTPBasicPassword
}
var rc *readinessChecker
if p.RespectReadinessChecks {
logger.Debug("Enabling Marathon readiness checker")
logger.Debug().Msg("Enabling Marathon readiness checker")
rc = defaultReadinessChecker(p.Trace)
}
p.readyChecker = rc
@ -149,7 +151,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
client, err := marathon.NewClient(confg)
if err != nil {
logger.Errorf("Failed to create a client for marathon, error: %s", err)
logger.Error().Err(err).Msg("Failed to create a client for marathon")
return err
}
p.marathonClient = client
@ -157,7 +159,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
if p.Watch {
update, err := client.AddEventsListener(marathonEventIDs)
if err != nil {
logger.Errorf("Failed to register for events, %s", err)
logger.Error().Err(err).Msg("Failed to register for events")
return err
}
pool.GoCtx(func(ctxPool context.Context) {
@ -167,7 +169,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
case <-ctxPool.Done():
return
case event := <-update:
logger.Debugf("Received provider event %s", event)
logger.Debug().Msgf("Received provider event %s", event)
conf := p.getConfigurations(ctx)
if conf != nil {
@ -190,11 +192,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctx), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider server: %+v", err)
logger.Error().Err(err).Msg("Cannot connect to Provider server")
}
return nil
}
@ -202,7 +204,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
func (p *Provider) getConfigurations(ctx context.Context) *dynamic.Configuration {
applications, err := p.getApplications()
if err != nil {
log.FromContext(ctx).Errorf("Failed to retrieve Marathon applications: %v", err)
log.Ctx(ctx).Error().Err(err).Msg("Failed to retrieve Marathon applications")
return nil
}

6
pkg/provider/marathon/readiness.go
View file

@ -4,7 +4,7 @@ import (
"time"
"github.com/gambol99/go-marathon"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/rs/zerolog/log"
)
const (
@ -98,7 +98,7 @@ func (rc *readinessChecker) Do(task marathon.Task, app marathon.Application) boo
// An unparseable start time should never occur; if it does, we assume the
// problem should be surfaced as quickly as possible, which is easiest if
// we shun the task from rotation.
log.Warnf("Failed to parse start-time %s of task %s from application %s: %s (assuming unready)", task.StartedAt, task.ID, app.ID, err)
log.Warn().Err(err).Msgf("Failed to parse start-time %s of task %s from application %s (assuming unready)", task.StartedAt, task.ID, app.ID)
return false
}
@ -117,6 +117,6 @@ func (rc *readinessChecker) Do(task marathon.Task, app marathon.Application) boo
func (rc *readinessChecker) tracef(format string, args ...interface{}) {
if rc.traceLogging {
log.Debugf(readinessLogHeader+format, args...)
log.Debug().Msgf(readinessLogHeader+format, args...)
}
}

23
pkg/provider/nomad/config.go
View file

@ -10,9 +10,10 @@ import (
"strconv"
"strings"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -22,18 +23,18 @@ func (p *Provider) buildConfig(ctx context.Context, items []item) *dynamic.Confi
for _, i := range items {
svcName := provider.Normalize(i.Node + "-" + i.Name + "-" + i.ID)
ctxSvc := log.With(ctx, log.Str(log.ServiceName, svcName))
logger := log.Ctx(ctx).With().Str(logs.ServiceName, svcName).Logger()
ctxSvc := logger.WithContext(ctx)
if !p.keepItem(ctxSvc, i) {
continue
}
logger := log.FromContext(ctx)
labels := tagsToLabels(i.Tags, p.Prefix)
config, err := label.DecodeConfiguration(labels)
if err != nil {
logger.Errorf("Failed to decode configuration: %v", err)
logger.Error().Err(err).Msg("Failed to decode configuration")
continue
}
@ -42,7 +43,7 @@ func (p *Provider) buildConfig(ctx context.Context, items []item) *dynamic.Confi
if len(config.TCP.Routers) > 0 || len(config.TCP.Services) > 0 {
tcpOrUDP = true
if err := p.buildTCPConfig(i, config.TCP); err != nil {
logger.Errorf("Failed to build TCP service configuration: %v", err)
logger.Error().Err(err).Msg("Failed to build TCP service configuration")
continue
}
provider.BuildTCPRouterConfiguration(ctxSvc, config.TCP)
@ -51,7 +52,7 @@ func (p *Provider) buildConfig(ctx context.Context, items []item) *dynamic.Confi
if len(config.UDP.Routers) > 0 || len(config.UDP.Services) > 0 {
tcpOrUDP = true
if err := p.buildUDPConfig(i, config.UDP); err != nil {
logger.Errorf("Failed to build UDP service configuration: %v", err)
logger.Error().Err(err).Msg("Failed to build UDP service configuration")
continue
}
provider.BuildUDPRouterConfiguration(ctxSvc, config.UDP)
@ -67,7 +68,7 @@ func (p *Provider) buildConfig(ctx context.Context, items []item) *dynamic.Confi
// configure http service
if err := p.buildServiceConfig(i, config.HTTP); err != nil {
logger.Errorf("Failed to build HTTP service configuration: %v", err)
logger.Error().Err(err).Msg("Failed to build HTTP service configuration")
continue
}
@ -148,20 +149,20 @@ func (p *Provider) buildServiceConfig(i item, configuration *dynamic.HTTPConfigu
// TODO: check whether it is mandatory to filter again.
func (p *Provider) keepItem(ctx context.Context, i item) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if !i.ExtraConf.Enable {
logger.Debug("Filtering disabled item")
logger.Debug().Msg("Filtering disabled item")
return false
}
matches, err := constraints.MatchTags(i.Tags, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expressions: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expressions")
return false
}
if !matches {
logger.Debugf("Filtering out item due to constraints: %q", p.Constraints)
logger.Debug().Msgf("Filtering out item due to constraints: %q", p.Constraints)
return false
}

21
pkg/provider/nomad/nomad.go
View file

@ -10,10 +10,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/hashicorp/nomad/api"
"github.com/rs/zerolog/log"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
"github.com/traefik/traefik/v2/pkg/safe"
@ -59,7 +60,7 @@ type ProviderBuilder struct {
// BuildProviders builds Nomad provider instances for the given namespaces configuration.
func (p *ProviderBuilder) BuildProviders() []*Provider {
if p.Namespace != "" {
log.WithoutContext().Warnf("Namespace option is deprecated, please use the Namespaces option instead.")
log.Warn().Msg("Namespace option is deprecated, please use the Namespaces option instead.")
}
if len(p.Namespaces) == 0 {
@ -154,8 +155,8 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, p.name))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, p.name).Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
ctx, cancel := context.WithCancel(ctxLog)
@ -186,7 +187,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
failure := func(err error, d time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, d)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", d)
}
if retryErr := backoff.RetryNotify(
@ -194,7 +195,7 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxLog),
failure,
); retryErr != nil {
logger.Errorf("Cannot connect to Nomad server %+v", retryErr)
logger.Error().Err(retryErr).Msg("Cannot connect to Nomad server")
}
})
@ -273,22 +274,22 @@ func (p *Provider) getNomadServiceData(ctx context.Context) ([]item, error) {
for _, stub := range stubs {
for _, service := range stub.Services {
logger := log.FromContext(log.With(ctx, log.Str("serviceName", service.ServiceName)))
logger := log.Ctx(ctx).With().Str("serviceName", service.ServiceName).Logger()
extraConf := p.getExtraConf(service.Tags)
if !extraConf.Enable {
logger.Debug("Filter Nomad service that is not enabled")
logger.Debug().Msg("Filter Nomad service that is not enabled")
continue
}
matches, err := constraints.MatchTags(service.Tags, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expressions: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expressions")
continue
}
if !matches {
logger.Debugf("Filter Nomad service not matching constraints: %q", p.Constraints)
logger.Debug().Msgf("Filter Nomad service not matching constraints: %q", p.Constraints)
continue
}

33
pkg/provider/rancher/config.go
View file

@ -7,9 +7,9 @@ import (
"net"
"strings"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/label"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/provider/constraints"
)
@ -18,17 +18,16 @@ func (p *Provider) buildConfiguration(ctx context.Context, services []rancherDat
configurations := make(map[string]*dynamic.Configuration)
for _, service := range services {
ctxService := log.With(ctx, log.Str("service", service.Name))
logger := log.Ctx(ctx).With().Str("service", service.Name).Logger()
ctxService := logger.WithContext(ctx)
if !p.keepService(ctx, service) {
continue
}
logger := log.FromContext(ctxService)
confFromLabel, err := label.DecodeConfiguration(service.Labels)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -38,7 +37,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, services []rancherDat
err := p.buildTCPServiceConfiguration(ctxService, service, confFromLabel.TCP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildTCPRouterConfiguration(ctxService, confFromLabel.TCP)
@ -49,7 +48,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, services []rancherDat
err := p.buildUDPServiceConfiguration(ctxService, service, confFromLabel.UDP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
provider.BuildUDPRouterConfiguration(ctxService, confFromLabel.UDP)
@ -64,7 +63,7 @@ func (p *Provider) buildConfiguration(ctx context.Context, services []rancherDat
err = p.buildServiceConfiguration(ctx, service, confFromLabel.HTTP)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}
@ -151,30 +150,30 @@ func (p *Provider) buildServiceConfiguration(ctx context.Context, service ranche
}
func (p *Provider) keepService(ctx context.Context, service rancherData) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if !service.ExtraConf.Enable {
logger.Debug("Filtering disabled service.")
logger.Debug().Msg("Filtering disabled service")
return false
}
matches, err := constraints.MatchLabels(service.Labels, p.Constraints)
if err != nil {
logger.Errorf("Error matching constraint expression: %v", err)
logger.Error().Err(err).Msg("Error matching constraint expression")
return false
}
if !matches {
logger.Debugf("Service pruned by constraint expression: %q", p.Constraints)
logger.Debug().Msgf("Service pruned by constraint expression: %q", p.Constraints)
return false
}
if p.EnableServiceHealthFilter {
if service.Health != "" && service.Health != healthy && service.Health != updatingHealthy {
logger.Debugf("Filtering service %s with healthState of %s \n", service.Name, service.Health)
logger.Debug().Msgf("Filtering service %s with healthState of %s", service.Name, service.Health)
return false
}
if service.State != "" && service.State != active && service.State != updatingActive && service.State != upgraded && service.State != upgrading {
logger.Debugf("Filtering service %s with state of %s \n", service.Name, service.State)
logger.Debug().Msgf("Filtering service %s with state of %s", service.Name, service.State)
return false
}
}
@ -183,7 +182,7 @@ func (p *Provider) keepService(ctx context.Context, service rancherData) bool {
}
func (p *Provider) addServerTCP(ctx context.Context, service rancherData, loadBalancer *dynamic.TCPServersLoadBalancer) error {
log.FromContext(ctx).Debugf("Trying to add servers for service %s \n", service.Name)
log.Ctx(ctx).Debug().Msgf("Trying to add servers for service %s", service.Name)
if loadBalancer == nil {
return errors.New("load-balancer is not defined")
@ -217,7 +216,7 @@ func (p *Provider) addServerTCP(ctx context.Context, service rancherData, loadBa
}
func (p *Provider) addServerUDP(ctx context.Context, service rancherData, loadBalancer *dynamic.UDPServersLoadBalancer) error {
log.FromContext(ctx).Debugf("Trying to add servers for service %s \n", service.Name)
log.Ctx(ctx).Debug().Msgf("Trying to add servers for service %s", service.Name)
if loadBalancer == nil {
return errors.New("load-balancer is not defined")
@ -251,7 +250,7 @@ func (p *Provider) addServerUDP(ctx context.Context, service rancherData, loadBa
}
func (p *Provider) addServers(ctx context.Context, service rancherData, loadBalancer *dynamic.ServersLoadBalancer) error {
log.FromContext(ctx).Debugf("Trying to add servers for service %s \n", service.Name)
log.Ctx(ctx).Debug().Msgf("Trying to add servers for service %s", service.Name)
if loadBalancer == nil {
return errors.New("load-balancer is not defined")

33
pkg/provider/rancher/rancher.go
View file

@ -8,9 +8,10 @@ import (
"github.com/cenkalti/backoff/v4"
rancher "github.com/rancher/go-rancher-metadata/metadata"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/job"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
)
@ -86,7 +87,7 @@ func (p *Provider) createClient(ctx context.Context) (rancher.Client, error) {
metadataServiceURL := fmt.Sprintf("http://rancher-metadata.rancher.internal/%s", p.Prefix)
client, err := rancher.NewClientAndWait(metadataServiceURL)
if err != nil {
log.FromContext(ctx).Errorf("Failed to create Rancher metadata service client: %v", err)
log.Ctx(ctx).Error().Err(err).Msg("Failed to create Rancher metadata service client")
return nil, err
}
@ -96,20 +97,20 @@ func (p *Provider) createClient(ctx context.Context) (rancher.Client, error) {
// Provide allows the rancher provider to provide configurations to traefik using the given configuration channel.
func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.Pool) error {
pool.GoCtx(func(routineCtx context.Context) {
ctxLog := log.With(routineCtx, log.Str(log.ProviderName, "rancher"))
logger := log.FromContext(ctxLog)
logger := log.Ctx(routineCtx).With().Str(logs.ProviderName, "rancher").Logger()
ctxLog := logger.WithContext(routineCtx)
operation := func() error {
client, err := p.createClient(ctxLog)
if err != nil {
logger.Errorf("Failed to create the metadata client metadata service: %v", err)
logger.Error().Err(err).Msg("Failed to create the metadata client metadata service")
return err
}
updateConfiguration := func(_ string) {
stacks, err := client.GetStacks()
if err != nil {
logger.Errorf("Failed to query Rancher metadata service: %v", err)
logger.Error().Err(err).Msg("Failed to query Rancher metadata service")
return
}
@ -139,11 +140,11 @@ func (p *Provider) Provide(configurationChan chan<- dynamic.Message, pool *safe.
}
notify := func(err error, time time.Duration) {
logger.Errorf("Provider connection error %+v, retrying in %s", err, time)
logger.Error().Err(err).Msgf("Provider connection error, retrying in %s", time)
}
err := backoff.RetryNotify(safe.OperationWithRecover(operation), backoff.WithContext(job.NewBackOff(backoff.NewExponentialBackOff()), ctxLog), notify)
if err != nil {
logger.Errorf("Cannot connect to Provider server: %+v", err)
logger.Error().Err(err).Msg("Cannot connect to Provider server")
}
})
@ -160,7 +161,7 @@ func (p *Provider) intervalPoll(ctx context.Context, client rancher.Client, upda
case <-ticker.C:
newVersion, err := client.GetVersion()
if err != nil {
log.FromContext(ctx).Errorf("Failed to create Rancher metadata service client: %v", err)
log.Ctx(ctx).Error().Err(err).Msg("Failed to create Rancher metadata service client")
} else if version != newVersion {
version = newVersion
updateConfiguration(version)
@ -174,15 +175,15 @@ func (p *Provider) intervalPoll(ctx context.Context, client rancher.Client, upda
func (p *Provider) parseMetadataSourcedRancherData(ctx context.Context, stacks []rancher.Stack) (rancherDataList []rancherData) {
for _, stack := range stacks {
for _, service := range stack.Services {
ctxSvc := log.With(ctx, log.Str("stack", stack.Name), log.Str("service", service.Name))
logger := log.FromContext(ctxSvc)
logger := log.Ctx(ctx).With().Str("stack", stack.Name).Str("service", service.Name).Logger()
ctxSvc := logger.WithContext(ctx)
servicePort := ""
if len(service.Ports) > 0 {
servicePort = service.Ports[0]
}
for _, port := range service.Ports {
logger.Debugf("Set Port %s", port)
logger.Debug().Msgf("Set Port %s", port)
}
var containerIPAddresses []string
@ -202,7 +203,7 @@ func (p *Provider) parseMetadataSourcedRancherData(ctx context.Context, stacks [
extraConf, err := p.getConfiguration(service)
if err != nil {
logger.Errorf("Skip container %s: %v", service.Name, err)
logger.Error().Err(err).Msgf("Skip container %s", service.Name)
continue
}
@ -215,15 +216,15 @@ func (p *Provider) parseMetadataSourcedRancherData(ctx context.Context, stacks [
}
func containerFilter(ctx context.Context, name, healthState, state string) bool {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
if healthState != "" && healthState != healthy && healthState != updatingHealthy {
logger.Debugf("Filtering container %s with healthState of %s", name, healthState)
logger.Debug().Msgf("Filtering container %s with healthState of %s", name, healthState)
return false
}
if state != "" && state != running && state != updatingRunning && state != upgraded {
logger.Debugf("Filtering container %s with state of %s", name, state)
logger.Debug().Msgf("Filtering container %s with state of %s", name, state)
return false
}

6
pkg/provider/rest/rest.go
View file

@ -6,8 +6,8 @@ import (
"net/http"
"github.com/gorilla/mux"
"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/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/unrolled/render"
@ -48,14 +48,14 @@ func (p *Provider) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
configuration := new(dynamic.Configuration)
if err := json.NewDecoder(req.Body).Decode(configuration); err != nil {
log.WithoutContext().Errorf("Error parsing configuration %+v", err)
log.Error().Err(err).Msg("Error parsing configuration")
http.Error(rw, fmt.Sprintf("%+v", err), http.StatusBadRequest)
return
}
p.configurationChan <- dynamic.Message{ProviderName: "rest", Configuration: configuration}
if err := templatesRenderer.JSON(rw, http.StatusOK, configuration); err != nil {
log.WithoutContext().Error(err)
log.Error().Err(err).Send()
}
}

34
pkg/provider/tailscale/provider.go
View file

@ -9,9 +9,10 @@ import (
"sync"
"time"
"github.com/rs/zerolog/log"
"github.com/tailscale/tscert"
"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/muxer/http"
"github.com/traefik/traefik/v2/pkg/muxer/tcp"
"github.com/traefik/traefik/v2/pkg/safe"
@ -56,21 +57,20 @@ func (p *Provider) HandleConfigUpdate(cfg dynamic.Configuration) {
func (p *Provider) Provide(dynMessages chan<- dynamic.Message, pool *safe.Pool) error {
p.dynMessages = dynMessages
fields := log.Str(log.ProviderName, p.ResolverName+".tailscale")
logger := log.With().Str(logs.ProviderName, p.ResolverName+".tailscale").Logger()
pool.GoCtx(func(ctx context.Context) {
p.watchDomains(log.With(ctx, fields))
p.watchDomains(logger.WithContext(ctx))
})
pool.GoCtx(func(ctx context.Context) {
p.renewCertificates(log.With(ctx, fields))
p.renewCertificates(logger.WithContext(ctx))
})
return nil
}
// watchDomains watches for Tailscale domain certificates that should be
// fetched from the Tailscale daemon.
// watchDomains watches for Tailscale domain certificates that should be fetched from the Tailscale daemon.
func (p *Provider) watchDomains(ctx context.Context) {
for {
select {
@ -110,9 +110,9 @@ func (p *Provider) renewCertificates(ctx context.Context) {
for domain, cert := range p.certByDomain {
tlsCert, err := cert.GetCertificateFromBytes()
if err != nil {
log.FromContext(ctx).
WithError(err).
Errorf("Unable to get certificate for domain %s", domain)
log.Ctx(ctx).
Err(err).
Msgf("Unable to get certificate for domain %s", domain)
continue
}
@ -139,7 +139,7 @@ func (p *Provider) renewCertificates(ctx context.Context) {
// findDomains goes through the given dynamic.Configuration and returns all
// Tailscale-specific domains found.
func (p *Provider) findDomains(ctx context.Context, cfg dynamic.Configuration) []string {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
var domains []string
@ -162,7 +162,7 @@ func (p *Provider) findDomains(ctx context.Context, cfg dynamic.Configuration) [
parsedDomains, err := http.ParseDomains(router.Rule)
if err != nil {
logger.Errorf("Unable to parse HTTP router domains: %v", err)
logger.Error().Err(err).Msg("Unable to parse HTTP router domains")
continue
}
@ -189,7 +189,7 @@ func (p *Provider) findDomains(ctx context.Context, cfg dynamic.Configuration) [
parsedDomains, err := tcp.ParseHostSNI(router.Rule)
if err != nil {
logger.Errorf("Unable to parse TCP router domains: %v", err)
logger.Error().Err(err).Msg("Unable to parse TCP router domains")
continue
}
@ -241,16 +241,16 @@ func (p *Provider) purgeUnusedCerts(domains []string) bool {
// fetchCerts fetches the certificates for the provided domains from the
// Tailscale daemon.
func (p *Provider) fetchCerts(ctx context.Context, domains []string) {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
for _, domain := range domains {
cert, key, err := tscert.CertPair(ctx, domain)
if err != nil {
logger.WithError(err).Errorf("Unable to fetch certificate for domain %q", domain)
logger.Error().Err(err).Msgf("Unable to fetch certificate for domain %q", domain)
continue
}
logger.Debugf("Fetched certificate for domain %q", domain)
logger.Debug().Msgf("Fetched certificate for domain %q", domain)
p.certByDomainMu.Lock()
p.certByDomain[domain] = traefiktls.Certificate{
@ -300,7 +300,7 @@ func (p *Provider) sendDynamicConfig() {
// sanitizeDomains removes duplicated and invalid Tailscale subdomains, from
// the provided list.
func sanitizeDomains(ctx context.Context, domains []string) []string {
logger := log.FromContext(ctx)
logger := log.Ctx(ctx)
seen := map[string]struct{}{}
@ -311,7 +311,7 @@ func sanitizeDomains(ctx context.Context, domains []string) []string {
}
if !isTailscaleDomain(domain) {
logger.Errorf("Domain %s is not a valid Tailscale domain", domain)
logger.Error().Msgf("Domain %s is not a valid Tailscale domain", domain)
continue
}

11
pkg/provider/traefik/internal.go
View file

@ -8,9 +8,10 @@ import (
"regexp"
"time"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/config/dynamic"
"github.com/traefik/traefik/v2/pkg/config/static"
"github.com/traefik/traefik/v2/pkg/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/provider"
"github.com/traefik/traefik/v2/pkg/safe"
"github.com/traefik/traefik/v2/pkg/tls"
@ -37,7 +38,7 @@ func (i Provider) ThrottleDuration() time.Duration {
// Provide allows the provider to provide configurations to traefik using the given configuration channel.
func (i *Provider) Provide(configurationChan chan<- dynamic.Message, _ *safe.Pool) error {
ctx := log.With(context.Background(), log.Str(log.ProviderName, "internal"))
ctx := log.With().Str(logs.ProviderName, "internal").Logger().WithContext(context.Background())
configurationChan <- dynamic.Message{
ProviderName: "internal",
@ -118,17 +119,17 @@ func (i *Provider) redirection(ctx context.Context, cfg *dynamic.Configuration)
continue
}
logger := log.FromContext(log.With(ctx, log.Str(log.EntryPointName, name)))
logger := log.Ctx(ctx).With().Str(logs.EntryPointName, name).Logger()
def := ep.HTTP.Redirections
if def.EntryPoint == nil || def.EntryPoint.To == "" {
logger.Error("Unable to create redirection: the entry point or the port is missing")
logger.Error().Msg("Unable to create redirection: the entry point or the port is missing")
continue
}
port, err := i.getRedirectPort(name, def)
if err != nil {
logger.Error(err)
logger.Error().Err(err).Send()
continue
}