From 86bd2fca2f4cb8b643741265878f5032d6740a8f Mon Sep 17 00:00:00 2001 From: CMGS Date: Mon, 17 Oct 2022 17:05:19 +0800 Subject: [PATCH] unified logs! --- client/clientpool.go | 11 +- client/interceptor/retry.go | 2 +- client/resolver/eru/resolver.go | 8 +- .../servicediscovery/eru_service_discovery.go | 6 +- client/utils/servicepusher.go | 4 +- cluster/calcium/build.go | 44 ++--- cluster/calcium/calcium.go | 30 ++-- cluster/calcium/capacity.go | 4 +- cluster/calcium/control.go | 13 +- cluster/calcium/copy.go | 8 +- cluster/calcium/create.go | 54 +++--- cluster/calcium/dissociate.go | 14 +- cluster/calcium/execute.go | 10 +- cluster/calcium/helper.go | 13 +- cluster/calcium/hook.go | 4 +- cluster/calcium/image.go | 39 +++-- cluster/calcium/lambda.go | 36 ++-- cluster/calcium/lock.go | 20 +-- cluster/calcium/log.go | 6 +- cluster/calcium/metrics.go | 6 +- cluster/calcium/network.go | 27 +-- cluster/calcium/node.go | 85 +++++----- cluster/calcium/pod.go | 24 ++- cluster/calcium/realloc.go | 12 +- cluster/calcium/remap.go | 12 +- cluster/calcium/remove.go | 20 +-- cluster/calcium/replace.go | 24 +-- cluster/calcium/resource.go | 28 ++-- cluster/calcium/send.go | 15 +- cluster/calcium/service.go | 8 +- cluster/calcium/status.go | 21 ++- cluster/calcium/stream.go | 15 +- cluster/calcium/wal.go | 19 ++- cluster/calcium/workload.go | 21 ++- core.go | 26 +-- discovery/helium/helium.go | 10 +- engine/docker/container.go | 6 +- engine/docker/docker.go | 2 +- engine/docker/exec.go | 2 +- engine/docker/helper.go | 4 +- engine/factory/factory.go | 12 +- engine/virt/virt.go | 6 +- go.mod | 5 +- go.sum | 12 +- lock/etcdlock/mutex.go | 5 +- lock/redis/lock.go | 6 +- log/log.go | 158 +++++++++--------- metrics/handler.go | 4 +- metrics/metrics.go | 18 +- resources/binary.go | 4 +- resources/manager.go | 66 ++++---- resources/plugins.go | 4 +- resources/volume/types/volume.go | 21 ++- rpc/rpc.go | 14 +- rpc/transform.go | 2 +- selfmon/selfmon.go | 22 +-- store/etcdv3/meta/ephemeral.go | 8 +- store/etcdv3/meta/etcd.go | 4 +- store/etcdv3/node.go | 10 +- store/etcdv3/processing.go | 2 +- store/etcdv3/service.go | 4 +- store/etcdv3/workload.go | 8 +- store/redis/ephemeral.go | 4 +- store/redis/node.go | 10 +- store/redis/processing.go | 4 +- store/redis/service.go | 2 +- store/redis/workload.go | 6 +- strategy/average.go | 8 +- strategy/communism.go | 4 +- strategy/fill.go | 12 +- strategy/global.go | 10 +- strategy/strategy.go | 6 +- types/node.go | 8 +- types/options.go | 28 ++-- types/specs.go | 6 +- types/workload.go | 16 +- utils/transaction.go | 2 +- utils/utils.go | 16 +- wal/hydro.go | 8 +- 79 files changed, 654 insertions(+), 604 deletions(-) diff --git a/client/clientpool.go b/client/clientpool.go index 12d4b4496..ebe8b045d 100644 --- a/client/clientpool.go +++ b/client/clientpool.go @@ -5,11 +5,10 @@ import ( "sync" "time" + "github.com/projecteru2/core/log" pb "github.com/projecteru2/core/rpc/gen" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - log "github.com/sirupsen/logrus" ) type clientWithStatus struct { @@ -43,7 +42,7 @@ func NewCoreRPCClientPool(ctx context.Context, config *PoolConfig) (*Pool, error rpc, err = NewClient(ctx, addr, config.Auth) }) if err != nil { - log.Errorf("[NewCoreRPCClientPool] connect to %s failed, err: %s", addr, err) + log.Errorf(ctx, err, "[NewCoreRPCClientPool] connect to %s failed, err: %s", addr, err) continue } rpcClient := rpc.GetRPCClient() @@ -61,7 +60,7 @@ func NewCoreRPCClientPool(ctx context.Context, config *PoolConfig) (*Pool, error } if allFailed { - log.Error("[NewCoreRPCClientPool] all connections failed") + log.Error(ctx, types.ErrAllConnectionsFailed, "[NewCoreRPCClientPool] all connections failed") return nil, types.ErrAllConnectionsFailed } @@ -97,10 +96,10 @@ func checkAlive(ctx context.Context, rpc *clientWithStatus, timeout time.Duratio _, err = rpc.client.Info(ctx, &pb.Empty{}) }) if err != nil { - log.Errorf("[ClientPool] connect to %s failed, err: %s", rpc.addr, err) + log.Errorf(ctx, err, "[ClientPool] connect to %s failed, err: %s", rpc.addr, err) return false } - log.Debugf("[ClientPool] connect to %s success", rpc.addr) + log.Debugf(ctx, "[ClientPool] connect to %s success", rpc.addr) return true } diff --git a/client/interceptor/retry.go b/client/interceptor/retry.go index c47bbf5d3..4072fc1e5 100644 --- a/client/interceptor/retry.go +++ b/client/interceptor/retry.go @@ -57,7 +57,7 @@ func (s *retryStream) RecvMsg(m interface{}) (err error) { } return backoff.Retry(func() error { - log.Debug(nil, "[retryStream] retry on new stream") //nolint + log.Debug(s.ctx, "[retryStream] retry on new stream") stream, err := s.newStream() if err != nil { // even io.EOF triggers retry, and it's what we want! diff --git a/client/resolver/eru/resolver.go b/client/resolver/eru/resolver.go index 6a21393b3..4dc41ee6c 100644 --- a/client/resolver/eru/resolver.go +++ b/client/resolver/eru/resolver.go @@ -45,23 +45,23 @@ func (r *Resolver) Close() { func (r *Resolver) sync() { ctx := context.TODO() - log.Debug(ctx, "[EruResolver] start sync service discovery") ctx, r.cancel = context.WithCancel(ctx) defer r.cancel() + log.Debug(ctx, "[EruResolver] start sync service discovery") ch, err := r.discovery.Watch(ctx) if err != nil { - log.Errorf(ctx, "[EruResolver] failed to watch service status: %v", err) + log.Errorf(ctx, err, "[EruResolver] failed to watch service status: %v", err) return } for { select { case <-ctx.Done(): - log.Errorf(ctx, "[EruResolver] watch interrupted: %v", ctx.Err()) + log.Errorf(ctx, ctx.Err(), "[EruResolver] watch interrupted: %v", ctx.Err()) return case endpoints, ok := <-ch: if !ok { - log.Error("[EruResolver] watch closed") + log.Info(ctx, nil, "[EruResolver] watch closed") return } diff --git a/client/servicediscovery/eru_service_discovery.go b/client/servicediscovery/eru_service_discovery.go index 51ec8e573..555e184f2 100644 --- a/client/servicediscovery/eru_service_discovery.go +++ b/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, "[EruServiceWatch] dial failed: %v", err) + log.Errorf(ctx, err, "[EruServiceWatch] dial failed: %v", err) 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, "[EruServiceWatch] watch failed, try later: %v", err) + log.Errorf(ctx, err, "[EruServiceWatch] watch failed, try later: %v", err) 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, "[EruServiceWatch] recv failed: %v", err) + log.Errorf(ctx, err, "[EruServiceWatch] recv failed: %v", err) break } expectedInterval = time.Duration(status.GetIntervalInSecond()) diff --git a/client/utils/servicepusher.go b/client/utils/servicepusher.go index 2f550c080..09c7b2683 100644 --- a/client/utils/servicepusher.go +++ b/client/utils/servicepusher.go @@ -82,7 +82,7 @@ func (p *EndpointPusher) addCheck(endpoints []string) { func (p *EndpointPusher) pollReachability(ctx context.Context, endpoint string) { parts := strings.Split(endpoint, ":") if len(parts) != 2 { - log.Errorf(ctx, "[EruResolver] wrong format of endpoint: %s", endpoint) + log.Errorf(ctx, nil, "[EruResolver] wrong format of endpoint: %s", endpoint) return } @@ -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, "[EruResolver] failed to create pinger: %+v", err) //nolint + log.Errorf(nil, err, "[EruResolver] failed to create pinger: %+v", err) //nolint return } pinger.SetPrivileged(os.Getuid() == 0) diff --git a/cluster/calcium/build.go b/cluster/calcium/build.go index 3d3c53663..706353fb3 100644 --- a/cluster/calcium/build.go +++ b/cluster/calcium/build.go @@ -13,8 +13,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // BuildImage will build image @@ -22,12 +20,14 @@ func (c *Calcium) BuildImage(ctx context.Context, opts *types.BuildOptions) (ch logger := log.WithField("Calcium", "BuildImage").WithField("opts", opts) // Disable build API if scm not set if c.source == nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrSCMNotSet)) + logger.Errorf(ctx, types.ErrSCMNotSet, "") + return nil, types.ErrSCMNotSet } // select nodes node, err := c.selectBuildNode(ctx) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } log.Infof(ctx, "[BuildImage] Building image at pod %s node %s", node.Podname, node.Name) @@ -44,20 +44,23 @@ func (c *Calcium) BuildImage(ctx context.Context, opts *types.BuildOptions) (ch case types.BuildFromExist: refs, node, resp, err = c.buildFromExist(ctx, opts) default: - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrUnknownBuildType)) + logger.Errorf(ctx, types.ErrUnknownBuildType, "") + return nil, types.ErrUnknownBuildType } if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } ch, err = c.pushImageAndClean(ctx, resp, node, refs) - return ch, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return ch, err } func (c *Calcium) selectBuildNode(ctx context.Context) (*types.Node, error) { // get pod from config // TODO can choose multiple pod here for other engine support if c.config.Docker.BuildPod == "" { - return nil, errors.WithStack(types.ErrNoBuildPod) + return nil, types.ErrNoBuildPod } // get nodes @@ -67,7 +70,7 @@ func (c *Calcium) selectBuildNode(ctx context.Context) (*types.Node, error) { } if len(nodes) == 0 { - return nil, errors.WithStack(types.ErrInsufficientNodes) + return nil, types.ErrInsufficientNodes } // get idle max node return c.getMostIdleNode(ctx, nodes) @@ -97,7 +100,7 @@ func (c *Calcium) buildFromSCM(ctx context.Context, node *types.Node, opts *type path, content, err := node.Engine.BuildContent(ctx, c.source, buildContentOpts) defer os.RemoveAll(path) if err != nil { - return nil, nil, errors.WithStack(err) + return nil, nil, err } opts.Tar = content return c.buildFromContent(ctx, node, opts) @@ -106,7 +109,7 @@ func (c *Calcium) buildFromSCM(ctx context.Context, node *types.Node, opts *type func (c *Calcium) buildFromContent(ctx context.Context, node *types.Node, opts *types.BuildOptions) ([]string, io.ReadCloser, error) { refs := node.Engine.BuildRefs(ctx, toBuildRefOptions(opts)) resp, err := node.Engine.ImageBuild(ctx, opts.Tar, refs, opts.Platform) - return refs, resp, errors.WithStack(err) + return refs, resp, err } func (c *Calcium) buildFromExist(ctx context.Context, opts *types.BuildOptions) (refs []string, node *types.Node, resp io.ReadCloser, err error) { @@ -117,12 +120,12 @@ func (c *Calcium) buildFromExist(ctx context.Context, opts *types.BuildOptions) refs = node.Engine.BuildRefs(ctx, toBuildRefOptions(opts)) imgID, err := node.Engine.ImageBuildFromExist(ctx, opts.ExistID, refs, opts.User) if err != nil { - return nil, nil, nil, errors.WithStack(err) + return nil, nil, nil, err } buildMsg, err := json.Marshal(types.BuildImageMessage{ID: imgID}) if err != nil { - return nil, nil, nil, errors.WithStack(err) + return nil, nil, nil, err } return refs, node, io.NopCloser(bytes.NewReader(buildMsg)), nil @@ -143,14 +146,14 @@ func (c *Calcium) pushImageAndClean(ctx context.Context, resp io.ReadCloser, nod break } if err == context.Canceled || err == context.DeadlineExceeded { - log.Errorf(ctx, "[BuildImage] context timeout") + log.Errorf(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, "[BuildImage] Decode build image message failed %+v, buffered: %v", err, malformed) + logger.Errorf(ctx, nil, "[BuildImage] Decode build image message failed %+v, buffered: %v", err, malformed) return } ch <- message @@ -158,7 +161,7 @@ func (c *Calcium) pushImageAndClean(ctx context.Context, resp io.ReadCloser, nod } if lastMessage.Error != "" { - log.Errorf(ctx, "[BuildImage] Build image failed %v", lastMessage.ErrorDetail.Message) + log.Errorf(ctx, nil, "[BuildImage] Build image failed %v", lastMessage.ErrorDetail.Message) return } @@ -168,7 +171,8 @@ func (c *Calcium) pushImageAndClean(ctx context.Context, resp io.ReadCloser, nod log.Infof(ctx, "[BuildImage] Push image %s", tag) rc, err := node.Engine.ImagePush(ctx, tag) if err != nil { - ch <- &types.BuildImageMessage{Error: logger.ErrWithTracing(ctx, err).Error()} + logger.Errorf(ctx, err, "") + ch <- &types.BuildImageMessage{Error: err.Error()} continue } @@ -212,13 +216,13 @@ 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, "[BuildImage] Remove image error: %+v", errors.WithStack(err)) + logger.Errorf(ctx, err, "[BuildImage] Remove image error: %+v", err) } } if spaceReclaimed, err := node.Engine.ImageBuildCachePrune(ctx, true); err != nil { - logger.Errorf(ctx, "[BuildImage] Remove build image cache error: %+v", errors.WithStack(err)) + logger.Errorf(ctx, err, "[BuildImage] Remove build image cache error: %+v", err) } else { - log.Infof(ctx, "[BuildImage] Clean cached image and release space %d", spaceReclaimed) + logger.Infof(ctx, "[BuildImage] Clean cached image and release space %d", spaceReclaimed) } } diff --git a/cluster/calcium/calcium.go b/cluster/calcium/calcium.go index 83bc21066..34a15c912 100644 --- a/cluster/calcium/calcium.go +++ b/cluster/calcium/calcium.go @@ -20,8 +20,6 @@ import ( "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" "github.com/projecteru2/core/wal" - - "github.com/pkg/errors" ) // Calcium implement the cluster @@ -38,12 +36,11 @@ type Calcium struct { // New returns a new cluster config func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, error) { - logger := log.WithField("Calcium", "New").WithField("config", config) - // set store store, err := store.NewStore(config, t) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + log.Errorf(ctx, err, "") + return nil, err } // set scm @@ -55,11 +52,11 @@ func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, erro case cluster.Github: scm, err = github.New(config) default: - log.Warn("[Calcium] SCM not set, build API disabled") + log.Warn(ctx, "[Calcium] SCM not set, build API disabled") } if err != nil { - logger.Errorf(nil, "[Calcium] SCM failed: %+v", err) //nolint - return nil, errors.WithStack(err) + log.Errorf(ctx, err, "[Calcium] SCM failed: %+v", err) + return nil, err } // set watcher @@ -68,18 +65,19 @@ func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, erro // set resource plugin manager rmgr, err := resources.NewPluginsManager(config) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + log.Errorf(ctx, err, "") + return nil, err } // load internal plugins cpumem, err := cpumem.NewPlugin(config) if err != nil { - log.Errorf(ctx, "[NewPluginManager] new cpumem plugin error: %v", err) + log.Errorf(ctx, err, "[NewPluginManager] new cpumem plugin error: %v", err) return nil, err } volume, err := volume.NewPlugin(config) if err != nil { - log.Errorf(ctx, "[NewPluginManager] new volume plugin error: %v", err) + log.Errorf(ctx, err, "[NewPluginManager] new volume plugin error: %v", err) return nil, err } rmgr.AddPlugins(cpumem, volume) @@ -98,17 +96,19 @@ func New(ctx context.Context, config types.Config, t *testing.T) (*Calcium, erro cal.wal, err = enableWAL(config, cal, store) if err != nil { - return nil, logger.ErrWithTracing(nil, errors.WithStack(err)) //nolint + log.Errorf(ctx, err, "") + return nil, err } cal.identifier, err = config.Identifier() if err != nil { - return nil, logger.ErrWithTracing(nil, errors.WithStack(err)) //nolint + log.Errorf(ctx, err, "") + return nil, err } _ = pool.Invoke(func() { cal.InitMetrics(ctx) }) - - return cal, logger.ErrWithTracing(nil, errors.WithStack(err)) //nolint + log.Errorf(ctx, err, "") + return cal, err } // DisasterRecover . diff --git a/cluster/calcium/capacity.go b/cluster/calcium/capacity.go index 009a745ee..3b77264a7 100644 --- a/cluster/calcium/capacity.go +++ b/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, "[Calcium.CalculateCapacity] doGetDeployMap failed: %+v", err) + logger.Errorf(ctx, err, "[Calcium.CalculateCapacity] doGetDeployMap failed: %+v", err) 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, "[Calcium.CalculateCapacity] failed to get nodes capacity: %+v", err) + logger.Errorf(ctx, err, "[Calcium.CalculateCapacity] failed to get nodes capacity: %+v", err) return err } if msg.Total <= 0 { diff --git a/cluster/calcium/control.go b/cluster/calcium/control.go index 2f0c1692d..2232b2971 100644 --- a/cluster/calcium/control.go +++ b/cluster/calcium/control.go @@ -9,8 +9,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // ControlWorkload control workloads status @@ -46,16 +44,17 @@ func (c *Calcium) ControlWorkload(ctx context.Context, ids []string, t string, f message = append(message, startHook...) return err } - return errors.WithStack(types.ErrUnknownControlType) + return types.ErrUnknownControlType }) if err == nil { - log.Infof(ctx, "[ControlWorkload] Workload %s %s", id, t) - log.Info("[ControlWorkload] Hook Output:") - log.Info(string(utils.MergeHookOutputs(message))) + logger.Infof(ctx, "[ControlWorkload] Workload %s %s", id, t) + logger.Infof(ctx, "%v", "[ControlWorkload] Hook Output:") + logger.Infof(ctx, "%v", string(utils.MergeHookOutputs(message))) } + logger.Errorf(ctx, err, "") ch <- &types.ControlWorkloadMessage{ WorkloadID: id, - Error: logger.ErrWithTracing(ctx, err), + Error: err, Hook: message, } }) diff --git a/cluster/calcium/copy.go b/cluster/calcium/copy.go index 1b3048fe1..7d67ff9ab 100644 --- a/cluster/calcium/copy.go +++ b/cluster/calcium/copy.go @@ -12,7 +12,8 @@ import ( func (c *Calcium) Copy(ctx context.Context, opts *types.CopyOptions) (chan *types.CopyMessage, error) { logger := log.WithField("Calcium", "Copy").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } ch := make(chan *types.CopyMessage) @@ -22,7 +23,7 @@ func (c *Calcium) Copy(ctx context.Context, opts *types.CopyOptions) (chan *type wg := sync.WaitGroup{} wg.Add(len(opts.Targets)) defer wg.Wait() - log.Infof(ctx, "[Copy] Copy %d workloads files", len(opts.Targets)) + logger.Infof(ctx, "[Copy] Copy %d workloads files", len(opts.Targets)) // workload one by one for id, paths := range opts.Targets { @@ -33,10 +34,11 @@ func (c *Calcium) Copy(ctx context.Context, opts *types.CopyOptions) (chan *type workload, err := c.GetWorkload(ctx, id) if err != nil { for _, path := range paths { + logger.Errorf(ctx, err, "") ch <- &types.CopyMessage{ ID: id, Path: path, - Error: logger.ErrWithTracing(ctx, err), + Error: err, } } return diff --git a/cluster/calcium/create.go b/cluster/calcium/create.go index a079a8fa1..658b35c16 100644 --- a/cluster/calcium/create.go +++ b/cluster/calcium/create.go @@ -16,7 +16,6 @@ import ( "github.com/projecteru2/core/utils" "github.com/projecteru2/core/wal" - "github.com/pkg/errors" "github.com/sanity-io/litter" ) @@ -24,14 +23,17 @@ import ( func (c *Calcium) CreateWorkload(ctx context.Context, opts *types.DeployOptions) (chan *types.CreateWorkloadMessage, error) { logger := log.WithField("Calcium", "CreateWorkload").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } opts.ProcessIdent = utils.RandomString(16) - log.Infof(ctx, "[CreateWorkload %s] Creating workload with options:\n%s", opts.ProcessIdent, litter.Options{Compact: true}.Sdump(opts)) + logger.Infof(ctx, "[CreateWorkload %s] Creating workload with options:\n%s", opts.ProcessIdent, litter.Options{Compact: true}.Sdump(opts)) // Count 要大于0 if opts.Count <= 0 { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.NewDetailedErr(types.ErrBadCount, opts.Count))) + err := types.NewDetailedErr(types.ErrBadCount, opts.Count) + logger.Errorf(ctx, err, "") + return nil, err } return c.doCreateWorkloads(ctx, opts), nil @@ -60,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, "[Calcium.doCreateWorkloads] delete processing failed for %s: %+v", nodename, err) + logger.Errorf(ctx, err, "[Calcium.doCreateWorkloads] delete processing failed for %s: %+v", nodename, err) } } close(ch) @@ -71,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, "commit wal failed: %s, %+v", eventWorkloadResourceAllocated, err) + logger.Errorf(ctx, err, "commit wal failed: %s, %+v", eventWorkloadResourceAllocated, err) } } }() @@ -83,7 +85,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio continue } if err := processingCommits[nodename](); err != nil { - logger.Errorf(ctx, "commit wal failed: %s, %s, %+v", eventProcessingCreated, nodename, err) + logger.Errorf(ctx, err, "commit wal failed: %s, %s, %+v", eventProcessingCreated, nodename, err) } } }() @@ -95,7 +97,8 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio func(ctx context.Context) (err error) { defer func() { if err != nil { - ch <- &types.CreateWorkloadMessage{Error: logger.ErrWithTracing(ctx, err)} + logger.Errorf(ctx, err, "") + ch <- &types.CreateWorkloadMessage{Error: err} } }() return c.withNodesPodLocked(ctx, opts.NodeFilter, func(ctx context.Context, nodeMap map[string]*types.Node) (err error) { @@ -107,7 +110,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio } if resourceCommit, err = c.wal.Log(eventWorkloadResourceAllocated, nodes); err != nil { - return errors.WithStack(err) + return err } deployMap, err = c.doGetDeployStrategy(ctx, nodenames, opts) @@ -120,15 +123,15 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio for nodename, deploy := range deployMap { nodes = append(nodes, nodeMap[nodename]) if engineArgsMap[nodename], resourceArgsMap[nodename], err = c.rmgr.Alloc(ctx, nodename, deploy, opts.ResourceOpts); err != nil { - return errors.WithStack(err) + return err } processing := opts.GetProcessing(nodename) if processingCommits[nodename], err = c.wal.Log(eventProcessingCreated, processing); err != nil { - return errors.WithStack(err) + return err } if err = c.store.CreateProcessing(ctx, processing, deploy); err != nil { - return errors.WithStack(err) + return err } } return nil @@ -153,7 +156,8 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio }) return c.rmgr.RollbackAlloc(ctx, nodename, resourceArgsToRollback) }); e != nil { - err = logger.ErrWithTracing(ctx, e) + logger.Errorf(ctx, e, "") + err = e } } return err @@ -223,7 +227,8 @@ func (c *Calcium) doDeployWorkloadsOnNode(ctx context.Context, node, err := c.doGetAndPrepareNode(ctx, nodename, opts.Image) if err != nil { for i := 0; i < deploy; i++ { - ch <- &types.CreateWorkloadMessage{Error: logger.ErrWithTracing(ctx, err)} + logger.Errorf(ctx, err, "") + ch <- &types.CreateWorkloadMessage{Error: err} } return utils.Range(deploy), err } @@ -245,7 +250,8 @@ func (c *Calcium) doDeployWorkloadsOnNode(ctx context.Context, defer func() { if e != nil { err = e - createMsg.Error = logger.ErrWithTracing(ctx, e) + logger.Errorf(ctx, err, "") + createMsg.Error = err appendLock.Lock() indices = append(indices, idx) appendLock.Unlock() @@ -316,7 +322,7 @@ func (c *Calcium) doDeployOneWorkload( defer func() { if commit != nil { if err := commit(); err != nil { - logger.Errorf(ctx, "Commit WAL %s failed: %+v", eventWorkloadCreated, err) + logger.Errorf(ctx, err, "Commit WAL %s failed: %+v", eventWorkloadCreated, err) } } }() @@ -326,7 +332,7 @@ func (c *Calcium) doDeployOneWorkload( func(ctx context.Context) error { created, err := node.Engine.VirtualizationCreate(ctx, config) if err != nil { - return errors.WithStack(err) + return err } workload.ID = created.ID @@ -341,7 +347,7 @@ func (c *Calcium) doDeployOneWorkload( ID: workload.ID, Nodename: workload.Nodename, }) - return errors.WithStack(err) + return err }, func(ctx context.Context) (err error) { @@ -352,9 +358,9 @@ func (c *Calcium) doDeployOneWorkload( } // add workload metadata first if err := c.store.AddWorkload(ctx, workload, processing); err != nil { - return errors.WithStack(err) + return err } - log.Infof(ctx, "[doDeployOneWorkload] workload %s metadata created", workload.ID) + logger.Infof(ctx, "[doDeployOneWorkload] workload %s metadata created", workload.ID) // Copy data to workload if len(opts.Files) > 0 { @@ -407,9 +413,9 @@ func (c *Calcium) doDeployOneWorkload( workload.User = workloadInfo.User if err := c.store.UpdateWorkload(ctx, workload); err != nil { - return errors.WithStack(err) + return err } - log.Infof(ctx, "[doDeployOneWorkload] workload %s metadata updated", workload.ID) + logger.Infof(ctx, "[doDeployOneWorkload] workload %s metadata updated", workload.ID) } msg.WorkloadID = workload.ID @@ -421,13 +427,13 @@ func (c *Calcium) doDeployOneWorkload( // remove workload func(ctx context.Context, _ bool) error { - logger.Errorf(ctx, "[doDeployOneWorkload] failed to deploy workload %s, rollback", workload.ID) + logger.Errorf(ctx, nil, "[doDeployOneWorkload] failed to deploy workload %s, rollback", workload.ID) if workload.ID == "" { return nil } if err := c.store.RemoveWorkload(ctx, workload); err != nil { - logger.Errorf(ctx, "[doDeployOneWorkload] failed to remove workload %s", workload.ID) + logger.Errorf(ctx, err, "[doDeployOneWorkload] failed to remove workload %s", workload.ID) } return workload.Remove(ctx, true) diff --git a/cluster/calcium/dissociate.go b/cluster/calcium/dissociate.go index b6755e282..5a5cb7996 100644 --- a/cluster/calcium/dissociate.go +++ b/cluster/calcium/dissociate.go @@ -7,8 +7,6 @@ import ( "github.com/projecteru2/core/resources" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // DissociateWorkload dissociate workload from eru, return it resource but not modity it @@ -17,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, "failed to group workloads by node: %+v", err) + logger.Errorf(ctx, err, "failed to group workloads by node: %+v", err) return nil, err } @@ -39,11 +37,11 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, ids []string) (chan *t resourceArgs[plugin] = args } _, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []map[string]types.WorkloadResourceArgs{resourceArgs}, true, resources.Decr) - return errors.WithStack(err) + return err }, // then func(ctx context.Context) error { - return errors.WithStack(c.store.RemoveWorkload(ctx, workload)) + return c.store.RemoveWorkload(ctx, workload) }, // rollback func(ctx context.Context, failedByCond bool) error { @@ -55,12 +53,12 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, ids []string) (chan *t resourceArgs[plugin] = args } _, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []map[string]types.WorkloadResourceArgs{resourceArgs}, true, resources.Incr) - return errors.WithStack(err) + return err }, c.config.GlobalTimeout, ) }); err != nil { - logger.WithField("id", workloadID).Errorf(ctx, "failed to lock workload: %+v", err) + logger.WithField("id", workloadID).Errorf(ctx, err, "failed to lock workload: %+v", err) msg.Error = err } ch <- msg @@ -68,7 +66,7 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, ids []string) (chan *t _ = c.pool.Invoke(func() { c.doRemapResourceAndLog(ctx, logger, node) }) return nil }); err != nil { - logger.WithField("nodename", nodename).Errorf(ctx, "failed to lock node: %+v", err) + logger.WithField("nodename", nodename).Errorf(ctx, err, "failed to lock node: %+v", err) } } }) diff --git a/cluster/calcium/execute.go b/cluster/calcium/execute.go index 1cb666a5a..857c9ba8d 100644 --- a/cluster/calcium/execute.go +++ b/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, "[ExecuteWorkload] Failed to get workload: %+v", err) + logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to get workload: %+v", err) 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, "[ExecuteWorkload] Failed to attach execID: %+v", err) + logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to attach execID: %+v", err) return } @@ -62,14 +62,14 @@ 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, "[ExecuteWorkload] Failed to get exitcode: %+v", err) + logger.Errorf(ctx, err, "[ExecuteWorkload] Failed to get exitcode: %+v", err) return } exitData := []byte(exitDataPrefix + strconv.Itoa(execCode)) ch <- &types.AttachWorkloadMessage{WorkloadID: opts.WorkloadID, Data: exitData} - log.Infof(ctx, "[ExecuteWorkload] Execuate in workload %s complete", opts.WorkloadID) - log.Infof(ctx, "[ExecuteWorkload] %v", opts.Commands) + logger.Infof(ctx, "[ExecuteWorkload] Execuate in workload %s complete", opts.WorkloadID) + logger.Infof(ctx, "[ExecuteWorkload] %v", opts.Commands) }) return ch diff --git a/cluster/calcium/helper.go b/cluster/calcium/helper.go index 04024de5b..2c25c543e 100644 --- a/cluster/calcium/helper.go +++ b/cluster/calcium/helper.go @@ -5,14 +5,13 @@ import ( "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - "github.com/pkg/errors" "golang.org/x/net/context" ) 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, "[distributionInspect] get manifest failed %v", err) + log.Errorf(ctx, err, "[distributionInspect] get manifest failed %v", err) return false } @@ -30,14 +29,14 @@ func distributionInspect(ctx context.Context, node *types.Node, image string, di func pullImage(ctx context.Context, node *types.Node, image string) error { log.Infof(ctx, "[pullImage] Pulling image %s", image) if image == "" { - return errors.WithStack(types.ErrNoImage) + return types.ErrNoImage } // check local exists := false digests, err := node.Engine.ImageLocalDigests(ctx, image) if err != nil { - log.Errorf(ctx, "[pullImage] Check image failed %v", err) + log.Errorf(ctx, err, "[pullImage] Check image failed %v", err) } else { log.Debug(ctx, "[pullImage] Local Image exists") exists = true @@ -48,12 +47,12 @@ func pullImage(ctx context.Context, node *types.Node, image string) error { return nil } - log.Info("[pullImage] Image not cached, pulling") + log.Info(ctx, "[pullImage] Image not cached, pulling") rc, err := node.Engine.ImagePull(ctx, image, false) defer utils.EnsureReaderClosed(ctx, rc) if err != nil { - log.Errorf(ctx, "[pullImage] Error during pulling image %s: %v", image, err) - return errors.WithStack(err) + log.Errorf(ctx, err, "[pullImage] Error during pulling image %s: %v", image, err) + return err } log.Infof(ctx, "[pullImage] Done pulling image %s", image) return nil diff --git a/cluster/calcium/hook.go b/cluster/calcium/hook.go index 8ef59642b..aff651176 100644 --- a/cluster/calcium/hook.go +++ b/cluster/calcium/hook.go @@ -5,8 +5,6 @@ import ( "context" "github.com/projecteru2/core/engine" - - "github.com/pkg/errors" ) func (c *Calcium) doHook( @@ -23,7 +21,7 @@ func (c *Calcium) doHook( // 执行 hook 的过程中,如果 cmdForce 为真并且不忽略 hook 就输出错误 outputs = append(outputs, bytes.NewBufferString(err.Error())) if cmdForce && !force { - return outputs, errors.WithStack(err) + return outputs, err } continue } diff --git a/cluster/calcium/image.go b/cluster/calcium/image.go index d10fd5378..8fcdedbe1 100644 --- a/cluster/calcium/image.go +++ b/cluster/calcium/image.go @@ -7,8 +7,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // CacheImage cache Image @@ -17,16 +15,19 @@ import ( func (c *Calcium) CacheImage(ctx context.Context, opts *types.ImageOptions) (chan *types.CacheImageMessage, error) { logger := log.WithField("Calcium", "CacheImage").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } nodes, err := c.filterNodes(ctx, &types.NodeFilter{Podname: opts.Podname, Includes: opts.Nodenames}) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } if len(nodes) == 0 { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrPodNoNodes)) + logger.Errorf(ctx, types.ErrPodNoNodes, "") + return nil, types.ErrPodNoNodes } ch := make(chan *types.CacheImageMessage) @@ -48,8 +49,9 @@ func (c *Calcium) CacheImage(ctx context.Context, opts *types.ImageOptions) (cha Message: "", } if err := pullImage(ctx, node, image); err != nil { + logger.Errorf(ctx, err, "") m.Success = false - m.Message = logger.ErrWithTracing(ctx, err).Error() + m.Message = err.Error() } ch <- m } @@ -64,16 +66,19 @@ func (c *Calcium) CacheImage(ctx context.Context, opts *types.ImageOptions) (cha func (c *Calcium) RemoveImage(ctx context.Context, opts *types.ImageOptions) (chan *types.RemoveImageMessage, error) { logger := log.WithField("Calcium", "RemoveImage").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } nodes, err := c.filterNodes(ctx, &types.NodeFilter{Podname: opts.Podname, Includes: opts.Nodenames}) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } if len(nodes) == 0 { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrPodNoNodes)) + logger.Errorf(ctx, types.ErrPodNoNodes, "") + return nil, types.ErrPodNoNodes } ch := make(chan *types.RemoveImageMessage) @@ -94,7 +99,8 @@ func (c *Calcium) RemoveImage(ctx context.Context, opts *types.ImageOptions) (ch Messages: []string{}, } if removeItems, err := node.Engine.ImageRemove(ctx, image, false, true); err != nil { - m.Messages = append(m.Messages, logger.ErrWithTracing(ctx, err).Error()) + logger.Errorf(ctx, err, "") + m.Messages = append(m.Messages, err.Error()) } else { m.Success = true for _, item := range removeItems { @@ -105,9 +111,9 @@ 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, "[RemoveImage] Prune %s pod %s node failed: %+v", opts.Podname, node.Name, err) + logger.Errorf(ctx, err, "[RemoveImage] Prune %s pod %s node failed: %+v", opts.Podname, node.Name, err) } else { - log.Infof(ctx, "[RemoveImage] Prune %s pod %s node", opts.Podname, node.Name) + logger.Infof(ctx, "[RemoveImage] Prune %s pod %s node", opts.Podname, node.Name) } } }) @@ -123,11 +129,13 @@ func (c *Calcium) ListImage(ctx context.Context, opts *types.ImageOptions) (chan nodes, err := c.filterNodes(ctx, &types.NodeFilter{Podname: opts.Podname, Includes: opts.Nodenames}) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } if len(nodes) == 0 { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrPodNoNodes)) + logger.Errorf(ctx, types.ErrPodNoNodes, "") + return nil, err } ch := make(chan *types.ListImageMessage) @@ -147,7 +155,8 @@ func (c *Calcium) ListImage(ctx context.Context, opts *types.ImageOptions) (chan Error: nil, } if images, err := node.Engine.ImageList(ctx, opts.Filter); err != nil { - msg.Error = logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + msg.Error = err } else { for _, image := range images { msg.Images = append(msg.Images, &types.Image{ diff --git a/cluster/calcium/lambda.go b/cluster/calcium/lambda.go index 3a0f2dd45..f54b0060d 100644 --- a/cluster/calcium/lambda.go +++ b/cluster/calcium/lambda.go @@ -27,18 +27,19 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC logger := log.WithField("Calcium", "RunAndWait").WithField("opts", opts) if err := opts.Validate(); err != nil { - return workloadIDs, nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return workloadIDs, nil, err } opts.Lambda = true // count = 1 && OpenStdin if opts.OpenStdin && (opts.Count != 1 || opts.DeployStrategy != strategy.Auto) { - logger.Errorf(ctx, "Count %d method %s", opts.Count, opts.DeployStrategy) - return workloadIDs, nil, errors.WithStack(types.ErrRunAndWaitCountOneWithStdin) + logger.Errorf(ctx, types.ErrRunAndWaitCountOneWithStdin, "Count %d method %s", opts.Count, opts.DeployStrategy) + return workloadIDs, nil, types.ErrRunAndWaitCountOneWithStdin } createChan, err := c.CreateWorkload(ctx, opts) if err != nil { - logger.Errorf(ctx, "[RunAndWait] Create workload error %+v", err) + logger.Errorf(ctx, err, "[RunAndWait] Create workload error %+v", err) return workloadIDs, nil, err } @@ -59,7 +60,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, "[RunAndWait] Create workload failed %+v", message.Error) + logger.Errorf(ctx, message.Error, "[RunAndWait] Create workload failed %+v", message.Error) return &types.AttachWorkloadMessage{ WorkloadID: "", Data: []byte(fmt.Sprintf("Create workload failed %+v", errors.Unwrap(message.Error))), @@ -69,15 +70,16 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC commit, err := c.wal.Log(eventCreateLambda, message.WorkloadID) if err != nil { + logger.Errorf(ctx, err, "") return &types.AttachWorkloadMessage{ WorkloadID: message.WorkloadID, - Data: []byte(fmt.Sprintf("Create wal failed: %s, %+v", message.WorkloadID, logger.ErrWithTracing(ctx, err))), + Data: []byte(fmt.Sprintf("Create wal failed: %s, %+v", message.WorkloadID, err)), StdStreamType: types.EruError, } } defer func() { if err := commit(); err != nil { - logger.Errorf(ctx, "[RunAndWait] Commit WAL %s failed: %s, %v", eventCreateLambda, message.WorkloadID, err) + logger.Errorf(ctx, err, "[RunAndWait] Commit WAL %s failed: %s, %v", eventCreateLambda, message.WorkloadID, err) } }() @@ -87,9 +89,9 @@ 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, "[RunAndWait] Remove lambda workload failed %+v", err) + logger.Errorf(ctx, err, "[RunAndWait] Remove lambda workload failed %+v", err) } else { - log.Infof(ctx, "[RunAndWait] Workload %s finished and removed", utils.ShortID(message.WorkloadID)) + logger.Infof(ctx, "[RunAndWait] Workload %s finished and removed", utils.ShortID(message.WorkloadID)) } }() @@ -97,10 +99,10 @@ 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, "[RunAndWait] Get workload failed %+v", err) + logger.Errorf(ctx, err, "[RunAndWait] Get workload failed %+v", err) return &types.AttachWorkloadMessage{ WorkloadID: message.WorkloadID, - Data: []byte(fmt.Sprintf("Get workload %s failed %+v", message.WorkloadID, errors.Unwrap(err))), + Data: []byte(fmt.Sprintf("Get workload %s failed %+v", message.WorkloadID, err)), StdStreamType: types.EruError, } } @@ -115,10 +117,10 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC Stdout: true, Stderr: true, }); err != nil { - logger.Errorf(ctx, "[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 error %+v", message.WorkloadID, err) return &types.AttachWorkloadMessage{ WorkloadID: message.WorkloadID, - Data: []byte(fmt.Sprintf("Fetch log for workload %s failed %+v", message.WorkloadID, errors.Unwrap(err))), + Data: []byte(fmt.Sprintf("Fetch log for workload %s failed %+v", message.WorkloadID, err)), StdStreamType: types.EruError, } } @@ -130,7 +132,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, "[RunAndWait] Can't attach workload %s error %+v", message.WorkloadID, err) + logger.Errorf(ctx, err, "[RunAndWait] Can't attach workload %s error %+v", message.WorkloadID, err) return &types.AttachWorkloadMessage{ WorkloadID: message.WorkloadID, Data: []byte(fmt.Sprintf("Attach to workload %s failed %+v", message.WorkloadID, errors.Unwrap(err))), @@ -156,7 +158,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, "[RunAndWait] %s wait failed %+v", utils.ShortID(message.WorkloadID), err) + logger.Errorf(ctx, err, "[RunAndWait] %s wait failed %+v", utils.ShortID(message.WorkloadID), err) return &types.AttachWorkloadMessage{ WorkloadID: message.WorkloadID, Data: []byte(fmt.Sprintf("Wait workload %s failed %+v", message.WorkloadID, errors.Unwrap(err))), @@ -165,7 +167,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC } if r.Code != 0 { - logger.Errorf(ctx, "[RunAndWait] %s run failed %s", utils.ShortID(message.WorkloadID), r.Message) + logger.Errorf(ctx, err, "[RunAndWait] %s run failed %s", utils.ShortID(message.WorkloadID), r.Message) } exitData := []byte(exitDataPrefix + strconv.Itoa(int(r.Code))) @@ -191,7 +193,7 @@ func (c *Calcium) RunAndWait(ctx context.Context, opts *types.DeployOptions, inC defer close(runMsgCh) wg.Wait() - log.Info("[RunAndWait] Finish run and wait for workloads") + logger.Infof(context.TODO(), "%v", "[RunAndWait] Finish run and wait for workloads") }) return workloadIDs, runMsgCh, nil diff --git a/cluster/calcium/lock.go b/cluster/calcium/lock.go index 0d25a81a6..639e7b079 100644 --- a/cluster/calcium/lock.go +++ b/cluster/calcium/lock.go @@ -11,13 +11,11 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) func (c *Calcium) doLock(ctx context.Context, name string, timeout time.Duration) (lock lock.DistributedLock, rCtx context.Context, err error) { if lock, err = c.store.CreateLock(name, timeout); err != nil { - return lock, rCtx, errors.WithStack(err) + return lock, rCtx, err } defer func() { if err != nil { @@ -25,17 +23,17 @@ 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, "failed to unlock %s: %+v", name, err) + log.Errorf(rollbackCtx, err, "failed to unlock %s: %+v", name, err) } } }() rCtx, err = lock.Lock(ctx) - return lock, rCtx, errors.WithStack(err) + return lock, rCtx, err } func (c *Calcium) doUnlock(ctx context.Context, lock lock.DistributedLock, msg string) error { log.Debugf(ctx, "[doUnlock] Unlock %s", msg) - return errors.WithStack(lock.Unlock(ctx)) + return lock.Unlock(ctx) } func (c *Calcium) doUnlockAll(ctx context.Context, locks map[string]lock.DistributedLock, order ...string) { @@ -49,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, "[doUnlockAll] Unlock %s failed %v", key, err) + log.Errorf(ctx, err, "[doUnlockAll] Unlock %s failed %v", key, err) continue } } @@ -60,7 +58,7 @@ func (c *Calcium) withWorkloadLocked(ctx context.Context, id string, f func(cont if c, ok := workloads[id]; ok { return f(ctx, c) } - return errors.WithStack(types.ErrWorkloadNotExists) + return types.ErrWorkloadNotExists }) } @@ -85,7 +83,7 @@ func (c *Calcium) withWorkloadsLocked(ctx context.Context, ids []string, f func( for _, workload := range cs { lock, ctx, err = c.doLock(ctx, fmt.Sprintf(cluster.WorkloadLock, workload.ID), c.config.LockTimeout) if err != nil { - return errors.WithStack(err) + return err } log.Debugf(ctx, "[withWorkloadsLocked] Workload %s locked", workload.ID) locks[workload.ID] = lock @@ -103,7 +101,7 @@ func (c *Calcium) withNodePodLocked(ctx context.Context, nodename string, f func if n, ok := nodes[nodename]; ok { return f(ctx, n) } - return errors.WithStack(types.ErrNodeNotExists) + return types.ErrNodeNotExists }) } @@ -116,7 +114,7 @@ func (c *Calcium) withNodeOperationLocked(ctx context.Context, nodename string, if n, ok := nodes[nodename]; ok { return f(ctx, n) } - return errors.WithStack(types.ErrNodeNotExists) + return types.ErrNodeNotExists }) } diff --git a/cluster/calcium/log.go b/cluster/calcium/log.go index 7c20511d9..87e63a20c 100644 --- a/cluster/calcium/log.go +++ b/cluster/calcium/log.go @@ -17,7 +17,8 @@ func (c *Calcium) LogStream(ctx context.Context, opts *types.LogStreamOptions) ( defer close(ch) workload, err := c.GetWorkload(ctx, opts.ID) if err != nil { - ch <- &types.LogStreamMessage{ID: opts.ID, Error: logger.ErrWithTracing(ctx, err)} + logger.Errorf(ctx, err, "") + ch <- &types.LogStreamMessage{ID: opts.ID, Error: err} return } @@ -30,8 +31,9 @@ func (c *Calcium) LogStream(ctx context.Context, opts *types.LogStreamOptions) ( Stdout: true, Stderr: true, }) + logger.Errorf(ctx, err, "") if err != nil { - ch <- &types.LogStreamMessage{ID: opts.ID, Error: logger.ErrWithTracing(ctx, err)} + ch <- &types.LogStreamMessage{ID: opts.ID, Error: err} return } diff --git a/cluster/calcium/metrics.go b/cluster/calcium/metrics.go index 3e5d1cdea..19041c9a2 100644 --- a/cluster/calcium/metrics.go +++ b/cluster/calcium/metrics.go @@ -14,11 +14,11 @@ import ( func (c *Calcium) InitMetrics(ctx context.Context) { metricsDescriptions, err := c.rmgr.GetMetricsDescription(ctx) if err != nil { - log.Errorf(ctx, "[InitMetrics] failed to get metrics description, err: %v", err) + log.Errorf(ctx, err, "[InitMetrics] failed to get metrics description, err: %v", err) return } if err = metrics.InitMetrics(c.config, metricsDescriptions); err != nil { - log.Errorf(ctx, "[InitMetrics] failed to init metrics, err: %v", err) + log.Errorf(ctx, err, "[InitMetrics] failed to init metrics, err: %v", err) return } log.Infof(ctx, "[InitMetrics] init metrics %v success", litter.Sdump(metricsDescriptions)) @@ -27,7 +27,7 @@ func (c *Calcium) InitMetrics(ctx context.Context) { func (c *Calcium) doSendNodeMetrics(ctx context.Context, node *types.Node) { nodeMetrics, err := c.rmgr.GetNodeMetrics(ctx, node) if err != nil { - log.Errorf(ctx, "[SendNodeMetrics] convert node %s resource info to metrics failed, %v", node.Name, err) + log.Errorf(ctx, err, "[SendNodeMetrics] convert node %s resource info to metrics failed, %v", node.Name, err) return } metrics.Client.SendMetrics(nodeMetrics...) diff --git a/cluster/calcium/network.go b/cluster/calcium/network.go index 6110e4e73..36d3f99f7 100644 --- a/cluster/calcium/network.go +++ b/cluster/calcium/network.go @@ -6,8 +6,6 @@ import ( enginetypes "github.com/projecteru2/core/engine/types" "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // ListNetworks by podname @@ -19,11 +17,14 @@ func (c *Calcium) ListNetworks(ctx context.Context, podname string, driver strin networks := []*enginetypes.Network{} nodes, err := c.store.GetNodesByPod(ctx, &types.NodeFilter{Podname: podname}) if err != nil { - return networks, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return networks, err } if len(nodes) == 0 { - return networks, logger.ErrWithTracing(ctx, errors.WithStack(types.NewDetailedErr(types.ErrPodNoNodes, podname))) + err := types.NewDetailedErr(types.ErrPodNoNodes, podname) + logger.Errorf(ctx, err, "") + return networks, err } drivers := []string{} @@ -34,7 +35,8 @@ func (c *Calcium) ListNetworks(ctx context.Context, podname string, driver strin node := nodes[0] networks, err = node.Engine.NetworkList(ctx, drivers) - return networks, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return networks, err } // ConnectNetwork connect to a network @@ -42,11 +44,13 @@ func (c *Calcium) ConnectNetwork(ctx context.Context, network, target, ipv4, ipv logger := log.WithField("Calcium", "ConnectNetwork").WithField("network", network).WithField("target", target).WithField("ipv4", ipv4).WithField("ipv6", ipv6) workload, err := c.GetWorkload(ctx, target) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } networks, err := workload.Engine.NetworkConnect(ctx, network, target, ipv4, ipv6) - return networks, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return networks, err } // DisconnectNetwork connect to a network @@ -54,8 +58,11 @@ func (c *Calcium) DisconnectNetwork(ctx context.Context, network, target string, logger := log.WithField("Calcium", "DisconnectNetwork").WithField("network", network).WithField("target", target).WithField("force", force) workload, err := c.GetWorkload(ctx, target) if err != nil { - return logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return err } - - return logger.ErrWithTracing(ctx, errors.WithStack(workload.Engine.NetworkDisconnect(ctx, network, target, force))) + if err = workload.Engine.NetworkDisconnect(ctx, network, target, force); err != nil { + logger.Errorf(ctx, err, "") + } + return err } diff --git a/cluster/calcium/node.go b/cluster/calcium/node.go index cd7137830..7ce4785b3 100644 --- a/cluster/calcium/node.go +++ b/cluster/calcium/node.go @@ -10,8 +10,6 @@ import ( "github.com/projecteru2/core/resources" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // AddNode adds a node @@ -19,7 +17,8 @@ import ( func (c *Calcium) AddNode(ctx context.Context, opts *types.AddNodeOptions) (*types.Node, error) { logger := log.WithField("Calcium", "AddNode").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } var resourceCapacity map[string]types.NodeResourceArgs var resourceUsage map[string]types.NodeResourceArgs @@ -29,26 +28,26 @@ func (c *Calcium) AddNode(ctx context.Context, opts *types.AddNodeOptions) (*typ // check if the node is alive client, err := enginefactory.GetEngine(ctx, c.config, opts.Nodename, opts.Endpoint, opts.Ca, opts.Cert, opts.Key) if err != nil { - return nil, errors.WithStack(err) + return nil, err } // get node info nodeInfo, err := client.Info(ctx) if err != nil { - return nil, errors.WithStack(err) + return nil, err } - return node, logger.ErrWithTracing(ctx, utils.Txn( + return node, utils.Txn( ctx, // if: add node resource with resource plugins func(ctx context.Context) error { resourceCapacity, resourceUsage, err = c.rmgr.AddNode(ctx, opts.Nodename, opts.ResourceOpts, nodeInfo) - return errors.WithStack(err) + return err }, // then: add node meta in store func(ctx context.Context) error { node, err = c.store.AddNode(ctx, opts) if err != nil { - return errors.WithStack(err) + return err } node.Resource.Capacity = resourceCapacity node.Resource.Usage = resourceUsage @@ -60,43 +59,44 @@ func (c *Calcium) AddNode(ctx context.Context, opts *types.AddNodeOptions) (*typ if failureByCond { return nil } - return errors.WithStack(c.rmgr.RemoveNode(ctx, opts.Nodename)) + return c.rmgr.RemoveNode(ctx, opts.Nodename) }, - c.config.GlobalTimeout), - ) + c.config.GlobalTimeout) } // RemoveNode remove a node func (c *Calcium) RemoveNode(ctx context.Context, nodename string) error { logger := log.WithField("Calcium", "RemoveNode").WithField("nodename", nodename) if nodename == "" { - return logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyNodeName)) + logger.Errorf(ctx, types.ErrEmptyNodeName, "") + return types.ErrEmptyNodeName } return c.withNodePodLocked(ctx, nodename, func(ctx context.Context, node *types.Node) error { workloads, err := c.ListNodeWorkloads(ctx, node.Name, nil) if err != nil { - return logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return err } // need drain first if len(workloads) > 0 { - return logger.ErrWithTracing(ctx, errors.WithStack(types.ErrNodeNotEmpty)) + logger.Errorf(ctx, types.ErrNodeNotEmpty, "") + return types.ErrNodeNotEmpty } - return logger.ErrWithTracing(ctx, utils.Txn(ctx, + return utils.Txn(ctx, // if: remove node metadata func(ctx context.Context) error { - return errors.WithStack(c.store.RemoveNode(ctx, node)) + return c.store.RemoveNode(ctx, node) }, // then: remove node resource metadata func(ctx context.Context) error { - return errors.WithStack(c.rmgr.RemoveNode(ctx, nodename)) + return c.rmgr.RemoveNode(ctx, nodename) }, // rollback: do nothing func(ctx context.Context, failureByCond bool) error { return nil }, - c.config.GlobalTimeout, - )) + c.config.GlobalTimeout) }) } @@ -106,7 +106,8 @@ func (c *Calcium) ListPodNodes(ctx context.Context, opts *types.ListNodesOptions logger := log.WithField("Calcium", "ListPodNodes").WithField("podname", opts.Podname).WithField("labels", opts.Labels).WithField("all", opts.All).WithField("info", opts.CallInfo) nodes, err := c.store.GetNodesByPod(ctx, &types.NodeFilter{Podname: opts.Podname, Labels: opts.Labels, All: opts.All}) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } ch := make(chan *types.Node) @@ -121,11 +122,11 @@ func (c *Calcium) ListPodNodes(ctx context.Context, opts *types.ListNodesOptions defer wg.Done() var err error if node.Resource.Capacity, node.Resource.Usage, node.Resource.Diffs, err = c.rmgr.GetNodeResourceInfo(ctx, node.Name, nil, false); err != nil { - logger.Errorf(ctx, "failed to get node %v resource info: %+v", node.Name, err) + logger.Errorf(ctx, err, "failed to get node %v resource info: %+v", node.Name, err) } if opts.CallInfo { if err := node.Info(ctx); err != nil { - logger.Errorf(ctx, "failed to get node %v info: %+v", node.Name, err) + logger.Errorf(ctx, err, "failed to get node %v info: %+v", node.Name, err) } } ch <- node @@ -141,13 +142,16 @@ func (c *Calcium) ListPodNodes(ctx context.Context, opts *types.ListNodesOptions func (c *Calcium) GetNode(ctx context.Context, nodename string) (node *types.Node, err error) { logger := log.WithField("Calcium", "GetNode").WithField("nodename", nodename) if nodename == "" { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyNodeName)) + logger.Errorf(ctx, types.ErrEmptyNodeName, "") + return nil, types.ErrEmptyNodeName } if node, err = c.store.GetNode(ctx, nodename); err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } if node.Resource.Capacity, node.Resource.Usage, node.Resource.Diffs, err = c.rmgr.GetNodeResourceInfo(ctx, node.Name, nil, false); err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } return node, nil } @@ -156,14 +160,17 @@ func (c *Calcium) GetNode(ctx context.Context, nodename string) (node *types.Nod func (c *Calcium) GetNodeEngineInfo(ctx context.Context, nodename string) (*enginetypes.Info, error) { logger := log.WithField("Calcium", "GetNodeEngine").WithField("nodename", nodename) if nodename == "" { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyNodeName)) + logger.Errorf(ctx, types.ErrEmptyNodeName, "") + return nil, types.ErrEmptyNodeName } node, err := c.store.GetNode(ctx, nodename) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } engineInfo, err := node.Engine.Info(ctx) - return engineInfo, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return engineInfo, err } // SetNode set node available or not @@ -171,7 +178,8 @@ func (c *Calcium) GetNodeEngineInfo(ctx context.Context, nodename string) (*engi func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*types.Node, error) { logger := log.WithField("Calcium", "SetNode").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } var n *types.Node return n, c.withNodePodLocked(ctx, opts.Nodename, func(ctx context.Context, node *types.Node) error { @@ -186,7 +194,7 @@ func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*typ n.Bypass = (opts.Bypass == types.TriTrue) || (opts.Bypass == types.TriKeep && n.Bypass) if n.IsDown() { - logger.Errorf(ctx, "[SetNode] node marked down: %s", opts.Nodename) + logger.Errorf(ctx, err, "[SetNode] node marked down: %s", opts.Nodename) } if opts.WorkloadsDown { @@ -207,7 +215,7 @@ func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*typ } var originNodeResourceCapacity map[string]types.NodeResourceArgs - return logger.ErrWithTracing(ctx, utils.Txn(ctx, + return utils.Txn(ctx, // if: update node resource capacity success func(ctx context.Context) error { if len(opts.ResourceOpts) == 0 { @@ -215,11 +223,11 @@ func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*typ } originNodeResourceCapacity, _, err = c.rmgr.SetNodeResourceCapacity(ctx, n.Name, opts.ResourceOpts, nil, opts.Delta, resources.Incr) - return errors.WithStack(err) + return err }, // then: update node metadata func(ctx context.Context) error { - if err := errors.WithStack(c.store.UpdateNodes(ctx, n)); err != nil { + if err := c.store.UpdateNodes(ctx, n); err != nil { return err } // update resource @@ -240,10 +248,9 @@ func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*typ return nil } _, _, err = c.rmgr.SetNodeResourceCapacity(ctx, n.Name, nil, originNodeResourceCapacity, false, resources.Decr) - return errors.WithStack(err) + return err }, - c.config.GlobalTimeout, - )) + c.config.GlobalTimeout) }) } @@ -300,14 +307,14 @@ func (c *Calcium) filterNodes(ctx context.Context, nodeFilter *types.NodeFilter) func (c *Calcium) setAllWorkloadsOnNodeDown(ctx context.Context, nodename string) { workloads, err := c.store.ListNodeWorkloads(ctx, nodename, nil) if err != nil { - log.Errorf(ctx, "[setAllWorkloadsOnNodeDown] failed to list node workloads, node %v, err: %v", nodename, errors.WithStack(err)) + log.Errorf(ctx, err, "[setAllWorkloadsOnNodeDown] failed to list node workloads, node %v, err: %v", nodename, err) return } for _, workload := range workloads { appname, entrypoint, _, err := utils.ParseWorkloadName(workload.Name) if err != nil { - log.Errorf(ctx, "[setAllWorkloadsOnNodeDown] Set workload %s on node %s as inactive failed %v", workload.ID, nodename, err) + log.Errorf(ctx, err, "[setAllWorkloadsOnNodeDown] Set workload %s on node %s as inactive failed %v", workload.ID, nodename, err) continue } @@ -324,7 +331,7 @@ func (c *Calcium) setAllWorkloadsOnNodeDown(ctx context.Context, nodename string // mark workload which belongs to this node as unhealthy if err = c.store.SetWorkloadStatus(ctx, workload.StatusMeta, 0); err != nil { - log.Errorf(ctx, "[SetNodeAvailable] Set workload %s on node %s as inactive failed %v", workload.ID, nodename, errors.WithStack(err)) + log.Errorf(ctx, err, "[SetNodeAvailable] Set workload %s on node %s as inactive failed %v", workload.ID, nodename, err) } else { log.Infof(ctx, "[SetNodeAvailable] Set workload %s on node %s as inactive", workload.ID, nodename) } diff --git a/cluster/calcium/pod.go b/cluster/calcium/pod.go index 600db0107..96b831ac3 100644 --- a/cluster/calcium/pod.go +++ b/cluster/calcium/pod.go @@ -5,25 +5,26 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // AddPod add pod func (c *Calcium) AddPod(ctx context.Context, podname, desc string) (*types.Pod, error) { logger := log.WithField("Calcium", "AddPod").WithField("podname", podname).WithField("desc", desc) if podname == "" { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyPodName)) + logger.Errorf(ctx, types.ErrEmptyPodName, "") + return nil, types.ErrEmptyPodName } pod, err := c.store.AddPod(ctx, podname, desc) - return pod, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return pod, err } // RemovePod remove pod func (c *Calcium) RemovePod(ctx context.Context, podname string) error { logger := log.WithField("Calcium", "RemovePod").WithField("podname", podname) if podname == "" { - return logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyPodName)) + logger.Errorf(ctx, types.ErrEmptyPodName, "") + return types.ErrEmptyPodName } nodeFilter := &types.NodeFilter{ @@ -33,7 +34,9 @@ func (c *Calcium) RemovePod(ctx context.Context, podname string) error { return c.withNodesPodLocked(ctx, nodeFilter, func(ctx context.Context, nodes map[string]*types.Node) error { // TODO dissociate workload to node // TODO should remove node first - return logger.ErrWithTracing(ctx, errors.WithStack(c.store.RemovePod(ctx, podname))) + err := c.store.RemovePod(ctx, podname) + logger.Errorf(ctx, err, "") + return err }) } @@ -41,14 +44,17 @@ func (c *Calcium) RemovePod(ctx context.Context, podname string) error { func (c *Calcium) GetPod(ctx context.Context, podname string) (*types.Pod, error) { logger := log.WithField("Calcium", "GetPod").WithField("podname", podname) if podname == "" { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyPodName)) + logger.Errorf(ctx, types.ErrEmptyPodName, "") + return nil, types.ErrEmptyPodName } pod, err := c.store.GetPod(ctx, podname) - return pod, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return pod, err } // ListPods show pods func (c *Calcium) ListPods(ctx context.Context) ([]*types.Pod, error) { pods, err := c.store.GetAllPods(ctx) - return pods, log.WithField("Calcium", "ListPods").ErrWithTracing(ctx, errors.WithStack(err)) + log.WithField("Calcium", "ListPods").Errorf(ctx, err, "") + return pods, err } diff --git a/cluster/calcium/realloc.go b/cluster/calcium/realloc.go index 2187e93b4..376de801e 100644 --- a/cluster/calcium/realloc.go +++ b/cluster/calcium/realloc.go @@ -9,8 +9,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // ReallocResource updates workload resource dynamically @@ -25,7 +23,9 @@ func (c *Calcium) ReallocResource(ctx context.Context, opts *types.ReallocOption originWorkload := *workload return c.withNodePodLocked(ctx, workload.Nodename, func(ctx context.Context, node *types.Node) error { return c.withWorkloadLocked(ctx, opts.ID, func(ctx context.Context, workload *types.Workload) error { - return logger.ErrWithTracing(ctx, c.doReallocOnNode(ctx, node, workload, originWorkload, opts)) + err := c.doReallocOnNode(ctx, node, workload, originWorkload, opts) + logger.Errorf(ctx, err, "") + return err }) }) } @@ -61,15 +61,15 @@ func (c *Calcium) doReallocOnNode(ctx context.Context, node *types.Node, workloa return nil } if err := c.rmgr.RollbackRealloc(ctx, workload.Nodename, deltaResourceArgs); err != nil { - log.Errorf(ctx, "[doReallocOnNode] failed to rollback workload %v, resource args %v, engine args %v, err %v", workload.ID, litter.Sdump(resourceArgs), litter.Sdump(engineArgs), err) + log.Errorf(ctx, err, "[doReallocOnNode] failed to rollback workload %v, resource args %v, engine args %v, err %v", workload.ID, litter.Sdump(resourceArgs), litter.Sdump(engineArgs), err) // don't return here, so the node resource can still be fixed } - return errors.WithStack(c.store.UpdateWorkload(ctx, &originWorkload)) + return c.store.UpdateWorkload(ctx, &originWorkload) }, c.config.GlobalTimeout, ) if err != nil { - return errors.WithStack(err) + return err } _ = c.pool.Invoke(func() { c.doRemapResourceAndLog(ctx, log.WithField("Calcium", "doReallocOnNode"), node) }) return nil diff --git a/cluster/calcium/remap.go b/cluster/calcium/remap.go index dba2fe623..d31b06981 100644 --- a/cluster/calcium/remap.go +++ b/cluster/calcium/remap.go @@ -14,24 +14,24 @@ type remapMsg struct { err error } -func (c *Calcium) doRemapResourceAndLog(ctx context.Context, logger log.Fields, node *types.Node) { - log.Debugf(ctx, "[doRemapResourceAndLog] remap node %s", node.Name) +func (c *Calcium) doRemapResourceAndLog(ctx context.Context, logger *log.Fields, node *types.Node) { + logger.Infof(ctx, "[doRemapResourceAndLog] remap node %s", node.Name) ctx, cancel := context.WithTimeout(utils.InheritTracingInfo(ctx, context.TODO()), c.config.GlobalTimeout) defer cancel() err := c.withNodeOperationLocked(ctx, node.Name, func(ctx context.Context, node *types.Node) error { logger = logger.WithField("Calcium", "doRemapResourceAndLog").WithField("nodename", node.Name) - if ch, err := c.remapResource(ctx, node); logger.ErrWithTracing(ctx, err) == nil { + if ch, err := c.remapResource(ctx, node); err == nil { for msg := range ch { - log.Infof(ctx, "[doRemapResourceAndLog] id %v", msg.id) - logger.WithField("id", msg.id).ErrWithTracing(ctx, msg.err) // nolint:errcheck + logger.Infof(ctx, "[doRemapResourceAndLog] id %v", msg.id) + logger.WithField("id", msg.id).Errorf(ctx, msg.err, "") // nolint:errcheck } } return nil }) if err != nil { - log.Errorf(ctx, "[doRemapResourceAndLog] remap node %s failed, err: %v", node.Name, err) + logger.Errorf(ctx, err, "[doRemapResourceAndLog] remap node %s failed, err: %v", node.Name, err) } } diff --git a/cluster/calcium/remove.go b/cluster/calcium/remove.go index 26c8973a7..0c24443ef 100644 --- a/cluster/calcium/remove.go +++ b/cluster/calcium/remove.go @@ -9,8 +9,6 @@ import ( "github.com/projecteru2/core/resources" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // RemoveWorkload remove workloads @@ -20,7 +18,7 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, ids []string, force bool) nodeWorkloadGroup, err := c.groupWorkloadsByNode(ctx, ids) if err != nil { - logger.Errorf(ctx, "failed to group workloads by node: %+v", err) + logger.Errorf(ctx, err, "failed to group workloads by node: %+v", err) return nil, err } @@ -47,12 +45,12 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, ids []string, force bool) resourceArgs[plugin] = args } _, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []map[string]types.WorkloadResourceArgs{resourceArgs}, true, resources.Decr) - return errors.WithStack(err) + return err }, // then func(ctx context.Context) (err error) { if err = c.doRemoveWorkload(ctx, workload, force); err == nil { - log.Infof(ctx, "[RemoveWorkload] Workload %s removed", workload.ID) + logger.Infof(ctx, "[RemoveWorkload] Workload %s removed", workload.ID) } return err }, @@ -66,12 +64,12 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, ids []string, force bool) resourceArgs[plugin] = args } _, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []map[string]types.WorkloadResourceArgs{resourceArgs}, true, resources.Incr) - return errors.WithStack(err) + return err }, c.config.GlobalTimeout, ) }); err != nil { - logger.WithField("id", workloadID).Errorf(ctx, "failed to lock workload: %+v", err) + logger.WithField("id", workloadID).Errorf(ctx, err, "failed to lock workload: %+v", err) ret.Hook = append(ret.Hook, bytes.NewBufferString(err.Error())) ret.Success = false } @@ -80,7 +78,7 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, ids []string, force bool) _ = c.pool.Invoke(func() { c.doRemapResourceAndLog(ctx, logger, node) }) return nil }); err != nil { - logger.WithField("nodename", nodename).Errorf(ctx, "failed to lock node: %+v", err) + logger.WithField("nodename", nodename).Errorf(ctx, err, "failed to lock node: %+v", err) ch <- &types.RemoveWorkloadMessage{Success: false} } } @@ -101,7 +99,7 @@ func (c *Calcium) doRemoveWorkload(ctx context.Context, workload *types.Workload ctx, // if func(ctx context.Context) error { - return errors.WithStack(c.store.RemoveWorkload(ctx, workload)) + return c.store.RemoveWorkload(ctx, workload) }, // then func(ctx context.Context) error { @@ -112,7 +110,7 @@ func (c *Calcium) doRemoveWorkload(ctx context.Context, workload *types.Workload if failedByCond { return nil } - return errors.WithStack(c.store.AddWorkload(ctx, workload, nil)) + return c.store.AddWorkload(ctx, workload, nil) }, c.config.GlobalTimeout, ) @@ -135,7 +133,7 @@ func (c *Calcium) doRemoveWorkloadSync(ctx context.Context, ids []string) error func (c *Calcium) groupWorkloadsByNode(ctx context.Context, ids []string) (map[string][]string, error) { workloads, err := c.store.GetWorkloads(ctx, ids) if err != nil { - return nil, errors.WithStack(err) + return nil, err } nodeWorkloadGroup := map[string][]string{} for _, workload := range workloads { diff --git a/cluster/calcium/replace.go b/cluster/calcium/replace.go index 46a74affc..9b2eacd11 100644 --- a/cluster/calcium/replace.go +++ b/cluster/calcium/replace.go @@ -18,7 +18,8 @@ import ( func (c *Calcium) ReplaceWorkload(ctx context.Context, opts *types.ReplaceOptions) (chan *types.ReplaceWorkloadMessage, error) { logger := log.WithField("Calcium", "ReplaceWorkload").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } opts.Normalize() if len(opts.IDs) == 0 { @@ -30,7 +31,8 @@ func (c *Calcium) ReplaceWorkload(ctx context.Context, opts *types.ReplaceOption Appname: opts.Name, Entrypoint: opts.Entrypoint.Name, Nodename: nodename, }) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } for _, workload := range workloads { opts.IDs = append(opts.IDs, workload.ID) @@ -55,9 +57,9 @@ func (c *Calcium) ReplaceWorkload(ctx context.Context, opts *types.ReplaceOption if err = c.withWorkloadLocked(ctx, id, func(ctx context.Context, workload *types.Workload) error { if opts.Podname != "" && workload.Podname != opts.Podname { log.Warnf(ctx, "[ReplaceWorkload] Skip not in pod workload %s", workload.ID) - return errors.WithStack(types.NewDetailedErr(types.ErrIgnoreWorkload, + return types.NewDetailedErr(types.ErrIgnoreWorkload, fmt.Sprintf("workload %s not in pod %s", workload.ID, opts.Podname), - )) + ) } // 使用复制之后的配置 // 停老的，起新的 @@ -71,9 +73,9 @@ func (c *Calcium) ReplaceWorkload(ctx context.Context, opts *types.ReplaceOption if err != nil { return err } else if !info.Running { - return errors.WithStack(types.NewDetailedErr(types.ErrNotSupport, + return types.NewDetailedErr(types.ErrNotSupport, fmt.Sprintf("workload %s is not running, can not inherit", workload.ID), - )) + ) } replaceOpts.Networks = info.Networks log.Infof(ctx, "[ReplaceWorkload] Inherit old workload network configuration mode %v", replaceOpts.Networks) @@ -85,7 +87,7 @@ func (c *Calcium) ReplaceWorkload(ctx context.Context, opts *types.ReplaceOption log.Warnf(ctx, "[ReplaceWorkload] ignore workload: %v", err) return } - logger.Errorf(ctx, "[ReplaceWorkload] Replace and remove failed %+v, old workload restarted", err) + logger.Errorf(ctx, err, "[ReplaceWorkload] Replace and remove failed %+v, old workload restarted", err) } else { log.Infof(ctx, "[ReplaceWorkload] Replace and remove success %s", id) log.Infof(ctx, "[ReplaceWorkload] New workload %s", createMessage.WorkloadID) @@ -112,7 +114,7 @@ func (c *Calcium) doReplaceWorkload( } // label filter if !utils.LabelsFilter(workload.Labels, opts.FilterLabels) { - return nil, removeMessage, errors.WithStack(types.ErrNotFitLabels) + return nil, removeMessage, types.ErrNotFitLabels } // prepare node node, err := c.doGetAndPrepareNode(ctx, workload.Nodename, opts.Image) @@ -123,7 +125,7 @@ func (c *Calcium) doReplaceWorkload( for src, dst := range opts.Copy { content, uid, gid, mode, err := workload.Engine.VirtualizationCopyFrom(ctx, workload.ID, src) if err != nil { - return nil, removeMessage, errors.WithStack(err) + return nil, removeMessage, err } opts.DeployOptions.Files = append(opts.DeployOptions.Files, types.LinuxFile{ Filename: dst, @@ -162,7 +164,7 @@ func (c *Calcium) doReplaceWorkload( // then func(ctx context.Context) (err error) { if err = c.doRemoveWorkload(ctx, workload, true); err != nil { - log.Errorf(ctx, "[doReplaceWorkload] the new started but the old failed to stop") + log.Errorf(ctx, err, "[doReplaceWorkload] the new started but the old failed to stop") return err } removeMessage.Success = true @@ -176,7 +178,7 @@ func (c *Calcium) doReplaceWorkload( func(ctx context.Context, _ bool) (err error) { messages, err := c.doStartWorkload(ctx, workload, opts.IgnoreHook) if err != nil { - log.Errorf(ctx, "[replaceAndRemove] Old workload %s restart failed %v", workload.ID, err) + log.Errorf(ctx, err, "[replaceAndRemove] Old workload %s restart failed %v", workload.ID, err) removeMessage.Hook = append(removeMessage.Hook, bytes.NewBufferString(err.Error())) } else { removeMessage.Hook = append(removeMessage.Hook, messages...) diff --git a/cluster/calcium/resource.go b/cluster/calcium/resource.go index bba9c8717..1d8faa1dd 100644 --- a/cluster/calcium/resource.go +++ b/cluster/calcium/resource.go @@ -8,8 +8,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/strategy" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // PodResource show pod resource usage @@ -17,7 +15,8 @@ func (c *Calcium) PodResource(ctx context.Context, podname string) (chan *types. logger := log.WithField("Calcium", "PodResource").WithField("podname", podname) nodes, err := c.store.GetNodesByPod(ctx, &types.NodeFilter{Podname: podname}) if err != nil { - return nil, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nil, err } ch := make(chan *types.NodeResource) @@ -32,8 +31,9 @@ func (c *Calcium) PodResource(ctx context.Context, podname string) (chan *types. defer wg.Done() nr, err := c.doGetNodeResource(ctx, node.Name, false, false) if err != nil { + logger.Errorf(ctx, err, "") nr = &types.NodeResource{ - Name: node.Name, Diffs: []string{logger.ErrWithTracing(ctx, err).Error()}, + Name: node.Name, Diffs: []string{err.Error()}, } } ch <- nr @@ -48,26 +48,28 @@ func (c *Calcium) PodResource(ctx context.Context, podname string) (chan *types. func (c *Calcium) NodeResource(ctx context.Context, nodename string, fix bool) (*types.NodeResource, error) { logger := log.WithField("Calcium", "NodeResource").WithField("nodename", nodename).WithField("fix", fix) nr, err := c.doGetNodeResource(ctx, nodename, true, fix) - return nr, logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return nr, err } func (c *Calcium) doGetNodeResource(ctx context.Context, nodename string, inspect, fix bool) (*types.NodeResource, error) { logger := log.WithField("Calcium", "doGetNodeResource").WithField("nodename", nodename).WithField("inspect", inspect).WithField("fix", fix) if nodename == "" { - return nil, logger.ErrWithTracing(ctx, types.ErrEmptyNodeName) + logger.Errorf(ctx, types.ErrEmptyNodeName, "") + return nil, types.ErrEmptyNodeName } var nr *types.NodeResource return nr, c.withNodePodLocked(ctx, nodename, func(ctx context.Context, node *types.Node) error { workloads, err := c.store.ListNodeWorkloads(ctx, node.Name, nil) if err != nil { - log.Errorf(ctx, "[doGetNodeResource] failed to list node workloads, node %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodeResource] failed to list node workloads, node %v, err: %v", node.Name, err) return err } // get node resources resourceCapacity, resourceUsage, resourceDiffs, err := c.rmgr.GetNodeResourceInfo(ctx, node.Name, workloads, fix) if err != nil { - log.Errorf(ctx, "[doGetNodeResource] failed to get node resources, node %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodeResource] failed to get node resources, node %v, err: %v", node.Name, err) return err } nr = &types.NodeResource{ @@ -95,15 +97,15 @@ func (c *Calcium) doGetDeployStrategy(ctx context.Context, nodenames []string, o // get nodes with capacity > 0 nodeResourceInfoMap, total, err := c.rmgr.GetNodesDeployCapacity(ctx, nodenames, opts.ResourceOpts) if err != nil { - log.Errorf(ctx, "[doGetDeployMap] failed to select available nodes, nodes %v, err %v", nodenames, err) - return nil, errors.WithStack(err) + log.Errorf(ctx, err, "[doGetDeployMap] failed to select available nodes, nodes %v, err %v", nodenames, err) + return nil, err } // get deployed & processing workload count on each node deployStatusMap, err := c.store.GetDeployStatus(ctx, opts.Name, opts.Entrypoint.Name) if err != nil { - log.Errorf(ctx, "failed to get deploy status for %v_%v, err %v", opts.Name, opts.Entrypoint.Name, err) - return nil, errors.WithStack(err) + log.Errorf(ctx, err, "failed to get deploy status for %v_%v, err %v", opts.Name, opts.Entrypoint.Name, err) + return nil, err } // generate strategy info @@ -121,7 +123,7 @@ func (c *Calcium) doGetDeployStrategy(ctx context.Context, nodenames []string, o // generate deploy plan deployMap, err := strategy.Deploy(ctx, opts.DeployStrategy, opts.Count, opts.NodesLimit, strategyInfos, total) if err != nil { - return nil, errors.WithStack(err) + return nil, err } return deployMap, nil diff --git a/cluster/calcium/send.go b/cluster/calcium/send.go index 7bfff0f57..4658a05d9 100644 --- a/cluster/calcium/send.go +++ b/cluster/calcium/send.go @@ -7,15 +7,14 @@ import ( "github.com/projecteru2/core/engine" "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // Send files to workload func (c *Calcium) Send(ctx context.Context, opts *types.SendOptions) (chan *types.SendMessage, error) { logger := log.WithField("Calcium", "Send").WithField("opts", opts) if err := opts.Validate(); err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } ch := make(chan *types.SendMessage) _ = c.pool.Invoke(func() { @@ -24,18 +23,20 @@ func (c *Calcium) Send(ctx context.Context, opts *types.SendOptions) (chan *type wg.Add(len(opts.IDs)) for _, id := range opts.IDs { - log.Infof(ctx, "[Send] Send files to %s", id) + logger.Infof(ctx, "[Send] Send files to %s", id) _ = c.pool.Invoke(func(id string) func() { return func() { defer wg.Done() if err := c.withWorkloadLocked(ctx, id, func(ctx context.Context, workload *types.Workload) error { for _, file := range opts.Files { err := c.doSendFileToWorkload(ctx, workload.Engine, workload.ID, file) - ch <- &types.SendMessage{ID: id, Path: file.Filename, Error: logger.ErrWithTracing(ctx, err)} + logger.Errorf(ctx, err, "") + ch <- &types.SendMessage{ID: id, Path: file.Filename, Error: err} } return nil }); err != nil { - ch <- &types.SendMessage{ID: id, Error: logger.ErrWithTracing(ctx, err)} + logger.Errorf(ctx, err, "") + ch <- &types.SendMessage{ID: id, Error: err} } } }(id)) @@ -47,5 +48,5 @@ func (c *Calcium) Send(ctx context.Context, opts *types.SendOptions) (chan *type func (c *Calcium) doSendFileToWorkload(ctx context.Context, engine engine.API, ID string, file types.LinuxFile) error { log.Infof(ctx, "[doSendFileToWorkload] Send file to %s:%s", ID, file.Filename) - return errors.WithStack(engine.VirtualizationCopyTo(ctx, ID, file.Filename, file.Clone().Content, file.UID, file.GID, file.Mode)) + return engine.VirtualizationCopyTo(ctx, ID, file.Filename, file.Clone().Content, file.UID, file.GID, file.Mode) } diff --git a/cluster/calcium/service.go b/cluster/calcium/service.go index 1cb580632..9ff643e67 100644 --- a/cluster/calcium/service.go +++ b/cluster/calcium/service.go @@ -26,7 +26,7 @@ func (c *Calcium) WatchServiceStatus(ctx context.Context) (<-chan types.ServiceS func (c *Calcium) RegisterService(ctx context.Context) (unregister func(), err error) { serviceAddress, err := utils.GetOutboundAddress(c.config.Bind, c.config.ProbeTarget) if err != nil { - log.Errorf(ctx, "[RegisterService] failed to get outbound address: %v", err) + log.Errorf(ctx, err, "[RegisterService] failed to get outbound address: %v", err) return } @@ -43,8 +43,8 @@ func (c *Calcium) RegisterService(ctx context.Context) (unregister func(), err e time.Sleep(time.Second) continue } - log.Errorf(ctx, "[RegisterService] failed to first register service: %+v", err) - return nil, errors.WithStack(err) + log.Errorf(ctx, err, "[RegisterService] failed to first register service: %+v", err) + return nil, err } wg := &sync.WaitGroup{} @@ -61,7 +61,7 @@ func (c *Calcium) RegisterService(ctx context.Context) (unregister func(), err e case <-expiry: // The original one had been expired, we're going to register again. if ne, us, err := c.registerService(ctx, serviceAddress); err != nil { - log.Errorf(ctx, "[RegisterService] failed to re-register service: %v", err) + log.Errorf(ctx, err, "[RegisterService] failed to re-register service: %v", err) time.Sleep(c.config.GRPCConfig.ServiceHeartbeatInterval) } else { expiry = ne diff --git a/cluster/calcium/status.go b/cluster/calcium/status.go index 1a41a77fb..328514625 100644 --- a/cluster/calcium/status.go +++ b/cluster/calcium/status.go @@ -6,8 +6,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // GetNodeStatus set status of a node @@ -22,9 +20,12 @@ func (c *Calcium) SetNodeStatus(ctx context.Context, nodename string, ttl int64) logger := log.WithField("Calcium", "SetNodeStatus").WithField("nodename", nodename).WithField("ttl", ttl) node, err := c.store.GetNode(ctx, nodename) if err != nil { - return logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return err } - return logger.ErrWithTracing(ctx, errors.WithStack(c.store.SetNodeStatus(ctx, node, ttl))) + err = c.store.SetNodeStatus(ctx, node, ttl) + logger.Errorf(ctx, err, "") + return err } // NodeStatusStream returns a stream of node status for subscribing @@ -38,7 +39,8 @@ func (c *Calcium) GetWorkloadsStatus(ctx context.Context, ids []string) ([]*type for _, id := range ids { s, err := c.store.GetWorkloadStatus(ctx, id) if err != nil { - return r, log.WithField("Calcium", "GetWorkloadStatus").WithField("ids", ids).ErrWithTracing(ctx, errors.WithStack(err)) + log.WithField("Calcium", "GetWorkloadStatus").WithField("ids", ids).Errorf(ctx, err, "") + return r, err } r = append(r, s) } @@ -54,12 +56,14 @@ func (c *Calcium) SetWorkloadsStatus(ctx context.Context, statusMetas []*types.S if statusMeta.Appname == "" || statusMeta.Nodename == "" || statusMeta.Entrypoint == "" { workload, err := c.store.GetWorkload(ctx, statusMeta.ID) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } appname, entrypoint, _, err := utils.ParseWorkloadName(workload.Name) if err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } statusMeta.Appname = appname @@ -73,7 +77,8 @@ func (c *Calcium) SetWorkloadsStatus(ctx context.Context, statusMetas []*types.S } if err := c.store.SetWorkloadStatus(ctx, statusMeta, ttl); err != nil { - return nil, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return nil, err } r = append(r, statusMeta) } diff --git a/cluster/calcium/stream.go b/cluster/calcium/stream.go index fcbf4927b..96be1566b 100644 --- a/cluster/calcium/stream.go +++ b/cluster/calcium/stream.go @@ -8,7 +8,6 @@ import ( "io" "sync" - "github.com/pkg/errors" "github.com/projecteru2/core/engine" enginetypes "github.com/projecteru2/core/engine/types" "github.com/projecteru2/core/log" @@ -37,7 +36,7 @@ func (c *Calcium) execuateInside(ctx context.Context, client engine.API, ID, cmd b := []byte{} execID, stdout, stderr, _, err := client.Execute(ctx, ID, execConfig) if err != nil { - return nil, errors.WithStack(err) + return nil, err } for m := range c.processStdStream(ctx, stdout, stderr, bufio.ScanLines, byte('\n')) { @@ -46,10 +45,10 @@ func (c *Calcium) execuateInside(ctx context.Context, client engine.API, ID, cmd exitCode, err := client.ExecExitCode(ctx, ID, execID) if err != nil { - return b, errors.WithStack(err) + return b, err } if exitCode != 0 { - return b, errors.WithStack(fmt.Errorf("%s", b)) + return b, fmt.Errorf("%s", b) } return b, nil } @@ -64,11 +63,11 @@ func (c *Calcium) processVirtualizationInStream( string(winchCommand): func(body []byte) { w := &window{} if err := json.Unmarshal(body, w); err != nil { - log.Errorf(ctx, "[processVirtualizationInStream] invalid winch command: %q", body) + log.Errorf(ctx, err, "[processVirtualizationInStream] invalid winch command: %q", body) return } if err := resizeFunc(w.Height, w.Width); err != nil { - log.Errorf(ctx, "[processVirtualizationInStream] resize window error: %v", err) + log.Errorf(ctx, err, "[processVirtualizationInStream] resize window error: %v", err) return } }, @@ -100,7 +99,7 @@ func (c *Calcium) rawProcessVirtualizationInStream( continue } if _, err := inStream.Write(cmd); err != nil { - log.Errorf(ctx, "[rawProcessVirtualizationInStream] failed to write virtual input stream: %v", err) + log.Errorf(ctx, err, "[rawProcessVirtualizationInStream] failed to write virtual input stream: %v", err) continue } } @@ -151,7 +150,7 @@ func (c *Calcium) processBuildImageStream(ctx context.Context, reader io.ReadClo if err != nil { if err != io.EOF { malformed, _ := io.ReadAll(decoder.Buffered()) // TODO err check - log.Errorf(ctx, "[processBuildImageStream] Decode image message failed %v, buffered: %s", err, string(malformed)) + log.Errorf(ctx, err, "[processBuildImageStream] Decode image message failed %v, buffered: %s", err, string(malformed)) message.Error = err.Error() ch <- message } diff --git a/cluster/calcium/wal.go b/cluster/calcium/wal.go index bb9cb0d80..5cef73ae9 100644 --- a/cluster/calcium/wal.go +++ b/cluster/calcium/wal.go @@ -88,21 +88,21 @@ func (h *CreateLambdaHandler) Handle(ctx context.Context, raw interface{}) error go func() { workload, err := h.calcium.GetWorkload(ctx, workloadID) if err != nil { - logger.Errorf(ctx, "Get workload failed: %v", err) + logger.Errorf(ctx, err, "Get workload failed: %v", err) return } r, err := workload.Engine.VirtualizationWait(ctx, workloadID, "") if err != nil { - logger.Errorf(ctx, "Wait failed: %+v", err) + logger.Errorf(ctx, err, "Wait failed: %+v", err) return } if r.Code != 0 { - logger.Errorf(ctx, "Run failed: %s", r.Message) + logger.Errorf(ctx, nil, "Run failed: %s", r.Message) } if err := h.calcium.RemoveWorkloadSync(ctx, []string{workloadID}); err != nil { - logger.Errorf(ctx, "Remove failed: %+v", err) + logger.Errorf(ctx, err, "Remove failed: %+v", err) } logger.Infof(ctx, "waited and removed") }() @@ -172,10 +172,12 @@ func (h *CreateWorkloadHandler) Handle(ctx context.Context, raw interface{}) (er // workload meta doesn't exist node, err := h.calcium.GetNode(ctx, wrk.Nodename) if err != nil { - return logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return err } if err = node.Engine.VirtualizationRemove(ctx, wrk.ID, true, true); err != nil && !errors.Is(err, types.ErrWorkloadNotExists) { - return logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return err } logger.Infof(ctx, "workload removed") @@ -246,7 +248,7 @@ func (h *WorkloadResourceAllocatedHandler) Handle(ctx context.Context, raw inter _ = h.pool.Invoke(func() { defer wg.Done() if _, err = h.calcium.NodeResource(ctx, node.Name, true); err != nil { - logger.Errorf(ctx, "failed to fix node resource: %s, %+v", node.Name, err) + logger.Errorf(ctx, err, "failed to fix node resource: %s, %+v", node.Name, err) return } logger.Infof(ctx, "fixed node resource: %s", node.Name) @@ -310,7 +312,8 @@ func (h *ProcessingCreatedHandler) Handle(ctx context.Context, raw interface{}) defer cancel() if err = h.store.DeleteProcessing(ctx, processing); err != nil { - return logger.ErrWithTracing(ctx, err) + logger.Errorf(ctx, err, "") + return err } logger.Infof(ctx, "obsolete processing deleted") return diff --git a/cluster/calcium/workload.go b/cluster/calcium/workload.go index 36b7ad1dc..12554f2d2 100644 --- a/cluster/calcium/workload.go +++ b/cluster/calcium/workload.go @@ -8,40 +8,43 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // GetWorkload get a workload func (c *Calcium) GetWorkload(ctx context.Context, id string) (workload *types.Workload, err error) { logger := log.WithField("Calcium", "GetWorkload").WithField("id", id) if id == "" { - return workload, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyWorkloadID)) + logger.Errorf(ctx, types.ErrEmptyWorkloadID, "") + return workload, types.ErrEmptyWorkloadID } workload, err = c.store.GetWorkload(ctx, id) - return workload, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return workload, err } // GetWorkloads get workloads func (c *Calcium) GetWorkloads(ctx context.Context, ids []string) (workloads []*types.Workload, err error) { workloads, err = c.store.GetWorkloads(ctx, ids) - return workloads, log.WithField("Calcium", "GetWorkloads").WithField("ids", ids).ErrWithTracing(ctx, errors.WithStack(err)) + log.WithField("Calcium", "GetWorkloads").WithField("ids", ids).Errorf(ctx, err, "") + return workloads, err } // ListWorkloads list workloads func (c *Calcium) ListWorkloads(ctx context.Context, opts *types.ListWorkloadsOptions) (workloads []*types.Workload, err error) { if workloads, err = c.store.ListWorkloads(ctx, opts.Appname, opts.Entrypoint, opts.Nodename, opts.Limit, opts.Labels); err != nil { - log.WithField("opts", opts).Errorf(ctx, "Calcium.ListWorkloads] store list failed: %+v", err) + log.WithField("opts", opts).Errorf(ctx, err, "Calcium.ListWorkloads] store list failed: %+v", err) } - return workloads, errors.WithStack(err) + return workloads, err } // ListNodeWorkloads list workloads belong to one node func (c *Calcium) ListNodeWorkloads(ctx context.Context, nodename string, labels map[string]string) (workloads []*types.Workload, err error) { logger := log.WithField("Calcium", "ListNodeWorkloads").WithField("nodename", nodename).WithField("labels", labels) if nodename == "" { - return workloads, logger.ErrWithTracing(ctx, errors.WithStack(types.ErrEmptyNodeName)) + logger.Errorf(ctx, types.ErrEmptyNodeName, "") + return workloads, types.ErrEmptyNodeName } workloads, err = c.store.ListNodeWorkloads(ctx, nodename, labels) - return workloads, logger.ErrWithTracing(ctx, errors.WithStack(err)) + logger.Errorf(ctx, err, "") + return workloads, err } diff --git a/core.go b/core.go index 5da6501aa..8d978452a 100644 --- a/core.go +++ b/core.go @@ -38,11 +38,11 @@ var ( func serve(c *cli.Context) error { config, err := utils.LoadConfig(configPath) if err != nil { - log.Fatalf("[main] %v", err) + return err } if err := log.SetupLog(config.LogLevel); err != nil { - log.Fatalf("[main] %v", err) + return err } defer utils.SentryDefer() @@ -60,7 +60,7 @@ func serve(c *cli.Context) error { } cluster, err := calcium.New(c.Context, config, t) if err != nil { - log.Errorf(c.Context, "[main] %v", err) //nolint + log.Errorf(c.Context, err, "") return err } defer cluster.Finalizer() @@ -70,7 +70,7 @@ func serve(c *cli.Context) error { vibranium := rpc.New(cluster, config, stop) s, err := net.Listen("tcp", config.Bind) if err != nil { - log.Errorf(c.Context, "[main] %v", err) //nolint + log.Errorf(c.Context, err, "") return err } @@ -80,7 +80,7 @@ func serve(c *cli.Context) error { } if config.Auth.Username != "" { - log.Info("[main] Cluster auth enable.") + log.Info(c.Context, "[main] Cluster auth enable.") auth := auth.NewAuth(config.Auth) opts = append(opts, grpc.StreamInterceptor(auth.StreamInterceptor)) opts = append(opts, grpc.UnaryInterceptor(auth.UnaryInterceptor)) @@ -91,7 +91,7 @@ func serve(c *cli.Context) error { pb.RegisterCoreRPCServer(grpcServer, vibranium) utils.SentryGo(func() { if err := grpcServer.Serve(s); err != nil { - log.Errorf(c.Context, "[main] start grpc failed %v", err) //nolint + log.Errorf(c.Context, err, "%v", "start grpc failed") } }) @@ -103,17 +103,17 @@ func serve(c *cli.Context) error { ReadHeaderTimeout: 3 * time.Second, } if err := server.ListenAndServe(); err != nil { - log.Errorf(c.Context, "[main] start http failed %v", err) //nolint + log.Errorf(c.Context, err, "%v", "start http failed") } }) } unregisterService, err := cluster.RegisterService(c.Context) if err != nil { - log.Errorf(c.Context, "[main] failed to register service: %v", err) //nolint + log.Errorf(c.Context, err, "%v", "failed to register service") return err } - log.Info("[main] Cluster started successfully.") + log.Info(c.Context, "[main] Cluster started successfully.") // wait for unix signals and try to GracefulStop ctx, cancel := signal.NotifyContext(c.Context, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT) @@ -124,15 +124,15 @@ func serve(c *cli.Context) error { <-ctx.Done() - log.Info("[main] Interrupt by signal") + log.Info(c.Context, "[main] Interrupt by signal") close(stop) unregisterService() grpcServer.GracefulStop() - log.Info("[main] gRPC server gracefully stopped.") + log.Info(c.Context, "[main] gRPC server gracefully stopped.") - log.Info("[main] Check if cluster still have running tasks.") + log.Info(c.Context, "[main] Check if cluster still have running tasks.") vibranium.Wait() - log.Info("[main] cluster gracefully stopped.") + log.Info(c.Context, "[main] cluster gracefully stopped.") return nil } diff --git a/discovery/helium/helium.go b/discovery/helium/helium.go index a662f417b..a134933c9 100644 --- a/discovery/helium/helium.go +++ b/discovery/helium/helium.go @@ -69,13 +69,13 @@ func (h *Helium) Unsubscribe(id uuid.UUID) { func (h *Helium) start(ctx context.Context) { ch, err := h.store.ServiceStatusStream(ctx) if err != nil { - log.Errorf(nil, "[WatchServiceStatus] failed to start watch: %v", err) //nolint + log.Errorf(ctx, err, "[WatchServiceStatus] failed to start watch: %v", err) //nolint return } go func() { - log.Info("[WatchServiceStatus] service discovery start") - defer log.Error("[WatchServiceStatus] service discovery exited") + log.Info(ctx, "[WatchServiceStatus] service discovery start") + defer log.Error(ctx, nil, "[WatchServiceStatus] service discovery exited") //nolint var latestStatus types.ServiceStatus ticker := time.NewTicker(h.interval) defer ticker.Stop() @@ -83,7 +83,7 @@ func (h *Helium) start(ctx context.Context) { select { case addresses, ok := <-ch: if !ok { - log.Error("[WatchServiceStatus] watch channel closed") + log.Error(ctx, nil, "[WatchServiceStatus] watch channel closed") //nolint return } @@ -111,7 +111,7 @@ func (h *Helium) dispatch(status types.ServiceStatus) { f := func(key uint32, val entry) { defer func() { if err := recover(); err != nil { - log.Errorf(context.TODO(), "[dispatch] dispatch %v failed, err: %v", key, err) + log.Errorf(context.TODO(), nil, "[dispatch] dispatch %v failed, err: %v", key, err) } }() select { diff --git a/engine/docker/container.go b/engine/docker/container.go index 48e1d3835..e60f625dd 100644 --- a/engine/docker/container.go +++ b/engine/docker/container.go @@ -83,7 +83,7 @@ func (e *Engine) VirtualizationCreate(ctx context.Context, opts *enginetypes.Vir // parse engine args to resource options opts.VirtualizationResource, err = engine.MakeVirtualizationResource(opts.EngineArgs) if err != nil { - log.Errorf(ctx, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) + log.Errorf(ctx, err, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) return r, coretypes.ErrInvalidEngineArgs } @@ -403,7 +403,7 @@ func (e *Engine) VirtualizationUpdateResource(ctx context.Context, ID string, op // parse engine args to resource options resourceOpts, err := engine.MakeVirtualizationResource(opts.EngineArgs) if err != nil { - log.Errorf(ctx, "[VirtualizationUpdateResource] failed to parse engine args %+v, workload id %v, err %v", opts.EngineArgs, ID, err) + log.Errorf(ctx, err, "[VirtualizationUpdateResource] failed to parse engine args %+v, workload id %v, err %v", opts.EngineArgs, ID, err) return coretypes.ErrInvalidEngineArgs } @@ -411,7 +411,7 @@ func (e *Engine) VirtualizationUpdateResource(ctx context.Context, ID string, op return coretypes.ErrBadMemory } if len(opts.Volumes) > 0 || resourceOpts.VolumeChanged { - log.Errorf(ctx, "[VirtualizationUpdateResource] docker engine not support rebinding volume resource: %v", resourceOpts.Volumes) + log.Errorf(ctx, err, "[VirtualizationUpdateResource] docker engine not support rebinding volume resource: %v", resourceOpts.Volumes) return coretypes.ErrNotSupport } diff --git a/engine/docker/docker.go b/engine/docker/docker.go index 91236494b..66d38b04c 100644 --- a/engine/docker/docker.go +++ b/engine/docker/docker.go @@ -38,7 +38,7 @@ func MakeClient(ctx context.Context, config coretypes.Config, nodename, endpoint } else { client, err = utils.GetHTTPSClient(ctx, config.CertPath, nodename, ca, cert, key) if err != nil { - log.Errorf(ctx, "[MakeClient] GetHTTPSClient for %s %s error: %v", nodename, endpoint, err) + log.Errorf(ctx, err, "[MakeClient] GetHTTPSClient for %s %s error: %v", nodename, endpoint, err) return nil, err } } diff --git a/engine/docker/exec.go b/engine/docker/exec.go index 0f0ad2e82..984324c8a 100644 --- a/engine/docker/exec.go +++ b/engine/docker/exec.go @@ -71,7 +71,7 @@ func (e *Engine) demultiplexStdStream(ctx context.Context, stdStream io.Reader) defer stdoutW.Close() defer stderrW.Close() if _, err := stdcopy.StdCopy(stdoutW, stderrW, stdStream); err != nil { - log.Errorf(ctx, "[docker.demultiplex] StdCopy failed: %v", err) + log.Errorf(ctx, err, "[docker.demultiplex] StdCopy failed: %v", err) } }() return stdout, stderr diff --git a/engine/docker/helper.go b/engine/docker/helper.go index f1b0603bb..e010f4f7e 100644 --- a/engine/docker/helper.go +++ b/engine/docker/helper.go @@ -93,7 +93,7 @@ func makeMountPaths(opts *enginetypes.VirtualizationCreateOptions) ([]string, ma binds = append(binds, fmt.Sprintf("%s:%s:%s", parts[0], parts[1], parts[2])) volumes[parts[1]] = struct{}{} if len(parts) == 4 { - log.Warn("[makeMountPaths] docker engine not support volume with size limit") + log.Warn(nil, "[makeMountPaths] docker engine not support volume with size limit") //nolint } } } @@ -293,7 +293,7 @@ func CreateTarStream(path string) (io.ReadCloser, error) { func GetIP(ctx context.Context, daemonHost string) string { u, err := url.Parse(daemonHost) if err != nil { - log.Errorf(ctx, "[GetIP] GetIP %s failed %v", daemonHost, err) + log.Errorf(ctx, err, "[GetIP] GetIP %s failed %v", daemonHost, err) return "" } return u.Hostname() diff --git a/engine/factory/factory.go b/engine/factory/factory.go index d94076920..e5b07bbc3 100644 --- a/engine/factory/factory.go +++ b/engine/factory/factory.go @@ -79,8 +79,8 @@ func (e *EngineCache) Delete(key string) { // CheckAlive checks if the engine in cache is available func (e *EngineCache) CheckAlive(ctx context.Context) { - log.Info("[EngineCache] starts") - defer log.Info("[EngineCache] ends") + log.Info(ctx, "[EngineCache] starts") + defer log.Info(ctx, "[EngineCache] ends") defer e.pool.Release() for { select { @@ -113,14 +113,14 @@ func (e *EngineCache) CheckAlive(ctx context.Context) { } if _, ok := client.(*fake.Engine); ok { if newClient, err := newEngine(ctx, e.config, utils.RandomString(8), params.endpoint, params.ca, params.key, params.cert); err != nil { - log.Errorf(ctx, "[EngineCache] engine %v is still unavailable, err: %v", cacheKey, err) + log.Errorf(ctx, err, "[EngineCache] engine %v is still unavailable, err: %v", cacheKey, err) } else { e.cache.Set(cacheKey, newClient) } return } if err := validateEngine(ctx, client, e.config.ConnectionTimeout); err != nil { - log.Errorf(ctx, "[EngineCache] engine %v is unavailable, will be replaced with a fake engine, err: %v", cacheKey, err) + log.Errorf(ctx, err, "[EngineCache] engine %v is unavailable, will be replaced with a fake engine, err: %v", cacheKey, err) e.cache.Set(cacheKey, &fake.Engine{DefaultErr: err}) } }) @@ -138,7 +138,7 @@ func GetEngineFromCache(endpoint, ca, cert, key string) engine.API { // RemoveEngineFromCache . func RemoveEngineFromCache(endpoint, ca, cert, key string) { cacheKey := getEngineCacheKey(endpoint, ca, cert, key) - log.Infof(nil, "[RemoveEngineFromCache] remove engine %v from cache", cacheKey) // nolint + log.Infof(nil, "[RemoveEngineFromCache] remove engine %v from cache", cacheKey) //nolint engineCache.Delete(cacheKey) } @@ -216,7 +216,7 @@ func newEngine(ctx context.Context, config types.Config, nodename, endpoint, ca, return nil, err } if err = validateEngine(ctx, client, config.ConnectionTimeout); err != nil { - log.Errorf(ctx, "[GetEngine] engine of %v is unavailable, err: %v", endpoint, err) + log.Errorf(ctx, err, "[GetEngine] engine of %v is unavailable, err: %v", endpoint, err) return nil, err } return client, nil diff --git a/engine/virt/virt.go b/engine/virt/virt.go index 9a28fd064..9b5903951 100644 --- a/engine/virt/virt.go +++ b/engine/virt/virt.go @@ -183,7 +183,7 @@ func (v *Virt) VirtualizationCreate(ctx context.Context, opts *enginetypes.Virtu // parse engine args to resource options opts.VirtualizationResource, err = engine.MakeVirtualizationResource(opts.EngineArgs) if err != nil { - log.Errorf(ctx, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) + log.Errorf(ctx, err, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) return nil, coretypes.ErrInvalidEngineArgs } @@ -324,8 +324,8 @@ func (v *Virt) VirtualizationUpdateResource(ctx context.Context, ID string, reso // parse engine args to resource options opts, err := engine.MakeVirtualizationResource(resourceOpts.EngineArgs) if err != nil { - log.Errorf(ctx, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) - return coretypes.ErrInvalidEngineArgs + log.Errorf(ctx, err, "[VirtualizationCreate] failed to parse engine args %+v, err %v", opts.EngineArgs, err) + return err } vols, err := v.parseVolumes(opts.Volumes) diff --git a/go.mod b/go.mod index b44e62ec3..47c45bb0b 100644 --- a/go.mod +++ b/go.mod @@ -26,6 +26,7 @@ require ( github.com/pkg/errors v0.9.1 github.com/projecteru2/libyavirt v0.0.0-20220621042712-95cdc6363b1c github.com/prometheus/client_golang v1.11.0 + github.com/rs/zerolog v1.28.0 github.com/sanity-io/litter v1.5.1 github.com/sirupsen/logrus v1.8.1 github.com/stretchr/testify v1.7.1 @@ -57,7 +58,7 @@ require ( github.com/containerd/containerd v1.5.13 // indirect github.com/containerd/continuity v0.1.0 // indirect github.com/coreos/go-semver v0.3.0 // indirect - github.com/coreos/go-systemd/v22 v22.3.2 // indirect + github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534 // indirect github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect @@ -84,6 +85,8 @@ require ( github.com/json-iterator/go v1.1.11 // indirect github.com/juju/errors v0.0.0-20220331221717-b38fca44723b // indirect github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd // indirect + github.com/mattn/go-colorable v0.1.12 // indirect + github.com/mattn/go-isatty v0.0.14 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/moby/sys/mount v0.2.0 // indirect diff --git a/go.sum b/go.sum index 78a5f5cc3..722e28bf8 100644 --- a/go.sum +++ b/go.sum @@ -112,8 +112,9 @@ github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmf github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd/v22 v22.1.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk= -github.com/coreos/go-systemd/v22 v22.3.2 h1:D9/bQk5vlXQFZ6Kwuu6zaiXJ9oTPe68++AzAJc1DzSI= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534 h1:rtAn27wIbmOGUs7RIbVgPEjb31ehTVniDwPGXyMxm5U= +github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cornelk/hashmap v1.0.8 h1:nv0AWgw02n+iDcawr5It4CjQIAcdMMKRrs10HOJYlrc= github.com/cornelk/hashmap v1.0.8/go.mod h1:RfZb7JO3RviW/rT6emczVuC/oxpdz4UsSB2LJSclR1k= @@ -370,10 +371,14 @@ github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czP github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= +github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= @@ -493,6 +498,9 @@ github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40T github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.28.0 h1:MirSo27VyNi7RJYP3078AA1+Cyzd2GB66qy3aUHvsWY= +github.com/rs/zerolog v1.28.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= @@ -788,7 +796,9 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0= diff --git a/lock/etcdlock/mutex.go b/lock/etcdlock/mutex.go index b3dbf7f6b..ba55de6cf 100644 --- a/lock/etcdlock/mutex.go +++ b/lock/etcdlock/mutex.go @@ -8,7 +8,6 @@ import ( "github.com/projecteru2/core/types" - "github.com/pkg/errors" clientv3 "go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3/concurrency" "golang.org/x/net/context" @@ -41,13 +40,13 @@ func (c *lockContext) Err() error { if c.err != nil { return c.err } - return errors.WithStack(c.Context.Err()) + return c.Context.Err() } // New new a lock func New(cli *clientv3.Client, key string, ttl time.Duration) (*Mutex, error) { if key == "" { - return nil, errors.WithStack(types.ErrKeyIsEmpty) + return nil, types.ErrKeyIsEmpty } if !strings.HasPrefix(key, "/") { diff --git a/lock/redis/lock.go b/lock/redis/lock.go index 333d92053..7ca79ea76 100644 --- a/lock/redis/lock.go +++ b/lock/redis/lock.go @@ -5,10 +5,8 @@ import ( "strings" "time" - "github.com/projecteru2/core/types" - "github.com/muroq/redislock" - "github.com/pkg/errors" + "github.com/projecteru2/core/types" ) var opts = &redislock.Options{ @@ -30,7 +28,7 @@ type RedisLock struct { // lockTTL: ttl of lock, after this time, lock will be released automatically func New(cli redislock.RedisClient, key string, waitTimeout, lockTTL time.Duration) (*RedisLock, error) { if key == "" { - return nil, errors.WithStack(types.ErrKeyIsEmpty) + return nil, types.ErrKeyIsEmpty } if !strings.HasPrefix(key, "/") { diff --git a/log/log.go b/log/log.go index 83b0941ab..03d1880d3 100644 --- a/log/log.go +++ b/log/log.go @@ -5,126 +5,123 @@ import ( "fmt" "os" "strings" + "time" + "github.com/pkg/errors" "github.com/projecteru2/core/types" "github.com/getsentry/sentry-go" - log "github.com/sirupsen/logrus" + "github.com/rs/zerolog" + "github.com/rs/zerolog/pkgerrors" "google.golang.org/grpc/peer" ) +var globalLogger zerolog.Logger + // SetupLog init logger func SetupLog(l string) error { - level, err := log.ParseLevel(l) + level, err := zerolog.ParseLevel(l) if err != nil { return err } - log.SetLevel(level) + zerolog.TimestampFieldName = "ts" + zerolog.LevelFieldName = "lv" + zerolog.MessageFieldName = "msg" + zerolog.TimeFieldFormat = time.StampNano + zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack + // TODO can use file + rslog := zerolog.New(os.Stdout) + rslog.Level(level) + globalLogger = rslog - formatter := &log.TextFormatter{ - ForceColors: true, - TimestampFormat: "2006-01-02 15:04:05", - FullTimestamp: true, - } - log.SetFormatter(formatter) - log.SetOutput(os.Stdout) return nil } -// Fields is a wrapper for logrus.Entry -// we need to insert some sentry captures here -type Fields struct { - e *log.Entry +// Fatalf forwards to sentry +func Fatalf(ctx context.Context, err error, format string, args ...interface{}) { + sentry.CaptureMessage(fmt.Sprintf(genSentryTracingInfo(ctx)+format, args...)) + globalLogger.Fatal().Err(err).Msgf(format, args...) } -// WithField . -func (f Fields) WithField(key string, value interface{}) Fields { - e := f.e.WithField(key, value) - return Fields{e: e} +// Warnf is Warnf +func Warnf(ctx context.Context, format string, args ...interface{}) { + globalLogger.Warn().Msgf(format, args...) } -// Errorf sends sentry message -func (f Fields) Errorf(ctx context.Context, format string, args ...interface{}) { - format = getTracingInfo(ctx) + format - sentry.CaptureMessage(fmt.Sprintf(format, args...)) - f.e.Errorf(format, args...) +// Warn is Warn +func Warn(ctx context.Context, args ...interface{}) { + Warnf(ctx, "%v", args...) } -// ErrWithTracing is a decorator returning the argument -func (f Fields) ErrWithTracing(ctx context.Context, err error) error { - format := getTracingInfo(ctx) + "%+v" - if err != nil { - sentry.CaptureMessage(fmt.Sprintf(format, err)) - f.e.Errorf(format, err) - } - return err +// Infof is Infof +func Infof(ctx context.Context, format string, args ...interface{}) { + infoEvent().Msgf(format, args...) } -// Infof . -func (f Fields) Infof(ctx context.Context, format string, args ...interface{}) { - format = getTracingInfo(ctx) + format - f.e.Infof(format, args...) +// Info is Info +func Info(ctx context.Context, args ...interface{}) { + Infof(ctx, "%v", args...) } -// WithField add kv into log entry -func WithField(key string, value interface{}) Fields { - return Fields{ - e: log.WithField(key, value), - } +// Debugf is Debugf +func Debugf(ctx context.Context, format string, args ...interface{}) { + globalLogger.Debug().Msgf(format, args...) } -// Error forwards to sentry -func Error(args ...interface{}) { - sentry.CaptureMessage(fmt.Sprint(args...)) - log.Error(args...) +// Debug is Debug +func Debug(ctx context.Context, args ...interface{}) { + Debugf(ctx, "%v", args...) } // Errorf forwards to sentry -func Errorf(ctx context.Context, format string, args ...interface{}) { - format = getTracingInfo(ctx) + format - sentry.CaptureMessage(fmt.Sprintf(format, args...)) - log.Errorf(format, args...) -} - -// Fatalf forwards to sentry -func Fatalf(format string, args ...interface{}) { - sentry.CaptureMessage(fmt.Sprintf(format, args...)) - log.Fatalf(format, args...) +func Errorf(ctx context.Context, err error, format string, args ...interface{}) { + if err == nil { + return + } + sentry.CaptureMessage(fmt.Sprintf(genSentryTracingInfo(ctx)+format, args...)) + errorEvent(err).Msgf(format, args...) } -// Warn is Warn -func Warn(args ...interface{}) { - log.Warn(args...) +// Error forwards to sentry +func Error(ctx context.Context, err error, args ...interface{}) { + Errorf(ctx, err, "%v", args...) } -// Warnf is Warnf -func Warnf(ctx context.Context, format string, args ...interface{}) { - log.Warnf(getTracingInfo(ctx)+format, args...) +// Fields is a wrapper for zerolog.Entry +// we need to insert some sentry captures here +type Fields struct { + kv map[string]interface{} } -// Info is Info -func Info(args ...interface{}) { - log.Info(args...) +// WithField add kv into log entry +func WithField(key string, value interface{}) *Fields { + return &Fields{ + kv: map[string]interface{}{key: value}, + } } -// Infof is Infof -func Infof(ctx context.Context, format string, args ...interface{}) { - log.Infof(getTracingInfo(ctx)+format, args...) +// WithField . +func (f *Fields) WithField(key string, value interface{}) *Fields { + f.kv[key] = value + return f } -// Debug is Debug -func Debug(ctx context.Context, args ...interface{}) { - a := []interface{}{getTracingInfo(ctx)} - a = append(a, args...) - log.Debug(a) +// Infof . +func (f Fields) Infof(ctx context.Context, format string, args ...interface{}) { + infoEvent().Fields(f.kv).Msgf(format, args...) } -// Debugf is Debugf -func Debugf(ctx context.Context, format string, args ...interface{}) { - log.Debugf(getTracingInfo(ctx)+format, args...) +// Errorf sends sentry message +func (f Fields) Errorf(ctx context.Context, err error, format string, args ...interface{}) { + if err == nil { + return + } + sentry.CaptureMessage(fmt.Sprintf(genSentryTracingInfo(ctx)+format, args...)) + errorEvent(err).Fields(f.kv).Msgf(format, args...) } -func getTracingInfo(ctx context.Context) (tracingInfo string) { +// for sentry +func genSentryTracingInfo(ctx context.Context) (tracingInfo string) { if ctx == nil { return "" } @@ -145,3 +142,14 @@ func getTracingInfo(ctx context.Context) (tracingInfo string) { } return } + +func infoEvent() *zerolog.Event { + return globalLogger.Info() +} + +func errorEvent(err error) *zerolog.Event { + if err != nil { + err = errors.WithStack(err) + } + return globalLogger.Error().Err(err) +} diff --git a/metrics/handler.go b/metrics/handler.go index 6a9619d00..ae3749b8f 100644 --- a/metrics/handler.go +++ b/metrics/handler.go @@ -17,12 +17,12 @@ func (m *Metrics) ResourceMiddleware(cluster cluster.Cluster) func(http.Handler) defer cancel() nodes, err := cluster.ListPodNodes(ctx, &types.ListNodesOptions{All: true}) if err != nil { - log.Errorf(ctx, "[ResourceMiddleware] Get all nodes err %v", err) + log.Errorf(ctx, err, "[ResourceMiddleware] Get all nodes err %v", err) } for node := range nodes { metrics, err := m.rmgr.GetNodeMetrics(ctx, node) if err != nil { - log.Errorf(ctx, "[ResourceMiddleware] Get metrics failed %v", err) + log.Errorf(ctx, err, "[ResourceMiddleware] Get metrics failed %v", err) continue } m.SendMetrics(metrics...) diff --git a/metrics/metrics.go b/metrics/metrics.go index ef9606b74..ccb67d9f5 100644 --- a/metrics/metrics.go +++ b/metrics/metrics.go @@ -37,7 +37,7 @@ type Metrics struct { // SendDeployCount update deploy counter func (m *Metrics) SendDeployCount(n int) { - log.Info("[Metrics] Update deploy counter") + log.Info(nil, "[Metrics] Update deploy counter") //nolint metrics := &resources.Metrics{ Name: deployCountName, Labels: []string{m.Hostname}, @@ -53,30 +53,30 @@ func (m *Metrics) SendMetrics(metrics ...*resources.Metrics) { for _, metric := range metrics { collector, ok := m.Collectors[metric.Name] if !ok { - log.Errorf(nil, "[SendMetrics] Collector not found: %s", metric.Name) //nolint + log.Errorf(nil, nil, "[SendMetrics] Collector not found: %s", metric.Name) //nolint continue } switch collector.(type) { // nolint case *prometheus.GaugeVec: value, err := strconv.ParseFloat(metric.Value, 64) if err != nil { - log.Errorf(nil, "[SendMetrics] Error occurred while parsing %v value %v: %v", metric.Name, metric.Value, err) //nolint + log.Errorf(nil, err, "[SendMetrics] Error occurred while parsing %v value %v: %v", metric.Name, metric.Value, err) //nolint } collector.(*prometheus.GaugeVec).WithLabelValues(metric.Labels...).Set(value) // nolint if err := m.gauge(metric.Key, value); err != nil { - log.Errorf(nil, "[SendMetrics] Error occurred while sending %v data to statsd: %v", metric.Name, err) //nolint + log.Errorf(nil, err, "[SendMetrics] Error occurred while sending %v data to statsd: %v", metric.Name, err) //nolint } case *prometheus.CounterVec: value, err := strconv.ParseInt(metric.Value, 10, 32) // nolint if err != nil { - log.Errorf(nil, "[SendMetrics] Error occurred while parsing %v value %v: %v", metric.Name, metric.Value, err) //nolint + log.Errorf(nil, err, "[SendMetrics] Error occurred while parsing %v value %v: %v", metric.Name, metric.Value, err) //nolint } collector.(*prometheus.CounterVec).WithLabelValues(metric.Labels...).Add(float64(value)) // nolint if err := m.count(metric.Key, int(value), 1.0); err != nil { - log.Errorf(nil, "[SendMetrics] Error occurred while sending %v data to statsd: %v", metric.Name, err) //nolint + log.Errorf(nil, err, "[SendMetrics] Error occurred while sending %v data to statsd: %v", metric.Name, err) //nolint } default: - log.Errorf(nil, "[SendMetrics] Unknown collector type: %T", collector) // nolint + log.Errorf(nil, nil, "[SendMetrics] Unknown collector type: %T", collector) //nolint } } } @@ -90,9 +90,9 @@ func (m *Metrics) checkConn() error { // We needn't try to renew/reconnect because of only supporting UDP protocol now // We should add an `errorCount` to reconnect when implementing TCP protocol if m.statsdClient, err = statsdlib.New(m.StatsdAddr, statsdlib.WithErrorHandler(func(err error) { - log.Errorf(nil, "[statsd] Sending statsd failed: %v", err) //nolint + log.Errorf(nil, err, "[statsd] Sending statsd failed: %v", err) //nolint })); err != nil { - log.Errorf(nil, "[statsd] Connect statsd failed: %v", err) //nolint + log.Errorf(nil, err, "[statsd] Connect statsd failed: %v", err) //nolint return err } return nil diff --git a/resources/binary.go b/resources/binary.go index dd24b691c..6d1b97e69 100644 --- a/resources/binary.go +++ b/resources/binary.go @@ -260,7 +260,7 @@ func (bp *BinaryPlugin) call(ctx context.Context, cmd string, req interface{}, r defer log.Infof(ctx, "[callBinaryPlugin] output from plugin %s: %s", bp.path, pluginOutput) if err != nil { - log.Errorf(ctx, "[callBinaryPlugin] failed to run plugin %s, command %v, err %s", bp.path, args, err) + log.Errorf(ctx, err, "[callBinaryPlugin] failed to run plugin %s, command %v, err %s", bp.path, args, err) return err } @@ -268,7 +268,7 @@ func (bp *BinaryPlugin) call(ctx context.Context, cmd string, req interface{}, r pluginOutput = "{}" } if err := json.Unmarshal([]byte(pluginOutput), resp); err != nil { - log.Errorf(ctx, "[callBinaryPlugin] failed to unmarshal output of plugin %s, command %v, output %s, err %s", bp.path, args, pluginOutput, err) + log.Errorf(ctx, err, "[callBinaryPlugin] failed to unmarshal output of plugin %s, command %v, output %s, err %s", bp.path, args, pluginOutput, err) return err } return nil diff --git a/resources/manager.go b/resources/manager.go index a5d047e32..07553d5ba 100644 --- a/resources/manager.go +++ b/resources/manager.go @@ -23,13 +23,13 @@ func (pm *PluginsManager) GetMostIdleNode(ctx context.Context, nodenames []strin respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetMostIdleNodeResponse, error) { resp, err := plugin.GetMostIdleNode(ctx, nodenames) if err != nil { - log.Errorf(ctx, "[GetMostIdleNode] plugin %v failed to get the most idle node of %v, err: %v", plugin.Name(), nodenames, err) + log.Errorf(ctx, err, "[GetMostIdleNode] plugin %v failed to get the most idle node of %v, err: %v", plugin.Name(), nodenames, err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[GetMostIdleNode] failed to get the most idle node of %v", nodenames) + log.Errorf(ctx, err, "[GetMostIdleNode] failed to get the most idle node of %v", nodenames) return "", err } @@ -54,7 +54,7 @@ func (pm *PluginsManager) GetNodesDeployCapacity(ctx context.Context, nodenames respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetNodesDeployCapacityResponse, error) { resp, err := plugin.GetNodesDeployCapacity(ctx, nodenames, resourceOpts) if err != nil { - log.Errorf(ctx, "[GetNodesDeployCapacity] plugin %v failed to get available nodenames, request %v, err %v", plugin.Name(), resourceOpts, err) + log.Errorf(ctx, err, "[GetNodesDeployCapacity] plugin %v failed to get available nodenames, request %v, err %v", plugin.Name(), resourceOpts, err) } return resp, err }) @@ -103,7 +103,7 @@ func (pm *PluginsManager) SetNodeResourceCapacity(ctx context.Context, nodename respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*SetNodeResourceCapacityResponse, error) { resp, err := plugin.SetNodeResourceCapacity(ctx, nodename, nodeResourceOpts, nodeResourceArgs[plugin.Name()], delta, incr) if err != nil { - log.Errorf(ctx, "[SetNodeResourceCapacity] node %v plugin %v failed to set node resource capacity, err: %v", nodename, plugin.Name(), err) + log.Errorf(ctx, err, "[SetNodeResourceCapacity] node %v plugin %v failed to set node resource capacity, err: %v", nodename, plugin.Name(), err) } return resp, err }) @@ -114,7 +114,7 @@ func (pm *PluginsManager) SetNodeResourceCapacity(ctx context.Context, nodename beforeMap[plugin.Name()] = resp.Before afterMap[plugin.Name()] = resp.After } - log.Errorf(ctx, "[SetNodeResourceCapacity] failed to set node resource for node %v", nodename) + log.Errorf(ctx, err, "[SetNodeResourceCapacity] failed to set node resource for node %v", nodename) return err } return nil @@ -124,7 +124,7 @@ func (pm *PluginsManager) SetNodeResourceCapacity(ctx context.Context, nodename _, err := callPlugins(ctx, rollbackPlugins, func(plugin Plugin) (*SetNodeResourceCapacityResponse, error) { resp, err := plugin.SetNodeResourceCapacity(ctx, nodename, nil, beforeMap[plugin.Name()], false, false) if err != nil { - log.Errorf(ctx, "[SetNodeResourceCapacity] node %v plugin %v failed to rollback node resource capacity, err: %v", err) + log.Errorf(ctx, err, "[SetNodeResourceCapacity] node %v plugin %v failed to rollback node resource capacity, err: %v", nodename, plugin.Name(), err) } return resp, err }) @@ -156,7 +156,7 @@ func (pm *PluginsManager) GetNodeResourceInfo(ctx context.Context, nodename stri resp, err = plugin.GetNodeResourceInfo(ctx, nodename, workloads) } if err != nil { - log.Errorf(ctx, "[GetNodeResourceInfo] plugin %v failed to get node resource of node %v, err: %v", plugin.Name(), nodename, err) + log.Errorf(ctx, err, "[GetNodeResourceInfo] plugin %v failed to get node resource of node %v, err: %v", plugin.Name(), nodename, err) } return resp, err }) @@ -203,7 +203,7 @@ func (pm *PluginsManager) SetNodeResourceUsage(ctx context.Context, nodename str respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*SetNodeResourceUsageResponse, error) { resp, err := plugin.SetNodeResourceUsage(ctx, nodename, nodeResourceOpts, nodeResourceArgs[plugin.Name()], workloadResourceArgsMap[plugin.Name()], delta, incr) if err != nil { - log.Errorf(ctx, "[SetNodeResourceUsage] node %v plugin %v failed to update node resource, err: %v", nodename, plugin.Name(), err) + log.Errorf(ctx, err, "[SetNodeResourceUsage] node %v plugin %v failed to update node resource, err: %v", nodename, plugin.Name(), err) } return resp, err }) @@ -214,7 +214,7 @@ func (pm *PluginsManager) SetNodeResourceUsage(ctx context.Context, nodename str beforeMap[plugin.Name()] = resp.Before afterMap[plugin.Name()] = resp.After } - log.Errorf(ctx, "[UpdateNodeResourceUsage] failed to set node resource for node %v", nodename) + log.Errorf(ctx, err, "[UpdateNodeResourceUsage] failed to set node resource for node %v", nodename) return err } return nil @@ -224,7 +224,7 @@ func (pm *PluginsManager) SetNodeResourceUsage(ctx context.Context, nodename str _, err := callPlugins(ctx, rollbackPlugins, func(plugin Plugin) (*SetNodeResourceUsageResponse, error) { resp, err := plugin.SetNodeResourceUsage(ctx, nodename, nil, beforeMap[plugin.Name()], nil, false, false) if err != nil { - log.Errorf(ctx, "[UpdateNodeResourceUsage] node %v plugin %v failed to rollback node resource, err: %v", err) + log.Errorf(ctx, err, "[UpdateNodeResourceUsage] node %v plugin %v failed to rollback node resource, err: %v", nodename, plugin.Name(), err) } return resp, err }) @@ -251,7 +251,7 @@ func (pm *PluginsManager) Alloc(ctx context.Context, nodename string, deployCoun respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetDeployArgsResponse, error) { resp, err := plugin.GetDeployArgs(ctx, nodename, deployCount, resourceOpts) if err != nil { - log.Errorf(ctx, "[Alloc] plugin %v failed to compute alloc args, request %v, node %v, deploy count %v, err %v", plugin.Name(), resourceOpts, nodename, deployCount, err) + log.Errorf(ctx, err, "[Alloc] plugin %v failed to compute alloc args, request %v, node %v, deploy count %v, err %v", plugin.Name(), resourceOpts, nodename, deployCount, err) } return resp, err }) @@ -267,7 +267,7 @@ func (pm *PluginsManager) Alloc(ctx context.Context, nodename string, deployCoun for index, args := range resp.EngineArgs { resEngineArgs[index], err = pm.mergeEngineArgs(ctx, resEngineArgs[index], args) if err != nil { - log.Errorf(ctx, "[Alloc] invalid engine args") + log.Errorf(ctx, err, "[Alloc] invalid engine args") return err } } @@ -277,7 +277,7 @@ func (pm *PluginsManager) Alloc(ctx context.Context, nodename string, deployCoun // commit: update node resources func(ctx context.Context) error { if _, _, err := pm.SetNodeResourceUsage(ctx, nodename, nil, nil, resResourceArgs, true, Incr); err != nil { - log.Errorf(ctx, "[Alloc] failed to update node resource, err: %v", err) + log.Errorf(ctx, err, "[Alloc] failed to update node resource, err: %v", err) return err } return nil @@ -308,19 +308,19 @@ func (pm *PluginsManager) Realloc(ctx context.Context, nodename string, originRe respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetReallocArgsResponse, error) { resp, err := plugin.GetReallocArgs(ctx, nodename, originResourceArgs[plugin.Name()], resourceOpts) if err != nil { - log.Errorf(ctx, "[Realloc] plugin %v failed to calculate realloc args, err: %v", plugin.Name(), err) + log.Errorf(ctx, err, "[Realloc] plugin %v failed to calculate realloc args, err: %v", plugin.Name(), err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[Realloc] realloc failed, origin: %+v, opts: %+v", originResourceArgs, resourceOpts) + log.Errorf(ctx, err, "[Realloc] realloc failed, origin: %+v, opts: %+v", originResourceArgs, resourceOpts) return err } for plugin, resp := range respMap { if resEngineArgs, err = pm.mergeEngineArgs(ctx, resEngineArgs, resp.EngineArgs); err != nil { - log.Errorf(ctx, "[Realloc] invalid engine args, err: %v", err) + log.Errorf(ctx, err, "[Realloc] invalid engine args, err: %v", err) return err } resDeltaResourceArgs[plugin.Name()] = resp.Delta @@ -331,7 +331,7 @@ func (pm *PluginsManager) Realloc(ctx context.Context, nodename string, originRe // commit: update node resource func(ctx context.Context) error { if _, _, err := pm.SetNodeResourceUsage(ctx, nodename, nil, nil, []map[string]types.WorkloadResourceArgs{resDeltaResourceArgs}, true, Incr); err != nil { - log.Errorf(ctx, "[Realloc] failed to update nodename resource, err: %v", err) + log.Errorf(ctx, err, "[Realloc] failed to update nodename resource, err: %v", err) return err } return nil @@ -356,13 +356,13 @@ func (pm *PluginsManager) GetMetricsDescription(ctx context.Context) ([]*Metrics respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetMetricsDescriptionResponse, error) { resp, err := plugin.GetMetricsDescription(ctx) if err != nil { - log.Errorf(ctx, "[GetMetricsDescription] plugin %v failed to get metrics description, err: %v", plugin.Name(), err) + log.Errorf(ctx, err, "[GetMetricsDescription] plugin %v failed to get metrics description, err: %v", plugin.Name(), err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[GetMetricsDescription] failed to get metrics description") + log.Errorf(ctx, err, "[GetMetricsDescription] failed to get metrics description") return nil, err } @@ -380,13 +380,13 @@ func (pm *PluginsManager) GetNodeMetrics(ctx context.Context, node *types.Node) capacity, usage := node.Resource.Capacity[plugin.Name()], node.Resource.Usage[plugin.Name()] resp, err := plugin.GetNodeMetrics(ctx, node.Podname, node.Name, &NodeResourceInfo{Capacity: capacity, Usage: usage}) if err != nil { - log.Errorf(ctx, "[GetNodeMetrics] plugin %v failed to convert node resource info to metrics, err: %v", plugin.Name(), err) + log.Errorf(ctx, err, "[GetNodeMetrics] plugin %v failed to convert node resource info to metrics, err: %v", plugin.Name(), err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[GetNodeMetrics] failed to convert node resource info to metrics") + log.Errorf(ctx, err, "[GetNodeMetrics] failed to convert node resource info to metrics") return nil, err } @@ -413,7 +413,7 @@ func (pm *PluginsManager) AddNode(ctx context.Context, nodename string, resource respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*AddNodeResponse, error) { resp, err := plugin.AddNode(ctx, nodename, resourceOpts, nodeInfo) if err != nil { - log.Errorf(ctx, "[AddNode] node %v plugin %v failed to add node, req: %v, err: %v", nodename, plugin.Name(), resourceOpts, err) + log.Errorf(ctx, err, "[AddNode] node %v plugin %v failed to add node, req: %v, err: %v", nodename, plugin.Name(), resourceOpts, err) } return resp, err }) @@ -423,7 +423,7 @@ func (pm *PluginsManager) AddNode(ctx context.Context, nodename string, resource rollbackPlugins = append(rollbackPlugins, plugin) } - log.Errorf(ctx, "[AddNode] node %v failed to add node %v, rollback", nodename, resourceOpts) + log.Errorf(ctx, err, "[AddNode] node %v failed to add node %v, rollback", nodename, resourceOpts) return err } @@ -439,13 +439,13 @@ func (pm *PluginsManager) AddNode(ctx context.Context, nodename string, resource _, err := callPlugins(ctx, rollbackPlugins, func(plugin Plugin) (*RemoveNodeResponse, error) { resp, err := plugin.RemoveNode(ctx, nodename) if err != nil { - log.Errorf(ctx, "[AddNode] node %v plugin %v failed to rollback, err: %v", nodename, plugin.Name(), err) + log.Errorf(ctx, err, "[AddNode] node %v plugin %v failed to rollback, err: %v", nodename, plugin.Name(), err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[AddNode] failed to rollback") + log.Errorf(ctx, err, "[AddNode] failed to rollback") return err } @@ -467,7 +467,7 @@ func (pm *PluginsManager) RemoveNode(ctx context.Context, nodename string) error var err error resourceCapacityMap, resourceUsageMap, _, err = pm.GetNodeResourceInfo(ctx, nodename, nil, false) if err != nil { - log.Errorf(ctx, "[RemoveNode] failed to get node %v resource, err: %v", nodename, err) + log.Errorf(ctx, err, "[RemoveNode] failed to get node %v resource, err: %v", nodename, err) return err } return nil @@ -477,7 +477,7 @@ func (pm *PluginsManager) RemoveNode(ctx context.Context, nodename string) error respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*RemoveNodeResponse, error) { resp, err := plugin.RemoveNode(ctx, nodename) if err != nil { - log.Errorf(ctx, "[AddNode] plugin %v failed to remove node, err: %v", plugin.Name(), nodename, err) + log.Errorf(ctx, err, "[AddNode] plugin %v failed to remove node, err: %v", plugin.Name(), err) } return resp, err }) @@ -487,7 +487,7 @@ func (pm *PluginsManager) RemoveNode(ctx context.Context, nodename string) error rollbackPlugins = append(rollbackPlugins, plugin) } - log.Errorf(ctx, "[AddNode] failed to remove node %v", nodename) + log.Errorf(ctx, err, "[AddNode] failed to remove node %v", nodename) return err } return nil @@ -497,13 +497,13 @@ func (pm *PluginsManager) RemoveNode(ctx context.Context, nodename string) error _, err := callPlugins(ctx, rollbackPlugins, func(plugin Plugin) (*SetNodeResourceInfoResponse, error) { resp, err := plugin.SetNodeResourceInfo(ctx, nodename, resourceCapacityMap[plugin.Name()], resourceUsageMap[plugin.Name()]) if err != nil { - log.Errorf(ctx, "[RemoveNode] plugin %v node %v failed to rollback, err: %v", plugin.Name(), nodename, err) + log.Errorf(ctx, err, "[RemoveNode] plugin %v node %v failed to rollback, err: %v", plugin.Name(), nodename, err) } return resp, err }) if err != nil { - log.Errorf(ctx, "[RemoveNode] failed to rollback") + log.Errorf(ctx, err, "[RemoveNode] failed to rollback") return err } return nil @@ -521,7 +521,7 @@ func (pm *PluginsManager) GetRemapArgs(ctx context.Context, nodename string, wor respMap, err := callPlugins(ctx, pm.plugins, func(plugin Plugin) (*GetRemapArgsResponse, error) { resp, err := plugin.GetRemapArgs(ctx, nodename, workloadMap) if err != nil { - log.Errorf(ctx, "[GetRemapArgs] plugin %v node %v failed to remap, err: %v", plugin.Name(), nodename, err) + log.Errorf(ctx, err, "[GetRemapArgs] plugin %v node %v failed to remap, err: %v", plugin.Name(), nodename, err) } return resp, err }) @@ -538,7 +538,7 @@ func (pm *PluginsManager) GetRemapArgs(ctx context.Context, nodename string, wor } resEngineArgsMap[workloadID], err = pm.mergeEngineArgs(ctx, resEngineArgsMap[workloadID], engineArgs) if err != nil { - log.Errorf(ctx, "[GetRemapArgs] invalid engine args") + log.Errorf(ctx, err, "[GetRemapArgs] invalid engine args") return nil, err } } @@ -581,7 +581,7 @@ func (pm *PluginsManager) mergeEngineArgs(ctx context.Context, m1 types.EngineAr _, ok1 := res[key].([]string) _, ok2 := value.([]string) if !ok1 || !ok2 { - log.Errorf(ctx, "[mergeEngineArgs] only two string slices can be merged! error key %v, m1[key] = %v, m2[key] = %v", key, m1[key], m2[key]) + log.Errorf(ctx, nil, "[mergeEngineArgs] only two string slices can be merged! error key %v, m1[key] = %v, m2[key] = %v", key, m1[key], m2[key]) return nil, types.ErrInvalidEngineArgs } res[key] = append(res[key].([]string), value.([]string)...) diff --git a/resources/plugins.go b/resources/plugins.go index 122e35368..0794b95ec 100644 --- a/resources/plugins.go +++ b/resources/plugins.go @@ -34,7 +34,7 @@ func (pm *PluginsManager) LoadPlugins(ctx context.Context) error { pluginFiles, err := utils.ListAllExecutableFiles(pm.config.ResourcePlugin.Dir) if err != nil { - log.Errorf(ctx, "[LoadPlugins] failed to list all executable files dir: %v, err: %v", pm.config.ResourcePlugin.Dir, err) + log.Errorf(ctx, err, "[LoadPlugins] failed to list all executable files dir: %v, err: %v", pm.config.ResourcePlugin.Dir, err) return err } @@ -72,7 +72,7 @@ func callPlugins[T any](ctx context.Context, plugins []Plugin, f func(Plugin) (T for _, plugin := range plugins { result, err := f(plugin) if err != nil { - log.Errorf(ctx, "[callPlugins] failed to call plugin %v, err: %v", plugin.Name(), err) + log.Errorf(ctx, err, "[callPlugins] failed to call plugin %v, err: %v", plugin.Name(), err) combinedErr = multierror.Append(combinedErr, types.NewDetailedErr(err, plugin.Name())) continue } diff --git a/resources/volume/types/volume.go b/resources/volume/types/volume.go index 20b3ec6ac..dae11e7f3 100644 --- a/resources/volume/types/volume.go +++ b/resources/volume/types/volume.go @@ -7,7 +7,6 @@ import ( "strings" "github.com/pkg/errors" - "github.com/projecteru2/core/utils" ) @@ -32,7 +31,7 @@ func NewVolumeBinding(volume string) (_ *VolumeBinding, err error) { parts := strings.Split(volume, ":") if len(parts) > 8 || len(parts) < 2 { - return nil, errors.WithStack(errors.Errorf("invalid volume: %s", volume)) + return nil, errors.Errorf("invalid volume: %s", volume) } if len(parts) == 2 { parts = append(parts, "rw") @@ -48,7 +47,7 @@ func NewVolumeBinding(volume string) (_ *VolumeBinding, err error) { for i, ptr := range ptrs { value, err := utils.ParseRAMInHuman(parts[i+3]) if err != nil { - return nil, errors.WithStack(err) + return nil, err } *ptr = value } @@ -77,7 +76,7 @@ func NewVolumeBinding(volume string) (_ *VolumeBinding, err error) { // Validate return error if invalid func (vb VolumeBinding) Validate() error { if vb.Destination == "" { - return errors.WithStack(errors.Errorf("invalid volume, dest must be provided: %v", vb)) + return errors.Errorf("invalid volume, dest must be provided: %v", vb) } return nil } @@ -173,10 +172,10 @@ func NewVolumeBindings(volumes []string) (volumeBindings VolumeBindings, err err func (vbs VolumeBindings) Validate() error { for _, vb := range vbs { if vb.RequireScheduleMonopoly() && vb.RequireScheduleUnlimitedQuota() { - return errors.WithStack(errors.Errorf("invalid volume, monopoly volume can't be unlimited: %v", vb)) + return errors.Errorf("invalid volume, monopoly volume can't be unlimited: %v", vb) } if !vb.ValidIOParameters() { - return errors.WithStack(errors.Errorf("invalid io parameters: %v", vb)) + return errors.Errorf("invalid io parameters: %v", vb) } } return nil @@ -186,7 +185,7 @@ func (vbs VolumeBindings) Validate() error { func (vbs *VolumeBindings) UnmarshalJSON(b []byte) (err error) { volumes := []string{} if err = json.Unmarshal(b, &volumes); err != nil { - return errors.WithStack(err) + return err } *vbs, err = NewVolumeBindings(volumes) return @@ -199,7 +198,7 @@ func (vbs VolumeBindings) MarshalJSON() ([]byte, error) { volumes = append(volumes, vb.ToString(false)) } bs, err := json.Marshal(volumes) - return bs, errors.WithStack(err) + return bs, err } func (vbs VolumeBindings) String() string { @@ -328,12 +327,12 @@ func (p *VolumePlan) UnmarshalJSON(b []byte) (err error) { } plan := map[string]VolumeMap{} if err = json.Unmarshal(b, &plan); err != nil { - return errors.WithStack(err) + return err } for volume, vmap := range plan { vb, err := NewVolumeBinding(volume) if err != nil { - return errors.WithStack(err) + return err } (*p)[vb] = vmap } @@ -347,7 +346,7 @@ func (p VolumePlan) MarshalJSON() ([]byte, error) { plan[vb.ToString(false)] = vmap } bs, err := json.Marshal(plan) - return bs, errors.WithStack(err) + return bs, err } // String . diff --git a/rpc/rpc.go b/rpc/rpc.go index c3b4b7ea3..75af52b4b 100644 --- a/rpc/rpc.go +++ b/rpc/rpc.go @@ -529,11 +529,11 @@ func (v *Vibranium) Copy(opts *pb.CopyOptions, stream pb.CoreRPC_CopyServer) err Size: int64(len(m.Content)), } if err = tw.WriteHeader(header); err != nil { - log.Errorf(task.context, "[Copy] Error during writing tarball header: %v", err) + log.Errorf(task.context, err, "[Copy] Error during writing tarball header: %v", err) return } if _, err = tw.Write(m.Content); err != nil { - log.Errorf(task.context, "[Copy] Error during writing tarball content: %v", err) + log.Errorf(task.context, err, "[Copy] Error during writing tarball content: %v", err) return } } @@ -543,7 +543,7 @@ func (v *Vibranium) Copy(opts *pb.CopyOptions, stream pb.CoreRPC_CopyServer) err n, err := r.Read(p) if err != nil { if err != io.EOF { - log.Errorf(task.context, "[Copy] Error during buffer resp: %v", err) + log.Errorf(task.context, err, "[Copy] Error during buffer resp: %v", err) msg.Error = err.Error() if err = stream.Send(msg); err != nil { v.logUnsentMessages(task.context, "Copy", err, m) @@ -814,7 +814,7 @@ func (v *Vibranium) ExecuteWorkload(stream pb.CoreRPC_ExecuteWorkloadServer) err for { execWorkloadOpt, err := stream.Recv() if execWorkloadOpt == nil || err != nil { - log.Errorf(task.context, "[ExecuteWorkload] Recv command error: %v", err) + log.Errorf(task.context, err, "[ExecuteWorkload] Recv command error: %v", err) return } inCh <- execWorkloadOpt.ReplCmd @@ -934,7 +934,7 @@ func (v *Vibranium) RunAndWait(stream pb.CoreRPC_RunAndWaitServer) error { for { RunAndWaitOptions, err := stream.Recv() if RunAndWaitOptions == nil || err != nil { - log.Errorf(ctx, "[RunAndWait] Recv command error: %v", err) + log.Errorf(ctx, err, "[RunAndWait] Recv command error: %v", err) break } inCh <- RunAndWaitOptions.Cmd @@ -984,7 +984,7 @@ func (v *Vibranium) RunAndWait(stream pb.CoreRPC_RunAndWaitServer) error { defer w.Close() for m := range ch { if _, err := w.Write(m.Data); err != nil { - log.Errorf(ctx, "[Async RunAndWait] iterate and forward AttachWorkloadMessage error: %v", err) + log.Errorf(ctx, err, "[Async RunAndWait] iterate and forward AttachWorkloadMessage error: %v", err) } } }) @@ -998,7 +998,7 @@ func (v *Vibranium) RunAndWait(stream pb.CoreRPC_RunAndWaitServer) error { for { if part, isPrefix, err = bufReader.ReadLine(); err != nil { if err != io.EOF { - log.Errorf(ctx, "[Aysnc RunAndWait] read error: %+v", err) + log.Errorf(ctx, err, "[Aysnc RunAndWait] read error: %+v", err) } return } diff --git a/rpc/transform.go b/rpc/transform.go index 3ae5162cb..c38b49a17 100644 --- a/rpc/transform.go +++ b/rpc/transform.go @@ -467,7 +467,7 @@ func toRPCWorkloads(ctx context.Context, workloads []*types.Workload, labels map for _, c := range workloads { pWorkload, err := toRPCWorkload(ctx, c) if err != nil { - log.Errorf(ctx, "[toRPCWorkloads] trans to pb workload failed %v", err) + log.Errorf(ctx, err, "[toRPCWorkloads] trans to pb workload failed %v", err) continue } if !utils.LabelsFilter(pWorkload.Labels, labels) { diff --git a/selfmon/selfmon.go b/selfmon/selfmon.go index 1c2681a84..dd4a97da1 100644 --- a/selfmon/selfmon.go +++ b/selfmon/selfmon.go @@ -32,7 +32,7 @@ func RunNodeStatusWatcher(ctx context.Context, config types.Config, cluster clus id := rand.Int63n(10000) // nolint store, err := store.NewStore(config, t) if err != nil { - log.Errorf(ctx, "[RunNodeStatusWatcher] %v failed to create store, err: %v", id, err) + log.Errorf(ctx, err, "[RunNodeStatusWatcher] %v failed to create store, err: %v", id, err) return } @@ -53,7 +53,7 @@ func (n *NodeStatusWatcher) run(ctx context.Context) { default: n.withActiveLock(ctx, func(ctx context.Context) { if err := n.monitor(ctx); err != nil { - log.Errorf(ctx, "[NodeStatusWatcher] %v stops watching, err: %v", n.id, err) + log.Errorf(ctx, err, "[NodeStatusWatcher] %v stops watching, err: %v", n.id, err) } }) time.Sleep(n.config.ConnectionTimeout) @@ -80,7 +80,7 @@ func (n *NodeStatusWatcher) withActiveLock(parentCtx context.Context, f func(ctx for { select { case <-ctx.Done(): - log.Info("[Register] context canceled") + log.Info(ctx, "[Register] context canceled") return default: } @@ -88,10 +88,10 @@ func (n *NodeStatusWatcher) withActiveLock(parentCtx context.Context, f func(ctx // try to get the lock if ne, un, err := n.register(ctx); err != nil { if errors.Is(err, context.Canceled) { - log.Info("[Register] context canceled") + log.Info(ctx, "[Register] context canceled") return } else if !errors.Is(err, types.ErrKeyExists) { - log.Errorf(ctx, "[Register] failed to re-register: %v", err) + log.Errorf(ctx, err, "[Register] failed to re-register: %v", err) time.Sleep(time.Second) continue } @@ -114,10 +114,10 @@ func (n *NodeStatusWatcher) withActiveLock(parentCtx context.Context, f func(ctx select { case <-ctx.Done(): - log.Info("[Register] context canceled") + log.Info(ctx, "[Register] context canceled") return case <-expiry: - log.Info("[Register] lock expired") + log.Info(ctx, "[Register] lock expired") return } }() @@ -146,7 +146,7 @@ func (n *NodeStatusWatcher) initNodeStatus(ctx context.Context) { CallInfo: false, }) if err != nil { - log.Errorf(ctx, "[NodeStatusWatcher] get pod nodes failed %v", err) + log.Errorf(ctx, err, "[NodeStatusWatcher] get pod nodes failed %v", err) return } for node := range ch { @@ -155,7 +155,7 @@ func (n *NodeStatusWatcher) initNodeStatus(ctx context.Context) { } }) if err != nil { - log.Errorf(ctx, "[NodeStatusWatcher] get pod nodes failed %v", err) + log.Errorf(ctx, err, "[NodeStatusWatcher] get pod nodes failed %v", err) return } }() @@ -197,7 +197,7 @@ func (n *NodeStatusWatcher) monitor(ctx context.Context) error { func (n *NodeStatusWatcher) dealNodeStatusMessage(ctx context.Context, message *types.NodeStatus) { if message.Error != nil { - log.Errorf(ctx, "[NodeStatusWatcher] deal with node status stream message failed %+v", message) + log.Errorf(ctx, message.Error, "[NodeStatusWatcher] deal with node status stream message failed %+v", message) return } // here we ignore node back to alive status because it will updated by agent @@ -214,7 +214,7 @@ func (n *NodeStatusWatcher) dealNodeStatusMessage(ctx context.Context, message * WorkloadsDown: true, } if _, err := n.cluster.SetNode(ctx, opts); err != nil { - log.Errorf(ctx, "[NodeStatusWatcher] set node %s failed %v", message.Nodename, err) + log.Errorf(ctx, err, "[NodeStatusWatcher] set node %s failed %v", message.Nodename, err) return } log.Infof(ctx, "[NodeStatusWatcher] set node %s as alive: %v", message.Nodename, message.Alive) diff --git a/store/etcdv3/meta/ephemeral.go b/store/etcdv3/meta/ephemeral.go index f5537a77c..8d6d5bcd6 100644 --- a/store/etcdv3/meta/ephemeral.go +++ b/store/etcdv3/meta/ephemeral.go @@ -16,7 +16,7 @@ import ( func (e *ETCD) StartEphemeral(ctx context.Context, path string, heartbeat time.Duration) (<-chan struct{}, func(), error) { lease, err := e.cliv3.Grant(ctx, int64(heartbeat/time.Second)) if err != nil { - return nil, nil, errors.WithStack(err) + return nil, nil, err } switch tx, err := e.cliv3.Txn(ctx). @@ -24,7 +24,7 @@ func (e *ETCD) StartEphemeral(ctx context.Context, path string, heartbeat time.D Then(clientv3.OpPut(path, "", clientv3.WithLease(lease.ID))). Commit(); { case err != nil: - return nil, nil, errors.WithStack(err) + return nil, nil, err case !tx.Succeeded: return nil, nil, errors.Wrap(types.ErrKeyExists, path) } @@ -47,7 +47,7 @@ func (e *ETCD) StartEphemeral(ctx context.Context, path string, heartbeat time.D ctx, cancel := context.WithTimeout(context.TODO(), time.Minute) defer cancel() if _, err := e.cliv3.Revoke(ctx, lease.ID); err != nil { - log.Errorf(ctx, "[StartEphemeral] revoke %d with %s failed: %v", lease.ID, path, err) + log.Errorf(ctx, err, "[StartEphemeral] revoke %d with %s failed: %v", lease.ID, path, err) } }() @@ -55,7 +55,7 @@ func (e *ETCD) StartEphemeral(ctx context.Context, path string, heartbeat time.D select { case <-tick.C: if _, err := e.cliv3.KeepAliveOnce(ctx, lease.ID); err != nil { - log.Errorf(ctx, "[StartEphemeral] keepalive %d with %s failed: %v", lease.ID, path, err) + log.Errorf(ctx, err, "[StartEphemeral] keepalive %d with %s failed: %v", lease.ID, path, err) return } case <-ctx.Done(): diff --git a/store/etcdv3/meta/etcd.go b/store/etcdv3/meta/etcd.go index 862a44d11..c99ebb7eb 100644 --- a/store/etcdv3/meta/etcd.go +++ b/store/etcdv3/meta/etcd.go @@ -63,7 +63,7 @@ func NewETCD(config types.EtcdConfig, t *testing.T) (*ETCD, error) { case t != nil: embededETCD := embedded.NewCluster(t, config.Prefix) cliv3 = embededETCD.RandClient() - log.Info("[Mercury] use embedded cluster") + log.Info(nil, "[Mercury] use embedded cluster") //nolint default: if config.Ca != "" && config.Key != "" && config.Cert != "" { tlsInfo := transport.TLSInfo{ @@ -415,7 +415,7 @@ func (e *ETCD) revokeLease(ctx context.Context, leaseID clientv3.LeaseID) { return } if _, err := e.cliv3.Revoke(ctx, leaseID); err != nil { - log.Errorf(ctx, "[etcd revoke lease error] %v", err) + log.Errorf(ctx, err, "[etcd revoke lease error] %v", err) } } diff --git a/store/etcdv3/node.go b/store/etcdv3/node.go index b8c560601..a55bb6657 100644 --- a/store/etcdv3/node.go +++ b/store/etcdv3/node.go @@ -107,7 +107,7 @@ func (m *Mercury) UpdateNodes(ctx context.Context, nodes ...*types.Node) error { for _, node := range nodes { bytes, err := json.Marshal(node) if err != nil { - return errors.WithStack(err) + return err } d := string(bytes) data[fmt.Sprintf(nodeInfoKey, node.Name)] = d @@ -180,7 +180,7 @@ func (m *Mercury) NodeStatusStream(ctx context.Context) chan *types.NodeStatus { ch := make(chan *types.NodeStatus) _ = m.pool.Invoke(func() { defer func() { - log.Info("[NodeStatusStream] close NodeStatusStream channel") + log.Info(ctx, "[NodeStatusStream] close NodeStatusStream channel") close(ch) }() @@ -188,7 +188,7 @@ func (m *Mercury) NodeStatusStream(ctx context.Context) chan *types.NodeStatus { for resp := range m.Watch(ctx, nodeStatusPrefix, clientv3.WithPrefix()) { if resp.Err() != nil { if !resp.Canceled { - log.Errorf(ctx, "[NodeStatusStream] watch failed %v", resp.Err()) + log.Errorf(ctx, resp.Err(), "[NodeStatusStream] watch failed %v", resp.Err()) } return } @@ -318,7 +318,7 @@ func (m *Mercury) doGetNodes(ctx context.Context, kvs []*mvccpb.KeyValue, labels _ = m.pool.Invoke(func() { defer wg.Done() if _, err := m.GetNodeStatus(ctx, node.Name); err != nil && !errors.Is(err, types.ErrBadCount) { - log.Errorf(ctx, "[doGetNodes] failed to get node status of %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodes] failed to get node status of %v, err: %v", node.Name, err) } else { node.Available = err == nil } @@ -329,7 +329,7 @@ func (m *Mercury) doGetNodes(ctx context.Context, kvs []*mvccpb.KeyValue, labels // update engine if client, err := m.makeClient(ctx, node); err != nil { - log.Errorf(ctx, "[doGetNodes] failed to make client for %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodes] failed to make client for %v, err: %v", node.Name, err) } else { node.Engine = client } diff --git a/store/etcdv3/processing.go b/store/etcdv3/processing.go index 7314ddc0b..a9bdf52e0 100644 --- a/store/etcdv3/processing.go +++ b/store/etcdv3/processing.go @@ -47,7 +47,7 @@ func (m *Mercury) doLoadProcessing(ctx context.Context, appname, entryname strin nodename := parts[len(parts)-2] count, err := strconv.Atoi(string(ev.Value)) if err != nil { - log.Errorf(ctx, "[doLoadProcessing] Load processing status failed %v", err) + log.Errorf(ctx, err, "[doLoadProcessing] Load processing status failed %v", err) continue } if _, ok := nodesCount[nodename]; !ok { diff --git a/store/etcdv3/service.go b/store/etcdv3/service.go index de48e48fe..e006a1ae5 100644 --- a/store/etcdv3/service.go +++ b/store/etcdv3/service.go @@ -48,7 +48,7 @@ func (m *Mercury) ServiceStatusStream(ctx context.Context) (chan []string, error resp, err := m.Get(ctx, fmt.Sprintf(serviceStatusKey, ""), clientv3.WithPrefix()) if err != nil { - log.Errorf(ctx, "[ServiceStatusStream] failed to get current services: %v", err) + log.Errorf(ctx, err, "[ServiceStatusStream] failed to get current services: %v", err) return } eps := endpoints{} @@ -60,7 +60,7 @@ func (m *Mercury) ServiceStatusStream(ctx context.Context) (chan []string, error for resp := range watchChan { if resp.Err() != nil { if !resp.Canceled { - log.Errorf(ctx, "[ServiceStatusStream] watch failed %v", resp.Err()) + log.Errorf(ctx, err, "[ServiceStatusStream] watch failed %v", resp.Err()) } return } diff --git a/store/etcdv3/workload.go b/store/etcdv3/workload.go index 6889ae536..3205a9f41 100644 --- a/store/etcdv3/workload.go +++ b/store/etcdv3/workload.go @@ -144,7 +144,7 @@ func (m *Mercury) WorkloadStatusStream(ctx context.Context, appname, entrypoint, ch := make(chan *types.WorkloadStatus) _ = m.pool.Invoke(func() { defer func() { - log.Info("[WorkloadStatusStream] close WorkloadStatus channel") + log.Info(ctx, "[WorkloadStatusStream] close WorkloadStatus channel") close(ch) }() @@ -152,7 +152,7 @@ func (m *Mercury) WorkloadStatusStream(ctx context.Context, appname, entrypoint, for resp := range m.Watch(ctx, statusKey, clientv3.WithPrefix()) { if resp.Err() != nil { if !resp.Canceled { - log.Errorf(ctx, "[WorkloadStatusStream] watch failed %v", resp.Err()) + log.Errorf(ctx, resp.Err(), "[WorkloadStatusStream] watch failed %v", resp.Err()) } return } @@ -201,7 +201,7 @@ func (m *Mercury) doGetWorkloads(ctx context.Context, keys []string) (workloads for _, kv := range kvs { workload := &types.Workload{} if err = json.Unmarshal(kv.Value, workload); err != nil { - log.Errorf(ctx, "[doGetWorkloads] failed to unmarshal %v, err: %v", string(kv.Key), err) + log.Errorf(ctx, err, "[doGetWorkloads] failed to unmarshal %v, err: %v", string(kv.Key), err) return } workloads = append(workloads, workload) @@ -249,7 +249,7 @@ func (m *Mercury) bindWorkloadsAdditions(ctx context.Context, workloads []*types status := &types.StatusMeta{} if err := json.Unmarshal(kv.Value, &status); err != nil { log.Warnf(ctx, "[bindWorkloadsAdditions] unmarshal %s status data failed %v", workload.ID, err) - log.Errorf(ctx, "[bindWorkloadsAdditions] status raw: %s", kv.Value) + log.Errorf(ctx, err, "[bindWorkloadsAdditions] status raw: %s", kv.Value) continue } workloads[index].StatusMeta = status diff --git a/store/redis/ephemeral.go b/store/redis/ephemeral.go index 546d0c3b2..1c88de1b8 100644 --- a/store/redis/ephemeral.go +++ b/store/redis/ephemeral.go @@ -17,7 +17,7 @@ var ephemeralValue = "__aaron__" func (r *Rediaron) StartEphemeral(ctx context.Context, path string, heartbeat time.Duration) (<-chan struct{}, func(), error) { set, err := r.cli.SetNX(ctx, path, ephemeralValue, heartbeat).Result() if err != nil { - return nil, nil, errors.WithStack(err) + return nil, nil, err } if !set { return nil, nil, errors.Wrap(types.ErrKeyExists, path) @@ -59,7 +59,7 @@ func (r *Rediaron) revokeEphemeral(path string) { ctx, cancel := context.WithTimeout(context.TODO(), time.Second) defer cancel() if _, err := r.cli.Del(ctx, path).Result(); err != nil { - log.Errorf(nil, "[refreshEphemeral] revoke with %s failed: %v", path, err) //nolint + log.Errorf(nil, err, "[refreshEphemeral] revoke with %s failed: %v", path, err) //nolint } } diff --git a/store/redis/node.go b/store/redis/node.go index e7ad26658..8b088f3bb 100644 --- a/store/redis/node.go +++ b/store/redis/node.go @@ -106,7 +106,7 @@ func (r *Rediaron) UpdateNodes(ctx context.Context, nodes ...*types.Node) error for _, node := range nodes { bytes, err := json.Marshal(node) if err != nil { - return errors.WithStack(err) + return err } d := string(bytes) data[fmt.Sprintf(nodeInfoKey, node.Name)] = d @@ -116,7 +116,7 @@ func (r *Rediaron) UpdateNodes(ctx context.Context, nodes ...*types.Node) error addIfNotEmpty(fmt.Sprintf(nodeKeyKey, node.Name), node.Key) enginefactory.RemoveEngineFromCache(node.Endpoint, node.Ca, node.Cert, node.Key) } - return errors.WithStack(r.BatchPut(ctx, data)) + return r.BatchPut(ctx, data) } // SetNodeStatus sets status for a node, value will expire after ttl seconds @@ -171,7 +171,7 @@ func (r *Rediaron) NodeStatusStream(ctx context.Context) chan *types.NodeStatus ch := make(chan *types.NodeStatus) _ = r.pool.Invoke(func() { defer func() { - log.Info("[NodeStatusStream] close NodeStatusStream channel") + log.Info(ctx, "[NodeStatusStream] close NodeStatusStream channel") //nolint close(ch) }() @@ -301,7 +301,7 @@ func (r *Rediaron) doGetNodes(ctx context.Context, kvs map[string]string, labels _ = r.pool.Invoke(func() { defer wg.Done() if _, err := r.GetNodeStatus(ctx, node.Name); err != nil && !errors.Is(err, types.ErrBadCount) { - log.Errorf(ctx, "[doGetNodes] failed to get node status of %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodes] failed to get node status of %v, err: %v", node.Name, err) } else { node.Available = err == nil } @@ -312,7 +312,7 @@ func (r *Rediaron) doGetNodes(ctx context.Context, kvs map[string]string, labels nodeChan <- node if client, err := r.makeClient(ctx, node); err != nil { - log.Errorf(ctx, "[doGetNodes] failed to make client for %v, err: %v", node.Name, err) + log.Errorf(ctx, err, "[doGetNodes] failed to make client for %v, err: %v", node.Name, err) } else { node.Engine = client } diff --git a/store/redis/processing.go b/store/redis/processing.go index bf7ea8a81..daa2226f1 100644 --- a/store/redis/processing.go +++ b/store/redis/processing.go @@ -43,7 +43,7 @@ func (r *Rediaron) doLoadProcessing(ctx context.Context, appname, entryname stri nodename := parts[len(parts)-2] count, err := strconv.Atoi(v) if err != nil { - log.Errorf(ctx, "[doLoadProcessing] Load processing status failed %v", err) + log.Errorf(ctx, err, "[doLoadProcessing] Load processing status failed %v", err) continue } if _, ok := nodesCount[nodename]; !ok { @@ -53,6 +53,6 @@ func (r *Rediaron) doLoadProcessing(ctx context.Context, appname, entryname stri nodesCount[nodename] += count } - log.Debug(ctx, "[doLoadProcessing] Processing result: %+v", nodesCount) + log.Debug(ctx, "[doLoadProcessing] Processing result: %+v", nodesCount) //nolint return nodesCount, nil } diff --git a/store/redis/service.go b/store/redis/service.go index 6a52f0731..5e39d6182 100644 --- a/store/redis/service.go +++ b/store/redis/service.go @@ -45,7 +45,7 @@ func (r *Rediaron) ServiceStatusStream(ctx context.Context) (chan []string, erro data, err := r.getByKeyPattern(ctx, key, 0) if err != nil { - log.Errorf(ctx, "[ServiceStatusStream] failed to get current services: %v", err) + log.Errorf(ctx, err, "[ServiceStatusStream] failed to get current services: %v", err) return } eps := endpoints{} diff --git a/store/redis/workload.go b/store/redis/workload.go index dc2dae93f..e80f477c3 100644 --- a/store/redis/workload.go +++ b/store/redis/workload.go @@ -141,7 +141,7 @@ func (r *Rediaron) WorkloadStatusStream(ctx context.Context, appname, entrypoint ch := make(chan *types.WorkloadStatus) _ = r.pool.Invoke(func() { defer func() { - log.Info("[WorkloadStatusStream] close WorkloadStatus channel") + log.Info(ctx, "[WorkloadStatusStream] close WorkloadStatus channel") close(ch) }() @@ -193,7 +193,7 @@ func (r *Rediaron) doGetWorkloads(ctx context.Context, keys []string) ([]*types. for k, v := range data { workload := &types.Workload{} if err = json.Unmarshal([]byte(v), workload); err != nil { - log.Errorf(ctx, "[doGetWorkloads] failed to unmarshal %v, err: %v", k, err) + log.Errorf(ctx, err, "[doGetWorkloads] failed to unmarshal %v, err: %v", k, err) return nil, err } workloads = append(workloads, workload) @@ -241,7 +241,7 @@ func (r *Rediaron) bindWorkloadsAdditions(ctx context.Context, workloads []*type status := &types.StatusMeta{} if err := json.Unmarshal([]byte(v), &status); err != nil { log.Warnf(ctx, "[bindWorkloadsAdditions] unmarshal %s status data failed %v", workload.ID, err) - log.Errorf(ctx, "[bindWorkloadsAdditions] status raw: %s", v) + log.Errorf(ctx, err, "[bindWorkloadsAdditions] status raw: %s", v) continue } workloads[index].StatusMeta = status diff --git a/strategy/average.go b/strategy/average.go index 3de6b90db..8d7d53517 100644 --- a/strategy/average.go +++ b/strategy/average.go @@ -7,8 +7,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) // AveragePlan deploy workload each node @@ -22,13 +20,13 @@ func AveragePlan(ctx context.Context, infos []Info, need, total, limit int) (map limit = scheduleInfosLength } if scheduleInfosLength < limit { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("node len %d < limit, cannot alloc an average node plan", scheduleInfosLength))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("node len %d < limit, cannot alloc an average node plan", scheduleInfosLength)) } sort.Slice(infos, func(i, j int) bool { return infos[i].Capacity > infos[j].Capacity }) p := sort.Search(scheduleInfosLength, func(i int) bool { return infos[i].Capacity < need }) if p == 0 { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientCap, "insufficient nodes, at least 1 needed")) + return nil, types.NewDetailedErr(types.ErrInsufficientCap, "insufficient nodes, at least 1 needed") } if p < limit { return nil, types.NewDetailedErr(types.ErrInsufficientRes, fmt.Sprintf("not enough nodes with capacity of %d, require %d nodes", need, limit)) diff --git a/strategy/communism.go b/strategy/communism.go index 844b5b180..6a79c5d40 100644 --- a/strategy/communism.go +++ b/strategy/communism.go @@ -60,8 +60,8 @@ func newInfoHeap(infos []Info, limit int) heap.Interface { // 部署完 N 个后全局尽可能平均 func CommunismPlan(ctx context.Context, infos []Info, need, total, limit int) (map[string]int, error) { if total < need { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("need: %d, available: %d", need, total))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("need: %d, available: %d", need, total)) } deploy := map[string]int{} diff --git a/strategy/fill.go b/strategy/fill.go index afb310c6a..b7b2a33d5 100644 --- a/strategy/fill.go +++ b/strategy/fill.go @@ -8,8 +8,6 @@ import ( "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" "github.com/projecteru2/core/utils" - - "github.com/pkg/errors" ) // FillPlan deploy workload each node @@ -23,8 +21,8 @@ func FillPlan(ctx context.Context, infos []Info, need, _, limit int) (_ map[stri limit = scheduleInfosLength } if scheduleInfosLength < limit { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("node len %d cannot alloc a fill node plan", scheduleInfosLength))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("node len %d cannot alloc a fill node plan", scheduleInfosLength)) } sort.Slice(infos, func(i, j int) bool { if infos[i].Count == infos[j].Count { @@ -40,12 +38,12 @@ func FillPlan(ctx context.Context, infos []Info, need, _, limit int) (_ map[stri limit-- if limit == 0 { if toDeploy == 0 { - err = errors.WithStack(types.ErrAlreadyFilled) + err = types.ErrAlreadyFilled } return deployMap, err } } } - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("not enough nodes that can fill up to %d instances, require %d nodes", need, limit))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("not enough nodes that can fill up to %d instances, require %d nodes", need, limit)) } diff --git a/strategy/global.go b/strategy/global.go index 1e6fb8c42..d18cd73b8 100644 --- a/strategy/global.go +++ b/strategy/global.go @@ -5,8 +5,6 @@ import ( "context" "fmt" - "github.com/pkg/errors" - "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" ) @@ -46,8 +44,8 @@ func (r *infoHeapForGlobalStrategy) Pop() interface{} { // 尽量使得资源消耗平均 func GlobalPlan(ctx context.Context, infos []Info, need, total, _ int) (map[string]int, error) { if total < need { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("need: %d, available: %d", need, total))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("need: %d, available: %d", need, total)) } strategyInfos := make([]Info, len(infos)) copy(strategyInfos, infos) @@ -63,8 +61,8 @@ func GlobalPlan(ctx context.Context, infos []Info, need, total, _ int) (map[stri for i := 0; i < need; i++ { if infoHeap.Len() == 0 { - return nil, errors.WithStack(types.NewDetailedErr(types.ErrInsufficientRes, - fmt.Sprintf("need: %d, available: %d", need, i))) + return nil, types.NewDetailedErr(types.ErrInsufficientRes, + fmt.Sprintf("need: %d, available: %d", need, i)) } infoWithMinUsage := heap.Pop(infoHeap).(Info) deployMap[infoWithMinUsage.Nodename]++ diff --git a/strategy/strategy.go b/strategy/strategy.go index f93134f4d..6ccd68f14 100644 --- a/strategy/strategy.go +++ b/strategy/strategy.go @@ -3,8 +3,6 @@ package strategy import ( "context" - "github.com/pkg/errors" - "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" ) @@ -36,10 +34,10 @@ type strategyFunc = func(_ context.Context, _ []Info, need, total, limit int) (m func Deploy(ctx context.Context, strategy string, count, nodesLimit int, strategyInfos []Info, total int) (map[string]int, error) { deployMethod, ok := Plans[strategy] if !ok { - return nil, errors.WithStack(types.ErrBadDeployStrategy) + return nil, types.ErrBadDeployStrategy } if count <= 0 { - return nil, errors.WithStack(types.ErrBadCount) + return nil, types.ErrBadCount } log.Debugf(ctx, "[strategy.Deploy] infos %+v, need %d, total %d, limit %d", strategyInfos, count, total, nodesLimit) diff --git a/types/node.go b/types/node.go index edead55b5..7a3e21d84 100644 --- a/types/node.go +++ b/types/node.go @@ -5,8 +5,6 @@ import ( "encoding/json" "github.com/mitchellh/mapstructure" - "github.com/pkg/errors" - engine "github.com/projecteru2/core/engine" ) @@ -24,7 +22,7 @@ type NodeMeta struct { // DeepCopy returns a deepcopy of nodemeta func (n NodeMeta) DeepCopy() (nn NodeMeta, err error) { - return nn, errors.WithStack(mapstructure.Decode(n, &nn)) + return nn, mapstructure.Decode(n, &nn) } // NodeResource for resource @@ -54,12 +52,12 @@ func (n *Node) Info(ctx context.Context) (err error) { if err != nil { n.Available = false n.NodeInfo = err.Error() - return errors.WithStack(err) + return err } bs, err := json.Marshal(info) if err != nil { n.NodeInfo = err.Error() - return errors.WithStack(err) + return err } n.NodeInfo = string(bs) return nil diff --git a/types/options.go b/types/options.go index e6d70e3ef..ad45970c1 100644 --- a/types/options.go +++ b/types/options.go @@ -3,8 +3,6 @@ package types import ( "fmt" "io" - - "github.com/pkg/errors" ) // TODO should validate options @@ -58,16 +56,16 @@ func (o DeployOptions) GetProcessing(nodename string) *Processing { // Validate checks options func (o *DeployOptions) Validate() error { if o.Name == "" { - return errors.WithStack(ErrEmptyAppName) + return ErrEmptyAppName } if o.Podname == "" { - return errors.WithStack(ErrEmptyPodName) + return ErrEmptyPodName } if o.Image == "" { - return errors.WithStack(ErrEmptyImage) + return ErrEmptyImage } if o.Count == 0 { - return errors.WithStack(ErrEmptyCount) + return ErrEmptyCount } return o.Entrypoint.Validate() } @@ -80,7 +78,7 @@ type CopyOptions struct { // Validate checks options func (o *CopyOptions) Validate() error { if len(o.Targets) == 0 { - return errors.WithStack(ErrNoFilesToCopy) + return ErrNoFilesToCopy } return nil } @@ -126,10 +124,10 @@ type SendOptions struct { // Validate checks options func (o *SendOptions) Validate() error { if len(o.IDs) == 0 { - return errors.WithStack(ErrNoWorkloadIDs) + return ErrNoWorkloadIDs } if len(o.Files) == 0 { - return errors.WithStack(ErrNoFilesToSend) + return ErrNoFilesToSend } for i, file := range o.Files { if file.UID == 0 && file.GID == 0 && file.Mode == 0 { @@ -163,7 +161,7 @@ type ReplaceOptions struct { // to keep the original behavior, no check here. func (o *ReplaceOptions) Validate() error { if o.DeployOptions.Name == "" { - return errors.WithStack(ErrEmptyAppName) + return ErrEmptyAppName } return o.DeployOptions.Entrypoint.Validate() } @@ -198,13 +196,13 @@ type AddNodeOptions struct { // Validate checks options func (o *AddNodeOptions) Validate() error { if o.Nodename == "" { - return errors.WithStack(ErrEmptyNodeName) + return ErrEmptyNodeName } if o.Podname == "" { - return errors.WithStack(ErrEmptyPodName) + return ErrEmptyPodName } if o.Endpoint == "" { - return errors.WithStack(ErrEmptyNodeEndpoint) + return ErrEmptyNodeEndpoint } return nil } @@ -226,7 +224,7 @@ type SetNodeOptions struct { // Validate checks options func (o *SetNodeOptions) Validate() error { if o.Nodename == "" { - return errors.WithStack(ErrEmptyNodeName) + return ErrEmptyNodeName } return nil } @@ -244,7 +242,7 @@ type ImageOptions struct { // Validate checks the options func (o *ImageOptions) Validate() error { if o.Podname == "" { - return errors.WithStack(ErrEmptyPodName) + return ErrEmptyPodName } return nil } diff --git a/types/specs.go b/types/specs.go index d355f4158..b6b01db04 100644 --- a/types/specs.go +++ b/types/specs.go @@ -2,8 +2,6 @@ package types import ( "strings" - - "github.com/pkg/errors" ) // Hook define hooks @@ -38,10 +36,10 @@ type Entrypoint struct { // Validate checks entrypoint's name func (e *Entrypoint) Validate() error { if e.Name == "" { - return errors.WithStack(ErrEmptyEntrypointName) + return ErrEmptyEntrypointName } if strings.Contains(e.Name, "_") { - return errors.WithStack(ErrUnderlineInEntrypointName) + return ErrUnderlineInEntrypointName } return nil } diff --git a/types/workload.go b/types/workload.go index d4f796e2b..2aefe561e 100644 --- a/types/workload.go +++ b/types/workload.go @@ -55,41 +55,41 @@ type Workload struct { // Inspect a workload func (c *Workload) Inspect(ctx context.Context) (*enginetypes.VirtualizationInfo, error) { if c.Engine == nil { - return nil, errors.WithStack(ErrNilEngine) + return nil, ErrNilEngine } info, err := c.Engine.VirtualizationInspect(ctx, c.ID) - return info, errors.WithStack(err) + return info, err } // Start a workload func (c *Workload) Start(ctx context.Context) error { if c.Engine == nil { - return errors.WithStack(ErrNilEngine) + return ErrNilEngine } - return errors.WithStack(c.Engine.VirtualizationStart(ctx, c.ID)) + return c.Engine.VirtualizationStart(ctx, c.ID) } // Stop a workload func (c *Workload) Stop(ctx context.Context, force bool) error { if c.Engine == nil { - return errors.WithStack(ErrNilEngine) + return ErrNilEngine } gracefulTimeout := time.Duration(-1) // -1 indicates use engine default timeout if force { gracefulTimeout = 0 // don't wait, kill -15 && kill -9 } - return errors.WithStack(c.Engine.VirtualizationStop(ctx, c.ID, gracefulTimeout)) + return c.Engine.VirtualizationStop(ctx, c.ID, gracefulTimeout) } // Remove a workload func (c *Workload) Remove(ctx context.Context, force bool) (err error) { if c.Engine == nil { - return errors.WithStack(ErrNilEngine) + return ErrNilEngine } if err = c.Engine.VirtualizationRemove(ctx, c.ID, true, force); errors.Is(err, ErrWorkloadNotExists) { err = nil } - return errors.WithStack(err) + return err } // WorkloadStatus store deploy status diff --git a/utils/transaction.go b/utils/transaction.go index 60a1db219..2978fb863 100644 --- a/utils/transaction.go +++ b/utils/transaction.go @@ -25,7 +25,7 @@ func Txn(ctx context.Context, cond contextFunc, then contextFunc, rollback func( return } if rollback == nil { - log.Error("[txn] txn failed but no rollback function") + log.Error(ctx, nil, "[txn] txn failed but no rollback function") return } diff --git a/utils/utils.go b/utils/utils.go index 9db01004c..fc2a940e1 100644 --- a/utils/utils.go +++ b/utils/utils.go @@ -18,8 +18,6 @@ import ( "github.com/projecteru2/core/cluster" "github.com/projecteru2/core/log" "github.com/projecteru2/core/types" - - "github.com/pkg/errors" ) const ( @@ -51,7 +49,7 @@ func Tail(path string) string { // GetGitRepoName return git repo name func GetGitRepoName(url string) (string, error) { if !(strings.Contains(url, "git@") || strings.Contains(url, "gitlab@") || strings.Contains(url, "https://")) || !strings.HasSuffix(url, ".git") { - return "", errors.WithStack(types.NewDetailedErr(types.ErrInvalidGitURL, url)) + return "", types.NewDetailedErr(types.ErrInvalidGitURL, url) } return strings.TrimSuffix(Tail(url), ".git"), nil @@ -98,7 +96,7 @@ func ParseWorkloadName(workloadName string) (string, string, string, error) { if length >= 3 { return strings.Join(splits[0:length-2], "_"), splits[length-2], splits[length-1], nil } - return "", "", "", errors.WithStack(types.NewDetailedErr(types.ErrInvalidWorkloadName, workloadName)) + return "", "", "", types.NewDetailedErr(types.ErrInvalidWorkloadName, workloadName) } // MakePublishInfo generate publish info @@ -142,7 +140,7 @@ func DecodePublishInfo(info map[string]string) map[string][]string { func EncodeMetaInLabel(ctx context.Context, meta *types.LabelMeta) string { data, err := json.Marshal(meta) if err != nil { - log.Errorf(ctx, "[EncodeMetaInLabel] Encode meta failed %v", err) + log.Errorf(ctx, err, "[EncodeMetaInLabel] Encode meta failed %v", err) return "" } return string(data) @@ -154,7 +152,7 @@ func DecodeMetaInLabel(ctx context.Context, labels map[string]string) *types.Lab metastr, ok := labels[cluster.LabelMeta] if ok { if err := json.Unmarshal([]byte(metastr), meta); err != nil { - log.Errorf(ctx, "[DecodeMetaInLabel] Decode failed %v", err) + log.Errorf(ctx, err, "[DecodeMetaInLabel] Decode failed %v", err) } } return meta @@ -184,13 +182,13 @@ func CleanStatsdMetrics(k string) string { func TempFile(stream io.ReadCloser) (string, error) { f, err := os.CreateTemp(os.TempDir(), "") if err != nil { - return "", errors.WithStack(err) + return "", err } defer f.Close() defer stream.Close() _, err = io.Copy(f, stream) - return f.Name(), errors.WithStack(err) + return f.Name(), err } // Round for float64 to int @@ -214,7 +212,7 @@ func EnsureReaderClosed(ctx context.Context, stream io.ReadCloser) { return } if _, err := io.Copy(io.Discard, stream); err != nil { - log.Errorf(ctx, "[EnsureReaderClosed] empty stream failed %v", err) + log.Errorf(ctx, err, "[EnsureReaderClosed] empty stream failed %v", err) } _ = stream.Close() } diff --git a/wal/hydro.go b/wal/hydro.go index c5ffb24cd..29542640e 100644 --- a/wal/hydro.go +++ b/wal/hydro.go @@ -51,13 +51,13 @@ func (h *Hydro) Recover(ctx context.Context) { for { scanEntry, ok := <-ch if !ok { - log.Errorf(nil, "[Recover] closed ch") // nolint + log.Errorf(nil, nil, "[Recover] closed ch") // nolint break } event, err := h.decodeEvent(scanEntry) if err != nil { - log.Errorf(nil, "[Recover] decode event error: %v", err) // nolint + log.Errorf(nil, err, "[Recover] decode event error: %v", err) // nolint continue } events = append(events, event) @@ -66,12 +66,12 @@ func (h *Hydro) Recover(ctx context.Context) { for _, event := range events { handler, ok := h.getEventHandler(event.Type) if !ok { - log.Errorf(nil, "[Recover] no such event handler for %s", event.Type) // nolint + log.Errorf(nil, nil, "[Recover] no such event handler for %s", event.Type) // nolint continue } if err := h.recover(ctx, handler, event); err != nil { - log.Errorf(nil, "[Recover] handle event %d (%s) failed: %v", event.ID, event.Type, err) // nolint + log.Errorf(nil, err, "[Recover] handle event %d (%s) failed: %v", event.ID, event.Type, err) // nolint continue } }