chore: unify the logging component (#2584)
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...)
}
