chore: unified logger print (#2456)

ronething · Copilot · dspo · commit 9656885233ca · 2025-07-07T17:25:47.000+08:00
Signed-off-by: ashing <axingfly@gmail.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> (cherry picked from commit 8a2b2b1)
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -403,7 +403,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)
 		}
 	}
@@ -432,7 +437,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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -144,7 +144,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()

Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,7 @@ func (r *ConsumerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c`
`212`	`212`
`213`	`213`	`rk := utils.NamespacedNameKind(consumer)`
`214`	`214`
`215`		`- if err := ProcessGatewayProxy(r.Client, tctx, gateway, rk); err != nil {`
	`215`	`+ if err := ProcessGatewayProxy(r.Client, r.Log, tctx, gateway, rk); err != nil {`
`216`	`216`	`r.Log.Error(err, "failed to process gateway proxy", "gateway", gateway)`
`217`	`217`	`statusErr = err`
`218`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ import (`
`23`	`23`	`"fmt"`
`24`	`24`	`"reflect"`
`25`	`25`
`26`		`- "github.com/api7/gopkg/pkg/log"`
`27`	`26`	`"github.com/go-logr/logr"`
`28`	`27`	`corev1 "k8s.io/api/core/v1"`
`29`	`28`	`metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"`
`@@ -412,7 +411,7 @@ func (r *GatewayReconciler) listReferenceGrantsForGateway(ctx context.Context, o`
`412`	`411`	`}`
`413`	`412`
`414`	`413`	`func (r GatewayReconciler) processInfrastructure(tctx provider.TranslateContext, gateway *gatewayv1.Gateway) error {`
`415`		`- return ProcessGatewayProxy(r.Client, tctx, gateway, utils.NamespacedNameKind(gateway))`
	`414`	`+ return ProcessGatewayProxy(r.Client, r.Log, tctx, gateway, utils.NamespacedNameKind(gateway))`
`416`	`415`	`}`
`417`	`416`
`418`	`417`	`func (r GatewayReconciler) processListenerConfig(tctx provider.TranslateContext, gateway *gatewayv1.Gateway) {`
`@@ -432,12 +431,12 @@ func (r GatewayReconciler) processListenerConfig(tctx provider.TranslateContex`
`432`	`431`	`Namespace: ns,`
`433`	`432`	`Name: string(ref.Name),`
`434`	`433`	`}, &secret); err != nil {`
`435`		`- log.Error(err, "failed to get secret", "namespace", ns, "name", ref.Name)`
	`434`	`+ r.Log.Error(err, "failed to get secret", "namespace", ns, "name", ref.Name)`
`436`	`435`	`SetGatewayListenerConditionProgrammed(gateway, string(listener.Name), false, err.Error())`
`437`	`436`	`SetGatewayListenerConditionResolvedRefs(gateway, string(listener.Name), false, err.Error())`
`438`	`437`	`break`
`439`	`438`	`}`
`440`		`- log.Info("Setting secret for listener", "listener", listener.Name, "secret", secret.Name, " namespace", ns)`
	`439`	`+ r.Log.Info("Setting secret for listener", "listener", listener.Name, "secret", secret.Name, " namespace", ns)`
`441`	`440`	`tctx.Secrets[types.NamespacedName{Namespace: ns, Name: string(ref.Name)}] = &secret`
`442`	`441`	`}`
`443`	`442`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (`
`177`	`177`	`tctx.RouteParentRefs = hr.Spec.ParentRefs`
`178`	`178`	`rk := utils.NamespacedNameKind(hr)`
`179`	`179`	`for _, gateway := range gateways {`
`180`		`- if err := ProcessGatewayProxy(r.Client, tctx, gateway.Gateway, rk); err != nil {`
	`180`	`+ if err := ProcessGatewayProxy(r.Client, r.Log, tctx, gateway.Gateway, rk); err != nil {`
`181`	`181`	`acceptStatus.status = false`
`182`	`182`	`acceptStatus.msg = err.Error()`
`183`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -471,7 +471,7 @@ func (r IngressReconciler) processTLS(tctx provider.TranslateContext, ingress`
`471`	`471`	`Namespace: ingress.Namespace,`
`472`	`472`	`Name: tls.SecretName,`
`473`	`473`	`}, &secret); err != nil {`
`474`		`- log.Error(err, "failed to get secret", "namespace", ingress.Namespace, "name", tls.SecretName)`
	`474`	`+ r.Log.Error(err, "failed to get secret", "namespace", ingress.Namespace, "name", tls.SecretName)`
`475`	`475`	`return err`
`476`	`476`	`}`
`477`	`477`
Original file line number	Diff line number	Diff line change
`@@ -403,7 +403,12 @@ func (d *adcClient) sync(ctx context.Context, task Task) error {`
`403`	`403`	`var failedConfigs []string`
`404`	`404`	`for _, config := range task.configs {`
`405`	`405`	`if err := d.executor.Execute(ctx, d.BackendMode, config, args); err != nil {`
`406`		`- log.Errorw("failed to execute adc command", zap.Error(err), zap.Any("config", config))`
	`406`	`+ log.Errorw("failed to execute adc command",`
	`407`	`+ zap.Error(err),`
	`408`	`+ zap.String("configName", config.Name),`
	`409`	`+ zap.Any("serverAddrs", config.ServerAddrs),`
	`410`	`+ zap.Bool("tlsVerify", config.TlsVerify),`
	`411`	`+ )`
`407`	`412`	`failedConfigs = append(failedConfigs, config.Name)`
`408`	`413`	`}`
`409`	`414`	`}`
`@@ -432,7 +437,7 @@ func prepareSyncFile(resources any) (string, func(), error) {`
`432`	`437`	`return "", nil, err`
`433`	`438`	`}`
`434`	`439`
`435`		`- log.Debugf("generated adc file, filename: %s, json: %s\n", tmpFile.Name(), string(data))`
	`440`	`+ log.Debugw("generated adc file", zap.String("filename", tmpFile.Name()), zap.String("json", string(data)))`
`436`	`441`
`437`	`442`	`return tmpFile.Name(), cleanup, nil`
`438`	`443`	`}`