diff --git a/pkg/common/config/config.go b/pkg/common/config/config.go
index e1942a66d..855d5c6fb 100644
--- a/pkg/common/config/config.go
+++ b/pkg/common/config/config.go
@@ -648,7 +648,7 @@ func unmarshalConfig(config interface{}, configName string) {
 	} else {
 		bytes, err := ioutil.ReadFile(fmt.Sprintf("../config/%s", configName))
 		if err != nil {
-			panic(err.Error())
+			panic(err.Error() + configName)
 		}
 		if err = yaml.Unmarshal(bytes, config); err != nil {
 			panic(err.Error())
diff --git a/pkg/common/db/model.go b/pkg/common/db/model.go
index 5cdd83bb0..b586bab2f 100644
--- a/pkg/common/db/model.go
+++ b/pkg/common/db/model.go
@@ -46,10 +46,10 @@ func key(dbAddress, dbName string) string {
 }
 
 func init() {
-	//log.NewPrivateLog(constant.LogFileName)
 	var mongoClient *mongo.Client
 	var err1 error
-	//mysql init
+	fmt.Println("init mysql redis mongo ")
+	defer fmt.Println("init mysql redis mongo ok ")
 	initMysqlDB()
 	// mongo init
 	// "mongodb://sysop:moon@localhost/records"
@@ -84,45 +84,34 @@ func init() {
 
 	mongoClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
 	if err != nil {
-		fmt.Println(" mongo.Connect  failed, try ", utils.GetSelfFuncName(), err.Error(), uri)
 		time.Sleep(time.Duration(30) * time.Second)
 		mongoClient, err1 = mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
 		if err1 != nil {
-			fmt.Println(" mongo.Connect retry failed, panic", err.Error(), uri)
-			panic(err1.Error())
+			panic(err1.Error() + " mongo.Connect failed " + uri)
 		}
 	}
-	fmt.Println("mongo driver client init success: ", uri)
 	// mongodb create index
 	if err := createMongoIndex(mongoClient, cSendLog, false, "send_id", "-send_time"); err != nil {
-		fmt.Println("send_id", "-send_time", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + " index create failed " + cSendLog + " send_id, -send_time")
 	}
 	if err := createMongoIndex(mongoClient, cChat, false, "uid"); err != nil {
-		fmt.Println("uid", " index create failed", err.Error())
-		//panic(err.Error())
+		fmt.Println(err.Error() + " index create failed " + cChat + " uid ")
 	}
 	if err := createMongoIndex(mongoClient, cWorkMoment, true, "-create_time", "work_moment_id"); err != nil {
-		fmt.Println("-create_time", "work_moment_id", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + "index create failed " + cWorkMoment + " -create_time, work_moment_id")
 	}
 	if err := createMongoIndex(mongoClient, cWorkMoment, true, "work_moment_id"); err != nil {
-		fmt.Println("work_moment_id", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + "index create failed " + cWorkMoment + " work_moment_id ")
 	}
 	if err := createMongoIndex(mongoClient, cWorkMoment, false, "user_id", "-create_time"); err != nil {
-		fmt.Println("user_id", "-create_time", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + "index create failed " + cWorkMoment + "user_id, -create_time")
 	}
 	if err := createMongoIndex(mongoClient, cTag, false, "user_id", "-create_time"); err != nil {
-		fmt.Println("user_id", "-create_time", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + "index create failed " + cTag + " user_id, -create_time")
 	}
 	if err := createMongoIndex(mongoClient, cTag, true, "tag_id"); err != nil {
-		fmt.Println("tag_id", "index create failed", err.Error())
-		panic(err.Error())
+		panic(err.Error() + "index create failed " + cTag + " tag_id")
 	}
-	fmt.Println("createMongoIndex success")
 	DB.mongoClient = mongoClient
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -136,7 +125,8 @@ func init() {
 		})
 		_, err = DB.RDB.Ping(ctx).Result()
 		if err != nil {
-			panic(err.Error())
+			fmt.Println("redis cluster failed address ", config.Config.Redis.DBAddress)
+			panic(err.Error() + " redis cluster " + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
 		}
 	} else {
 		DB.RDB = go_redis.NewClient(&go_redis.Options{
@@ -148,7 +138,7 @@ func init() {
 		})
 		_, err = DB.RDB.Ping(ctx).Result()
 		if err != nil {
-			panic(err.Error())
+			panic(err.Error() + " redis " + config.Config.Redis.DBAddress[0] + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
 		}
 	}
 	// 强一致性缓存，当一个key被标记删除，其他请求线程会被锁住轮询直到新的key生成，适合各种同步的拉取, 如果弱一致可能导致拉取还是老数据，毫无意义
diff --git a/pkg/common/db/mysql.go b/pkg/common/db/mysql.go
index ca0e62008..9c8bc93df 100644
--- a/pkg/common/db/mysql.go
+++ b/pkg/common/db/mysql.go
@@ -22,37 +22,26 @@ func (w Writer) Printf(format string, args ...interface{}) {
 }
 
 func initMysqlDB() {
-	fmt.Println("init mysqlDB start")
-	//When there is no open IM database, connect to the mysql built-in database to create openIM database
 	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
 		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], "mysql")
 	var db *gorm.DB
 	var err1 error
 	db, err := gorm.Open(mysql.Open(dsn), nil)
-	if err != nil {
-		fmt.Println("Open failed ", err.Error(), dsn)
-	}
 	if err != nil {
 		time.Sleep(time.Duration(30) * time.Second)
 		db, err1 = gorm.Open(mysql.Open(dsn), nil)
 		if err1 != nil {
-			fmt.Println("Open failed ", err1.Error(), dsn)
-			panic(err1.Error())
+			panic(err1.Error() + " open failed " + dsn)
 		}
 	}
 
-	//Check the database and table during initialization
 	sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8 COLLATE utf8_general_ci;", config.Config.Mysql.DBDatabaseName)
-	fmt.Println("exec sql: ", sql, " begin")
 	err = db.Exec(sql).Error
 	if err != nil {
-		fmt.Println("Exec failed ", err.Error(), sql)
-		panic(err.Error())
+		panic(err.Error() + " Exec failed " + sql)
 	}
-	fmt.Println("exec sql: ", sql, " end")
 	dsn = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
 		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], config.Config.Mysql.DBDatabaseName)
-
 	newLogger := logger.New(
 		Writer{},
 		logger.Config{
@@ -66,20 +55,18 @@ func initMysqlDB() {
 		Logger: newLogger,
 	})
 	if err != nil {
-		fmt.Println("Open failed ", err.Error(), dsn)
-		panic(err.Error())
+		panic(err.Error() + " Open failed " + dsn)
 	}
 
 	sqlDB, err := db.DB()
 	if err != nil {
-		panic(err.Error())
+		panic(err.Error() + " db.DB() failed ")
 	}
 
 	sqlDB.SetConnMaxLifetime(time.Second * time.Duration(config.Config.Mysql.DBMaxLifeTime))
 	sqlDB.SetMaxOpenConns(config.Config.Mysql.DBMaxOpenConns)
 	sqlDB.SetMaxIdleConns(config.Config.Mysql.DBMaxIdleConns)
 
-	fmt.Println("open mysql ok ", dsn)
 	db.AutoMigrate(
 		&Register{},
 		&Friend{},
@@ -94,99 +81,69 @@ func initMysqlDB() {
 	db.Set("gorm:table_options", "collation=utf8_unicode_ci")
 
 	if !db.Migrator().HasTable(&Friend{}) {
-		fmt.Println("CreateTable Friend")
 		db.Migrator().CreateTable(&Friend{})
 	}
-
 	if !db.Migrator().HasTable(&FriendRequest{}) {
-		fmt.Println("CreateTable FriendRequest")
 		db.Migrator().CreateTable(&FriendRequest{})
 	}
-
 	if !db.Migrator().HasTable(&Group{}) {
-		fmt.Println("CreateTable Group")
 		db.Migrator().CreateTable(&Group{})
 	}
-
 	if !db.Migrator().HasTable(&GroupMember{}) {
-		fmt.Println("CreateTable GroupMember")
 		db.Migrator().CreateTable(&GroupMember{})
 	}
 	if !db.Migrator().HasTable(&GroupRequest{}) {
-		fmt.Println("CreateTable GroupRequest")
 		db.Migrator().CreateTable(&GroupRequest{})
 	}
 	if !db.Migrator().HasTable(&User{}) {
-		fmt.Println("CreateTable User")
 		db.Migrator().CreateTable(&User{})
 	}
 	if !db.Migrator().HasTable(&Black{}) {
-		fmt.Println("CreateTable Black")
 		db.Migrator().CreateTable(&Black{})
 	}
 	if !db.Migrator().HasTable(&ChatLog{}) {
-		fmt.Println("CreateTable ChatLog")
 		db.Migrator().CreateTable(&ChatLog{})
 	}
 	if !db.Migrator().HasTable(&Register{}) {
-		fmt.Println("CreateTable Register")
 		db.Migrator().CreateTable(&Register{})
 	}
 	if !db.Migrator().HasTable(&Conversation{}) {
-		fmt.Println("CreateTable Conversation")
 		db.Migrator().CreateTable(&Conversation{})
 	}
-
 	if !db.Migrator().HasTable(&Department{}) {
-		fmt.Println("CreateTable Department")
 		db.Migrator().CreateTable(&Department{})
 	}
 	if !db.Migrator().HasTable(&OrganizationUser{}) {
-		fmt.Println("CreateTable OrganizationUser")
 		db.Migrator().CreateTable(&OrganizationUser{})
 	}
 	if !db.Migrator().HasTable(&DepartmentMember{}) {
-		fmt.Println("CreateTable DepartmentMember")
 		db.Migrator().CreateTable(&DepartmentMember{})
 	}
 	if !db.Migrator().HasTable(&AppVersion{}) {
-		fmt.Println("CreateTable DepartmentMember")
 		db.Migrator().CreateTable(&AppVersion{})
 	}
 	if !db.Migrator().HasTable(&BlackList{}) {
-		fmt.Println("CreateTable BlackList")
 		db.Migrator().CreateTable(&BlackList{})
 	}
 	if !db.Migrator().HasTable(&IpLimit{}) {
-		fmt.Println("CreateTable IpLimit")
 		db.Migrator().CreateTable(&IpLimit{})
 	}
 	if !db.Migrator().HasTable(&UserIpLimit{}) {
-		fmt.Println("CreateTable UserIpLimit")
 		db.Migrator().CreateTable(&UserIpLimit{})
 	}
-
 	if !db.Migrator().HasTable(&RegisterAddFriend{}) {
-		fmt.Println("CreateTable RegisterAddFriend")
 		db.Migrator().CreateTable(&RegisterAddFriend{})
 	}
 	if !db.Migrator().HasTable(&Invitation{}) {
-		fmt.Println("CreateTable Invitation")
 		db.Migrator().CreateTable(&Invitation{})
 	}
-
 	if !db.Migrator().HasTable(&ClientInitConfig{}) {
-		fmt.Println("CreateTable ClientInitConfig")
 		db.Migrator().CreateTable(&ClientInitConfig{})
 	}
-
 	if !db.Migrator().HasTable(&UserIpRecord{}) {
-		fmt.Println("CreateTable Friend")
 		db.Migrator().CreateTable(&UserIpRecord{})
 	}
-
 	DB.MysqlDB.db = db
-	return
 }
 
 func (m *mysqlDB) DefaultGormDB() *gorm.DB {