diff --git a/.gitignore b/.gitignore
index 89582288ea4f73e2cce6bc0fc5b7768c434fcd22..b5e44172e575f9ea2ea4a2285bae6952f2738d31 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,8 +17,8 @@ PilotGo-plugin-topology-agent
 PilotGo-plugin-topology-server
 
 # static files
-cmd/server/handler/frontendResource/assets/
-cmd/server/handler/frontendResource/index.html
+cmd/server/webserver/frontendResource/assets/
+cmd/server/webserver/frontendResource/index.html
 web/node_modules
 web/dist/
 web/src/assets/*.json
diff --git a/cmd/server/agentmanager/PAgentMap.go b/cmd/server/agentmanager/PAgentMap.go
index bbc6f3196c2b0eb7ea89a6ca90ee1def31d07647..df3499a42652f0d3fd23f89241125807027e2c9b 100644
--- a/cmd/server/agentmanager/PAgentMap.go
+++ b/cmd/server/agentmanager/PAgentMap.go
@@ -53,7 +53,7 @@ func (am *AgentManager) InitMachineList() {
 
 	if pluginclient.Global_Client == nil {
 		err := errors.New("Global_Client is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, true, true)
 		return
 	}
 
@@ -62,7 +62,7 @@ func (am *AgentManager) InitMachineList() {
 	machine_list, err := pluginclient.Global_Client.MachineList()
 	if err != nil {
 		err = errors.Errorf(err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, true, true)
 	}
 
 	for _, m := range machine_list {
@@ -80,7 +80,7 @@ func (am *AgentManager) UpdateMachineList() {
 	machine_list, err := pluginclient.Global_Client.MachineList()
 	if err != nil {
 		err = errors.Errorf(err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, true, true)
 	}
 
 	am.PAgentMap.Range(func(key, value interface{}) bool {
diff --git a/cmd/server/agentmanager/agent.go b/cmd/server/agentmanager/agent.go
index 982cc21554d9b98e88cb1e8da44a850d68bf3455..1d04c5b441c3267b953f0cda62accfe78ce2aa0f 100644
--- a/cmd/server/agentmanager/agent.go
+++ b/cmd/server/agentmanager/agent.go
@@ -60,14 +60,14 @@ func (am *AgentManager) GetAgent_P(uuid string) *Agent {
 func (am *AgentManager) DeleteAgent_P(uuid string) {
 	if _, ok := am.PAgentMap.LoadAndDelete(uuid); !ok {
 		err := errors.Errorf("delete unknown agent:%s", uuid)
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, false, true)
 	}
 }
 
 func (am *AgentManager) AddAgent_T(a *Agent) {
 	if a == nil {
 		err := errors.Errorf("failed to add agent_t: %+v", a)
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, false, true)
 		return
 	}
 	am.TAgentMap.Store(a.UUID, a)
@@ -89,6 +89,6 @@ func (am *AgentManager) GetAgent_T(uuid string) *Agent {
 func (am *AgentManager) DeleteAgent_T(uuid string) {
 	if _, ok := am.TAgentMap.LoadAndDelete(uuid); !ok {
 		err := errors.Errorf("delete unknown agent:%s", uuid)
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("agentmanager", "error", err, false, true)
 	}
 }
diff --git a/cmd/server/db/dbmanager.go b/cmd/server/db/dbmanager.go
index 9aa09aaedd9da08e7716d75f738a5d590e936ddc..d77bb81da9b4d037af0e1cdbf707ad6e3bc84493 100644
--- a/cmd/server/db/dbmanager.go
+++ b/cmd/server/db/dbmanager.go
@@ -20,7 +20,7 @@ func InitDB() {
 		ClearGraphData(conf.Global_Config.Neo4j.Retention)
 	} else {
 		err := errors.New("do not save graph data")
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("db", "warn", err, false, false)
 	}
 
 	initRedis()
@@ -42,7 +42,7 @@ func initGraphDB() {
 
 	default:
 		err := errors.Errorf("unknown database in topo_server.yaml: %s", conf.Global_Config.Topo.GraphDB)
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	if graphmanager.Global_GraphDB != nil {
@@ -83,7 +83,7 @@ func initInflux() {
 func ClearGraphData(retention int64) {
 	if graphmanager.Global_GraphDB == nil {
 		err := errors.New("global_graphdb is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 		return
 	}
 
diff --git a/cmd/server/db/graphmanager/neo4j.go b/cmd/server/db/graphmanager/neo4j.go
index 696f226550cebfa4a54b6a8f52eda7761d96615a..10940076f4631fbb9b90afca2a1d422e7129b841 100644
--- a/cmd/server/db/graphmanager/neo4j.go
+++ b/cmd/server/db/graphmanager/neo4j.go
@@ -37,7 +37,7 @@ func Neo4jInit(url, user, pass, db string) *Neo4jClient {
 	})
 	if err != nil {
 		err := errors.Errorf("create neo4j driver failed: %s", err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	global.Global_neo4j_driver = driver
@@ -260,17 +260,17 @@ func (n *Neo4jClient) ClearExpiredData(retention int64) {
 	result, err := session.Run(cqlIN, params)
 	if err != nil {
 		err = errors.Errorf("ClearExpiredData failed: %s, %s", err.Error(), cqlIN)
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("db", "warn", err, false, false)
 		return
 	}
 
 	summary, err := result.Consume()
 	if err != nil {
 		err = errors.Errorf("failed to consume ClearExpiredData result: %s, %s", err.Error(), cqlIN)
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("db", "warn", err, false, false)
 		return
 	}
 
 	err = errors.Errorf("delete %d nodes", summary.Counters().NodesDeleted())
-	global.ERManager.ErrorTransmit("debug", err, false, false)
+	global.ERManager.ErrorTransmit("db", "debug", err, false, false)
 }
diff --git a/cmd/server/db/mysqlmanager/mysql.go b/cmd/server/db/mysqlmanager/mysql.go
index 13b7c76928781db2786104f71eeea8fae0661eaf..100c18f43e3fb3455d9a9c59f5efd76cbdd417a1 100644
--- a/cmd/server/db/mysqlmanager/mysql.go
+++ b/cmd/server/db/mysqlmanager/mysql.go
@@ -30,7 +30,7 @@ func MysqldbInit(conf *conf.MysqlConf) *MysqlClient {
 	err := ensureDatabase(conf)
 	if err != nil {
 		err = errors.Wrapf(err, " ")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	m := &MysqlClient{
@@ -50,13 +50,13 @@ func MysqldbInit(conf *conf.MysqlConf) *MysqlClient {
 	})
 	if err != nil {
 		err := errors.Errorf("mysql connect failed: %s(url: %s)", err.Error(), url)
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	var db *sql.DB
 	if db, err = m.db.DB(); err != nil {
 		err = errors.Errorf("get mysql sql.db failed: %s", err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	db.SetMaxIdleConns(10)
@@ -66,7 +66,7 @@ func MysqldbInit(conf *conf.MysqlConf) *MysqlClient {
 	err = m.db.AutoMigrate(&Topo_configuration_DB{})
 	if err != nil {
 		err = errors.Errorf("mysql automigrate failed: %s", err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	return m
diff --git a/cmd/server/db/redismanager/redis.go b/cmd/server/db/redismanager/redis.go
index e749eb214a860e5d8cf14084215abda61a190b96..c446b0edec33584fb31a54e2699726be32a0d1b8 100644
--- a/cmd/server/db/redismanager/redis.go
+++ b/cmd/server/db/redismanager/redis.go
@@ -61,7 +61,7 @@ func RedisInit(url, pass string, db int, dialTimeout time.Duration) *RedisClient
 	_, err := r.Client.Ping(timeoutCtx).Result()
 	if err != nil {
 		err = errors.Errorf("redis connection timeout: %s", err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 	}
 
 	return r
@@ -134,7 +134,7 @@ func (r *RedisClient) UpdateTopoRunningAgentList(uuids []string, updateonce bool
 
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 		return -1
 	}
 
@@ -149,7 +149,7 @@ func (r *RedisClient) UpdateTopoRunningAgentList(uuids []string, updateonce bool
 		agent_keys, err := r.Scan("heartbeat-topoagent*")
 		if err != nil {
 			err = errors.Wrap(err, " ")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("db", "error", err, false, true)
 			continue
 		}
 
@@ -161,7 +161,7 @@ func (r *RedisClient) UpdateTopoRunningAgentList(uuids []string, updateonce bool
 					v, err := r.Get(key, &AgentHeartbeat{})
 					if err != nil {
 						err = errors.Wrap(err, " ")
-						global.ERManager.ErrorTransmit("error", err, false, true)
+						global.ERManager.ErrorTransmit("db", "error", err, false, true)
 						return
 					}
 
@@ -196,7 +196,7 @@ func (r *RedisClient) UpdateTopoRunningAgentList(uuids []string, updateonce bool
 
 					if ok, err := global.IsIPandPORTValid(agentp.IP, agentmanager.Global_AgentManager.AgentPort); !ok {
 						err := errors.Errorf("%s:%s is unreachable (%s) %s", agentp.IP, agentmanager.Global_AgentManager.AgentPort, err.Error(), agentp.UUID)
-						global.ERManager.ErrorTransmit("warn", err, false, false)
+						global.ERManager.ErrorTransmit("db", "warn", err, false, false)
 						abort_reason = append(abort_reason, fmt.Sprintf("%s:ip||port不可达", agentvalue.UUID))
 						return
 					}
@@ -257,7 +257,7 @@ func (r *RedisClient) ActiveHeartbeatDetection(uuids []string) {
 			err = json.Unmarshal(resp.Body, &resp_body)
 			if err != nil {
 				err = errors.Errorf(err.Error())
-				global.ERManager.ErrorTransmit("error", err, false, true)
+				global.ERManager.ErrorTransmit("db", "error", err, false, true)
 				return
 			}
 
@@ -272,7 +272,7 @@ func (r *RedisClient) ActiveHeartbeatDetection(uuids []string) {
 			err = r.Set(key, value)
 			if err != nil {
 				err = errors.Wrap(err, " ")
-				global.ERManager.ErrorTransmit("error", err, false, true)
+				global.ERManager.ErrorTransmit("db", "error", err, false, true)
 				return
 			}
 		}
@@ -280,7 +280,7 @@ func (r *RedisClient) ActiveHeartbeatDetection(uuids []string) {
 
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("db", "error", err, true, true)
 		return
 	}
 
@@ -293,7 +293,7 @@ func (r *RedisClient) ActiveHeartbeatDetection(uuids []string) {
 
 				if ok, _ := global.IsIPandPORTValid(a.IP, agentmanager.Global_AgentManager.AgentPort); !ok {
 					// err := errors.Errorf("%s:%s is unreachable (%s) %s", a.IP, agentmanager.Topo.AgentPort, err.Error(), a.UUID)
-					// resourcemanage.ErrorTransmit("warn", err, false, false)
+					// resourcemanage.ErrorTransmit("db", "warn", err, false, false)
 					return
 				}
 
@@ -319,7 +319,7 @@ func (r *RedisClient) ActiveHeartbeatDetection(uuids []string) {
 
 			if ok, _ := global.IsIPandPORTValid(agent.IP, agentmanager.Global_AgentManager.AgentPort); !ok {
 				// err := errors.Errorf("%s:%s is unreachable (%s) %s", agent.IP, agentmanager.Topo.AgentPort, err.Error(), agent.UUID)
-				// resourcemanage.ErrorTransmit("warn", err, false, false)
+				// resourcemanage.ErrorTransmit("db", "warn", err, false, false)
 				return
 			}
 
diff --git a/cmd/server/generator/generator.go b/cmd/server/generator/generator.go
index 386fcf76751f4b656951aba89265331670ecd8a9..6cc006bcb1ea40ac9d8cb82144339f6325a9f9dd 100755
--- a/cmd/server/generator/generator.go
+++ b/cmd/server/generator/generator.go
@@ -15,7 +15,6 @@ import (
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/db/mysqlmanager"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/global"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/graph"
-	"gitee.com/openeuler/PilotGo/sdk/logger"
 	"gitee.com/openeuler/PilotGo/sdk/utils/httputils"
 	"github.com/mitchellh/mapstructure"
 	"github.com/pkg/errors"
@@ -84,7 +83,7 @@ func (t *TopoGenerator) ProcessingData(agentnum int) (*graph.Nodes, *graph.Edges
 
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("generator", "error", err, true, true)
 		return nil, nil, nil, nil
 	}
 
@@ -125,7 +124,8 @@ func (t *TopoGenerator) ProcessingData(agentnum int) (*graph.Nodes, *graph.Edges
 	atomic.StoreInt32(t.Factory.Return_Agent_node_count(), int32(0))
 
 	elapse := time.Since(start)
-	logger.Info("\033[32mtopo server 采集数据处理时间\033[0m: %v\n", elapse)
+	// logger.Info("topo server 采集数据处理时间[0m: %v\n", elapse)
+	global.ERManager.ErrorTransmit("generator", "info", errors.Errorf("采集数据处理时间: %v\n", elapse), false, false)
 
 	return nodes, edges, collect_errorlist, process_errorlist
 }
@@ -138,7 +138,7 @@ func (t *TopoGenerator) collectInstantData() []error {
 
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("generator", "error", err, true, true)
 		return nil
 	}
 
@@ -161,7 +161,8 @@ func (t *TopoGenerator) collectInstantData() []error {
 				agentmanager.Global_AgentManager.AddAgent_T(agent)
 
 				temp_elapse := time.Since(temp_start)
-				logger.Info("\033[32mtopo server 采集数据获取时间\033[0m: %s, %v, total\n", agent.UUID, temp_elapse)
+				// logger.Info("\033[32mtopo server 采集数据获取时间\033[0m: %s, %v, total\n", agent.UUID, temp_elapse)
+				global.ERManager.ErrorTransmit("generator", "info", errors.Errorf("采集数据获取时间: %s, %v, total\n", agent.UUID, temp_elapse), false, false)
 			}()
 
 			return true
@@ -171,8 +172,8 @@ func (t *TopoGenerator) collectInstantData() []error {
 	wg.Wait()
 
 	elapse := time.Since(start)
-	// fmt.Fprintf(agentmanager.Topo.Out, "\033[32mtopo server 采集数据获取时间\033[0m: %v\n", elapse)
-	logger.Info("\033[32mtopo server 采集数据获取时间\033[0m: %v\n", elapse)
+	// logger.Info("\033[32mtopo server 采集数据获取时间\033[0m: %v\n", elapse)
+	global.ERManager.ErrorTransmit("generator", "info", errors.Errorf("采集数据获取时间: %v\n", elapse), false, false)
 
 	if len(errorlist) != 0 {
 		return errorlist
@@ -194,7 +195,8 @@ func (t *TopoGenerator) getCollectDataFromTopoAgent(agent *agentmanager.Agent) e
 	reader := bytes.NewReader(resp.Body)
 	io.Copy(tmpfile, reader)
 	fileInfo, _ := tmpfile.Stat()
-	logger.Info("\033[32mtopo server 采集数据大小\033[0m: %s, %d kb\n", agent.UUID, fileInfo.Size()/1024)
+	// logger.Info("\033[32mtopo server 采集数据大小\033[0m: %s, %d kb\n", agent.UUID, fileInfo.Size()/1024)
+	global.ERManager.ErrorTransmit("generator", "info", errors.Errorf("采集数据大小: %s, %d kb\n", agent.UUID, fileInfo.Size()/1024), false, false)
 
 	if statuscode := resp.StatusCode; statuscode != 200 {
 		return errors.Errorf("%v, %s", resp.StatusCode, url)
diff --git a/cmd/server/generator/publicTopo.go b/cmd/server/generator/publicTopo.go
index 2af51ed0f626ec935721f6833128ac6054a7daa7..5b7bfd51df40aa795b154eb469a5bed1a1746ed3 100644
--- a/cmd/server/generator/publicTopo.go
+++ b/cmd/server/generator/publicTopo.go
@@ -85,7 +85,7 @@ func (p *PublicTopo) CreateNodeEntities(agent *agentmanager.Agent, nodes *graph.
 			nodes.Add(net_node)
 		} else {
 			err := errors.Errorf("syntax error: %s", net.Laddr)
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("generator", "error", err, false, true)
 		}
 	}
 
diff --git a/cmd/server/generator/utils/processMatch.go b/cmd/server/generator/utils/processMatch.go
index 699fa293aac72ab1fa10d91694764947cd9ae3f6..ac7bdd04f444c1a3b42adae2a32f6df5fc401b11 100755
--- a/cmd/server/generator/utils/processMatch.go
+++ b/cmd/server/generator/utils/processMatch.go
@@ -103,7 +103,7 @@ func ProcessMatching(agent *agentmanager.Agent, exename, cmdline, component stri
 		containers, err := ContainerList(agent)
 		if err != nil {
 			err = errors.Wrap(err, " ")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("generator", "error", err, false, true)
 			break
 		}
 
diff --git a/cmd/server/main.go b/cmd/server/main.go
index 5e8f08dd0904c238290c2cd0f0a51f5e87fdf8d6..a892245ce0fbb95160b32a42e486bf0e254c7026 100755
--- a/cmd/server/main.go
+++ b/cmd/server/main.go
@@ -6,7 +6,7 @@ import (
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/db"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/db/mysqlmanager"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/global"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/handler"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/webserver"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/logger"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/pluginclient"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/resourcemanage"
@@ -67,7 +67,7 @@ func main() {
 	/*
 		init web server
 	*/
-	handler.InitWebServer()
+	webserver.InitWebServer()
 
 	/*
 		init machine agent list
diff --git a/cmd/server/resourcemanage/resourcemanage.go b/cmd/server/resourcemanage/resourcemanage.go
index beea6787c2350048303c0859b50ff318b609f49d..9043eb14d0eb7bb2cc1123880151920491ee85d1 100644
--- a/cmd/server/resourcemanage/resourcemanage.go
+++ b/cmd/server/resourcemanage/resourcemanage.go
@@ -11,13 +11,18 @@ import (
 	"github.com/pkg/errors"
 )
 
-// var ERManager *ErrorReleaseManagement
+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
@@ -37,8 +42,8 @@ type ErrorReleaseManagement struct {
 	errEndChan chan struct{}
 
 	// cancelCtx: 控制 ERManager 本身资源释放的上下文，子上下文：errortransmit
-	cancelCtx    context.Context
-	cancelFunc   context.CancelFunc
+	cancelCtx  context.Context
+	cancelFunc context.CancelFunc
 
 	// GoCancelCtx: ERManager 用于控制项目指定goroutine优雅退出的上下文
 	GoCancelCtx  context.Context
@@ -83,38 +88,14 @@ func (erm *ErrorReleaseManagement) errorFactory() {
 
 			if _terror.Err != nil {
 				if !_terror.PrintStack && !_terror.ExitAfterPrint {
-					switch _terror.Severity {
-					case "debug":
-						logger.Debug(errors.Cause(_terror.Err).Error())
-					case "info":
-						logger.Info(errors.Cause(_terror.Err).Error())
-					case "warn":
-						logger.Warn(errors.Cause(_terror.Err).Error())
-					case "error":
-						logger.Error(errors.Cause(_terror.Err).Error())
-					default:
-						logger.Error("only support \"debug info warn error\" type: %s\n", errors.Cause(_terror.Err).Error())
-					}
+					erm.output(_terror)
 				} else if _terror.PrintStack && !_terror.ExitAfterPrint {
-					logger.ErrorStack("%+v", _terror.Err)
-					// errors.EORE(err)
+					logger.ErrorStack(erm.errorStackMsg(_terror.Module), _terror.Err)
 				} else if !_terror.PrintStack && _terror.ExitAfterPrint {
-					switch _terror.Severity {
-					case "debug":
-						logger.Debug(errors.Cause(_terror.Err).Error())
-					case "info":
-						logger.Info(errors.Cause(_terror.Err).Error())
-					case "warn":
-						logger.Warn(errors.Cause(_terror.Err).Error())
-					case "error":
-						logger.Error(errors.Cause(_terror.Err).Error())
-					default:
-						logger.Error("only support \"debug info warn error\" type: %s\n", errors.Cause(_terror.Err).Error())
-					}
+					erm.output(_terror)
 					_terror.Cancel()
 				} else if _terror.PrintStack && _terror.ExitAfterPrint {
-					logger.ErrorStack("%+v", _terror.Err)
-					// errors.EORE(err)
+					logger.ErrorStack(erm.errorStackMsg(_terror.Module), _terror.Err)
 					_terror.Cancel()
 				}
 			}
@@ -144,12 +125,13 @@ func (erm *ErrorReleaseManagement) ResourceRelease() {
 
 @print_stack: 是否打印异常日志错误链，打印错误链时默认severity为error
 */
-func (erm *ErrorReleaseManagement) ErrorTransmit(_severity string, _err error, _exit_after_print, _print_stack bool) {
+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,
@@ -162,8 +144,40 @@ func (erm *ErrorReleaseManagement) ErrorTransmit(_severity string, _err error, _
 	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 {
+	log := fmt.Sprintf("%v %s %s %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 {
+	return fmt.Sprintf("%v %s %s %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/server/service/custom/customService.go b/cmd/server/service/custom/customService.go
index a988686e3ac54973676617d0c6041f1429b34de2..088eb7aa26c914802d2cd43dc478b9eafbde3664 100755
--- a/cmd/server/service/custom/customService.go
+++ b/cmd/server/service/custom/customService.go
@@ -68,7 +68,7 @@ func RunCustomTopoService(tcid uint) (*graph.Nodes, *graph.Edges, []map[string]s
 	if len(collect_errlist) != 0 {
 		for i, cerr := range collect_errlist {
 			collect_errlist[i] = errors.Wrap(cerr, " ")
-			global.ERManager.ErrorTransmit("error", collect_errlist[i], false, true)
+			global.ERManager.ErrorTransmit("service", "error", collect_errlist[i], false, true)
 		}
 		collect_errlist_string := []string{}
 		for _, e := range collect_errlist {
@@ -79,7 +79,7 @@ func RunCustomTopoService(tcid uint) (*graph.Nodes, *graph.Edges, []map[string]s
 	if len(process_errlist) != 0 {
 		for i, perr := range process_errlist {
 			process_errlist[i] = errors.Wrap(perr, " ")
-			global.ERManager.ErrorTransmit("error", process_errlist[i], false, true)
+			global.ERManager.ErrorTransmit("service", "error", process_errlist[i], false, true)
 		}
 		process_errlist_string := []string{}
 		for _, e := range process_errlist {
@@ -89,7 +89,7 @@ func RunCustomTopoService(tcid uint) (*graph.Nodes, *graph.Edges, []map[string]s
 	}
 	if nodes == nil || edges == nil {
 		err := errors.New("nodes or edges is nil")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("service", "error", err, false, true)
 		return nil, nil, nil, err, false
 	}
 
diff --git a/cmd/server/service/periodcollect.go b/cmd/server/service/periodcollect.go
index 8b70aaa03f29f43b464d3d9e4c146b044f10675f..f396a0db45a97cb2625dd3262b0f642941bccba9 100644
--- a/cmd/server/service/periodcollect.go
+++ b/cmd/server/service/periodcollect.go
@@ -22,7 +22,7 @@ import (
 func InitPeriodCollectWorking(batch []string, noderules [][]mysqlmanager.Filter_rule) {
 	if graphmanager.Global_GraphDB == nil {
 		err := errors.New("global_graphdb is nil")
-		global.ERManager.ErrorTransmit("debug", err, false, false)
+		global.ERManager.ErrorTransmit("service", "info", err, false, false)
 		return
 	}
 
@@ -30,13 +30,13 @@ func InitPeriodCollectWorking(batch []string, noderules [][]mysqlmanager.Filter_
 
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("service", "error", err, true, true)
 		return
 	}
 
 	if redismanager.Global_Redis == nil {
 		err := errors.New("Global_Redis is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("service", "error", err, true, true)
 		return
 	}
 
@@ -72,7 +72,7 @@ func DataProcessWorking(unixtime int64, agentnum int, graphdb graphmanager.Graph
 	if len(collect_errlist) != 0 {
 		for i, cerr := range collect_errlist {
 			collect_errlist[i] = errors.Wrap(cerr, " ")
-			global.ERManager.ErrorTransmit("error", collect_errlist[i], false, true)
+			global.ERManager.ErrorTransmit("service", "error", collect_errlist[i], false, true)
 		}
 		collect_errlist_string := []string{}
 		for _, e := range collect_errlist {
@@ -83,7 +83,7 @@ func DataProcessWorking(unixtime int64, agentnum int, graphdb graphmanager.Graph
 	if len(process_errlist) != 0 {
 		for i, perr := range process_errlist {
 			process_errlist[i] = errors.Wrap(perr, " ")
-			global.ERManager.ErrorTransmit("error", process_errlist[i], false, true)
+			global.ERManager.ErrorTransmit("service", "error", process_errlist[i], false, true)
 		}
 		process_errlist_string := []string{}
 		for _, e := range process_errlist {
@@ -93,13 +93,13 @@ func DataProcessWorking(unixtime int64, agentnum int, graphdb graphmanager.Graph
 	}
 	if nodes == nil || edges == nil {
 		err := errors.New("nodes or edges is nil")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("service", "error", err, false, true)
 		return nil, nil, nil, err
 	}
 
 	if graphmanager.Global_GraphDB == nil {
 		err := errors.New("Global_GraphDB is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("service", "error", err, true, true)
 		return nil, nil, nil, err
 	}
 
@@ -136,7 +136,7 @@ func DataProcessWorking(unixtime int64, agentnum int, graphdb graphmanager.Graph
 							err := graphmanager.Global_GraphDB.Node_create(_unixtime, _node)
 							if err != nil {
 								err = errors.Wrapf(err, "create neo4j node failed; %s", cqlIN)
-								global.ERManager.ErrorTransmit("error", err, false, true)
+								global.ERManager.ErrorTransmit("service", "error", err, false, true)
 							}
 						}
 					}(__nodes)
@@ -159,7 +159,7 @@ func DataProcessWorking(unixtime int64, agentnum int, graphdb graphmanager.Graph
 					err := graphmanager.Global_GraphDB.Edge_create(_unixtime, _edge)
 					if err != nil {
 						err = errors.Wrapf(err, "create neo4j edge failed")
-						global.ERManager.ErrorTransmit("error", err, false, true)
+						global.ERManager.ErrorTransmit("service", "error", err, false, true)
 					}
 				}
 			}(__edges)
diff --git a/cmd/server/service/webclient/webclientmanage.go b/cmd/server/service/webclient/webclientmanage.go
index 774db31d813c82594c8f37adcff5f9d076777e88..7a4c11292f5c1e59b2013fc5364dd7166f313d48 100644
--- a/cmd/server/service/webclient/webclientmanage.go
+++ b/cmd/server/service/webclient/webclientmanage.go
@@ -124,7 +124,7 @@ func (wcm *WebClientsManagement) UpdateClientTopoDataBuffer(_token string, _cust
 						err := wcm.Get(_token).Nodes.Remove(global_node)
 						if err != nil {
 							err = errors.Wrap(err, "->")
-							global.ERManager.ErrorTransmit("error", err, false, true)
+							global.ERManager.ErrorTransmit("webclient", "error", err, false, true)
 							continue
 						}
 						global_edge_id_slice_any, ok := wcm.Get(_token).Edges.Node_Edges_map.Load(global_node.ID)
@@ -140,7 +140,7 @@ func (wcm *WebClientsManagement) UpdateClientTopoDataBuffer(_token string, _cust
 							err := wcm.Get(_token).Edges.Remove(global_edge.ID)
 							if err != nil {
 								err = errors.Wrap(err, "->")
-								global.ERManager.ErrorTransmit("error", err, false, true)
+								global.ERManager.ErrorTransmit("webclient", "error", err, false, true)
 							}
 						}
 					}
diff --git a/cmd/server/handler/router.go b/cmd/server/webserver/engine.go
similarity index 70%
rename from cmd/server/handler/router.go
rename to cmd/server/webserver/engine.go
index af32b257b05467c990e05005cb0f19cee3f75e36..5272faa333b5b2ede1f0b81725f446f091a68f5d 100644
--- a/cmd/server/handler/router.go
+++ b/cmd/server/webserver/engine.go
@@ -1,4 +1,4 @@
-package handler
+package webserver
 
 import (
 	"context"
@@ -10,8 +10,9 @@ import (
 
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/conf"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/global"
-	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/handler/frontendResource"
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/pluginclient"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/webserver/frontendResource"
+	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/webserver/handle"
 	"gitee.com/openeuler/PilotGo/sdk/logger"
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
@@ -20,7 +21,7 @@ import (
 func InitWebServer() {
 	if pluginclient.Global_Client == nil {
 		err := errors.New("Global_Client is nil")
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
@@ -45,21 +46,21 @@ func InitWebServer() {
 			if err := webserver.ListenAndServeTLS(conf.Global_Config.Topo.Public_certificate, conf.Global_Config.Topo.Private_key); err != nil {
 				if strings.Contains(err.Error(), "Server closed") {
 					err = errors.New(err.Error())
-					global.ERManager.ErrorTransmit("info", err, false, false)
+					global.ERManager.ErrorTransmit("webserver", "info", err, false, false)
 					return
 				}
 				err = errors.Errorf("%s, addr: %s", err.Error(), conf.Global_Config.Topo.Addr)
-				global.ERManager.ErrorTransmit("error", err, true, true)
+				global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			}
 		}
 		if err := webserver.ListenAndServe(); err != nil {
 			if strings.Contains(err.Error(), "Server closed") {
 				err = errors.New(err.Error())
-				global.ERManager.ErrorTransmit("info", err, false, false)
+				global.ERManager.ErrorTransmit("webserver", "info", err, false, false)
 				return
 			}
 			err = errors.New(err.Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		}
 	}()
 
@@ -82,38 +83,38 @@ func InitWebServer() {
 func InitRouter(router *gin.Engine) {
 	api := router.Group("/plugin/topology/api")
 	{
-		api.POST("/heartbeat", HeartbeatHandle)
-		api.GET("/timestamps", TimestampsHandle)
-		api.GET("/agentlist", AgentListHandle)
-		api.GET("/batch_list", BatchListHandle)
-		api.GET("/batch_uuid", BatchMachineListHandle)
+		api.POST("/heartbeat", handle.HeartbeatHandle)
+		api.GET("/timestamps", handle.TimestampsHandle)
+		api.GET("/agentlist", handle.AgentListHandle)
+		api.GET("/batch_list", handle.BatchListHandle)
+		api.GET("/batch_uuid", handle.BatchMachineListHandle)
 	}
 
 	collect := router.Group("/plugin/topology/api")
 	{
-		collect.POST("/deploy_collect_endpoint", DeployCollectEndpointHandle)
-		collect.POST("/collect_endpoint", CollectEndpointHandle)
+		collect.POST("/deploy_collect_endpoint", handle.DeployCollectEndpointHandle)
+		collect.POST("/collect_endpoint", handle.CollectEndpointHandle)
 	}
 
 	custom := router.Group("/plugin/topology/api")
 	{
-		custom.GET("/custom_topo_list", CustomTopoListHandle)
-		custom.POST("/create_custom_topo", CreateCustomTopoHandle)
-		custom.DELETE("/delete_custom_topo", DeleteCustomTopoHandle)
-		custom.PUT("/update_custom_topo", UpdateCustomTopoHandle)
+		custom.GET("/custom_topo_list", handle.CustomTopoListHandle)
+		custom.POST("/create_custom_topo", handle.CreateCustomTopoHandle)
+		custom.DELETE("/delete_custom_topo", handle.DeleteCustomTopoHandle)
+		custom.PUT("/update_custom_topo", handle.UpdateCustomTopoHandle)
 	}
 
 	public := router.Group("/plugin/topology/api")
 	{
 		// public.GET("/single_host/:uuid", SingleHostHandle)
-		public.GET("/single_host_tree/:uuid", SingleHostTreeHandle)
-		public.GET("/multi_host", MultiHostHandle)
+		public.GET("/single_host_tree/:uuid", handle.SingleHostTreeHandle)
+		public.GET("/multi_host", handle.MultiHostHandle)
 	}
 
 	timeoutapi := router.Group("/plugin/topology/api")
 	timeoutapi.Use(TimeoutMiddleware2(15 * time.Second))
 	{
-		timeoutapi.GET("/run_custom_topo", RunCustomTopoHandle)
+		timeoutapi.GET("/run_custom_topo", handle.RunCustomTopoHandle)
 	}
 }
 
diff --git a/cmd/server/handler/frontendResource/static.go b/cmd/server/webserver/frontendResource/static.go
similarity index 100%
rename from cmd/server/handler/frontendResource/static.go
rename to cmd/server/webserver/frontendResource/static.go
diff --git a/cmd/server/handler/frontendResource/staticPro.go b/cmd/server/webserver/frontendResource/staticPro.go
similarity index 100%
rename from cmd/server/handler/frontendResource/staticPro.go
rename to cmd/server/webserver/frontendResource/staticPro.go
diff --git a/cmd/server/handler/basicHandler.go b/cmd/server/webserver/handle/basicHandler.go
similarity index 82%
rename from cmd/server/handler/basicHandler.go
rename to cmd/server/webserver/handle/basicHandler.go
index da3688cdd51adeb426777e880f15a8c9068678b6..0f0981553e85f1b0f587d6ee12b070183aed3e8c 100644
--- a/cmd/server/handler/basicHandler.go
+++ b/cmd/server/webserver/handle/basicHandler.go
@@ -1,4 +1,4 @@
-package handler
+package handle
 
 import (
 	"fmt"
@@ -26,7 +26,7 @@ func HeartbeatHandle(ctx *gin.Context) {
 			"error": err.Error(),
 			"data":  nil,
 		})
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 	}
 	key := "heartbeat-topoagent-" + value.UUID
 	value.Time = time.Now()
@@ -38,13 +38,13 @@ func HeartbeatHandle(ctx *gin.Context) {
 			"error": err.Error(),
 			"data":  nil,
 		})
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
 	if agentmanager.Global_AgentManager.GetAgent_P(value.UUID) == nil {
 		err := errors.Errorf("unknown agent's heartbeat: %s, %s", value.UUID, value.Addr)
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("webserver", "warn", err, false, false)
 		ctx.JSON(http.StatusUnauthorized, gin.H{
 			"code":  -1,
 			"error": err.Error(),
@@ -60,14 +60,14 @@ func HeartbeatHandle(ctx *gin.Context) {
 			"error": err.Error(),
 			"data":  nil,
 		})
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
 	err := redismanager.Global_Redis.Set(key, value)
 	if err != nil {
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 
 		ctx.JSON(http.StatusInternalServerError, gin.H{
 			"code":  -1,
@@ -88,14 +88,14 @@ func TimestampsHandle(ctx *gin.Context) {
 	if graphmanager.Global_GraphDB == nil {
 		err := errors.New("Global_GraphDB is nil")
 		response.Fail(ctx, nil, err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
 	times, err := graphmanager.Global_GraphDB.Timestamps_query()
 	if err != nil {
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 
 		response.Fail(ctx, nil, err.Error())
 		return
@@ -110,7 +110,7 @@ func AgentListHandle(ctx *gin.Context) {
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
 		response.Fail(ctx, nil, err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
@@ -132,14 +132,14 @@ func BatchListHandle(ctx *gin.Context) {
 	if pluginclient.Global_Client == nil {
 		err := errors.New("Global_Client is nil")
 		response.Fail(ctx, nil, err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
 	batchlist, err := pluginclient.Global_Client.BatchList()
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("webserver", "warn", err, false, false)
 		response.Fail(ctx, nil, err.Error())
 		return
 	}
@@ -159,14 +159,14 @@ func BatchMachineListHandle(ctx *gin.Context) {
 	if pluginclient.Global_Client == nil {
 		err := errors.New("Global_Client is nil")
 		response.Fail(ctx, nil, err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
 	machine_uuids, err := pluginclient.Global_Client.BatchUUIDList(BatchId)
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, err.Error())
 		return
 	}
@@ -174,7 +174,7 @@ func BatchMachineListHandle(ctx *gin.Context) {
 	if agentmanager.Global_AgentManager == nil {
 		err := errors.New("Global_AgentManager is nil")
 		response.Fail(ctx, nil, err.Error())
-		global.ERManager.ErrorTransmit("error", err, true, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 		return
 	}
 
diff --git a/cmd/server/handler/collectDeployHandler.go b/cmd/server/webserver/handle/collectDeployHandler.go
similarity index 81%
rename from cmd/server/handler/collectDeployHandler.go
rename to cmd/server/webserver/handle/collectDeployHandler.go
index 2e838381b9658a5ff90a71adce110f8f094095be..7d9379e1acf2aab62095545a402caa84ead17ec6 100644
--- a/cmd/server/handler/collectDeployHandler.go
+++ b/cmd/server/webserver/handle/collectDeployHandler.go
@@ -1,4 +1,4 @@
-package handler
+package handle
 
 import (
 	"fmt"
@@ -22,7 +22,7 @@ func DeployCollectEndpointHandle(ctx *gin.Context) {
 	}{}
 	if err := ctx.ShouldBind(uuids); err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "parameter error")
 		return
 	}
@@ -30,7 +30,7 @@ func DeployCollectEndpointHandle(ctx *gin.Context) {
 	file, err := os.Open(strings.TrimSuffix(conf.Global_Config.Topo.Path, "/") + "/deploy-collect-endpoint.sh")
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "open file error: "+errors.Cause(err).Error())
 		return
 	}
@@ -38,7 +38,7 @@ func DeployCollectEndpointHandle(ctx *gin.Context) {
 	script_bytes, err := io.ReadAll(file)
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "read file error: "+errors.Cause(err).Error())
 		return
 	}
@@ -54,13 +54,13 @@ func DeployCollectEndpointHandle(ctx *gin.Context) {
 	})
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
 	for _, res := range cmdresults {
 		err := errors.Errorf("collect endpoint deploy: [retcode:%d][uuid:%s][ip:%s][stdout:%s][stderr:%s]", res.RetCode, res.MachineUUID, res.MachineIP, res.Stdout, res.Stderr)
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("webserver", "warn", err, false, false)
 	}
 
 	response.Success(ctx, nil, "collect endpoint deploy")
@@ -73,7 +73,7 @@ func CollectEndpointHandle(ctx *gin.Context) {
 	}{}
 	if err := ctx.ShouldBind(uuids); err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "parameter error")
 		return
 	}
@@ -81,7 +81,7 @@ func CollectEndpointHandle(ctx *gin.Context) {
 	file, err := os.Open(strings.TrimSuffix(conf.Global_Config.Topo.Path, "/") + "/collect-endpoint.sh")
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "open file error: "+errors.Cause(err).Error())
 		return
 	}
@@ -89,7 +89,7 @@ func CollectEndpointHandle(ctx *gin.Context) {
 	script_bytes, err := io.ReadAll(file)
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, "read file error: "+errors.Cause(err).Error())
 		return
 	}
@@ -110,13 +110,13 @@ func CollectEndpointHandle(ctx *gin.Context) {
 	}
 	if err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
 	for _, res := range cmdresults {
 		err := errors.Errorf("collect endpoint deploy: [retcode:%d][uuid:%s][ip:%s][stdout:%s][stderr:%s]", res.RetCode, res.MachineUUID, res.MachineIP, res.Stdout, res.Stderr)
-		global.ERManager.ErrorTransmit("warn", err, false, false)
+		global.ERManager.ErrorTransmit("webserver", "warn", err, false, false)
 	}
 
 	response.Success(ctx, nil, fmt.Sprintf("collect endpoint %s", action))
diff --git a/cmd/server/handler/customTopoHandler.go b/cmd/server/webserver/handle/customTopoHandler.go
similarity index 79%
rename from cmd/server/handler/customTopoHandler.go
rename to cmd/server/webserver/handle/customTopoHandler.go
index dbfee2f6d192e9a9403662f08c54f6a582d11e57..ca08a85c53a58daf5ffcfa07b5f5deb2b11e0a22 100755
--- a/cmd/server/handler/customTopoHandler.go
+++ b/cmd/server/webserver/handle/customTopoHandler.go
@@ -1,4 +1,4 @@
-package handler
+package handle
 
 import (
 	"strconv"
@@ -18,14 +18,14 @@ func CustomTopoListHandle(ctx *gin.Context) {
 	err := ctx.ShouldBindQuery(query)
 	if err != nil {
 		err = errors.New("failed to load parameters in url")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
 
 	if query.PageSize == 0 && query.Page == 0 {
 		err := errors.New("query topo configuration list failed: page size and page can not be zero")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -35,11 +35,11 @@ func CustomTopoListHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -52,14 +52,14 @@ func CreateCustomTopoHandle(ctx *gin.Context) {
 
 	if err := ctx.ShouldBindJSON(tc); err != nil {
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
 
 	if tc.Name == "" && tc.BatchId == 0 && len(tc.NodeRules) == 0 && len(tc.TagRules) == 0 {
 		err := errors.New("create topo configuration failed: topo configuration required")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -69,11 +69,11 @@ func CreateCustomTopoHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -91,14 +91,14 @@ func UpdateCustomTopoHandle(ctx *gin.Context) {
 	// fmt.Printf("%+v\n", ctx.Request.Body)
 	if err := ctx.ShouldBindJSON(&req_body); err != nil {
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
 
 	if req_body.TC.Name == "" && req_body.TC.BatchId == 0 && len(req_body.TC.NodeRules) == 0 && len(req_body.TC.TagRules) == 0 {
 		err := errors.New("update topo configuration failed: topo configuration required")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -108,11 +108,11 @@ func UpdateCustomTopoHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -133,7 +133,7 @@ func RunCustomTopoHandle(ctx *gin.Context) {
 
 		if tcid_str == "" {
 			err := errors.New("id is nil")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 			doneChan <- custom_topodata
 			response.Fail(ctx, nil, errors.Cause(err).Error())
 			return
@@ -143,7 +143,7 @@ func RunCustomTopoHandle(ctx *gin.Context) {
 		tcid_int, err := strconv.Atoi(tcid_str)
 		if err != nil {
 			err = errors.Wrap(err, " ")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 			doneChan <- custom_topodata
 			response.Fail(ctx, nil, errors.Cause(err).Error())
 			return
@@ -156,18 +156,18 @@ func RunCustomTopoHandle(ctx *gin.Context) {
 				err = errors.Wrap(err, " ")
 				doneChan <- custom_topodata
 				response.Fail(ctx, nil, errors.Cause(err).Error())
-				global.ERManager.ErrorTransmit("error", err, true, true)
+				global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 				return
 			}
 			err = errors.Wrap(err, " ")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 			doneChan <- custom_topodata
 			response.Fail(ctx, nil, errors.Cause(err).Error())
 			return
 		}
 		if len(custom_topodata.Nodes.Nodes) == 0 || len(custom_topodata.Edges.Edges) == 0 {
 			err := errors.New("nodes list is null or edges list is null")
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 			doneChan <- custom_topodata
 			response.Fail(ctx, nil, errors.Cause(err).Error())
 			return
@@ -184,7 +184,7 @@ func RunCustomTopoHandle(ctx *gin.Context) {
 	case data := <-doneChan:
 		if data == nil {
 			err := errors.Errorf("topodatabuff is nill, client: %s, %s", ctx.Request.RemoteAddr, webclient_id)
-			global.ERManager.ErrorTransmit("error", err, false, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 			response.Fail(ctx, nil, err.Error())
 			return
 		}
@@ -205,7 +205,7 @@ func DeleteCustomTopoHandle(ctx *gin.Context) {
 
 	if err := ctx.ShouldBindJSON(&req_body); err != nil {
 		err = errors.New(err.Error())
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
@@ -214,11 +214,11 @@ func DeleteCustomTopoHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, errors.Cause(err).Error())
 		return
 	}
diff --git a/cmd/server/handler/publicTopoHandler.go b/cmd/server/webserver/handle/publicTopoHandler.go
similarity index 87%
rename from cmd/server/handler/publicTopoHandler.go
rename to cmd/server/webserver/handle/publicTopoHandler.go
index fb87c70e52f21321b6ea0278a13443142b9f62f5..7c0e6c4d21da1db94d94f6bd904bbec24415b03e 100644
--- a/cmd/server/handler/publicTopoHandler.go
+++ b/cmd/server/webserver/handle/publicTopoHandler.go
@@ -1,4 +1,4 @@
-package handler
+package handle
 
 import (
 	"gitee.com/openeuler/PilotGo-plugin-topology/cmd/server/global"
@@ -53,18 +53,18 @@ func SingleHostTreeHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, err.Error())
 		return
 	}
 
 	if nodes == nil {
 		err := errors.New("node tree is null")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 
 		response.Fail(ctx, nil, err.Error())
 		return
@@ -95,18 +95,18 @@ func MultiHostHandle(ctx *gin.Context) {
 		if exit {
 			err = errors.Wrap(err, " ")
 			response.Fail(ctx, nil, errors.Cause(err).Error())
-			global.ERManager.ErrorTransmit("error", err, true, true)
+			global.ERManager.ErrorTransmit("webserver", "error", err, true, true)
 			return
 		}
 		err = errors.Wrap(err, " ")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 		response.Fail(ctx, nil, err.Error())
 		return
 	}
 
 	if len(nodes) == 0 || len(edges) == 0 {
 		err := errors.New("nodes list is null or edges list is null")
-		global.ERManager.ErrorTransmit("error", err, false, true)
+		global.ERManager.ErrorTransmit("webserver", "error", err, false, true)
 
 		response.Fail(ctx, nil, err.Error())
 		return