This is an automated email from the ASF dual-hosted git repository.
ronething pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/apisix-ingress-controller.git
The following commit(s) were added to refs/heads/master by this push:
new 8a2b2b11 chore: unified logger print (#2456)
8a2b2b11 is described below
commit 8a2b2b11ed37c97fa9606675d4fafb0d186b2f0c
Author: Ashing Zheng <[email protected]>
AuthorDate: Sat Jul 5 22:21:24 2025 +0800
chore: unified logger print (#2456)
Signed-off-by: ashing <[email protected]>
Co-authored-by: Copilot <[email protected]>
---
internal/controller/apisixglobalrule_controller.go | 7 +++----
internal/controller/apisixtls_controller.go | 9 ++++----
internal/controller/consumer_controller.go | 2 +-
internal/controller/gateway_controller.go | 7 +++----
internal/controller/httproute_controller.go | 2 +-
internal/controller/ingress_controller.go | 2 +-
internal/controller/ingressclass_controller.go | 3 +--
internal/controller/utils.go | 24 +++++++++++-----------
internal/provider/adc/adc.go | 9 ++++++--
internal/provider/adc/executor.go | 4 ++--
internal/provider/adc/store.go | 18 ++++++++--------
internal/provider/adc/translator/apisixroute.go | 3 ++-
internal/provider/adc/translator/gateway.go | 3 ++-
internal/provider/adc/translator/httproute.go | 3 ++-
test/e2e/scaffold/adc.go | 2 +-
15 files changed, 51 insertions(+), 47 deletions(-)
diff --git a/internal/controller/apisixglobalrule_controller.go
b/internal/controller/apisixglobalrule_controller.go
index 70ee59d8..fc42b1fb 100644
--- a/internal/controller/apisixglobalrule_controller.go
+++ b/internal/controller/apisixglobalrule_controller.go
@@ -21,7 +21,6 @@ import (
"context"
"fmt"
- "github.com/api7/gopkg/pkg/log"
"github.com/go-logr/logr"
networkingv1 "k8s.io/api/networking/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -83,19 +82,19 @@ func (r *ApisixGlobalRuleReconciler) Reconcile(ctx
context.Context, req ctrl.Req
// get the ingress class
ingressClass, err := GetIngressClass(tctx, r.Client, r.Log,
globalRule.Spec.IngressClassName)
if err != nil {
- log.Error(err, "failed to get IngressClass")
+ r.Log.Error(err, "failed to get IngressClass")
return ctrl.Result{}, err
}
// process IngressClass parameters if they reference GatewayProxy
if err := ProcessIngressClassParameters(tctx, r.Client, r.Log,
&globalRule, ingressClass); err != nil {
- log.Error(err, "failed to process IngressClass parameters",
"ingressClass", ingressClass.Name)
+ r.Log.Error(err, "failed to process IngressClass parameters",
"ingressClass", ingressClass.Name)
return ctrl.Result{}, err
}
// Sync the global rule to APISIX
if err := r.Provider.Update(ctx, tctx, &globalRule); err != nil {
- log.Error(err, "failed to sync global rule to provider")
+ r.Log.Error(err, "failed to sync global rule to provider")
// Update status with failure condition
r.updateStatus(&globalRule, metav1.Condition{
Type: string(apiv2.ConditionTypeAccepted),
diff --git a/internal/controller/apisixtls_controller.go
b/internal/controller/apisixtls_controller.go
index 020aebcd..5cde26f6 100644
--- a/internal/controller/apisixtls_controller.go
+++ b/internal/controller/apisixtls_controller.go
@@ -21,7 +21,6 @@ import (
"context"
"fmt"
- "github.com/api7/gopkg/pkg/log"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1"
@@ -115,7 +114,7 @@ func (r *ApisixTlsReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
// get the ingress class
ingressClass, err := GetIngressClass(tctx, r.Client, r.Log,
tls.Spec.IngressClassName)
if err != nil {
- log.Error(err, "failed to get IngressClass")
+ r.Log.Error(err, "failed to get IngressClass")
r.updateStatus(&tls, metav1.Condition{
Type: string(apiv2.ConditionTypeAccepted),
Status: metav1.ConditionFalse,
@@ -129,7 +128,7 @@ func (r *ApisixTlsReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
// process IngressClass parameters if they reference GatewayProxy
if err := ProcessIngressClassParameters(tctx, r.Client, r.Log, &tls,
ingressClass); err != nil {
- log.Error(err, "failed to process IngressClass parameters",
"ingressClass", ingressClass.Name)
+ r.Log.Error(err, "failed to process IngressClass parameters",
"ingressClass", ingressClass.Name)
r.updateStatus(&tls, metav1.Condition{
Type: string(apiv2.ConditionTypeAccepted),
Status: metav1.ConditionFalse,
@@ -143,7 +142,7 @@ func (r *ApisixTlsReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
// process ApisixTls validation
if err := r.processApisixTls(ctx, tctx, &tls); err != nil {
- log.Error(err, "failed to process ApisixTls")
+ r.Log.Error(err, "failed to process ApisixTls")
r.updateStatus(&tls, metav1.Condition{
Type: string(apiv2.ConditionTypeAccepted),
Status: metav1.ConditionFalse,
@@ -156,7 +155,7 @@ func (r *ApisixTlsReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
}
if err := r.Provider.Update(ctx, tctx, &tls); err != nil {
- log.Error(err, "failed to sync apisix tls to provider")
+ r.Log.Error(err, "failed to sync apisix tls to provider")
// Update status with failure condition
r.updateStatus(&tls, metav1.Condition{
Type: string(apiv2.ConditionTypeAccepted),
diff --git a/internal/controller/consumer_controller.go
b/internal/controller/consumer_controller.go
index 0484680c..ef02e42f 100644
--- a/internal/controller/consumer_controller.go
+++ b/internal/controller/consumer_controller.go
@@ -212,7 +212,7 @@ func (r *ConsumerReconciler) Reconcile(ctx context.Context,
req ctrl.Request) (c
rk := utils.NamespacedNameKind(consumer)
- if err := ProcessGatewayProxy(r.Client, tctx, gateway, rk); err != nil {
+ if err := ProcessGatewayProxy(r.Client, r.Log, tctx, gateway, rk); err
!= nil {
r.Log.Error(err, "failed to process gateway proxy", "gateway",
gateway)
statusErr = err
}
diff --git a/internal/controller/gateway_controller.go
b/internal/controller/gateway_controller.go
index 31a64824..2ed7bf46 100644
--- a/internal/controller/gateway_controller.go
+++ b/internal/controller/gateway_controller.go
@@ -23,7 +23,6 @@ import (
"fmt"
"reflect"
- "github.com/api7/gopkg/pkg/log"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -412,7 +411,7 @@ func (r *GatewayReconciler)
listReferenceGrantsForGateway(ctx context.Context, o
}
func (r *GatewayReconciler) processInfrastructure(tctx
*provider.TranslateContext, gateway *gatewayv1.Gateway) error {
- return ProcessGatewayProxy(r.Client, tctx, gateway,
utils.NamespacedNameKind(gateway))
+ return ProcessGatewayProxy(r.Client, r.Log, tctx, gateway,
utils.NamespacedNameKind(gateway))
}
func (r *GatewayReconciler) processListenerConfig(tctx
*provider.TranslateContext, gateway *gatewayv1.Gateway) {
@@ -432,12 +431,12 @@ func (r *GatewayReconciler) processListenerConfig(tctx
*provider.TranslateContex
Namespace: ns,
Name: string(ref.Name),
}, &secret); err != nil {
- log.Error(err, "failed to get secret",
"namespace", ns, "name", ref.Name)
+ r.Log.Error(err, "failed to get
secret", "namespace", ns, "name", ref.Name)
SetGatewayListenerConditionProgrammed(gateway, string(listener.Name), false,
err.Error())
SetGatewayListenerConditionResolvedRefs(gateway, string(listener.Name), false,
err.Error())
break
}
- log.Info("Setting secret for listener",
"listener", listener.Name, "secret", secret.Name, " namespace", ns)
+ r.Log.Info("Setting secret for listener",
"listener", listener.Name, "secret", secret.Name, " namespace", ns)
tctx.Secrets[types.NamespacedName{Namespace:
ns, Name: string(ref.Name)}] = &secret
}
}
diff --git a/internal/controller/httproute_controller.go
b/internal/controller/httproute_controller.go
index 43d878fd..656095ba 100644
--- a/internal/controller/httproute_controller.go
+++ b/internal/controller/httproute_controller.go
@@ -177,7 +177,7 @@ func (r *HTTPRouteReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
tctx.RouteParentRefs = hr.Spec.ParentRefs
rk := utils.NamespacedNameKind(hr)
for _, gateway := range gateways {
- if err := ProcessGatewayProxy(r.Client, tctx, gateway.Gateway,
rk); err != nil {
+ if err := ProcessGatewayProxy(r.Client, r.Log, tctx,
gateway.Gateway, rk); err != nil {
acceptStatus.status = false
acceptStatus.msg = err.Error()
}
diff --git a/internal/controller/ingress_controller.go
b/internal/controller/ingress_controller.go
index 001a9f9b..d2a55079 100644
--- a/internal/controller/ingress_controller.go
+++ b/internal/controller/ingress_controller.go
@@ -471,7 +471,7 @@ func (r *IngressReconciler) processTLS(tctx
*provider.TranslateContext, ingress
Namespace: ingress.Namespace,
Name: tls.SecretName,
}, &secret); err != nil {
- log.Error(err, "failed to get secret", "namespace",
ingress.Namespace, "name", tls.SecretName)
+ r.Log.Error(err, "failed to get secret", "namespace",
ingress.Namespace, "name", tls.SecretName)
return err
}
diff --git a/internal/controller/ingressclass_controller.go
b/internal/controller/ingressclass_controller.go
index f653dbbd..c0e88f2d 100644
--- a/internal/controller/ingressclass_controller.go
+++ b/internal/controller/ingressclass_controller.go
@@ -21,7 +21,6 @@ import (
"context"
"fmt"
- "github.com/api7/gopkg/pkg/log"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1"
@@ -217,7 +216,7 @@ func (r *IngressClassReconciler) processInfrastructure(tctx
*provider.TranslateC
Namespace: namespace,
Name: secretRef.Name,
}, secret); err != nil {
- log.Error(err, "failed to get secret
for gateway proxy", "namespace", namespace, "name", secretRef.Name)
+ r.Log.Error(err, "failed to get secret
for gateway proxy", "namespace", namespace, "name", secretRef.Name)
return err
}
tctx.Secrets[client.ObjectKey{
diff --git a/internal/controller/utils.go b/internal/controller/utils.go
index 45cbf12c..f2abae16 100644
--- a/internal/controller/utils.go
+++ b/internal/controller/utils.go
@@ -380,8 +380,11 @@ func ParseRouteParentRefs(
listenerName = string(listener.Name)
ok, err := routeMatchesListenerAllowedRoutes(ctx, mgrc,
route, listener.AllowedRoutes, gateway.Namespace, parentRef.Namespace)
if err != nil {
- log.Warnf("failed matching listener %s to a
route %s for gateway %s: %v",
- listener.Name, route.GetName(),
gateway.Name, err,
+ log.Warnw("failed matching listener to a route
for gateway",
+ zap.String("listener",
string(listener.Name)),
+ zap.String("route", route.GetName()),
+ zap.String("gateway", gateway.Name),
+ zap.Error(err),
)
}
if !ok {
@@ -895,7 +898,7 @@ func SplitMetaNamespaceKey(key string) (namespace, name
string, err error) {
return "", "", fmt.Errorf("unexpected key format: %q", key)
}
-func ProcessGatewayProxy(r client.Client, tctx *provider.TranslateContext,
gateway *gatewayv1.Gateway, rk types.NamespacedNameKind) error {
+func ProcessGatewayProxy(r client.Client, log logr.Logger, tctx
*provider.TranslateContext, gateway *gatewayv1.Gateway, rk
types.NamespacedNameKind) error {
if gateway == nil {
return nil
}
@@ -914,10 +917,10 @@ func ProcessGatewayProxy(r client.Client, tctx
*provider.TranslateContext, gatew
Namespace: ns,
Name: paramRef.Name,
}, gatewayProxy); err != nil {
- log.Errorw("failed to get GatewayProxy",
zap.String("namespace", ns), zap.String("name", paramRef.Name), zap.Error(err))
+ log.Error(err, "failed to get GatewayProxy",
"namespace", ns, "name", paramRef.Name)
return err
} else {
- log.Infow("found GatewayProxy for Gateway",
zap.String("namespace", gateway.Namespace), zap.String("name", gateway.Name))
+ log.Info("found GatewayProxy for Gateway", "namespace",
gateway.Namespace, "name", gateway.Name)
tctx.GatewayProxies[gatewayKind] = *gatewayProxy
tctx.ResourceParentRefs[rk] =
append(tctx.ResourceParentRefs[rk], gatewayKind)
@@ -941,10 +944,7 @@ func ProcessGatewayProxy(r client.Client, tctx
*provider.TranslateContext, gatew
return err
}
- log.Info("found secret for
GatewayProxy provider",
- "gateway", gateway.Name,
- "gatewayproxy",
gatewayProxy.Name,
- "secret",
secretRef.Name)
+ log.Info("found secret for
GatewayProxy provider", "gateway", gateway.Name, "gatewayproxy",
gatewayProxy.Name, "secret", secretRef.Name)
tctx.Secrets[k8stypes.NamespacedName{
Namespace: ns,
@@ -1445,12 +1445,12 @@ func distinctRequests(requests []reconcile.Request)
[]reconcile.Request {
}
func addProviderEndpointsToTranslateContext(tctx *provider.TranslateContext, c
client.Client, serviceNN k8stypes.NamespacedName) error {
- log.Debugf("to process provider endpints by provider.service: %s",
serviceNN)
+ log.Debugw("to process provider endpoints by provider.service",
zap.Any("service", serviceNN))
var (
service corev1.Service
)
if err := c.Get(tctx, serviceNN, &service); err != nil {
- log.Error(err, "failed to get service from GatewayProxy
provider", "key", serviceNN)
+ log.Errorw("failed to get service from GatewayProxy provider",
zap.Error(err), zap.Any("key", serviceNN))
return err
}
tctx.Services[serviceNN] = &service
@@ -1464,7 +1464,7 @@ func addProviderEndpointsToTranslateContext(tctx
*provider.TranslateContext, c c
client.MatchingLabels{
discoveryv1.LabelServiceName: serviceNN.Name,
}); err != nil {
- log.Error(err, "failed to get endpoints for GatewayProxy
provider", "endpoints", serviceNN)
+ log.Errorw("failed to get endpoints for GatewayProxy provider",
zap.Error(err), zap.Any("endpoints", serviceNN))
return err
}
tctx.EndpointSlices[serviceNN] = esList.Items
diff --git a/internal/provider/adc/adc.go b/internal/provider/adc/adc.go
index 0ab02d44..8e7cac3f 100644
--- a/internal/provider/adc/adc.go
+++ b/internal/provider/adc/adc.go
@@ -366,7 +366,12 @@ func (d *adcClient) sync(ctx context.Context, task Task)
error {
var failedConfigs []string
for _, config := range task.configs {
if err := d.executor.Execute(ctx, d.BackendMode, config, args);
err != nil {
- log.Errorw("failed to execute adc command",
zap.Error(err), zap.Any("config", config))
+ log.Errorw("failed to execute adc command",
+ zap.Error(err),
+ zap.String("configName", config.Name),
+ zap.Any("serverAddrs", config.ServerAddrs),
+ zap.Bool("tlsVerify", config.TlsVerify),
+ )
failedConfigs = append(failedConfigs, config.Name)
}
}
@@ -395,7 +400,7 @@ func prepareSyncFile(resources any) (string, func(), error)
{
return "", nil, err
}
- log.Debugf("generated adc file, filename: %s, json: %s\n",
tmpFile.Name(), string(data))
+ log.Debugw("generated adc file", zap.String("filename",
tmpFile.Name()), zap.String("json", string(data)))
return tmpFile.Name(), cleanup, nil
}
diff --git a/internal/provider/adc/executor.go
b/internal/provider/adc/executor.go
index bd7b6c7f..774e7423 100644
--- a/internal/provider/adc/executor.go
+++ b/internal/provider/adc/executor.go
@@ -86,7 +86,7 @@ func (e *DefaultADCExecutor) runForSingleServer(ctx
context.Context, serverAddr,
cmd.Stderr = &stderr
cmd.Env = append(os.Environ(), env...)
- log.Debug("running adc command",
+ log.Debugw("running adc command",
zap.String("command", strings.Join(cmd.Args, " ")),
zap.Strings("env", env),
)
@@ -123,7 +123,7 @@ func (e *DefaultADCExecutor) buildCmdError(runErr error,
stdout, stderr []byte)
func (e *DefaultADCExecutor) handleOutput(output []byte) error {
var result adctypes.SyncResult
- log.Debugf("adc output: %s", string(output))
+ log.Debugw("adc output", zap.String("output", string(output)))
if lines := bytes.Split(output, []byte{'\n'}); len(lines) > 0 {
output = lines[len(lines)-1]
}
diff --git a/internal/provider/adc/store.go b/internal/provider/adc/store.go
index 62c554dc..d4c7056b 100644
--- a/internal/provider/adc/store.go
+++ b/internal/provider/adc/store.go
@@ -55,7 +55,7 @@ func (s *Store) Insert(name string, resourceTypes []string,
resources adctypes.R
s.cacheMap[name] = db
targetCache = s.cacheMap[name]
}
- log.Debugf("Inserting resources into cache for %s", name)
+ log.Debugw("Inserting resources into cache for", zap.String("name",
name))
selector := &cache.KindLabelSelector{
Kind: Labels[label.LabelKind],
Name: Labels[label.LabelName],
@@ -162,41 +162,41 @@ func (s *Store) Delete(name string, resourceTypes
[]string, Labels map[string]st
case "service":
services, err := targetCache.ListServices(selector)
if err != nil {
- log.Errorf("failed to list services: %v", err)
+ log.Errorw("failed to list services",
zap.Error(err))
}
for _, service := range services {
if err := targetCache.DeleteService(service);
err != nil {
- log.Errorf("failed to delete service
%s: %v", service.ID, err)
+ log.Errorw("failed to delete service",
zap.Error(err), zap.String("service", service.ID))
}
}
case "ssl":
ssls, err := targetCache.ListSSL(selector)
if err != nil {
- log.Errorf("failed to list ssl: %v", err)
+ log.Errorw("failed to list ssl", zap.Error(err))
}
for _, ssl := range ssls {
if err := targetCache.DeleteSSL(ssl); err !=
nil {
- log.Errorf("failed to delete ssl %s:
%v", ssl.ID, err)
+ log.Errorw("failed to delete ssl",
zap.Error(err), zap.String("ssl", ssl.ID))
}
}
case "consumer":
consumers, err := targetCache.ListConsumers(selector)
if err != nil {
- log.Errorf("failed to list consumers: %v", err)
+ log.Errorw("failed to list consumers",
zap.Error(err))
}
for _, consumer := range consumers {
if err := targetCache.DeleteConsumer(consumer);
err != nil {
- log.Errorf("failed to delete consumer
%s: %v", consumer.Username, err)
+ log.Errorw("failed to delete consumer",
zap.Error(err), zap.String("consumer", consumer.Username))
}
}
case "global_rule":
globalRules, err :=
targetCache.ListGlobalRules(selector)
if err != nil {
- log.Errorf("failed to list global rules: %v",
err)
+ log.Errorw("failed to list global rules",
zap.Error(err))
}
for _, globalRule := range globalRules {
if err :=
targetCache.DeleteGlobalRule(globalRule); err != nil {
- log.Errorf("failed to delete global
rule %s: %v", globalRule.ID, err)
+ log.Errorw("failed to delete global
rule", zap.Error(err), zap.String("global rule", globalRule.ID))
}
}
case "plugin_metadata":
diff --git a/internal/provider/adc/translator/apisixroute.go
b/internal/provider/adc/translator/apisixroute.go
index c622202e..3cf1a68c 100644
--- a/internal/provider/adc/translator/apisixroute.go
+++ b/internal/provider/adc/translator/apisixroute.go
@@ -25,6 +25,7 @@ import (
"github.com/api7/gopkg/pkg/log"
"github.com/pkg/errors"
+ "go.uber.org/zap"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
@@ -233,7 +234,7 @@ func (t *Translator) buildUpstream(tctx
*provider.TranslateContext, service *adc
}
au, ok := tctx.Upstreams[upsNN]
if !ok {
- log.Debugf("failed to retrieve ApisixUpstream from
tctx, ApisixUpstream: %s", upsNN)
+ log.Debugw("failed to retrieve ApisixUpstream from
tctx", zap.Any("ApisixUpstream", upsNN))
continue
}
upstream, err := t.translateApisixUpstream(tctx, au)
diff --git a/internal/provider/adc/translator/gateway.go
b/internal/provider/adc/translator/gateway.go
index 8a287d57..acfdf80b 100644
--- a/internal/provider/adc/translator/gateway.go
+++ b/internal/provider/adc/translator/gateway.go
@@ -96,11 +96,12 @@ func (t *Translator) translateSecret(tctx
*provider.TranslateContext, listener g
continue
}
if secret.Data == nil {
- log.Error("secret data is nil",
"secret", secret)
+ log.Errorw("secret data is nil",
zap.Any("secret", secret))
return nil, fmt.Errorf("no secret data
found for %s/%s", ns, name)
}
cert, key, err := extractKeyPair(secret, true)
if err != nil {
+ log.Errorw("failed to extract key
pair", zap.Error(err), zap.Any("secret", secret))
return nil, err
}
sslObj.Certificates =
append(sslObj.Certificates, adctypes.Certificate{
diff --git a/internal/provider/adc/translator/httproute.go
b/internal/provider/adc/translator/httproute.go
index 32cb9d8e..228111f5 100644
--- a/internal/provider/adc/translator/httproute.go
+++ b/internal/provider/adc/translator/httproute.go
@@ -274,7 +274,8 @@ func (t *Translator) fillHTTPRoutePolicies(routes
[]*adctypes.Route, policies []
for _, data := range policy.Spec.Vars {
var v []adctypes.StringOrSlice
if err := json.Unmarshal(data.Raw, &v); err !=
nil {
- log.Errorf("failed to unmarshal
spec.Vars item to []StringOrSlice, data: %s", string(data.Raw)) // todo: update
status
+ log.Errorw("failed to unmarshal
spec.Vars item to []StringOrSlice", zap.Error(err), zap.String("data",
string(data.Raw)))
+ // todo: update status
continue
}
route.Vars = append(route.Vars, v)
diff --git a/test/e2e/scaffold/adc.go b/test/e2e/scaffold/adc.go
index ef075689..12bd229e 100644
--- a/test/e2e/scaffold/adc.go
+++ b/test/e2e/scaffold/adc.go
@@ -143,7 +143,7 @@ func (a *adcDataplaneResource) dumpResources(ctx
context.Context) (*translator.T
cmd.Env = append(cmd.Env, os.Environ()...)
cmd.Env = append(cmd.Env, adcEnv...)
- log.Debug("running adc command", zap.String("command", cmd.String()),
zap.Strings("env", adcEnv))
+ log.Debugw("running adc command", zap.String("command", cmd.String()),
zap.Strings("env", adcEnv))
if err := cmd.Run(); err != nil {
stderrStr := stderr.String()
