diff --git a/cmd/agent/collector/init.go b/cmd/agent/collector/init.go
deleted file mode 100755
index c87b2bd0f7a38cfcda6745507d065a8b9d73c490..0000000000000000000000000000000000000000
--- a/cmd/agent/collector/init.go
+++ /dev/null
@@ -1 +0,0 @@
-package collector
\ No newline at end of file
diff --git a/cmd/agent/collector/psutil_collector.go b/cmd/agent/collector/psutil_collector.go
index 0cfef19579ad74b785da3e5898897778935eb9e4..25df0227b55c7d482227bd090652654efa9aaa34 100644
--- a/cmd/agent/collector/psutil_collector.go
+++ b/cmd/agent/collector/psutil_collector.go
@@ -5,8 +5,9 @@ import (
 	"strconv"
 	"sync"
 
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/utils"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
+	"github.com/pkg/errors"
+
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	"github.com/shirou/gopsutil/cpu"
 	"github.com/shirou/gopsutil/disk"
 	"github.com/shirou/gopsutil/process"
@@ -17,13 +18,13 @@ import (
 var Psutildata *PsutilCollector
 
 type PsutilCollector struct {
-	Host_1             *utils.Host
-	Processes_1        []*utils.Process
-	Netconnections_1   []*utils.Netconnection
-	NetIOcounters_1    []*utils.NetIOcounter
+	Host_1             *global.Host
+	Processes_1        []*global.Process
+	Netconnections_1   []*global.Netconnection
+	NetIOcounters_1    []*global.NetIOcounter
 	AddrInterfaceMap_1 map[string][]string
-	Disks_1            []*utils.Disk
-	Cpus_1             []*utils.Cpu
+	Disks_1            []*global.Disk
+	Cpus_1             []*global.Cpu
 }
 
 func CreatePsutilCollector() *PsutilCollector {
@@ -33,16 +34,12 @@ func CreatePsutilCollector() *PsutilCollector {
 func (pc *PsutilCollector) Collect_host_data() error {
 	hostinit, err := host.Info()
 	if err != nil {
-		// err = errors.New(err.Error())
-		logger.Error(err.Error())
-		return err
+		return errors.New(err.Error())
 	}
 
-	m_u_bytes, err := utils.FileReadBytes(utils.Agentuuid_filepath)
+	m_u_bytes, err := global.FileReadBytes(global.Agentuuid_filepath)
 	if err != nil {
-		// err = errors.New(err.Error())
-		logger.Error(err.Error())
-		return err
+		return errors.Wrap(err, " ")
 	}
 	type machineuuid struct {
 		Agentuuid string `json:"agent_uuid"`
@@ -50,7 +47,7 @@ func (pc *PsutilCollector) Collect_host_data() error {
 	m_u_struct := &machineuuid{}
 	json.Unmarshal(m_u_bytes, m_u_struct)
 
-	pc.Host_1 = &utils.Host{
+	pc.Host_1 = &global.Host{
 		Hostname:             hostinit.Hostname,
 		Uptime:               hostinit.Uptime,
 		BootTime:             hostinit.BootTime,
@@ -65,7 +62,6 @@ func (pc *PsutilCollector) Collect_host_data() error {
 		VirtualizationRole:   hostinit.VirtualizationRole,
 		MachineUUID:          m_u_struct.Agentuuid,
 	}
-
 	return nil
 }
 
@@ -86,16 +82,14 @@ func (pc *PsutilCollector) Collect_process_instant_data() error {
 
 	processes_0, err := process.Processes()
 	if err != nil {
-		// err = errors.Errorf("failed to get processes: %s", err)
-		logger.Error("failed to get processes: %s", err)
-		return err
+		return errors.Errorf("failed to get processes: %s", err)
 	}
 
 	for _, p0 := range processes_0 {
 		wg.Add(1)
 		go func(_p0 *process.Process, _lock *sync.Mutex) {
 			defer wg.Done()
-			p1 := &utils.Process{}
+			p1 := &global.Process{}
 
 			p1.Pid = _p0.Pid
 
@@ -118,7 +112,7 @@ func (pc *PsutilCollector) Collect_process_instant_data() error {
 
 				for k, v := range thread {
 					p1.Tids = append(p1.Tids, k)
-					t := &utils.Thread{
+					t := &global.Thread{
 						Tid:       k,
 						Tgid:      tgid,
 						CPU:       v.CPU,
@@ -172,7 +166,7 @@ func (pc *PsutilCollector) Collect_process_instant_data() error {
 
 			connections, err := _p0.Connections()
 			Echo_process_err("connections", err, _p0.Pid)
-			p1.Connections = utils.GopsutilNetMeta2TopoNetMeta(connections)
+			p1.Connections = global.GopsutilNetMeta2TopoNetMeta(connections)
 
 			p1.NetIOCounters, err = _p0.NetIOCounters(true)
 			Echo_process_err("netiocounters", err, _p0.Pid)
@@ -228,13 +222,11 @@ func (pc *PsutilCollector) Collect_process_instant_data() error {
 func (pc *PsutilCollector) Collect_netconnection_all_data() error {
 	connections, err := net.Connections("all")
 	if err != nil {
-		// err = errors.Errorf("failed to run net.connections: %s", err)
-		logger.Error("failed to run net.connections: %s", err)
-		return err
+		return errors.Errorf("failed to run net.connections: %s", err)
 	}
 
 	for _, c := range connections {
-		c1 := &utils.Netconnection{}
+		c1 := &global.Netconnection{}
 		// if c.Status == "NONE" {
 		// 	continue
 		// }
@@ -257,16 +249,13 @@ func (pc *PsutilCollector) Collect_netconnection_all_data() error {
 		c1.Pid = c.Pid
 		pc.Netconnections_1 = append(pc.Netconnections_1, c1)
 	}
-
 	return nil
 }
 
 func (pc *PsutilCollector) Collect_addrInterfaceMap_data() error {
 	interfaces, err := net.Interfaces()
 	if err != nil {
-		// err = errors.Errorf("failed to run net.interfaces: %s", err)
-		logger.Error("failed to run net.interfaces: %s", err)
-		return err
+		return errors.Errorf("failed to run net.interfaces: %s", err)
 	}
 
 	addrinterfacemap := map[string][]string{}
@@ -277,20 +266,17 @@ func (pc *PsutilCollector) Collect_addrInterfaceMap_data() error {
 	}
 
 	pc.AddrInterfaceMap_1 = addrinterfacemap
-
 	return nil
 }
 
 func (pc *PsutilCollector) Collect_interfaces_io_data() error {
 	iocounters, err := net.IOCounters(true)
 	if err != nil {
-		// err = errors.Errorf("failed to collect interfaces io: %s", err.Error())
-		logger.Error("failed to collect interfaces io: %s", err.Error())
-		return err
+		return errors.Errorf("failed to collect interfaces io: %s", err.Error())
 	}
 
 	for _, iocounter := range iocounters {
-		interfaceIO := &utils.NetIOcounter{}
+		interfaceIO := &global.NetIOcounter{}
 
 		interfaceIO.Name = iocounter.Name
 		interfaceIO.BytesRecv = iocounter.BytesRecv
@@ -306,68 +292,55 @@ func (pc *PsutilCollector) Collect_interfaces_io_data() error {
 
 		pc.NetIOcounters_1 = append(pc.NetIOcounters_1, interfaceIO)
 	}
-
 	return nil
 }
 
 func (pc *PsutilCollector) Collect_disk_data() error {
 	partitions, err := disk.Partitions(false)
 	if err != nil {
-		// err = errors.Errorf("failed to collect disk partitions: %s", err.Error())
-		logger.Error("failed to collect disk partitions: %s", err.Error())
-		return err
+		return errors.Errorf("failed to collect disk partitions: %s", err.Error())
 	}
 
 	for _, partition := range partitions {
-		disk_entity := &utils.Disk{}
+		disk_entity := &global.Disk{}
 		disk_entity.Partition = partition
 
 		iocounter, err := disk.IOCounters([]string{disk_entity.Partition.Device}...)
 		if err != nil {
-			// err = errors.Errorf("failed to collect disk io: %s", err.Error())
-			logger.Error("failed to collect disk io: %s", err.Error())
-			return err
+			return errors.Errorf("failed to collect disk io: %s", err.Error())
 		}
 
 		disk_entity.IOcounter = iocounter[partition.Device]
 
 		usage, err := disk.Usage(partition.Mountpoint)
 		if err != nil {
-			// err = errors.Errorf("failed to collect disk usage: %s", err.Error())
-			logger.Error("failed to collect disk usage: %s", err.Error())
-			return err
+			return errors.Errorf("failed to collect disk usage: %s", err.Error())
 		}
 
 		disk_entity.Usage = *usage
 
 		pc.Disks_1 = append(pc.Disks_1, disk_entity)
 	}
-
 	return nil
 }
 
 func (pc *PsutilCollector) Collect_cpu_data() error {
 	cputimes, err := cpu.Times(true)
 	if err != nil {
-		// err = errors.Errorf("failed to collect cpu times: %s", err.Error())
-		logger.Error("failed to collect cpu times: %s", err.Error())
-		return err
+		return errors.Errorf("failed to collect cpu times: %s", err.Error())
 	}
 
 	for i, cputime := range cputimes {
-		cpu_entity := &utils.Cpu{}
+		cpu_entity := &global.Cpu{}
 		cpu_entity.Time = cputime
 
 		cpuinfos, err := cpu.Info()
 		if err != nil {
-			// err = errors.Errorf("failed to collect cpu info: %s", err.Error())
-			logger.Error("failed to collect cpu info: %s", err.Error())
-			return err
+			return errors.Errorf("failed to collect cpu info: %s", err.Error())
 		}
 		cpu_entity.Info = cpuinfos[i]
 
 		pc.Cpus_1 = append(pc.Cpus_1, cpu_entity)
 	}
-
 	return nil
 }
diff --git a/cmd/agent/utils/client_data_meta.go b/cmd/agent/global/client_data_meta.go
similarity index 99%
rename from cmd/agent/utils/client_data_meta.go
rename to cmd/agent/global/client_data_meta.go
index a945196533c0c725ed10bffd65b0ab692ffe8b57..3ffb46cfa0d53c1051be8588652805639da06cfc 100755
--- a/cmd/agent/utils/client_data_meta.go
+++ b/cmd/agent/global/client_data_meta.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 import (
 	"github.com/shirou/gopsutil/cpu"
diff --git a/cmd/agent/global/close.go b/cmd/agent/global/close.go
new file mode 100644
index 0000000000000000000000000000000000000000..b6728a3df753d0d09f92997d5828f3919d27fe97
--- /dev/null
+++ b/cmd/agent/global/close.go
@@ -0,0 +1,5 @@
+package global
+
+func Close() {
+
+}
\ No newline at end of file
diff --git a/cmd/agent/utils/error.go b/cmd/agent/global/error.go
similarity index 94%
rename from cmd/agent/utils/error.go
rename to cmd/agent/global/error.go
index 0a21f2ffd7f4e9d8bda1d05949e5a0c0f0feebad..8983def62272accfcde760288f2bd83f5307e064 100755
--- a/cmd/agent/utils/error.go
+++ b/cmd/agent/global/error.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 import "runtime"
 
diff --git a/cmd/agent/utils/file.go b/cmd/agent/global/file.go
similarity index 97%
rename from cmd/agent/utils/file.go
rename to cmd/agent/global/file.go
index 9573784b0f3fec61ae92a10ee825719cb96fd9ff..940f6b4e5ed50cf501ac2596b066a685d584c882 100755
--- a/cmd/agent/utils/file.go
+++ b/cmd/agent/global/file.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 import (
 	"io"
diff --git a/cmd/agent/global/global.go b/cmd/agent/global/global.go
new file mode 100644
index 0000000000000000000000000000000000000000..76d6bd24777d467b333daaa7680133307d05829e
--- /dev/null
+++ b/cmd/agent/global/global.go
@@ -0,0 +1,11 @@
+package global
+
+import (
+	"context"
+
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/resourcemanage"
+)
+
+var ERManager *resourcemanage.ErrorReleaseManagement
+
+var RootCtx = context.Background()
\ No newline at end of file
diff --git a/cmd/agent/utils/gopsutilMeta2TopoMeta.go b/cmd/agent/global/gopsutilMeta2TopoMeta.go
similarity index 97%
rename from cmd/agent/utils/gopsutilMeta2TopoMeta.go
rename to cmd/agent/global/gopsutilMeta2TopoMeta.go
index e979522c02f3f4b5b259e05d279bd8edcfe70ad3..f782ca02f227dd90f85543c8aa027a33defaf62d 100644
--- a/cmd/agent/utils/gopsutilMeta2TopoMeta.go
+++ b/cmd/agent/global/gopsutilMeta2TopoMeta.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 import (
 	"strconv"
diff --git a/cmd/agent/utils/init.go b/cmd/agent/global/init.go
similarity index 83%
rename from cmd/agent/utils/init.go
rename to cmd/agent/global/init.go
index 7b5522375f1f7b4cbe3cb4c0abb7f97c425525aa..bdfbc574a5eb88284ff12dec7a754cd780686fda 100755
--- a/cmd/agent/utils/init.go
+++ b/cmd/agent/global/init.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 const (
 	Agentuuid_filepath = "/opt/PilotGo/agent/.pilotgo-agent.data"
diff --git a/cmd/agent/utils/size.go b/cmd/agent/global/size.go
similarity index 98%
rename from cmd/agent/utils/size.go
rename to cmd/agent/global/size.go
index 05b31d962b777fc6e252710a562d48d1e5742a5e..36849e5b72e07fd7dfc81347c884a0ab7457f2b2 100755
--- a/cmd/agent/utils/size.go
+++ b/cmd/agent/global/size.go
@@ -1,4 +1,4 @@
-package utils
+package global
 
 import "reflect"
 
diff --git a/cmd/agent/handler/router.go b/cmd/agent/handler/router.go
deleted file mode 100755
index 9b67516e6d090b086b90fd129ad0e9cd86fcb31c..0000000000000000000000000000000000000000
--- a/cmd/agent/handler/router.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package handler
-
-import (
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
-	"github.com/gin-gonic/gin"
-)
-
-func InitWebServer() {
-	go func() {
-		engine := gin.Default()
-		gin.SetMode(gin.ReleaseMode)
-		InitRouter(engine)
-
-		if conf.Config().Topo.Https_enabled {
-			err := engine.RunTLS(conf.Config().Topo.Agent_addr, conf.Config().Topo.Public_certificate, conf.Config().Topo.Private_key)
-			if err != nil {
-				logger.Fatal("failed to run web server: %+v", err.Error())
-			}
-		} else {
-			err := engine.Run(conf.Config().Topo.Agent_addr)
-			if err != nil {
-				logger.Fatal("failed to run web server: %+v", err.Error())
-			}
-		}
-	}()
-}
-
-func InitRouter(router *gin.Engine) {
-	api := router.Group("/plugin/topology/api")
-	{
-		api.GET("/health", HealthCheckHandle)
-		api.GET("/rawdata", RawMetricDataHandle)
-		api.GET("/container_list", ContainerListHandle)
-	}
-}
diff --git a/cmd/agent/main.go b/cmd/agent/main.go
index c7126ddb81831faaaa541ca5c2bbfc37e0c9eed5..2c395cc64b93b3c607a08a9ebd96e4056f7cb880 100755
--- a/cmd/agent/main.go
+++ b/cmd/agent/main.go
@@ -6,9 +6,11 @@ import (
 	"runtime"
 
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/handler"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/resourcemanage"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/service"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/signal"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/signal"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/webserver"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	"gitee.com/openeuler/PilotGo/sdk/logger"
 )
 
@@ -16,18 +18,20 @@ func main() {
 	numCPUs := runtime.NumCPU()
 	runtime.GOMAXPROCS(numCPUs)
 
-	InitLogger()
+	if err := logger.Init(conf.Config().Logopts); err != nil {
+		fmt.Printf("logger init failed, please check the config file: %s", err.Error())
+		os.Exit(1)
+	}
+
+	ermanager, err := resourcemanage.CreateErrorReleaseManager(global.RootCtx, global.Close)
+	if err != nil {
+		logger.Fatal(err.Error())
+	}
+	global.ERManager = ermanager
 
-	handler.InitWebServer()
+	webserver.InitWebServer()
 
 	service.SendHeartbeat()
 
 	signal.SignalMonitoring()
-}
-
-func InitLogger() {
-	if err := logger.Init(conf.Config().Logopts); err != nil {
-		fmt.Printf("logger init failed, please check the config file: %s", err)
-		os.Exit(1)
-	}
-}
+}
\ No newline at end of file
diff --git a/cmd/agent/resourcemanage/resourcemanage.go b/cmd/agent/resourcemanage/resourcemanage.go
new file mode 100644
index 0000000000000000000000000000000000000000..2740076fd5e1bf2ab53af24eb9f84b595175e2fe
--- /dev/null
+++ b/cmd/agent/resourcemanage/resourcemanage.go
@@ -0,0 +1,189 @@
+package resourcemanage
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"time"
+
+	"gitee.com/openeuler/PilotGo/sdk/logger"
+	"github.com/pkg/errors"
+)
+
+const (
+	green string = "\x1b[97;104m"
+	reset string = "\x1b[0m"
+)
+
+type ResourceReleaseFunction func()
+
+type FinalError struct {
+	Err error
+
+	Module string
+
+	Severity string
+
+	Cancel context.CancelFunc
+
+	PrintStack bool
+
+	ExitAfterPrint bool
+}
+
+func (e *FinalError) Error() string {
+	return fmt.Sprintf("%+v", e.Err)
+}
+
+type ErrorReleaseManagement struct {
+	ErrChan chan error
+
+	errEndChan chan struct{}
+
+	// cancelCtx: 控制 ERManager 本身资源释放的上下文，子上下文：errortransmit
+	cancelCtx  context.Context
+	cancelFunc context.CancelFunc
+
+	// GoCancelCtx: ERManager 用于控制项目指定goroutine优雅退出的上下文
+	GoCancelCtx  context.Context
+	GoCancelFunc context.CancelFunc
+
+	Wg sync.WaitGroup
+
+	// releaseFunc: 项目整体资源释放回调函数
+	releaseFunc ResourceReleaseFunction
+}
+
+func CreateErrorReleaseManager(_ctx context.Context, _releaseFunc ResourceReleaseFunction) (*ErrorReleaseManagement, error) {
+	if _ctx == nil || _releaseFunc == nil {
+		return nil, fmt.Errorf("context or closeFunc is nil")
+	}
+
+	ErrorM := &ErrorReleaseManagement{
+		ErrChan:     make(chan error, 20),
+		errEndChan:  make(chan struct{}),
+		releaseFunc: _releaseFunc,
+	}
+	ErrorM.cancelCtx, ErrorM.cancelFunc = context.WithCancel(_ctx)
+	ErrorM.GoCancelCtx, ErrorM.GoCancelFunc = context.WithCancel(_ctx)
+
+	go ErrorM.errorFactory()
+
+	return ErrorM, nil
+}
+
+func (erm *ErrorReleaseManagement) errorFactory() {
+	for {
+		select {
+		case <-erm.errEndChan:
+			logger.Info("error management stopped")
+			return
+		case _error := <-erm.ErrChan:
+			_terror, ok := _error.(*FinalError)
+			if !ok {
+				logger.Error("plain error: %s", _error.Error())
+				continue
+			}
+
+			if _terror.Err != nil {
+				if !_terror.PrintStack && !_terror.ExitAfterPrint {
+					erm.output(_terror)
+				} else if _terror.PrintStack && !_terror.ExitAfterPrint {
+					logger.ErrorStack(erm.errorStackMsg(_terror.Module), _terror.Err)
+				} else if !_terror.PrintStack && _terror.ExitAfterPrint {
+					erm.output(_terror)
+					_terror.Cancel()
+				} else if _terror.PrintStack && _terror.ExitAfterPrint {
+					logger.ErrorStack(erm.errorStackMsg(_terror.Module), _terror.Err)
+					_terror.Cancel()
+				}
+			}
+		}
+	}
+}
+
+func (erm *ErrorReleaseManagement) ResourceRelease() {
+	erm.releaseFunc()
+
+	erm.GoCancelFunc()
+
+	erm.Wg.Wait()
+
+	close(erm.errEndChan)
+	close(erm.ErrChan)
+
+	time.Sleep(100 * time.Millisecond)
+}
+
+/*
+@severity: debug info warn error
+
+@err:	最终生成的error
+
+@exit_after_print: 打印完异常日志后是否结束主程序
+
+@print_stack: 是否打印异常日志错误链，打印错误链时默认severity为error
+*/
+func (erm *ErrorReleaseManagement) ErrorTransmit(_module, _severity string, _err error, _exit_after_print, _print_stack bool) {
+	if _exit_after_print {
+		ctx, cancel := context.WithCancel(erm.cancelCtx)
+		erm.ErrChan <- &FinalError{
+			Err:            _err,
+			Cancel:         cancel,
+			Module:         _module,
+			Severity:       _severity,
+			PrintStack:     _print_stack,
+			ExitAfterPrint: _exit_after_print,
+		}
+		<-ctx.Done()
+		erm.ResourceRelease()
+		os.Exit(1)
+	}
+
+	erm.ErrChan <- &FinalError{
+		Err:            _err,
+		Cancel:         nil,
+		Module:         _module,
+		Severity:       _severity,
+		PrintStack:     _print_stack,
+		ExitAfterPrint: _exit_after_print,
+	}
+}
+
+func (erm *ErrorReleaseManagement) logFormat(_err error, _module string) string {
+	if len(_module) > 10 {
+		_module = _module[:10]
+	}
+	log := fmt.Sprintf("%v %s %-10s %s %+v",
+		time.Now().Format("2006-01-02 15:04:05"),
+		green, _module, reset,
+		_err.Error(),
+	)
+	return log
+}
+
+func (erm *ErrorReleaseManagement) errorStackMsg(_module string) string {
+	if len(_module) > 10 {
+		_module = _module[:10]
+	}
+	return fmt.Sprintf("%v %s %-10s %s",
+		time.Now().Format("2006-01-02 15:04:05"),
+		green, _module, reset,
+	)
+}
+
+func (erm *ErrorReleaseManagement) output(_err *FinalError) {
+	switch _err.Severity {
+	case "debug":
+		logger.Debug(erm.logFormat(errors.Cause(_err.Err), _err.Module))
+	case "info":
+		logger.Info(erm.logFormat(errors.Cause(_err.Err), _err.Module))
+	case "warn":
+		logger.Warn(erm.logFormat(errors.Cause(_err.Err), _err.Module))
+	case "error":
+		logger.Error(erm.logFormat(errors.Cause(_err.Err), _err.Module))
+	default:
+		logger.Error(erm.logFormat(errors.Cause(_err.Err), _err.Module))
+	}
+}
diff --git a/cmd/agent/service/container/container.go b/cmd/agent/service/container/container.go
index 1c4900c160a029da5267bc91c997c658722b26b3..a1f339cc3104f93d671df460d7e9bfdfa7cd98f3 100644
--- a/cmd/agent/service/container/container.go
+++ b/cmd/agent/service/container/container.go
@@ -5,22 +5,22 @@ import (
 	"fmt"
 	"strings"
 
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/utils"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	docker "github.com/fsouza/go-dockerclient"
 	"github.com/pkg/errors"
 )
 
 func ContainerList() ([]docker.APIContainers, error) {
 	if DOCKERD_PORT == "" {
-		bytes, err := utils.FileReadBytes(DOCKER_CONFIG)
+		bytes, err := global.FileReadBytes(DOCKER_CONFIG)
 		if err != nil {
-			return nil, errors.Wrap(err, " **errstack**0")
+			return nil, errors.Wrap(err, " ")
 		}
 		var daemoncontent struct {
 			Hosts []string `json:"hosts"`
 		}
 		if err := json.Unmarshal(bytes, &daemoncontent); err != nil {
-			return nil, errors.Errorf("%s **errstack**0", err.Error())
+			return nil, errors.New(err.Error())
 		}
 
 		for _, host := range daemoncontent.Hosts {
@@ -32,17 +32,17 @@ func ContainerList() ([]docker.APIContainers, error) {
 	}
 
 	if DOCKERD_PORT == "" {
-		return nil, errors.Errorf("no dockerd port found **errstack**0")
+		return nil, errors.New("no dockerd port found")
 	}
 
 	client, err := docker.NewClient(fmt.Sprintf("tcp://127.0.0.1:%s", DOCKERD_PORT))
 	if err != nil {
-		return nil, errors.Errorf("%s **errstack**0", err.Error())
+		return nil, errors.New(err.Error())
 	}
 
 	containers, err := client.ListContainers(docker.ListContainersOptions{All: true})
 	if err != nil {
-		return nil, errors.Errorf("%s **errstack**0", err.Error())
+		return nil, errors.New(err.Error())
 	}
 
 	return containers, nil
diff --git a/cmd/agent/service/dataCollector.go b/cmd/agent/service/dataCollector.go
index 93a47a0429689eb2e069ecaaf21a56dae49c771a..633247e4bfe683dcebda3e19a8500cc10766c172 100755
--- a/cmd/agent/service/dataCollector.go
+++ b/cmd/agent/service/dataCollector.go
@@ -7,12 +7,11 @@ import (
 
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/collector"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/utils"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	"github.com/pkg/errors"
 )
 
-func DataCollectorService() (utils.Data_collector, error) {
+func DataCollectorService() (global.Data_collector, error) {
 	datasource := conf.Config().Topo.Datasource
 	cost_time := []string{}
 	var wg sync.WaitGroup
@@ -27,7 +26,7 @@ func DataCollectorService() (utils.Data_collector, error) {
 		collector.Psutildata = collector.CreatePsutilCollector()
 		err := collector.Psutildata.Collect_host_data()
 		if err != nil {
-			err = errors.Wrap(err, "**2")
+			err = errors.Wrap(err, " ")
 			return nil, err
 		}
 
@@ -105,7 +104,7 @@ func DataCollectorService() (utils.Data_collector, error) {
 
 		for data := range ch {
 			if data.Err != nil {
-				err = errors.Wrap(err, "**2")
+				err = errors.Wrap(err, " ")
 				return nil, err
 			}
 			cost_time = append(cost_time, data.Time)
@@ -117,11 +116,10 @@ func DataCollectorService() (utils.Data_collector, error) {
 
 		wg.Wait()
 
-		logger.Debug("==========collect==========")
+		global.ERManager.ErrorTransmit("service", "debug", errors.New("==========collect=========="), false, false)
 		for _, t := range cost_time {
-			logger.Debug(t)
+			global.ERManager.ErrorTransmit("service", "debug", errors.New(t), false, false)
 		}
-		logger.Debug("============================")
 
 		return collector.Psutildata, nil
 	default:
diff --git a/cmd/agent/service/heartbeat.go b/cmd/agent/service/heartbeat.go
index 03e0fed09ea4431d4ce22ad45d0731a3a685b2ce..2e2dcde4fd85139c73c18465d4f12f6408486d73 100644
--- a/cmd/agent/service/heartbeat.go
+++ b/cmd/agent/service/heartbeat.go
@@ -7,8 +7,7 @@ import (
 	"time"
 
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/utils"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	"gitee.com/openeuler/PilotGo/sdk/utils/httputils"
 	"github.com/pkg/errors"
 )
@@ -21,7 +20,7 @@ func SendHeartbeat() {
 			err := sendHeartbeat(agent_addr)
 			if err != nil {
 				err = errors.Wrap(err, " ")
-				logger.Error(err.Error())
+				global.ERManager.ErrorTransmit("service", "error", err, false, false)
 			}
 			time.Sleep(time.Duration(conf.Config().Topo.Heartbeat) * time.Second)
 		}
@@ -29,10 +28,9 @@ func SendHeartbeat() {
 }
 
 func sendHeartbeat(addr string) error {
-	m_u_bytes, err := utils.FileReadBytes(utils.Agentuuid_filepath)
+	m_u_bytes, err := global.FileReadBytes(global.Agentuuid_filepath)
 	if err != nil {
-		// err = errors.New(err.Error())
-		logger.Error(err.Error())
+		err = errors.Wrap(err, " ")
 		return err
 	}
 	type machineuuid struct {
diff --git a/cmd/agent/signal/signalMonitor.go b/cmd/agent/signal/signalMonitor.go
index ddb233baed3d857dce416fad776601d4096fecdc..8911bcaa398ee1d6e9cd4e6ecc63b452417ba029 100644
--- a/cmd/agent/signal/signalMonitor.go
+++ b/cmd/agent/signal/signalMonitor.go
@@ -5,7 +5,8 @@ import (
 	"os/signal"
 	"syscall"
 
-	"gitee.com/openeuler/PilotGo/sdk/logger"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
+	"github.com/pkg/errors"
 )
 
 func SignalMonitoring() {
@@ -15,10 +16,10 @@ func SignalMonitoring() {
 	for s := range ch {
 		switch s {
 		case syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:
-			// actions before exit
+			global.ERManager.ResourceRelease()
 			os.Exit(1)
 		default:
-			logger.Warn("unknown signal-> %s\n", s.String())
+			global.ERManager.ErrorTransmit("signal", "warn", errors.Errorf("unknown signal-> %s\n", s.String()), false, false)
 		}
 	}
 }
diff --git a/cmd/agent/webserver/engine.go b/cmd/agent/webserver/engine.go
new file mode 100755
index 0000000000000000000000000000000000000000..414ea69bf3ba1c4baaa28a7e86520aa559fe4f6c
--- /dev/null
+++ b/cmd/agent/webserver/engine.go
@@ -0,0 +1,70 @@
+package webserver
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+func InitWebServer() {
+	engine := gin.Default()
+	gin.SetMode(gin.ReleaseMode)
+	InitRouter(engine)
+
+	web := &http.Server{
+		Addr:    conf.Config().Topo.Agent_addr,
+		Handler: engine,
+	}
+
+	global.ERManager.Wg.Add(1)
+	go func() {
+		if conf.Config().Topo.Https_enabled {
+			if err := web.ListenAndServeTLS(conf.Config().Topo.Public_certificate, conf.Config().Topo.Private_key); err != nil {
+				if strings.Contains(err.Error(), "Server closed") {
+					global.ERManager.ErrorTransmit("webserver", "info", errors.New(err.Error()), false, false)
+					return
+				}
+				global.ERManager.ErrorTransmit("webserver", "error", errors.Errorf("failed to run web server: %+v", err.Error()), true, false)
+			}
+		}
+		if err := web.ListenAndServe(); err != nil {
+			if strings.Contains(err.Error(), "Server closed") {
+				global.ERManager.ErrorTransmit("webserver", "info", errors.New(err.Error()), false, false)
+				return
+			}
+			global.ERManager.ErrorTransmit("webserver", "error", errors.Errorf("failed to run web server: %+v", err.Error()), true, false)
+		}
+	}()
+
+	go func() {
+		defer global.ERManager.Wg.Done()
+
+		<-global.ERManager.GoCancelCtx.Done()
+
+		global.ERManager.ErrorTransmit("webserver", "info", errors.New("shutting down web server..."), false, false)
+
+		ctx, cancel := context.WithTimeout(global.RootCtx, 1*time.Second)
+		defer cancel()
+
+		if err := web.Shutdown(ctx); err != nil {
+			global.ERManager.ErrorTransmit("webserver", "error", errors.Errorf("web server shutdown error: %s", err.Error()), false, false)
+		} else {
+			global.ERManager.ErrorTransmit("webserver", "info", errors.New("web server stopped"), false, false)
+		}
+	}()
+}
+
+func InitRouter(router *gin.Engine) {
+	api := router.Group("/plugin/topology/api")
+	{
+		api.GET("/health", HealthCheckHandle)
+		api.GET("/rawdata", RawMetricDataHandle)
+		api.GET("/container_list", ContainerListHandle)
+	}
+}
diff --git a/cmd/agent/handler/httphandler.go b/cmd/agent/webserver/httphandle.go
similarity index 81%
rename from cmd/agent/handler/httphandler.go
rename to cmd/agent/webserver/httphandle.go
index 6acde3694c3df2ea12e5bf0f1faf35cb8b9bac38..7f7f4ad7401ef7f45266c68313e7b39aa8098a64 100755
--- a/cmd/agent/handler/httphandler.go
+++ b/cmd/agent/webserver/httphandle.go
@@ -1,4 +1,4 @@
-package handler
+package webserver
 
 import (
 	"fmt"
@@ -6,23 +6,19 @@ import (
 	"strings"
 
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/conf"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/global"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/service"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/agent/service/container"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
 	"gitee.com/openeuler/PilotGo/sdk/response"
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
 )
 
 func RawMetricDataHandle(ctx *gin.Context) {
-	// ttcode
-	fmt.Printf(">>>req.header: %+v\n", ctx.Request.Header)
-
 	// 验证topo server请求来源
 	if ctx.RemoteIP() != strings.Split(conf.Config().Topo.Server_addr, ":")[0] {
 		err := errors.Errorf("unknow client request from %s: %s", ctx.RemoteIP(), ctx.Request.URL)
-		logger.Error(err.Error())
-		// errors.EORE(err)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, false)
 		ctx.JSON(http.StatusBadRequest, gin.H{
 			"code":  -1,
 			"error": err.Error(),
@@ -33,9 +29,8 @@ func RawMetricDataHandle(ctx *gin.Context) {
 
 	data, err := service.DataCollectorService()
 	if err != nil {
-		err = errors.Wrap(err, "**2")
-		logger.ErrorStack("", err)
-		// errors.EORE(err)
+		err = errors.Wrap(err, " ")
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		ctx.JSON(http.StatusBadRequest, gin.H{
 			"code":  -1,
 			"error": fmt.Errorf("(Raw_metric_data->DataCollectorService: %s)", err),
@@ -55,8 +50,7 @@ func HealthCheckHandle(ctx *gin.Context) {
 	// 验证topo server请求来源
 	if ctx.RemoteIP() != strings.Split(conf.Config().Topo.Server_addr, ":")[0] {
 		err := errors.Errorf("unknow client request from %s: %s", ctx.RemoteIP(), ctx.Request.URL)
-		logger.Error(err.Error())
-		// errors.EORE(err)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, false)
 		ctx.JSON(http.StatusBadRequest, gin.H{
 			"code":  -1,
 			"error": err.Error(),
@@ -78,8 +72,7 @@ func ContainerListHandle(ctx *gin.Context) {
 	// 验证topo server请求来源
 	if ctx.RemoteIP() != strings.Split(conf.Config().Topo.Server_addr, ":")[0] {
 		err := errors.Errorf("unknow client request from %s: %s", ctx.RemoteIP(), ctx.Request.URL)
-		logger.Error(err.Error())
-		// errors.EORE(err)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, false)
 		ctx.JSON(http.StatusBadRequest, gin.H{
 			"code":  -1,
 			"error": err.Error(),
@@ -91,7 +84,7 @@ func ContainerListHandle(ctx *gin.Context) {
 	containers, err := container.ContainerList()
 	if err != nil {
 		err = errors.Wrap(err, "")
-		logger.ErrorStack("", err)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 	}