This is an automated email from the ASF dual-hosted git repository.
alinsran 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 d9550d88 chore: unify the logging component (#2584)
d9550d88 is described below
commit d9550d8887012b63e5803cb281f48b32010158a2
Author: AlinsRan <[email protected]>
AuthorDate: Tue Sep 30 19:06:39 2025 +0800
chore: unify the logging component (#2584)
---
cmd/root/root.go | 11 ---
internal/adc/cache/store.go | 27 ++++----
internal/adc/client/client.go | 88 ++++++++++++------------
internal/adc/client/executor.go | 93 ++++++++++++--------------
internal/adc/translator/apisixroute.go | 4 +-
internal/adc/translator/apisixupstream.go | 6 +-
internal/adc/translator/gateway.go | 23 +++----
internal/adc/translator/gatewayproxy.go | 6 +-
internal/adc/translator/globalrule.go | 10 +--
internal/adc/translator/httproute.go | 10 ++-
internal/adc/translator/ingressclass.go | 4 +-
internal/adc/translator/translator.go | 2 +-
internal/controller/apisixroute_controller.go | 6 +-
internal/controller/gatewayproxy_controller.go | 2 +-
internal/controller/grpcroute_controller.go | 2 +-
internal/controller/httproute_controller.go | 6 +-
internal/controller/ingress_controller.go | 6 +-
internal/controller/ingressclass_controller.go | 2 +-
internal/controller/tcproute_controller.go | 2 +-
internal/controller/udproute_controller.go | 2 +-
internal/controller/utils.go | 32 ++++-----
internal/manager/readiness/manager.go | 10 +--
internal/manager/run.go | 7 +-
internal/provider/apisix/provider.go | 21 +++---
internal/provider/apisix/status.go | 23 +++----
internal/provider/init/init.go | 16 +++--
internal/provider/options.go | 4 +-
internal/provider/register.go | 13 +++-
28 files changed, 207 insertions(+), 231 deletions(-)
diff --git a/cmd/root/root.go b/cmd/root/root.go
index f9cc71f8..577b0567 100644
--- a/cmd/root/root.go
+++ b/cmd/root/root.go
@@ -38,7 +38,6 @@ import (
"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 @@ func newAPISIXIngressController() *cobra.Command {
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 70152266..6c5a1f23 100644
--- a/internal/adc/cache/store.go
+++ b/internal/adc/cache/store.go
@@ -21,9 +21,8 @@ import (
"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 @@ type Store struct {
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 @@ func (s *Store) Insert(name string, resourceTypes []string,
resources *adctypes.
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 @@ func (s *Store) Delete(name string, resourceTypes
[]string, Labels map[string]st
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 @@ func (s *Store) GetResources(name string)
(*adctypes.Resources, error) {
}
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 3474636d..b3951990 100644
--- a/internal/adc/client/client.go
+++ b/internal/adc/client/client.go
@@ -26,9 +26,8 @@ import (
"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 @@ type Client struct {
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 @@ type StoreDelta struct {
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 @@ func (d *Client) applyStoreChanges(args Task, isDelete
bool) (StoreDelta, error)
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 @@ func (d *Client) applySync(ctx context.Context, args
Task, delta StoreDelta) err
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 @@ func (c *Client) Sync(ctx context.Context)
(map[string]types.ADCExecutionErrors,
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 @@ func (c *Client) Sync(ctx context.Context)
(map[string]types.ADCExecutionErrors,
},
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)
(map[string]types.ADCExecutionErrors,
}
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 @@ func (c *Client) sync(ctx context.Context, task Task) error
{
}
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 @@ func (c *Client) sync(ctx context.Context, task Task) error
{
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 @@ func prepareSyncFile(resources any) (string, func(), error)
{
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 bda6c7d7..5d997efc 100644
--- a/internal/adc/client/executor.go
+++ b/internal/adc/client/executor.go
@@ -32,8 +32,7 @@ import (
"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 ADCExecutor interface {
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 @@ func (e *DefaultADCExecutor) runADC(ctx context.Context, mode
string, config adc
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 @@ func (e *DefaultADCExecutor) runForSingleServer(ctx
context.Context, serverAddr,
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 @@ func (e *DefaultADCExecutor) runForSingleServer(ctx
context.Context, serverAddr,
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 @@ func (e *DefaultADCExecutor) buildCmdError(runErr error,
stdout, stderr []byte)
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 ADCServerOpts struct {
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 @@ func NewHTTPADCExecutor(serverURL string, timeout
time.Duration) *HTTPADCExecuto
return &HTTPADCExecutor{
httpClient: httpClient,
serverURL: serverURL,
+ log: log.WithName("executor"),
}
}
@@ -274,11 +266,11 @@ func (e *HTTPADCExecutor) runHTTPSync(ctx
context.Context, mode string, config a
}
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 @@ func (e *HTTPADCExecutor) runHTTPSyncForSingleServer(ctx
context.Context, server
}
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 @@ func (e *HTTPADCExecutor) buildHTTPRequest(ctx
context.Context, serverAddr, mode
},
}
+ 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 @@ func (e *HTTPADCExecutor) handleHTTPResponse(resp
*http.Response, serverAddr str
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 @@ func (e *HTTPADCExecutor) handleHTTPResponse(resp
*http.Response, serverAddr str
// 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 5e2e1233..58a162c9 100644
--- a/internal/adc/translator/apisixroute.go
+++ b/internal/adc/translator/apisixroute.go
@@ -23,9 +23,7 @@ import (
"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 @@ func (t *Translator) buildUpstream(tctx
*provider.TranslateContext, service *adc
}
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 7aec7bad..86a39e62 100644
--- a/internal/adc/translator/apisixupstream.go
+++ b/internal/adc/translator/apisixupstream.go
@@ -22,9 +22,7 @@ import (
"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) translateApisixUpstream(tctx
*provider.TranslateContext, au
}
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 @@ func (t *Translator) translateApisixUpstreamForPort(tctx
*provider.TranslateCont
}
}
- 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 43fc765f..db284845 100644
--- a/internal/adc/translator/gateway.go
+++ b/internal/adc/translator/gateway.go
@@ -24,9 +24,7 @@ import (
"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 @@ func (t *Translator) TranslateGateway(tctx
*provider.TranslateContext, obj *gate
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 @@ func (t *Translator) translateSecret(tctx
*provider.TranslateContext, listener g
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 @@ func (t *Translator) translateSecret(tctx
*provider.TranslateContext, listener g
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 @@ func (t *Translator) fillPluginsFromGatewayProxy(plugins
adctypes.GlobalRule, ga
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 @@ func (t *Translator)
fillPluginMetadataFromGatewayProxy(pluginMetadata adctypes.
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 8b7fb673..6636816f 100644
--- a/internal/adc/translator/gatewayproxy.go
+++ b/internal/adc/translator/gatewayproxy.go
@@ -22,9 +22,7 @@ import (
"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 (t *Translator) TranslateGatewayProxyToConfig(tctx
*provider.TranslateConte
},
}, 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 @@ func (t *Translator) TranslateGatewayProxyToConfig(tctx
*provider.TranslateConte
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 692321db..89f1626a 100644
--- a/internal/adc/translator/globalrule.go
+++ b/internal/adc/translator/globalrule.go
@@ -20,9 +20,6 @@ package translator
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 @@ import (
// 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 @@ func (t *Translator) TranslateApisixGlobalRule(tctx
*provider.TranslateContext,
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 d88b32cf..7d829b16 100644
--- a/internal/adc/translator/httproute.go
+++ b/internal/adc/translator/httproute.go
@@ -22,9 +22,7 @@ import (
"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 @@ func (t *Translator) fillPluginFromExtensionRef(plugins
adctypes.Plugins, namesp
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 @@ 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.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 @@ func (t *Translator) translateEndpointSlice(portName
*string, weight int, endpoi
}
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 (t *Translator) translateEndpointSlice(portName
*string, weight int, endpoi
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 d9142592..064bd77d 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 @@ func (t *Translator) TranslateIngressClass(tctx
*provider.TranslateContext, obj
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 4c9bf0d8..aeaef250 100644
--- a/internal/adc/translator/translator.go
+++ b/internal/adc/translator/translator.go
@@ -29,7 +29,7 @@ type Translator struct {
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 dd57202b..c6e3afda 100644
--- a/internal/controller/apisixroute_controller.go
+++ b/internal/controller/apisixroute_controller.go
@@ -24,9 +24,7 @@ import (
"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 @@ func (r *ApisixRouteReconciler) validateHTTPBackend(tctx
*provider.TranslateCont
}
// 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 7b27d316..b2dd7980 100644
--- a/internal/controller/gatewayproxy_controller.go
+++ b/internal/controller/gatewayproxy_controller.go
@@ -100,7 +100,7 @@ func (r *GatewayProxyController) Reconcile(ctx
context.Context, req ctrl.Request
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 782f98f8..3b423417 100644
--- a/internal/controller/grpcroute_controller.go
+++ b/internal/controller/grpcroute_controller.go
@@ -182,7 +182,7 @@ func (r *GRPCRouteReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
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 8cd7b507..1c449e79 100644
--- a/internal/controller/httproute_controller.go
+++ b/internal/controller/httproute_controller.go
@@ -22,10 +22,8 @@ import (
"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 @@ func (r *HTTPRouteReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
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 @@ func (r *HTTPRouteReconciler) Reconcile(ctx
context.Context, req ctrl.Request) (
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 8ef3d735..5fe611da 100644
--- a/internal/controller/ingress_controller.go
+++ b/internal/controller/ingress_controller.go
@@ -22,9 +22,7 @@ import (
"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 @@ func (r *IngressReconciler) processTLS(tctx
*provider.TranslateContext, ingress
}
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 @@ func (r *IngressReconciler) updateStatus(ctx
context.Context, tctx *provider.Tra
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 fe11b7fc..5594ee6c 100644
--- a/internal/controller/ingressclass_controller.go
+++ b/internal/controller/ingressclass_controller.go
@@ -228,7 +228,7 @@ func (r *IngressClassReconciler) processInfrastructure(tctx
*provider.TranslateC
}
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 271198a6..125a14a9 100644
--- a/internal/controller/tcproute_controller.go
+++ b/internal/controller/tcproute_controller.go
@@ -255,7 +255,7 @@ func (r *TCPRouteReconciler) Reconcile(ctx context.Context,
req ctrl.Request) (c
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 88b11367..2a4a7a4a 100644
--- a/internal/controller/udproute_controller.go
+++ b/internal/controller/udproute_controller.go
@@ -255,7 +255,7 @@ func (r *UDPRouteReconciler) Reconcile(ctx context.Context,
req ctrl.Request) (c
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 4a0e9a65..530e7c4f 100644
--- a/internal/controller/utils.go
+++ b/internal/controller/utils.go
@@ -28,10 +28,8 @@ import (
"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 SetRouteParentRef(routeParentStatus
*gatewayv1.RouteParentStatus, gatewayNa
}
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 @@ func ParseRouteParentRefs(
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 @@ func ProcessGatewayProxy(r client.Client, log logr.Logger,
tctx *provider.Transl
}
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 @@ func filterHostnames(gateways []RouteParentRefContext,
httpRoute *gatewayv1.HTTP
}
}
- 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 @@ func ProcessIngressClassParameters(tctx
*provider.TranslateContext, c client.Cli
// 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 @@ func distinctRequests(requests []reconcile.Request)
[]reconcile.Request {
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 @@ func addProviderEndpointsToTranslateContext(tctx
*provider.TranslateContext, c c
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 7ba4b83b..eca380eb 100644
--- a/internal/manager/readiness/manager.go
+++ b/internal/manager/readiness/manager.go
@@ -24,8 +24,7 @@ import (
"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 @@ type readinessManager struct {
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 @@ func (r *readinessManager) Start(ctx context.Context) error
{
})
}
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 6adde7d7..fe16bafa 100644
--- a/internal/manager/run.go
+++ b/internal/manager/run.go
@@ -164,7 +164,7 @@ func Run(ctx context.Context, logger logr.Logger) error {
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 @@ func Run(ctx context.Context, logger logr.Logger) error {
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 188e6c2c..64d694c8 100644
--- a/internal/provider/apisix/provider.go
+++ b/internal/provider/apisix/provider.go
@@ -23,8 +23,7 @@ import (
"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 @@ type apisixProvider struct {
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 @@ func New(updater status.Updater, readier
readiness.ReadinessManager, opts ...pro
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) Register(pathPrefix string, mux
*http.ServeMux) {
}
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 @@ func (d *apisixProvider) Update(ctx context.Context, tctx
*provider.TranslateCon
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 @@ func (d *apisixProvider) Start(ctx context.Context) error {
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) syncNotify() {
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 3bc3dcd6..9a2824a8 100644
--- a/internal/provider/apisix/status.go
+++ b/internal/provider/apisix/status.go
@@ -21,8 +21,6 @@ import (
"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 @@ func (d *apisixProvider) updateStatus(nnk
types.NamespacedNameKind, condition me
})
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 @@ func (d *apisixProvider) updateStatus(nnk
types.NamespacedNameKind, condition me
})
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 @@ func (d *apisixProvider) updateStatus(nnk
types.NamespacedNameKind, condition me
})
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 @@ func (d *apisixProvider) updateStatus(nnk
types.NamespacedNameKind, condition me
})
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 @@ func (d *apisixProvider) handleEmptyFailedStatuses(
) {
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 @@ func (d *apisixProvider) handleEmptyFailedStatuses(
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 @@ func (d *apisixProvider) handleDetailedFailedStatuses(
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 3fc68912..b6ed9e99 100644
--- a/internal/provider/init/init.go
+++ b/internal/provider/init/init.go
@@ -22,13 +22,19 @@ import (
"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 540f2e63..379e8a0b 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 25cc670d..fddb1af5 100644
--- a/internal/provider/register.go
+++ b/internal/provider/register.go
@@ -23,13 +23,14 @@ import (
"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 @@ func Get(name string) (RegisterFunc, error) {
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...)
}
