diff --git a/cmd/root/root.go b/cmd/root/root.go
index f9cc71f..577b056 100644
--- a/cmd/root/root.go
+++ b/cmd/root/root.go
@@ -38,7 +38,6 @@
 	"github.com/apache/apisix-ingress-controller/internal/controller/config"
 	"github.com/apache/apisix-ingress-controller/internal/manager"
 	"github.com/apache/apisix-ingress-controller/internal/version"
-	"github.com/api7/gopkg/pkg/log"
 )
 
 type GatewayConfigsFlag struct {
@@ -115,16 +114,6 @@
 				return err
 			}
 
-			l, err := log.NewLogger(
-				log.WithOutputFile("stderr"),
-				log.WithLogLevel(cfg.LogLevel),
-				log.WithSkipFrames(3),
-			)
-			if err != nil {
-				return err
-			}
-			log.DefaultLogger = l
-
 			// controllers log
 			core := zapcore.NewCore(
 				zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig()),
diff --git a/internal/adc/cache/store.go b/internal/adc/cache/store.go
index 7015226..6c5a1f2 100644
--- a/internal/adc/cache/store.go
+++ b/internal/adc/cache/store.go
@@ -21,9 +21,8 @@
 	"fmt"
 	"sync"
 
-	"github.com/api7/gopkg/pkg/log"
+	"github.com/go-logr/logr"
 	"github.com/google/uuid"
-	"go.uber.org/zap"
 
 	adctypes "github.com/apache/apisix-ingress-controller/api/adc"
 	"github.com/apache/apisix-ingress-controller/internal/controller/label"
@@ -34,12 +33,14 @@
 	pluginMetadataMap map[string]adctypes.PluginMetadata
 
 	sync.Mutex
+	log logr.Logger
 }
 
-func NewStore() *Store {
+func NewStore(log logr.Logger) *Store {
 	return &Store{
 		cacheMap:          make(map[string]Cache),
 		pluginMetadataMap: make(map[string]adctypes.PluginMetadata),
+		log:               log,
 	}
 }
 
@@ -55,7 +56,7 @@
 		s.cacheMap[name] = db
 		targetCache = s.cacheMap[name]
 	}
-	log.Debugw("Inserting resources into cache for", zap.String("name", name))
+	s.log.V(1).Info("Inserting resources into cache", "name", name, "resourceTypes", resourceTypes, "Labels", Labels)
 	selector := &KindLabelSelector{
 		Kind:      Labels[label.LabelKind],
 		Name:      Labels[label.LabelName],
@@ -162,41 +163,41 @@
 		case adctypes.TypeService:
 			services, err := targetCache.ListServices(selector)
 			if err != nil {
-				log.Errorw("failed to list services", zap.Error(err))
+				s.log.Error(err, "failed to list services")
 			}
 			for _, service := range services {
 				if err := targetCache.DeleteService(service); err != nil {
-					log.Errorw("failed to delete service", zap.Error(err), zap.String("service", service.ID))
+					s.log.Error(err, "failed to delete service", "service", service.ID)
 				}
 			}
 		case adctypes.TypeSSL:
 			ssls, err := targetCache.ListSSL(selector)
 			if err != nil {
-				log.Errorw("failed to list ssl", zap.Error(err))
+				s.log.Error(err, "failed to list ssl")
 			}
 			for _, ssl := range ssls {
 				if err := targetCache.DeleteSSL(ssl); err != nil {
-					log.Errorw("failed to delete ssl", zap.Error(err), zap.String("ssl", ssl.ID))
+					s.log.Error(err, "failed to delete ssl", "ssl", ssl.ID)
 				}
 			}
 		case adctypes.TypeConsumer:
 			consumers, err := targetCache.ListConsumers(selector)
 			if err != nil {
-				log.Errorw("failed to list consumers", zap.Error(err))
+				s.log.Error(err, "failed to list consumers")
 			}
 			for _, consumer := range consumers {
 				if err := targetCache.DeleteConsumer(consumer); err != nil {
-					log.Errorw("failed to delete consumer", zap.Error(err), zap.String("consumer", consumer.Username))
+					s.log.Error(err, "failed to delete consumer", "consumer", consumer.Username)
 				}
 			}
 		case adctypes.TypeGlobalRule:
 			globalRules, err := targetCache.ListGlobalRules(selector)
 			if err != nil {
-				log.Errorw("failed to list global rules", zap.Error(err))
+				s.log.Error(err, "failed to list global rules")
 			}
 			for _, globalRule := range globalRules {
 				if err := targetCache.DeleteGlobalRule(globalRule); err != nil {
-					log.Errorw("failed to delete global rule", zap.Error(err), zap.String("global rule", globalRule.ID))
+					s.log.Error(err, "failed to delete global rule", "global rule", globalRule.ID)
 				}
 			}
 		case adctypes.TypePluginMetadata:
@@ -229,7 +230,7 @@
 		}
 		globalrule = adctypes.GlobalRule(merged)
 	}
-	log.Debugw("get resources global rule items", zap.Any("globalRuleItems", globalRuleItems))
+	s.log.V(1).Info("GetResources fetched global rule items", "items", globalRuleItems, "gobalrule", globalrule)
 	if meta, ok := s.pluginMetadataMap[name]; ok {
 		metadata = meta.DeepCopy()
 	}
diff --git a/internal/adc/client/client.go b/internal/adc/client/client.go
index 3474636..b395199 100644
--- a/internal/adc/client/client.go
+++ b/internal/adc/client/client.go
@@ -26,9 +26,8 @@
 	"sync"
 	"time"
 
-	"github.com/api7/gopkg/pkg/log"
+	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 
 	adctypes "github.com/apache/apisix-ingress-controller/api/adc"
 	"github.com/apache/apisix-ingress-controller/internal/adc/cache"
@@ -47,22 +46,28 @@
 
 	ConfigManager    *common.ConfigManager[types.NamespacedNameKind, adctypes.Config]
 	ADCDebugProvider *common.ADCDebugProvider
+
+	log logr.Logger
 }
 
-func New(mode string, timeout time.Duration) (*Client, error) {
+func New(log logr.Logger, mode string, timeout time.Duration) (*Client, error) {
 	serverURL := os.Getenv("ADC_SERVER_URL")
 	if serverURL == "" {
 		serverURL = defaultHTTPADCExecutorAddr
 	}
-	store := cache.NewStore()
+	store := cache.NewStore(log)
 	configManager := common.NewConfigManager[types.NamespacedNameKind, adctypes.Config]()
-	log.Infow("using HTTP ADC Executor", zap.String("server_url", serverURL))
+
+	logger := log.WithName("client")
+	logger.Info("ADC client initialized", "mode", mode)
+
 	return &Client{
 		Store:            store,
-		executor:         NewHTTPADCExecutor(serverURL, timeout),
+		executor:         NewHTTPADCExecutor(log, serverURL, timeout),
 		BackendMode:      mode,
 		ConfigManager:    configManager,
 		ADCDebugProvider: common.NewADCDebugProvider(store, configManager),
+		log:              logger,
 	}, nil
 }
 
@@ -80,31 +85,31 @@
 	Applied map[types.NamespacedNameKind]adctypes.Config
 }
 
-func (d *Client) applyStoreChanges(args Task, isDelete bool) (StoreDelta, error) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
+func (c *Client) applyStoreChanges(args Task, isDelete bool) (StoreDelta, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 
 	var delta StoreDelta
 
 	if isDelete {
-		delta.Deleted = d.ConfigManager.Get(args.Key)
-		d.ConfigManager.Delete(args.Key)
+		delta.Deleted = c.ConfigManager.Get(args.Key)
+		c.ConfigManager.Delete(args.Key)
 	} else {
-		deleted := d.ConfigManager.Update(args.Key, args.Configs)
+		deleted := c.ConfigManager.Update(args.Key, args.Configs)
 		delta.Deleted = deleted
 		delta.Applied = args.Configs
 	}
 
 	for _, cfg := range delta.Deleted {
-		if err := d.Store.Delete(cfg.Name, args.ResourceTypes, args.Labels); err != nil {
-			log.Errorw("store delete failed", zap.Error(err), zap.Any("cfg", cfg), zap.Any("args", args))
+		if err := c.Store.Delete(cfg.Name, args.ResourceTypes, args.Labels); err != nil {
+			c.log.Error(err, "store delete failed", "cfg", cfg, "args", args)
 			return StoreDelta{}, errors.Wrap(err, fmt.Sprintf("store delete failed for config %s", cfg.Name))
 		}
 	}
 
 	for _, cfg := range delta.Applied {
-		if err := d.Insert(cfg.Name, args.ResourceTypes, args.Resources, args.Labels); err != nil {
-			log.Errorw("store insert failed", zap.Error(err), zap.Any("cfg", cfg), zap.Any("args", args))
+		if err := c.Insert(cfg.Name, args.ResourceTypes, args.Resources, args.Labels); err != nil {
+			c.log.Error(err, "store insert failed", "cfg", cfg, "args", args)
 			return StoreDelta{}, errors.Wrap(err, fmt.Sprintf("store insert failed for config %s", cfg.Name))
 		}
 	}
@@ -112,23 +117,23 @@
 	return delta, nil
 }
 
-func (d *Client) applySync(ctx context.Context, args Task, delta StoreDelta) error {
-	d.syncMu.RLock()
-	defer d.syncMu.RUnlock()
+func (c *Client) applySync(ctx context.Context, args Task, delta StoreDelta) error {
+	c.syncMu.RLock()
+	defer c.syncMu.RUnlock()
 
 	if len(delta.Deleted) > 0 {
-		if err := d.sync(ctx, Task{
+		if err := c.sync(ctx, Task{
 			Name:          args.Name,
 			Labels:        args.Labels,
 			ResourceTypes: args.ResourceTypes,
 			Configs:       delta.Deleted,
 		}); err != nil {
-			log.Warnw("failed to sync deleted configs", zap.Error(err))
+			c.log.Error(err, "failed to sync deleted configs", "args", args, "delta", delta)
 		}
 	}
 
 	if len(delta.Applied) > 0 {
-		return d.sync(ctx, Task{
+		return c.sync(ctx, Task{
 			Name:          args.Name,
 			Labels:        args.Labels,
 			ResourceTypes: args.ResourceTypes,
@@ -139,45 +144,45 @@
 	return nil
 }
 
-func (d *Client) Update(ctx context.Context, args Task) error {
-	delta, err := d.applyStoreChanges(args, false)
+func (c *Client) Update(ctx context.Context, args Task) error {
+	delta, err := c.applyStoreChanges(args, false)
 	if err != nil {
 		return err
 	}
-	return d.applySync(ctx, args, delta)
+	return c.applySync(ctx, args, delta)
 }
 
-func (d *Client) UpdateConfig(ctx context.Context, args Task) error {
-	_, err := d.applyStoreChanges(args, false)
+func (c *Client) UpdateConfig(ctx context.Context, args Task) error {
+	_, err := c.applyStoreChanges(args, false)
 	return err
 }
 
-func (d *Client) Delete(ctx context.Context, args Task) error {
-	delta, err := d.applyStoreChanges(args, true)
+func (c *Client) Delete(ctx context.Context, args Task) error {
+	delta, err := c.applyStoreChanges(args, true)
 	if err != nil {
 		return err
 	}
-	return d.applySync(ctx, args, delta)
+	return c.applySync(ctx, args, delta)
 }
 
-func (d *Client) DeleteConfig(ctx context.Context, args Task) error {
-	_, err := d.applyStoreChanges(args, true)
+func (c *Client) DeleteConfig(ctx context.Context, args Task) error {
+	_, err := c.applyStoreChanges(args, true)
 	return err
 }
 
 func (c *Client) Sync(ctx context.Context) (map[string]types.ADCExecutionErrors, error) {
 	c.syncMu.Lock()
 	defer c.syncMu.Unlock()
-	log.Debug("syncing all resources")
+	c.log.Info("syncing all resources")
 
 	configs := c.ConfigManager.List()
 
 	if len(configs) == 0 {
-		log.Warn("no GatewayProxy configs provided")
+		c.log.Info("no GatewayProxy configs provided")
 		return nil, nil
 	}
 
-	log.Debugw("syncing resources with multiple configs", zap.Any("configs", configs))
+	c.log.V(1).Info("syncing resources with multiple configs", "configs", configs)
 
 	failedMap := map[string]types.ADCExecutionErrors{}
 	var failedConfigs []string
@@ -185,7 +190,7 @@
 		name := config.Name
 		resources, err := c.GetResources(name)
 		if err != nil {
-			log.Errorw("failed to get resources from store", zap.String("name", name), zap.Error(err))
+			c.log.Error(err, "failed to get resources from store", "name", name)
 			failedConfigs = append(failedConfigs, name)
 			continue
 		}
@@ -200,7 +205,7 @@
 			},
 			Resources: resources,
 		}); err != nil {
-			log.Errorw("failed to sync resources", zap.String("name", name), zap.Error(err))
+			c.log.Error(err, "failed to sync resources", "name", name)
 			failedConfigs = append(failedConfigs, name)
 			var execErrs types.ADCExecutionErrors
 			if errors.As(err, &execErrs) {
@@ -219,10 +224,10 @@
 }
 
 func (c *Client) sync(ctx context.Context, task Task) error {
-	log.Debugw("syncing resources", zap.Any("task", task))
+	c.log.V(1).Info("syncing resources", "task", task)
 
 	if len(task.Configs) == 0 {
-		log.Warnw("no adc configs provided", zap.Any("task", task))
+		c.log.Info("no adc configs provided")
 		return nil
 	}
 
@@ -238,6 +243,7 @@
 	}
 	pkgmetrics.RecordFileIODuration("prepare_sync_file", adctypes.StatusSuccess, time.Since(fileIOStart).Seconds())
 	defer cleanup()
+	c.log.V(1).Info("prepared sync file", "path", syncFilePath)
 
 	args := BuildADCExecuteArgs(syncFilePath, task.Labels, task.ResourceTypes)
 
@@ -255,7 +261,7 @@
 		status := adctypes.StatusSuccess
 		if err != nil {
 			status = "failure"
-			log.Errorw("failed to execute adc command", zap.Error(err), zap.Any("config", config))
+			c.log.Error(err, "failed to execute adc command", "config", config)
 
 			var execErr types.ADCExecutionError
 			if errors.As(err, &execErr) {
@@ -295,7 +301,5 @@
 		return "", nil, err
 	}
 
-	log.Debugw("generated adc file", zap.String("filename", tmpFile.Name()), zap.String("json", string(data)))
-
 	return tmpFile.Name(), cleanup, nil
 }
diff --git a/internal/adc/client/executor.go b/internal/adc/client/executor.go
index bda6c7d..5d997ef 100644
--- a/internal/adc/client/executor.go
+++ b/internal/adc/client/executor.go
@@ -32,8 +32,7 @@
 	"sync"
 	"time"
 
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
+	"github.com/go-logr/logr"
 	"k8s.io/utils/ptr"
 
 	adctypes "github.com/apache/apisix-ingress-controller/api/adc"
@@ -50,6 +49,7 @@
 
 type DefaultADCExecutor struct {
 	sync.Mutex
+	log logr.Logger
 }
 
 func (e *DefaultADCExecutor) Execute(ctx context.Context, mode string, config adctypes.Config, args []string) error {
@@ -63,7 +63,7 @@
 
 	for _, addr := range config.ServerAddrs {
 		if err := e.runForSingleServerWithTimeout(ctx, addr, mode, config, args); err != nil {
-			log.Errorw("failed to run adc for server", zap.String("server", addr), zap.Error(err))
+			e.log.Error(err, "failed to run adc for server", "server", addr)
 			var execErr types.ADCExecutionServerAddrError
 			if errors.As(err, &execErr) {
 				execErrs.FailedErrors = append(execErrs.FailedErrors, execErr)
@@ -103,9 +103,9 @@
 	cmd.Stderr = &stderr
 	cmd.Env = append(os.Environ(), env...)
 
-	log.Debugw("running adc command",
-		zap.String("command", strings.Join(cmd.Args, " ")),
-		zap.Strings("env", filterSensitiveEnv(env)),
+	e.log.V(1).Info("running adc command",
+		"command", strings.Join(cmd.Args, " "),
+		"env", filterSensitiveEnv(env),
 	)
 
 	if err := cmd.Run(); err != nil {
@@ -114,22 +114,21 @@
 
 	result, err := e.handleOutput(stdout.Bytes())
 	if err != nil {
-		log.Errorw("failed to handle adc output",
-			zap.Error(err),
-			zap.String("stdout", stdout.String()),
-			zap.String("stderr", stderr.String()),
-		)
+		e.log.Error(err, "failed to handle adc output",
+			"stdout", stdout.String(),
+			"stderr", stderr.String())
 		return fmt.Errorf("failed to handle adc output: %w", err)
 	}
 	if result.FailedCount > 0 && len(result.Failed) > 0 {
-		log.Errorw("adc sync failed", zap.Any("result", result))
+		reason := result.Failed[0].Reason
+		e.log.Error(fmt.Errorf("adc sync failed: %s", reason), "adc sync failed", "result", result)
 		return types.ADCExecutionServerAddrError{
 			ServerAddr:     serverAddr,
-			Err:            result.Failed[0].Reason,
+			Err:            reason,
 			FailedStatuses: result.Failed,
 		}
 	}
-	log.Debugw("adc sync success", zap.Any("result", result))
+	e.log.V(1).Info("adc sync success", "result", result)
 	return nil
 }
 
@@ -161,28 +160,19 @@
 	if errMsg == "" {
 		errMsg = string(stdout)
 	}
-	log.Errorw("failed to run adc",
-		zap.Error(runErr),
-		zap.String("output", string(stdout)),
-		zap.String("stderr", string(stderr)),
-	)
+	e.log.Error(runErr, "failed to run adc", "output", string(stdout), "stderr", string(stderr))
 	return errors.New("failed to sync resources: " + errMsg + ", exit err: " + runErr.Error())
 }
 
 func (e *DefaultADCExecutor) handleOutput(output []byte) (*adctypes.SyncResult, error) {
+	e.log.V(1).Info("adc command output", "output", string(output))
 	var result adctypes.SyncResult
-	log.Debugw("adc output", zap.String("output", string(output)))
 	if lines := bytes.Split(output, []byte{'\n'}); len(lines) > 0 {
 		output = lines[len(lines)-1]
 	}
 	if err := json.Unmarshal(output, &result); err != nil {
-		log.Errorw("failed to unmarshal adc output",
-			zap.Error(err),
-			zap.String("stdout", string(output)),
-		)
-		return nil, errors.New("failed to parse adc result: " + err.Error())
+		return nil, errors.New("failed to unmarshal response: " + string(output) + ", err: " + err.Error())
 	}
-
 	return &result, nil
 }
 
@@ -226,11 +216,12 @@
 type HTTPADCExecutor struct {
 	httpClient *http.Client
 	serverURL  string
+	log        logr.Logger
 }
 
 // NewHTTPADCExecutor creates a new HTTPADCExecutor with the specified ADC Server URL.
 // serverURL can be "http(s)://host:port" or "unix:///path/to/socket" or "unix:/path/to/socket".
-func NewHTTPADCExecutor(serverURL string, timeout time.Duration) *HTTPADCExecutor {
+func NewHTTPADCExecutor(log logr.Logger, serverURL string, timeout time.Duration) *HTTPADCExecutor {
 	httpClient := &http.Client{
 		Timeout: timeout,
 	}
@@ -254,6 +245,7 @@
 	return &HTTPADCExecutor{
 		httpClient: httpClient,
 		serverURL:  serverURL,
+		log:        log.WithName("executor"),
 	}
 }
 
@@ -274,11 +266,11 @@
 		}
 		return config.ServerAddrs
 	}()
-	log.Debugw("running http sync", zap.Strings("serverAddrs", serverAddrs), zap.String("mode", mode))
+	e.log.V(1).Info("running http sync", "serverAddrs", serverAddrs, "mode", mode)
 
 	for _, addr := range serverAddrs {
 		if err := e.runHTTPSyncForSingleServer(ctx, addr, mode, config, args); err != nil {
-			log.Errorw("failed to run http sync for server", zap.String("server", addr), zap.Error(err))
+			e.log.Error(err, "failed to run http sync for server", "server", addr)
 			var execErr types.ADCExecutionServerAddrError
 			if errors.As(err, &execErr) {
 				execErrs.FailedErrors = append(execErrs.FailedErrors, execErr)
@@ -326,7 +318,7 @@
 	}
 	defer func() {
 		if closeErr := resp.Body.Close(); closeErr != nil {
-			log.Warnw("failed to close response body", zap.Error(closeErr))
+			e.log.Error(closeErr, "failed to close response body")
 		}
 	}()
 
@@ -405,21 +397,21 @@
 		},
 	}
 
+	e.log.V(1).Info("prepared request body", "body", reqBody)
+
 	jsonData, err := json.Marshal(reqBody)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal request body: %w", err)
 	}
 
-	log.Debugw("request body", zap.String("body", string(jsonData)))
-
-	log.Debugw("sending HTTP request to ADC Server",
-		zap.String("url", e.serverURL+"/sync"),
-		zap.String("server", serverAddr),
-		zap.String("mode", mode),
-		zap.String("cacheKey", config.Name),
-		zap.Any("labelSelector", labels),
-		zap.Strings("includeResourceType", types),
-		zap.Bool("tlsSkipVerify", !tlsVerify),
+	e.log.V(1).Info("sending HTTP request to ADC Server",
+		"url", e.serverURL+"/sync",
+		"server", serverAddr,
+		"mode", mode,
+		"cacheKey", config.Name,
+		"labelSelector", labels,
+		"includeResourceType", types,
+		"tlsSkipVerify", !tlsVerify,
 	)
 
 	// Create HTTP request
@@ -439,10 +431,10 @@
 		return fmt.Errorf("failed to read response body: %w", err)
 	}
 
-	log.Debugw("received HTTP response from ADC Server",
-		zap.String("server", serverAddr),
-		zap.Int("status", resp.StatusCode),
-		zap.String("response", string(body)),
+	e.log.V(1).Info("received HTTP response from ADC Server",
+		"server", serverAddr,
+		"status", resp.StatusCode,
+		"response", string(body),
 	)
 
 	// not only 200, HTTP 202 is also accepted
@@ -456,23 +448,20 @@
 	// Parse response body
 	var result adctypes.SyncResult
 	if err := json.Unmarshal(body, &result); err != nil {
-		log.Errorw("failed to unmarshal ADC Server response",
-			zap.Error(err),
-			zap.String("response", string(body)),
-		)
-		return fmt.Errorf("failed to parse ADC Server response: %w", err)
+		return fmt.Errorf("failed to unmarshal response body: %s, err: %w", string(body), err)
 	}
 
 	// Check for sync failures
 	if result.FailedCount > 0 && len(result.Failed) > 0 {
-		log.Errorw("ADC Server sync failed", zap.Any("result", result))
+		reason := result.Failed[0].Reason
+		e.log.Error(fmt.Errorf("ADC Server sync failed: %s", reason), "ADC Server sync failed", "result", result)
 		return types.ADCExecutionServerAddrError{
 			ServerAddr:     serverAddr,
-			Err:            result.Failed[0].Reason,
+			Err:            reason,
 			FailedStatuses: result.Failed,
 		}
 	}
 
-	log.Debugw("ADC Server sync success", zap.Any("result", result))
+	e.log.V(1).Info("ADC Server sync success", "result", result)
 	return nil
 }
diff --git a/internal/adc/translator/apisixroute.go b/internal/adc/translator/apisixroute.go
index 5e2e123..58a162c 100644
--- a/internal/adc/translator/apisixroute.go
+++ b/internal/adc/translator/apisixroute.go
@@ -23,9 +23,7 @@
 	"fmt"
 	"strconv"
 
-	"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"
@@ -232,7 +230,7 @@
 		}
 		au, ok := tctx.Upstreams[upsNN]
 		if !ok {
-			log.Debugw("failed to retrieve ApisixUpstream from tctx", zap.Any("ApisixUpstream", upsNN))
+			t.Log.V(1).Info("failed to retrieve ApisixUpstream from tctx", "ApisixUpstream", upsNN.String())
 			continue
 		}
 		upstream, err := t.translateApisixUpstream(tctx, au)
diff --git a/internal/adc/translator/apisixupstream.go b/internal/adc/translator/apisixupstream.go
index 7aec7ba..86a39e6 100644
--- a/internal/adc/translator/apisixupstream.go
+++ b/internal/adc/translator/apisixupstream.go
@@ -22,9 +22,7 @@
 	"fmt"
 	"maps"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 
@@ -39,7 +37,7 @@
 }
 
 func (t *Translator) translateApisixUpstreamForPort(tctx *provider.TranslateContext, au *apiv2.ApisixUpstream, port *int32) (*adc.Upstream, error) {
-	log.Debugw("translating ApisixUpstream", zap.Any("apisixupstream", au), zap.Int32p("port", port))
+	t.Log.V(1).Info("translating ApisixUpstream", "apisixupstream", au, "port", port)
 
 	ups := adc.NewDefaultUpstream()
 	ups.Name = composeExternalUpstreamName(au)
@@ -70,7 +68,7 @@
 		}
 	}
 
-	log.Debugw("translated ApisixUpstream", zap.Any("upstream", ups))
+	t.Log.V(1).Info("translated ApisixUpstream", "upstream", ups)
 
 	return ups, nil
 }
diff --git a/internal/adc/translator/gateway.go b/internal/adc/translator/gateway.go
index 43fc765..db28484 100644
--- a/internal/adc/translator/gateway.go
+++ b/internal/adc/translator/gateway.go
@@ -24,9 +24,7 @@
 	"fmt"
 	"slices"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
@@ -57,7 +55,7 @@
 	rk := utils.NamespacedNameKind(obj)
 	gatewayProxy, ok := tctx.GatewayProxies[rk]
 	if !ok {
-		log.Debugw("no GatewayProxy found for Gateway", zap.String("gateway", obj.Name))
+		t.Log.V(1).Info("no GatewayProxy found for Gateway", "gateway", obj.Name)
 		return result, nil
 	}
 
@@ -92,17 +90,18 @@
 					Snis: []string{},
 				}
 				name := listener.TLS.CertificateRefs[0].Name
-				secret := tctx.Secrets[types.NamespacedName{Namespace: ns, Name: string(ref.Name)}]
+				secretNN := types.NamespacedName{Namespace: ns, Name: string(ref.Name)}
+				secret := tctx.Secrets[secretNN]
 				if secret == nil {
 					continue
 				}
 				if secret.Data == nil {
-					log.Errorw("secret data is nil", zap.Any("secret", secret))
+					t.Log.Error(errors.New("secret data is nil"), "failed to get secret data", "secret", secretNN)
 					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))
+					t.Log.Error(err, "extract key pair", "secret", secretNN)
 					return nil, err
 				}
 				sslObj.Certificates = append(sslObj.Certificates, adctypes.Certificate{
@@ -118,14 +117,14 @@
 						return nil, err
 					}
 					if len(hosts) == 0 {
-						log.Warnw("no valid hostname found in certificate", zap.String("secret", secret.Namespace+"/"+secret.Name))
+						t.Log.Info("no valid hostname found in certificate", "secret", secretNN.String())
 						continue
 					}
 					sslObj.Snis = append(sslObj.Snis, hosts...)
 				}
 				// Note: use cert as id to avoid duplicate certificate across ssl objects
 				sslObj.ID = id.GenID(string(cert))
-				log.Debugw("generated ssl id", zap.String("ssl id", sslObj.ID), zap.String("secret", secret.Namespace+"/"+secret.Name))
+				t.Log.V(1).Info("generated ssl id", "ssl id", sslObj.ID, "secret", secretNN.String())
 				sslObj.Labels = label.GenLabel(obj)
 				sslObjs = append(sslObjs, sslObj)
 			}
@@ -219,13 +218,13 @@
 		pluginConfig := map[string]any{}
 		if len(plugin.Config.Raw) > 0 {
 			if err := json.Unmarshal(plugin.Config.Raw, &pluginConfig); err != nil {
-				log.Errorw("gateway proxy plugin config unmarshal failed", zap.Error(err), zap.String("plugin", pluginName))
+				t.Log.Error(err, "gateway proxy plugin config unmarshal failed", "plugin", pluginName)
 				continue
 			}
 		}
 		plugins[pluginName] = pluginConfig
 	}
-	log.Debugw("fill plugins for gateway proxy", zap.Any("plugins", plugins))
+	t.Log.V(1).Info("fill plugins for gateway proxy", "plugins", plugins)
 }
 
 func (t *Translator) fillPluginMetadataFromGatewayProxy(pluginMetadata adctypes.PluginMetadata, gatewayProxy *v1alpha1.GatewayProxy) {
@@ -235,10 +234,10 @@
 	for pluginName, plugin := range gatewayProxy.Spec.PluginMetadata {
 		var pluginConfig map[string]any
 		if err := json.Unmarshal(plugin.Raw, &pluginConfig); err != nil {
-			log.Errorw("gateway proxy plugin_metadata unmarshal failed", zap.Error(err), zap.Any("plugin", pluginName), zap.String("config", string(plugin.Raw)))
+			t.Log.Error(err, "gateway proxy plugin_metadata unmarshal failed", "plugin", pluginName, "config", string(plugin.Raw))
 			continue
 		}
-		log.Debugw("fill plugin_metadata for gateway proxy", zap.String("plugin", pluginName), zap.Any("config", pluginConfig))
+		t.Log.V(1).Info("fill plugin_metadata for gateway proxy", "plugin", pluginName, "config", pluginConfig)
 		pluginMetadata[pluginName] = pluginConfig
 	}
 }
diff --git a/internal/adc/translator/gatewayproxy.go b/internal/adc/translator/gatewayproxy.go
index 8b7fb67..6636816 100644
--- a/internal/adc/translator/gatewayproxy.go
+++ b/internal/adc/translator/gatewayproxy.go
@@ -22,9 +22,7 @@
 	"net"
 	"strconv"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	k8stypes "k8s.io/apimachinery/pkg/types"
@@ -108,7 +106,7 @@
 				},
 			}, func(endpoint *discoveryv1.Endpoint) bool {
 				if endpoint.Conditions.Terminating != nil && *endpoint.Conditions.Terminating {
-					log.Debugw("skip terminating endpoint", zap.Any("endpoint", endpoint))
+					t.Log.V(1).Info("skip terminating endpoint", "endpoint", endpoint)
 					return false
 				}
 				return true
@@ -130,7 +128,7 @@
 			config.ServerAddrs = []string{serverAddr}
 		}
 
-		log.Debugw("add server address to config.ServiceAddrs", zap.Strings("config.ServerAddrs", config.ServerAddrs))
+		t.Log.V(1).Info("add server address to config.ServiceAddrs", "config.ServerAddrs", config.ServerAddrs)
 	}
 
 	return &config, nil
diff --git a/internal/adc/translator/globalrule.go b/internal/adc/translator/globalrule.go
index 692321d..89f1626 100644
--- a/internal/adc/translator/globalrule.go
+++ b/internal/adc/translator/globalrule.go
@@ -20,9 +20,6 @@
 import (
 	"encoding/json"
 
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
-
 	adctypes "github.com/apache/apisix-ingress-controller/api/adc"
 	apiv2 "github.com/apache/apisix-ingress-controller/api/v2"
 	"github.com/apache/apisix-ingress-controller/internal/provider"
@@ -30,10 +27,7 @@
 
 // TranslateApisixGlobalRule translates ApisixGlobalRule to APISIX GlobalRule
 func (t *Translator) TranslateApisixGlobalRule(tctx *provider.TranslateContext, obj *apiv2.ApisixGlobalRule) (*TranslateResult, error) {
-	log.Debugw("translating ApisixGlobalRule",
-		zap.String("namespace", obj.Namespace),
-		zap.String("name", obj.Name),
-	)
+	t.Log.V(1).Info("translating ApisixGlobalRule", "namespace", obj.Namespace, "name", obj.Name)
 
 	// Create global rule plugins
 	plugins := make(adctypes.Plugins)
@@ -48,7 +42,7 @@
 		pluginConfig := make(map[string]any)
 		if len(plugin.Config.Raw) > 0 {
 			if err := json.Unmarshal(plugin.Config.Raw, &pluginConfig); err != nil {
-				log.Errorw("failed to unmarshal plugin config", zap.String("plugin", plugin.Name), zap.Error(err))
+				t.Log.Error(err, "failed to unmarshal plugin config", "plugin", plugin.Name)
 				continue
 			}
 		}
diff --git a/internal/adc/translator/httproute.go b/internal/adc/translator/httproute.go
index d88b32c..7d829b1 100644
--- a/internal/adc/translator/httproute.go
+++ b/internal/adc/translator/httproute.go
@@ -22,9 +22,7 @@
 	"fmt"
 	"strings"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -84,13 +82,13 @@
 			pluginconfig := make(map[string]any)
 			if len(plugin.Config.Raw) > 0 {
 				if err := json.Unmarshal(plugin.Config.Raw, &pluginconfig); err != nil {
-					log.Errorw("plugin config unmarshal failed", zap.Error(err))
+					t.Log.Error(err, "plugin config unmarshal failed", "plugin", plugin.Name)
 					continue
 				}
 			}
 			plugins[pluginName] = pluginconfig
 		}
-		log.Debugw("fill plugin from extension ref", zap.Any("plugins", plugins))
+		t.Log.V(1).Info("fill plugin from extension ref", "plugins", plugins)
 	}
 }
 
@@ -322,7 +320,7 @@
 			for _, data := range policy.Spec.Vars {
 				var v []adctypes.StringOrSlice
 				if err := json.Unmarshal(data.Raw, &v); err != nil {
-					log.Errorw("failed to unmarshal spec.Vars item to []StringOrSlice", zap.Error(err), zap.String("data", string(data.Raw)))
+					t.Log.Error(err, "failed to unmarshal spec.Vars item to []StringOrSlice", "data", string(data.Raw))
 					// todo: update status
 					continue
 				}
@@ -344,6 +342,7 @@
 			}
 			for _, endpoint := range endpointSlice.Endpoints {
 				if endpointFilter != nil && !endpointFilter(&endpoint) {
+					t.Log.V(1).Info("skip endpoint by filter", "endpoint", endpoint)
 					continue
 				}
 				for _, addr := range endpoint.Addresses {
@@ -366,7 +365,6 @@
 
 func DefaultEndpointFilter(endpoint *discoveryv1.Endpoint) bool {
 	if endpoint.Conditions.Ready != nil && !*endpoint.Conditions.Ready {
-		log.Debugw("skip not ready endpoint", zap.Any("endpoint", endpoint))
 		return false
 	}
 	return true
diff --git a/internal/adc/translator/ingressclass.go b/internal/adc/translator/ingressclass.go
index d914259..064bd77 100644
--- a/internal/adc/translator/ingressclass.go
+++ b/internal/adc/translator/ingressclass.go
@@ -18,8 +18,6 @@
 package translator
 
 import (
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
 	networkingv1 "k8s.io/api/networking/v1"
 
 	adctypes "github.com/apache/apisix-ingress-controller/api/adc"
@@ -33,7 +31,7 @@
 	rk := utils.NamespacedNameKind(obj)
 	gatewayProxy, ok := tctx.GatewayProxies[rk]
 	if !ok {
-		log.Debugw("no GatewayProxy found for IngressClass", zap.String("ingressclass", obj.Name))
+		t.Log.V(1).Info("no GatewayProxy found for IngressClass", "ingressclass", obj.Name)
 		return result, nil
 	}
 
diff --git a/internal/adc/translator/translator.go b/internal/adc/translator/translator.go
index 4c9bf0d..aeaef25 100644
--- a/internal/adc/translator/translator.go
+++ b/internal/adc/translator/translator.go
@@ -29,7 +29,7 @@
 
 func NewTranslator(log logr.Logger) *Translator {
 	return &Translator{
-		Log: log,
+		Log: log.WithName("translator"),
 	}
 }
 
diff --git a/internal/controller/apisixroute_controller.go b/internal/controller/apisixroute_controller.go
index dd57202..c6e3afd 100644
--- a/internal/controller/apisixroute_controller.go
+++ b/internal/controller/apisixroute_controller.go
@@ -24,9 +24,7 @@
 	"fmt"
 	"slices"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/go-logr/logr"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	networkingv1 "k8s.io/api/networking/v1"
@@ -409,9 +407,9 @@
 	}
 
 	// try to get apisixupstream with the same name as the backend service
-	log.Debugw("try to get apisixupstream with the same name as the backend service", zap.Stringer("Service", serviceNN))
+	r.Log.V(1).Info("try to get apisixupstream with the same name as the backend service", "Service", serviceNN)
 	if err := r.Get(tctx, serviceNN, &au); err != nil {
-		log.Debugw("no ApisixUpstream with the same name as the backend service found", zap.Stringer("Service", serviceNN), zap.Error(err))
+		r.Log.V(1).Info("no ApisixUpstream with the same name as the backend service found", "Service", serviceNN, "Error", err)
 		if err = client.IgnoreNotFound(err); err != nil {
 			return err
 		}
diff --git a/internal/controller/gatewayproxy_controller.go b/internal/controller/gatewayproxy_controller.go
index 7b27d31..b2dd798 100644
--- a/internal/controller/gatewayproxy_controller.go
+++ b/internal/controller/gatewayproxy_controller.go
@@ -100,7 +100,7 @@
 	if providerService == nil {
 		tctx.EndpointSlices[req.NamespacedName] = nil
 	} else {
-		if err := addProviderEndpointsToTranslateContext(tctx, r.Client, types.NamespacedName{
+		if err := addProviderEndpointsToTranslateContext(tctx, r.Client, r.Log, types.NamespacedName{
 			Namespace: gp.Namespace,
 			Name:      providerService.Name,
 		}); err != nil {
diff --git a/internal/controller/grpcroute_controller.go b/internal/controller/grpcroute_controller.go
index 782f98f..3b42341 100644
--- a/internal/controller/grpcroute_controller.go
+++ b/internal/controller/grpcroute_controller.go
@@ -182,7 +182,7 @@
 		msg:    "Route is accepted",
 	}
 
-	gateways, err := ParseRouteParentRefs(ctx, r.Client, gr, gr.Spec.ParentRefs)
+	gateways, err := ParseRouteParentRefs(ctx, r.Client, r.Log, gr, gr.Spec.ParentRefs)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
diff --git a/internal/controller/httproute_controller.go b/internal/controller/httproute_controller.go
index 8cd7b50..1c449e7 100644
--- a/internal/controller/httproute_controller.go
+++ b/internal/controller/httproute_controller.go
@@ -22,10 +22,8 @@
 	"context"
 	"fmt"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
-	"go.uber.org/zap"
 	"golang.org/x/exp/slices"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
@@ -167,7 +165,7 @@
 		msg:    "Route is accepted",
 	}
 
-	gateways, err := ParseRouteParentRefs(ctx, r.Client, hr, hr.Spec.ParentRefs)
+	gateways, err := ParseRouteParentRefs(ctx, r.Client, r.Log, hr, hr.Spec.ParentRefs)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
@@ -250,7 +248,7 @@
 	if isRouteAccepted(gateways) && err == nil {
 		routeToUpdate := hr
 		if filteredHTTPRoute != nil {
-			log.Debugw("filteredHTTPRoute", zap.Any("filteredHTTPRoute", filteredHTTPRoute))
+			r.Log.V(1).Info("filtered httproute", "httproute", filteredHTTPRoute)
 			routeToUpdate = filteredHTTPRoute
 		}
 		if err := r.Provider.Update(ctx, tctx, routeToUpdate); err != nil {
diff --git a/internal/controller/ingress_controller.go b/internal/controller/ingress_controller.go
index 8ef3d73..5fe611d 100644
--- a/internal/controller/ingress_controller.go
+++ b/internal/controller/ingress_controller.go
@@ -22,9 +22,7 @@
 	"fmt"
 	"reflect"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/go-logr/logr"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	networkingv1 "k8s.io/api/networking/v1"
@@ -467,7 +465,7 @@
 		}
 
 		if secret.Data == nil {
-			log.Warnw("secret data is nil", zap.String("secret", secret.Namespace+"/"+secret.Name))
+			r.Log.Error(fmt.Errorf("no secret data found"), "secret data is nil", "namespace", ingress.Namespace, "name", tls.SecretName)
 			continue
 		}
 
@@ -571,7 +569,7 @@
 
 	gatewayProxy, ok := tctx.GatewayProxies[ingressClassKind]
 	if !ok {
-		log.Debugw("no gateway proxy found for ingress class", zap.String("ingressClass", ingressClass.Name))
+		r.Log.V(1).Info("no gateway proxy found for ingress class", "ingressClass", ingressClass.Name)
 		return nil
 	}
 
diff --git a/internal/controller/ingressclass_controller.go b/internal/controller/ingressclass_controller.go
index fe11b7f..5594ee6 100644
--- a/internal/controller/ingressclass_controller.go
+++ b/internal/controller/ingressclass_controller.go
@@ -228,7 +228,7 @@
 	}
 
 	if service := gatewayProxy.Spec.Provider.ControlPlane.Service; service != nil {
-		if err := addProviderEndpointsToTranslateContext(tctx, r.Client, types.NamespacedName{
+		if err := addProviderEndpointsToTranslateContext(tctx, r.Client, r.Log, types.NamespacedName{
 			Namespace: gatewayProxy.GetNamespace(),
 			Name:      service.Name,
 		}); err != nil {
diff --git a/internal/controller/tcproute_controller.go b/internal/controller/tcproute_controller.go
index 271198a..125a14a 100644
--- a/internal/controller/tcproute_controller.go
+++ b/internal/controller/tcproute_controller.go
@@ -255,7 +255,7 @@
 		msg:    "Route is accepted",
 	}
 
-	gateways, err := ParseRouteParentRefs(ctx, r.Client, tr, tr.Spec.ParentRefs)
+	gateways, err := ParseRouteParentRefs(ctx, r.Client, r.Log, tr, tr.Spec.ParentRefs)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
diff --git a/internal/controller/udproute_controller.go b/internal/controller/udproute_controller.go
index 88b1136..2a4a7a4 100644
--- a/internal/controller/udproute_controller.go
+++ b/internal/controller/udproute_controller.go
@@ -255,7 +255,7 @@
 		msg:    "Route is accepted",
 	}
 
-	gateways, err := ParseRouteParentRefs(ctx, r.Client, tr, tr.Spec.ParentRefs)
+	gateways, err := ParseRouteParentRefs(ctx, r.Client, r.Log, tr, tr.Spec.ParentRefs)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
diff --git a/internal/controller/utils.go b/internal/controller/utils.go
index 4a0e9a6..530e7c4 100644
--- a/internal/controller/utils.go
+++ b/internal/controller/utils.go
@@ -28,10 +28,8 @@
 	"slices"
 	"strings"
 
-	"github.com/api7/gopkg/pkg/log"
 	"github.com/go-logr/logr"
 	"github.com/samber/lo"
-	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	networkingv1 "k8s.io/api/networking/v1"
@@ -318,7 +316,11 @@
 }
 
 func ParseRouteParentRefs(
-	ctx context.Context, mgrc client.Client, route client.Object, parentRefs []gatewayv1.ParentReference,
+	ctx context.Context,
+	mgrc client.Client,
+	log logr.Logger,
+	route client.Object,
+	parentRefs []gatewayv1.ParentReference,
 ) ([]RouteParentRefContext, error) {
 	gateways := make([]RouteParentRefContext, 0)
 	for _, parentRef := range parentRefs {
@@ -387,12 +389,10 @@
 			listenerName = string(listener.Name)
 			ok, err := routeMatchesListenerAllowedRoutes(ctx, mgrc, route, listener.AllowedRoutes, gateway.Namespace, parentRef.Namespace)
 			if err != nil {
-				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),
-				)
+				log.Error(err, "failed matching listener to a route for gateway",
+					"listener", string(listener.Name),
+					"route", route.GetName(),
+					"gateway", gateway.Name)
 			}
 			if !ok {
 				reason = gatewayv1.RouteReasonNotAllowedByListeners
@@ -975,7 +975,7 @@
 					}
 
 					if cp.Service != nil {
-						if err := addProviderEndpointsToTranslateContext(tctx, r, k8stypes.NamespacedName{
+						if err := addProviderEndpointsToTranslateContext(tctx, r, log, k8stypes.NamespacedName{
 							Namespace: gatewayProxy.GetNamespace(),
 							Name:      cp.Service.Name,
 						}); err != nil {
@@ -1031,7 +1031,6 @@
 		}
 	}
 
-	log.Debugw("filtered hostnames", zap.Any("httpRouteHostnames", httpRoute.Spec.Hostnames), zap.Any("hostnames", filteredHostnames))
 	httpRoute.Spec.Hostnames = filteredHostnames
 	return httpRoute, nil
 }
@@ -1345,7 +1344,7 @@
 
 				// process control plane provider service
 				if cp.Service != nil {
-					if err := addProviderEndpointsToTranslateContext(tctx, c, client.ObjectKey{
+					if err := addProviderEndpointsToTranslateContext(tctx, c, log, client.ObjectKey{
 						Namespace: gatewayProxy.GetNamespace(),
 						Name:      cp.Service.Name,
 					}); err != nil {
@@ -1411,13 +1410,13 @@
 	return distinctRequests
 }
 
-func addProviderEndpointsToTranslateContext(tctx *provider.TranslateContext, c client.Client, serviceNN k8stypes.NamespacedName) error {
-	log.Debugw("to process provider endpoints by provider.service", zap.Any("service", serviceNN))
+func addProviderEndpointsToTranslateContext(tctx *provider.TranslateContext, c client.Client, log logr.Logger, serviceNN k8stypes.NamespacedName) error {
+	log.V(1).Info("to process provider endpoints by provider.service", "service", serviceNN)
 	var (
 		service corev1.Service
 	)
 	if err := c.Get(tctx, serviceNN, &service); err != nil {
-		log.Errorw("failed to get service from GatewayProxy provider", zap.Error(err), zap.Any("key", serviceNN))
+		log.Error(err, "failed to get service from GatewayProxy provider", "service", serviceNN)
 		return err
 	}
 	tctx.Services[serviceNN] = &service
@@ -1431,7 +1430,8 @@
 		client.MatchingLabels{
 			discoveryv1.LabelServiceName: serviceNN.Name,
 		}); err != nil {
-		log.Errorw("failed to get endpoints for GatewayProxy provider", zap.Error(err), zap.Any("endpoints", serviceNN))
+		log.Error(err, "failed to get endpoints for GatewayProxy provider", "endpoints", serviceNN)
+
 		return err
 	}
 	tctx.EndpointSlices[serviceNN] = esList.Items
diff --git a/internal/manager/readiness/manager.go b/internal/manager/readiness/manager.go
index 7ba4b83..eca380e 100644
--- a/internal/manager/readiness/manager.go
+++ b/internal/manager/readiness/manager.go
@@ -24,8 +24,7 @@
 	"sync/atomic"
 	"time"
 
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
+	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	k8stypes "k8s.io/apimachinery/pkg/types"
@@ -79,16 +78,19 @@
 	done      chan struct{}
 
 	isReady atomic.Bool
+
+	log logr.Logger
 }
 
 // ReadinessManager tracks readiness of specific resources across the cluster.
-func NewReadinessManager(client client.Client) ReadinessManager {
+func NewReadinessManager(client client.Client, log logr.Logger) ReadinessManager {
 	return &readinessManager{
 		client:  client,
 		state:   make(map[schema.GroupVersionKind]map[k8stypes.NamespacedName]struct{}),
 		started: make(chan struct{}),
 		done:    make(chan struct{}),
 		isReady: atomic.Bool{},
+		log:     log.WithName("readiness"),
 	}
 }
 
@@ -123,7 +125,7 @@
 					})
 				}
 				if len(expected) > 0 {
-					log.Debugw("registering readiness state", zap.Any("gvk", gvk), zap.Any("expected", expected))
+					r.log.V(1).Info("registering readiness state", "gvk", gvk, "expected", expected)
 					r.registerState(gvk, expected)
 				}
 			}
diff --git a/internal/manager/run.go b/internal/manager/run.go
index 6adde7d..fe16baf 100644
--- a/internal/manager/run.go
+++ b/internal/manager/run.go
@@ -164,7 +164,7 @@
 		return err
 	}
 
-	readier := readiness.NewReadinessManager(mgr.GetClient())
+	readier := readiness.NewReadinessManager(mgr.GetClient(), logger)
 	registerReadinessGVK(mgr.GetClient(), readier)
 
 	if err := mgr.Add(readier); err != nil {
@@ -179,12 +179,13 @@
 
 	providerType := string(config.ControllerConfig.ProviderConfig.Type)
 
-	provider, err := provider.New(providerType, updater.Writer(), readier, &provider.Options{
+	providerOptions := &provider.Options{
 		SyncTimeout:   config.ControllerConfig.ExecADCTimeout.Duration,
 		SyncPeriod:    config.ControllerConfig.ProviderConfig.SyncPeriod.Duration,
 		InitSyncDelay: config.ControllerConfig.ProviderConfig.InitSyncDelay.Duration,
 		BackendMode:   string(config.ControllerConfig.ProviderConfig.Type),
-	})
+	}
+	provider, err := provider.New(providerType, logger, updater.Writer(), readier, providerOptions)
 	if err != nil {
 		setupLog.Error(err, "unable to create provider")
 		return err
diff --git a/internal/provider/apisix/provider.go b/internal/provider/apisix/provider.go
index 188e6c2..64d694c 100644
--- a/internal/provider/apisix/provider.go
+++ b/internal/provider/apisix/provider.go
@@ -23,8 +23,7 @@
 	"sync"
 	"time"
 
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
+	"github.com/go-logr/logr"
 	networkingv1 "k8s.io/api/networking/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
@@ -67,16 +66,17 @@
 	syncCh chan struct{}
 
 	client *adcclient.Client
+	log    logr.Logger
 }
 
-func New(updater status.Updater, readier readiness.ReadinessManager, opts ...provider.Option) (provider.Provider, error) {
+func New(log logr.Logger, updater status.Updater, readier readiness.ReadinessManager, opts ...provider.Option) (provider.Provider, error) {
 	o := provider.Options{}
 	o.ApplyOptions(opts)
 	if o.BackendMode == "" {
 		o.BackendMode = ProviderTypeAPISIX
 	}
 
-	cli, err := adcclient.New(o.BackendMode, o.SyncTimeout)
+	cli, err := adcclient.New(log, o.BackendMode, o.SyncTimeout)
 	if err != nil {
 		return nil, err
 	}
@@ -84,10 +84,11 @@
 	return &apisixProvider{
 		client:     cli,
 		Options:    o,
-		translator: &translator.Translator{},
+		translator: translator.NewTranslator(log),
 		updater:    updater,
 		readier:    readier,
 		syncCh:     make(chan struct{}, 1),
+		log:        log.WithName("provider"),
 	}, nil
 }
 
@@ -96,7 +97,7 @@
 }
 
 func (d *apisixProvider) Update(ctx context.Context, tctx *provider.TranslateContext, obj client.Object) error {
-	log.Debugw("updating object", zap.Any("object", obj))
+	d.log.V(1).Info("updating object", "object", obj)
 	var (
 		result        *translator.TranslateResult
 		resourceTypes []string
@@ -177,13 +178,13 @@
 			Consumers:      result.Consumers,
 		},
 	}
-	log.Debugw("updating config", zap.Any("task", task))
+	d.log.V(1).Info("updating config", "task", task)
 
 	return d.client.UpdateConfig(ctx, task)
 }
 
 func (d *apisixProvider) Delete(ctx context.Context, obj client.Object) error {
-	log.Debugw("deleting object", zap.Any("object", obj))
+	d.log.V(1).Info("deleting object", "object", obj)
 
 	var resourceTypes []string
 	var labels map[string]string
@@ -270,7 +271,7 @@
 			return nil
 		}
 		if err := d.sync(ctx); err != nil {
-			log.Error(err)
+			d.log.Error(err, "failed to sync")
 			retrier.Next()
 		} else {
 			retrier.Reset()
@@ -294,7 +295,7 @@
 func (d *apisixProvider) handleADCExecutionErrors(statusesMap map[string]types.ADCExecutionErrors) {
 	statusUpdateMap := d.resolveADCExecutionErrors(statusesMap)
 	d.handleStatusUpdate(statusUpdateMap)
-	log.Debugw("handled ADC execution errors", zap.Any("status_record", statusesMap), zap.Any("status_update", statusUpdateMap))
+	d.log.V(1).Info("handled ADC execution errors", "status_record", statusesMap, "status_update", statusUpdateMap)
 }
 
 func (d *apisixProvider) NeedLeaderElection() bool {
diff --git a/internal/provider/apisix/status.go b/internal/provider/apisix/status.go
index 3bc3dcd..9a2824a 100644
--- a/internal/provider/apisix/status.go
+++ b/internal/provider/apisix/status.go
@@ -21,8 +21,6 @@
 	"fmt"
 	"strings"
 
-	"github.com/api7/gopkg/pkg/log"
-	"go.uber.org/zap"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
@@ -113,7 +111,7 @@
 		})
 	case types.KindHTTPRoute:
 		parentRefs := d.client.ConfigManager.GetConfigRefsByResourceKey(nnk)
-		log.Debugw("updating HTTPRoute status", zap.Any("parentRefs", parentRefs))
+		d.log.V(1).Info("updating HTTPRoute status", "parentRefs", parentRefs)
 		gatewayRefs := map[types.NamespacedNameKind]struct{}{}
 		for _, parentRef := range parentRefs {
 			if parentRef.Kind == types.KindGateway {
@@ -148,7 +146,7 @@
 		})
 	case types.KindUDPRoute:
 		parentRefs := d.client.ConfigManager.GetConfigRefsByResourceKey(nnk)
-		log.Debugw("updating UDPRoute status", zap.Any("parentRefs", parentRefs))
+		d.log.V(1).Info("updating UDPRoute status", "parentRefs", parentRefs)
 		gatewayRefs := map[types.NamespacedNameKind]struct{}{}
 		for _, parentRef := range parentRefs {
 			if parentRef.Kind == types.KindGateway {
@@ -183,7 +181,7 @@
 		})
 	case types.KindTCPRoute:
 		parentRefs := d.client.ConfigManager.GetConfigRefsByResourceKey(nnk)
-		log.Debugw("updating TCPRoute status", zap.Any("parentRefs", parentRefs))
+		d.log.V(1).Info("updating TCPRoute status", "parentRefs", parentRefs)
 		gatewayRefs := map[types.NamespacedNameKind]struct{}{}
 		for _, parentRef := range parentRefs {
 			if parentRef.Kind == types.KindGateway {
@@ -218,7 +216,7 @@
 		})
 	case types.KindGRPCRoute:
 		parentRefs := d.client.ConfigManager.GetConfigRefsByResourceKey(nnk)
-		log.Debugw("updating GRPCRoute status", zap.Any("parentRefs", parentRefs))
+		d.log.V(1).Info("updating GRPCRoute status", "parentRefs", parentRefs)
 		gatewayRefs := map[types.NamespacedNameKind]struct{}{}
 		for _, parentRef := range parentRefs {
 			if parentRef.Kind == types.KindGateway {
@@ -280,7 +278,7 @@
 ) {
 	resource, err := d.client.GetResources(configName)
 	if err != nil {
-		log.Errorw("failed to get resources from store", zap.String("configName", configName), zap.Error(err))
+		d.log.Error(err, "failed to get resources from store", "configName", configName)
 		return
 	}
 
@@ -298,7 +296,7 @@
 
 	globalRules, err := d.client.ListGlobalRules(configName)
 	if err != nil {
-		log.Errorw("failed to list global rules", zap.String("configName", configName), zap.Error(err))
+		d.log.Error(err, "failed to list global rules", "configName", configName)
 		return
 	}
 	for _, rule := range globalRules {
@@ -320,11 +318,10 @@
 		id := status.Event.ResourceID
 		labels, err := d.client.GetResourceLabel(configName, status.Event.ResourceType, id)
 		if err != nil {
-			log.Errorw("failed to get resource label",
-				zap.String("configName", configName),
-				zap.String("resourceType", status.Event.ResourceType),
-				zap.String("id", id),
-				zap.Error(err),
+			d.log.Error(err, "failed to get resource label",
+				"configName", configName,
+				"resourceType", status.Event.ResourceType,
+				"id", id,
 			)
 			continue
 		}
diff --git a/internal/provider/init/init.go b/internal/provider/init/init.go
index 3fc6891..b6ed9e9 100644
--- a/internal/provider/init/init.go
+++ b/internal/provider/init/init.go
@@ -22,13 +22,19 @@
 	"github.com/apache/apisix-ingress-controller/internal/manager/readiness"
 	"github.com/apache/apisix-ingress-controller/internal/provider"
 	"github.com/apache/apisix-ingress-controller/internal/provider/apisix"
+	"github.com/go-logr/logr"
 )
 
 func init() {
 	provider.Register("apisix", apisix.New)
-	provider.Register("apisix-standalone", func(statusUpdater status.Updater, readinessManager readiness.ReadinessManager, opts ...provider.Option) (provider.Provider, error) {
-		opts = append(opts, provider.WithBackendMode("apisix-standalone"))
-		opts = append(opts, provider.WithResolveEndpoints())
-		return apisix.New(statusUpdater, readinessManager, opts...)
-	})
+	provider.Register("apisix-standalone",
+		func(log logr.Logger,
+			statusUpdater status.Updater,
+			readinessManager readiness.ReadinessManager,
+			opts ...provider.Option,
+		) (provider.Provider, error) {
+			opts = append(opts, provider.WithBackendMode("apisix-standalone"))
+			opts = append(opts, provider.WithResolveEndpoints())
+			return apisix.New(log, statusUpdater, readinessManager, opts...)
+		})
 }
diff --git a/internal/provider/options.go b/internal/provider/options.go
index 540f2e6..379e8a0 100644
--- a/internal/provider/options.go
+++ b/internal/provider/options.go
@@ -17,7 +17,9 @@
 
 package provider
 
-import "time"
+import (
+	"time"
+)
 
 type Option interface {
 	ApplyToList(*Options)
diff --git a/internal/provider/register.go b/internal/provider/register.go
index 25cc670..fddb1af 100644
--- a/internal/provider/register.go
+++ b/internal/provider/register.go
@@ -23,13 +23,14 @@
 
 	"github.com/apache/apisix-ingress-controller/internal/controller/status"
 	"github.com/apache/apisix-ingress-controller/internal/manager/readiness"
+	"github.com/go-logr/logr"
 )
 
 type RegisterHandler interface {
 	Register(pathPrefix string, mux *http.ServeMux)
 }
 
-type RegisterFunc func(status.Updater, readiness.ReadinessManager, ...Option) (Provider, error)
+type RegisterFunc func(logr.Logger, status.Updater, readiness.ReadinessManager, ...Option) (Provider, error)
 
 var providers = map[string]RegisterFunc{}
 
@@ -45,10 +46,16 @@
 	return f, nil
 }
 
-func New(providerType string, updater status.Updater, readinesser readiness.ReadinessManager, opts ...Option) (Provider, error) {
+func New(
+	providerType string,
+	log logr.Logger,
+	updater status.Updater,
+	readinesser readiness.ReadinessManager,
+	opts ...Option,
+) (Provider, error) {
 	f, err := Get(providerType)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get provider %q: %w", providerType, err)
 	}
-	return f(updater, readinesser, opts...)
+	return f(log, updater, readinesser, opts...)
 }