remove usless error output in log

client/clientpool.go

@@ -42,7 +42,7 @@ func NewCoreRPCClientPool(ctx context.Context, config *PoolConfig) (*Pool, error
 			rpc, err = NewClient(ctx, addr, config.Auth)
 		})
 		if err != nil {
-			log.Errorf(ctx, err, "[NewCoreRPCClientPool] connect to %s failed, err: %s", addr, err)
+			log.Errorf(ctx, err, "[NewCoreRPCClientPool] connect to %s failed", addr)
 			continue
 		}
 		rpcClient := rpc.GetRPCClient()
@@ -96,7 +96,7 @@ func checkAlive(ctx context.Context, rpc *clientWithStatus, timeout time.Duratio
 		_, err = rpc.client.Info(ctx, &pb.Empty{})
 	})
 	if err != nil {
-		log.Errorf(ctx, err, "[ClientPool] connect to %s failed, err: %s", rpc.addr, err)
+		log.Errorf(ctx, err, "[ClientPool] connect to %s failed", rpc.addr)
 		return false
 	}
 	log.Debugf(ctx, "[ClientPool] connect to %s success", rpc.addr)

client/resolver/eru/resolver.go

@@ -51,13 +51,13 @@ func (r *Resolver) sync() {
 
 	ch, err := r.discovery.Watch(ctx)
 	if err != nil {
-		log.Errorf(ctx, err, "[EruResolver] failed to watch service status: %v", err)
+		log.Error(ctx, err, "[EruResolver] failed to watch service status")
 		return
 	}
 	for {
 		select {
 		case <-ctx.Done():
-			log.Errorf(ctx, ctx.Err(), "[EruResolver] watch interrupted: %v", ctx.Err())
+			log.Error(ctx, ctx.Err(), "[EruResolver] watch interrupted")
 			return
 		case endpoints, ok := <-ch:
 			if !ok {

client/servicediscovery/eru_service_discovery.go

@@ -34,7 +34,7 @@ func New(endpoint string, authConfig types.AuthConfig) *EruServiceDiscovery {
 func (w *EruServiceDiscovery) Watch(ctx context.Context) (_ <-chan []string, err error) {
 	cc, err := w.dial(ctx, w.endpoint, w.authConfig)
 	if err != nil {
-		log.Errorf(ctx, err, "[EruServiceWatch] dial failed: %v", err)
+		log.Error(ctx, err, "[EruServiceWatch] dial failed")
 		return
 	}
 	client := pb.NewCoreRPCClient(cc)
@@ -48,7 +48,7 @@ func (w *EruServiceDiscovery) Watch(ctx context.Context) (_ <-chan []string, err
 			watchCtx, cancelWatch := context.WithCancel(ctx)
 			stream, err := client.WatchServiceStatus(watchCtx, &pb.Empty{})
 			if err != nil {
-				log.Errorf(ctx, err, "[EruServiceWatch] watch failed, try later: %v", err)
+				log.Error(ctx, err, "[EruServiceWatch] watch failed, try later")
 				time.Sleep(10 * time.Second)
 				continue
 			}
@@ -69,7 +69,7 @@ func (w *EruServiceDiscovery) Watch(ctx context.Context) (_ <-chan []string, err
 				status, err := stream.Recv()
 				close(cancelTimer)
 				if err != nil {
-					log.Errorf(ctx, err, "[EruServiceWatch] recv failed: %v", err)
+					log.Error(ctx, err, "[EruServiceWatch] recv failed")
 					break
 				}
 				expectedInterval = time.Duration(status.GetIntervalInSecond())

client/utils/servicepusher.go

@@ -111,7 +111,7 @@ func (p *EndpointPusher) pollReachability(ctx context.Context, endpoint string)
 func (p *EndpointPusher) checkReachability(host string) (err error) {
 	pinger, err := ping.NewPinger(host)
 	if err != nil {
-		log.Errorf(nil, err, "[EruResolver] failed to create pinger: %+v", err) //nolint
+		log.Error(nil, err, "[EruResolver] failed to create pinger") //nolint
 		return
 	}
 	pinger.SetPrivileged(os.Getuid() == 0)

cluster/calcium/build.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"time"
 
+	"github.com/pkg/errors"
 	enginetypes "github.com/projecteru2/core/engine/types"
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/types"
@@ -140,28 +141,27 @@ func (c *Calcium) pushImageAndClean(ctx context.Context, resp io.ReadCloser, nod
 		lastMessage := &types.BuildImageMessage{}
 		for {
 			message := &types.BuildImageMessage{}
-			err := decoder.Decode(message)
-			if err != nil {
+			if err := decoder.Decode(message); err != nil {
 				if err == io.EOF {
 					break
 				}
 				if err == context.Canceled || err == context.DeadlineExceeded {
-					log.Errorf(ctx, err, "[BuildImage] context timeout")
+					log.Error(ctx, err, "[BuildImage] context timeout")
 					lastMessage.ErrorDetail.Code = -1
 					lastMessage.ErrorDetail.Message = err.Error()
 					lastMessage.Error = err.Error()
 					break
 				}
 				malformed, _ := io.ReadAll(decoder.Buffered()) // TODO err check
-				logger.Errorf(ctx, nil, "[BuildImage] Decode build image message failed %+v, buffered: %v", err, malformed)
+				logger.Errorf(ctx, err, "[BuildImage] Decode build image message failed, buffered: %v", malformed)
 				return
 			}
 			ch <- message
 			lastMessage = message
 		}
 
 		if lastMessage.Error != "" {
-			log.Errorf(ctx, nil, "[BuildImage] Build image failed %v", lastMessage.ErrorDetail.Message)
+			logger.Errorf(ctx, errors.New(lastMessage.Error), "[BuildImage] Build image failed %v", lastMessage.ErrorDetail.Message)
 			return
 		}
 
@@ -216,11 +216,11 @@ func cleanupNodeImages(ctx context.Context, node *types.Node, ids []string, ttl
 	defer cancel()
 	for _, id := range ids {
 		if _, err := node.Engine.ImageRemove(ctx, id, false, true); err != nil {
-			logger.Errorf(ctx, err, "[BuildImage] Remove image error: %+v", err)
+			logger.Error(ctx, err, "[BuildImage] Remove image error")
 		}
 	}
 	if spaceReclaimed, err := node.Engine.ImageBuildCachePrune(ctx, true); err != nil {
-		logger.Errorf(ctx, err, "[BuildImage] Remove build image cache error: %+v", err)
+		logger.Error(ctx, err, "[BuildImage] Remove build image cache error")
 	} else {
 		logger.Infof(ctx, "[BuildImage] Clean cached image and release space %d", spaceReclaimed)
 	}

cluster/calcium/calcium.go

@@ -55,7 +55,7 @@ func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, erro
 		log.Warn(ctx, "[Calcium] SCM not set, build API disabled")
 	}
 	if err != nil {
-		log.Errorf(ctx, err, "[Calcium] SCM failed: %+v", err)
+		log.Error(ctx, err, "[Calcium] SCM failed")
 		return nil, err
 	}
 
@@ -72,12 +72,12 @@ func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, erro
 	// load internal plugins
 	cpumem, err := cpumem.NewPlugin(config)
 	if err != nil {
-		log.Errorf(ctx, err, "[NewPluginManager] new cpumem plugin error: %v", err)
+		log.Error(ctx, err, "[NewPluginManager] new cpumem plugin error")
 		return nil, err
 	}
 	volume, err := volume.NewPlugin(config)
 	if err != nil {
-		log.Errorf(ctx, err, "[NewPluginManager] new volume plugin error: %v", err)
+		log.Error(ctx, err, "[NewPluginManager] new volume plugin error")
 		return nil, err
 	}
 	rmgr.AddPlugins(cpumem, volume)

cluster/calcium/capacity.go

@@ -28,7 +28,7 @@ func (c *Calcium) CalculateCapacity(ctx context.Context, opts *types.DeployOptio
 
 		if opts.DeployStrategy != strategy.Dummy {
 			if msg.NodeCapacities, err = c.doGetDeployStrategy(ctx, nodenames, opts); err != nil {
-				logger.Errorf(ctx, err, "[Calcium.CalculateCapacity] doGetDeployMap failed: %+v", err)
+				logger.Error(ctx, err, "[Calcium.CalculateCapacity] doGetDeployMap failed")
 				return err
 			}
 
@@ -41,7 +41,7 @@ func (c *Calcium) CalculateCapacity(ctx context.Context, opts *types.DeployOptio
 		var infos map[string]*resources.NodeCapacityInfo
 		infos, msg.Total, err = c.rmgr.GetNodesDeployCapacity(ctx, nodenames, opts.ResourceOpts)
 		if err != nil {
-			logger.Errorf(ctx, err, "[Calcium.CalculateCapacity] failed to get nodes capacity: %+v", err)
+			logger.Error(ctx, err, "[Calcium.CalculateCapacity] failed to get nodes capacity")
 			return err
 		}
 		if msg.Total <= 0 {

cluster/calcium/create.go

@@ -62,7 +62,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 			for nodename := range deployMap {
 				processing := opts.GetProcessing(nodename)
 				if err := c.store.DeleteProcessing(cctx, processing); err != nil {
-					logger.Errorf(ctx, err, "[Calcium.doCreateWorkloads] delete processing failed for %s: %+v", nodename, err)
+					logger.Errorf(ctx, err, "[Calcium.doCreateWorkloads] delete processing failed for %s", nodename)
 				}
 			}
 			close(ch)
@@ -73,7 +73,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 		defer func() {
 			if resourceCommit != nil {
 				if err := resourceCommit(); err != nil {
-					logger.Errorf(ctx, err, "commit wal failed: %s, %+v", eventWorkloadResourceAllocated, err)
+					logger.Errorf(ctx, err, "commit wal failed: %s", eventWorkloadResourceAllocated)
 				}
 			}
 		}()
@@ -85,7 +85,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 					continue
 				}
 				if err := processingCommits[nodename](); err != nil {
-					logger.Errorf(ctx, err, "commit wal failed: %s, %s, %+v", eventProcessingCreated, nodename, err)
+					logger.Errorf(ctx, err, "commit wal failed: %s, %s", eventProcessingCreated, nodename)
 				}
 			}
 		}()
@@ -186,7 +186,7 @@ func (c *Calcium) doDeployWorkloads(ctx context.Context,
 	for nodename, deploy := range deployMap {
 		_ = c.pool.Invoke(func(deploy int) func() {
 			return func() {
-				metrics.Client.SendDeployCount(deploy)
+				metrics.Client.SendDeployCount(ctx, deploy)
 			}
 		}(deploy))
 		_ = c.pool.Invoke(func(nodename string, deploy, seq int) func() {
@@ -322,7 +322,7 @@ func (c *Calcium) doDeployOneWorkload(
 	defer func() {
 		if commit != nil {
 			if err := commit(); err != nil {
-				logger.Errorf(ctx, err, "Commit WAL %s failed: %+v", eventWorkloadCreated, err)
+				logger.Errorf(ctx, err, "Commit WAL %s failed", eventWorkloadCreated)
 			}
 		}
 	}()
@@ -427,7 +427,7 @@ func (c *Calcium) doDeployOneWorkload(
 
 		// remove workload
 		func(ctx context.Context, _ bool) error {
-			logger.Errorf(ctx, nil, "[doDeployOneWorkload] failed to deploy workload %s, rollback", workload.ID)
+			logger.Infof(ctx, "[doDeployOneWorkload] failed to deploy workload %s, rollback", workload.ID)
 			if workload.ID == "" {
 				return nil
 			}

cluster/calcium/dissociate.go

@@ -15,7 +15,7 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, ids []string) (chan *t
 
 	nodeWorkloadGroup, err := c.groupWorkloadsByNode(ctx, ids)
 	if err != nil {
-		logger.Errorf(ctx, err, "failed to group workloads by node: %+v", err)
+		logger.Error(ctx, err, "failed to group workloads by node")
 		return nil, err
 	}
 
@@ -58,15 +58,15 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, ids []string) (chan *t
 							c.config.GlobalTimeout,
 						)
 					}); err != nil {
-						logger.WithField("id", workloadID).Errorf(ctx, err, "failed to lock workload: %+v", err)
+						logger.WithField("id", workloadID).Error(ctx, err, "failed to lock workload")
 						msg.Error = err
 					}
 					ch <- msg
 				}
 				_ = c.pool.Invoke(func() { c.doRemapResourceAndLog(ctx, logger, node) })
 				return nil
 			}); err != nil {
-				logger.WithField("nodename", nodename).Errorf(ctx, err, "failed to lock node: %+v", err)
+				logger.WithField("nodename", nodename).Error(ctx, err, "failed to lock node")
 			}
 		}
 	})

cluster/calcium/execute.go

@@ -27,7 +27,7 @@ func (c *Calcium) ExecuteWorkload(ctx context.Context, opts *types.ExecuteWorklo
 
 		workload, err := c.GetWorkload(ctx, opts.WorkloadID)
 		if err != nil {
-			logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to get workload: %+v", err)
+			logger.Error(ctx, err, "[ExecuteWorkload] Failed to get workload")
 			return
 		}
 
@@ -44,7 +44,7 @@ func (c *Calcium) ExecuteWorkload(ctx context.Context, opts *types.ExecuteWorklo
 
 		execID, stdout, stderr, inStream, err := workload.Engine.Execute(ctx, opts.WorkloadID, execConfig)
 		if err != nil {
-			logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to attach execID: %+v", err)
+			logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to attach execID %s", execID)
 			return
 		}
 
@@ -62,7 +62,7 @@ func (c *Calcium) ExecuteWorkload(ctx context.Context, opts *types.ExecuteWorklo
 
 		execCode, err := workload.Engine.ExecExitCode(ctx, opts.WorkloadID, execID)
 		if err != nil {
-			logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to get exitcode: %+v", err)
+			logger.Error(ctx, err, "[ExecuteWorkload] Failed to get exitcode")
 			return
 		}
 

cluster/calcium/helper.go

@@ -11,7 +11,7 @@ import (
 func distributionInspect(ctx context.Context, node *types.Node, image string, digests []string) bool {
 	remoteDigest, err := node.Engine.ImageRemoteDigest(ctx, image)
 	if err != nil {
-		log.Errorf(ctx, err, "[distributionInspect] get manifest failed %v", err)
+		log.Error(ctx, err, "[distributionInspect] get manifest failed")
 		return false
 	}
 
@@ -51,7 +51,7 @@ func pullImage(ctx context.Context, node *types.Node, image string) error {
 	rc, err := node.Engine.ImagePull(ctx, image, false)
 	defer utils.EnsureReaderClosed(ctx, rc)
 	if err != nil {
-		log.Errorf(ctx, err, "[pullImage] Error during pulling image %s: %v", image, err)
+		log.Errorf(ctx, err, "[pullImage] Error during pulling image %s", image)
 		return err
 	}
 	log.Infof(ctx, "[pullImage] Done pulling image %s", image)

cluster/calcium/image.go

@@ -111,7 +111,7 @@ func (c *Calcium) RemoveImage(ctx context.Context, opts *types.ImageOptions) (ch
 				}
 				if opts.Prune {
 					if err := node.Engine.ImagesPrune(ctx); err != nil {
-						logger.Errorf(ctx, err, "[RemoveImage] Prune %s pod %s node failed: %+v", opts.Podname, node.Name, err)
+						logger.Errorf(ctx, err, "[RemoveImage] Prune %s pod %s node failed", opts.Podname, node.Name)
 					} else {
 						logger.Infof(ctx, "[RemoveImage] Prune %s pod %s node", opts.Podname, node.Name)
 					}

cluster/calcium/lambda.go

@@ -37,7 +37,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 
 	createChan, err := c.CreateWorkload(ctx, opts)
 	if err != nil {
-		logger.Errorf(ctx, err, "[RunAndWait] Create workload error %+v", err)
+		logger.Error(ctx, err, "[RunAndWait] Create workload error")
 		return workloadIDs, nil, err
 	}
 
@@ -58,7 +58,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 		// we don't need to remove this non-existing workload
 		// so just send the error message and return
 		if message.Error != nil || message.WorkloadID == "" {
-			logger.Errorf(ctx, message.Error, "[RunAndWait] Create workload failed %+v", message.Error)
+			logger.Error(ctx, message.Error, "[RunAndWait] Create workload failed")
 			return &types.AttachWorkloadMessage{
 				WorkloadID:    "",
 				Data:          []byte(fmt.Sprintf("Create workload failed %+v", message.Error)),
@@ -77,7 +77,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 		}
 		defer func() {
 			if err := commit(); err != nil {
-				logger.Errorf(ctx, err, "[RunAndWait] Commit WAL %s failed: %s, %v", eventCreateLambda, message.WorkloadID, err)
+				logger.Errorf(ctx, err, "[RunAndWait] Commit WAL %s failed: %s", eventCreateLambda, message.WorkloadID)
 			}
 		}()
 
@@ -87,7 +87,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 			ctx, cancel := context.WithCancel(utils.InheritTracingInfo(ctx, context.TODO()))
 			defer cancel()
 			if err := c.doRemoveWorkloadSync(ctx, []string{message.WorkloadID}); err != nil {
-				logger.Errorf(ctx, err, "[RunAndWait] Remove lambda workload failed %+v", err)
+				logger.Error(ctx, err, "[RunAndWait] Remove lambda workload failed")
 			} else {
 				logger.Infof(ctx, "[RunAndWait] Workload %s finished and removed", utils.ShortID(message.WorkloadID))
 			}
@@ -97,7 +97,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 		// this is weird, we return the error directly and try to delete data
 		workload, err := c.GetWorkload(ctx, message.WorkloadID)
 		if err != nil {
-			logger.Errorf(ctx, err, "[RunAndWait] Get workload failed %+v", err)
+			logger.Error(ctx, err, "[RunAndWait] Get workload failed")
 			return &types.AttachWorkloadMessage{
 				WorkloadID:    message.WorkloadID,
 				Data:          []byte(fmt.Sprintf("Get workload %s failed %+v", message.WorkloadID, err)),
@@ -115,7 +115,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 			Stdout: true,
 			Stderr: true,
 		}); err != nil {
-			logger.Errorf(ctx, err, "[RunAndWait] Can't fetch log of workload %s error %+v", message.WorkloadID, err)
+			logger.Errorf(ctx, err, "[RunAndWait] Can't fetch log of workload %s", message.WorkloadID)
 			return &types.AttachWorkloadMessage{
 				WorkloadID:    message.WorkloadID,
 				Data:          []byte(fmt.Sprintf("Fetch log for workload %s failed %+v", message.WorkloadID, err)),
@@ -130,7 +130,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 			var inStream io.WriteCloser
 			stdout, stderr, inStream, err = workload.Engine.VirtualizationAttach(ctx, message.WorkloadID, true, true)
 			if err != nil {
-				logger.Errorf(ctx, err, "[RunAndWait] Can't attach workload %s error %+v", message.WorkloadID, err)
+				logger.Errorf(ctx, err, "[RunAndWait] Can't attach workload %s", message.WorkloadID)
 				return &types.AttachWorkloadMessage{
 					WorkloadID:    message.WorkloadID,
 					Data:          []byte(fmt.Sprintf("Attach to workload %s failed %+v", message.WorkloadID, err)),
@@ -156,7 +156,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC
 		// wait and forward exitcode
 		r, err := workload.Engine.VirtualizationWait(ctx, message.WorkloadID, "")
 		if err != nil {
-			logger.Errorf(ctx, err, "[RunAndWait] %s wait failed %+v", utils.ShortID(message.WorkloadID), err)
+			logger.Errorf(ctx, err, "[RunAndWait] %s wait failed", utils.ShortID(message.WorkloadID))
 			return &types.AttachWorkloadMessage{
 				WorkloadID:    message.WorkloadID,
 				Data:          []byte(fmt.Sprintf("Wait workload %s failed %+v", message.WorkloadID, err)),

cluster/calcium/lock.go

@@ -23,7 +23,7 @@ func (c *Calcium) doLock(ctx context.Context, name string, timeout time.Duration
 			defer cancel()
 			rollbackCtx = utils.InheritTracingInfo(rollbackCtx, ctx)
 			if e := lock.Unlock(rollbackCtx); e != nil {
-				log.Errorf(rollbackCtx, err, "failed to unlock %s: %+v", name, err)
+				log.Errorf(rollbackCtx, err, "failed to unlock %s", name)
 			}
 		}
 	}()
@@ -47,7 +47,7 @@ func (c *Calcium) doUnlockAll(ctx context.Context, locks map[string]lock.Distrib
 	}
 	for _, key := range order {
 		if err := c.doUnlock(ctx, locks[key], key); err != nil {
-			log.Errorf(ctx, err, "[doUnlockAll] Unlock %s failed %v", key, err)
+			log.Errorf(ctx, err, "[doUnlockAll] Unlock %s failed", key)
 			continue
 		}
 	}