log: migrate to unknwon.dev/clog/v2 (#5927)

* Add unknwon.dev/clog/v2

* Update all places

7 files changed, 65 insertions, 60 deletions

diff --git a/internal/cmd/admin.go b/internal/cmd/admin.go
index de8b6ba6..3ba654ee 100644
--- a/internal/cmd/admin.go
+++ b/internal/cmd/admin.go
@@ -144,7 +144,7 @@ func runCreateUser(c *cli.Context) error {
 		setting.CustomConf = c.String("config")
 	}
 
-	setting.NewContext()
+	setting.Init()
 	db.LoadConfigs()
 	db.SetEngine()
 
@@ -168,7 +168,7 @@ func adminDashboardOperation(operation func() error, successMessage string) func
 			setting.CustomConf = c.String("config")
 		}
 
-		setting.NewContext()
+		setting.Init()
 		db.LoadConfigs()
 		db.SetEngine()
 
diff --git a/internal/cmd/backup.go b/internal/cmd/backup.go
index 622f7ffe..6e9b24b0 100644
--- a/internal/cmd/backup.go
+++ b/internal/cmd/backup.go
@@ -14,8 +14,8 @@ import (
 	"github.com/unknwon/cae/zip"
 	"github.com/unknwon/com"
 	"github.com/urfave/cli"
-	log "gopkg.in/clog.v1"
 	"gopkg.in/ini.v1"
+	log "unknwon.dev/clog/v2"
 
 	"gogs.io/gogs/internal/db"
 	"gogs.io/gogs/internal/setting"
@@ -47,17 +47,17 @@ func runBackup(c *cli.Context) error {
 	if c.IsSet("config") {
 		setting.CustomConf = c.String("config")
 	}
-	setting.NewContext()
+	setting.Init()
 	db.LoadConfigs()
 	db.SetEngine()
 
 	tmpDir := c.String("tempdir")
 	if !com.IsExist(tmpDir) {
-		log.Fatal(0, "'--tempdir' does not exist: %s", tmpDir)
+		log.Fatal("'--tempdir' does not exist: %s", tmpDir)
 	}
 	rootDir, err := ioutil.TempDir(tmpDir, "gogs-backup-")
 	if err != nil {
-		log.Fatal(0, "Fail to create backup root directory '%s': %v", rootDir, err)
+		log.Fatal("Failed to create backup root directory '%s': %v", rootDir, err)
 	}
 	log.Info("Backup root directory: %s", rootDir)
 
@@ -68,7 +68,7 @@ func runBackup(c *cli.Context) error {
 	metadata.Section("").Key("DATE_TIME").SetValue(time.Now().String())
 	metadata.Section("").Key("GOGS_VERSION").SetValue(setting.AppVersion)
 	if err = metadata.SaveTo(metaFile); err != nil {
-		log.Fatal(0, "Fail to save metadata '%s': %v", metaFile, err)
+		log.Fatal("Failed to save metadata '%s': %v", metaFile, err)
 	}
 
 	archiveName := path.Join(c.String("target"), c.String("archive-name"))
@@ -76,25 +76,25 @@ func runBackup(c *cli.Context) error {
 
 	z, err := zip.Create(archiveName)
 	if err != nil {
-		log.Fatal(0, "Fail to create backup archive '%s': %v", archiveName, err)
+		log.Fatal("Failed to create backup archive '%s': %v", archiveName, err)
 	}
 	if err = z.AddFile(_ARCHIVE_ROOT_DIR+"/metadata.ini", metaFile); err != nil {
-		log.Fatal(0, "Fail to include 'metadata.ini': %v", err)
+		log.Fatal("Failed to include 'metadata.ini': %v", err)
 	}
 
 	// Database
 	dbDir := path.Join(rootDir, "db")
 	if err = db.DumpDatabase(dbDir); err != nil {
-		log.Fatal(0, "Fail to dump database: %v", err)
+		log.Fatal("Failed to dump database: %v", err)
 	}
 	if err = z.AddDir(_ARCHIVE_ROOT_DIR+"/db", dbDir); err != nil {
-		log.Fatal(0, "Fail to include 'db': %v", err)
+		log.Fatal("Failed to include 'db': %v", err)
 	}
 
 	// Custom files
 	if !c.Bool("database-only") {
 		if err = z.AddDir(_ARCHIVE_ROOT_DIR+"/custom", setting.CustomPath); err != nil {
-			log.Fatal(0, "Fail to include 'custom': %v", err)
+			log.Fatal("Failed to include 'custom': %v", err)
 		}
 	}
 
@@ -107,7 +107,7 @@ func runBackup(c *cli.Context) error {
 			}
 
 			if err = z.AddDir(path.Join(_ARCHIVE_ROOT_DIR+"/data", dir), dirPath); err != nil {
-				log.Fatal(0, "Fail to include 'data': %v", err)
+				log.Fatal("Failed to include 'data': %v", err)
 			}
 		}
 	}
@@ -117,21 +117,21 @@ func runBackup(c *cli.Context) error {
 		reposDump := path.Join(rootDir, "repositories.zip")
 		log.Info("Dumping repositories in '%s'", setting.RepoRootPath)
 		if err = zip.PackTo(setting.RepoRootPath, reposDump, true); err != nil {
-			log.Fatal(0, "Fail to dump repositories: %v", err)
+			log.Fatal("Failed to dump repositories: %v", err)
 		}
 		log.Info("Repositories dumped to: %s", reposDump)
 
 		if err = z.AddFile(_ARCHIVE_ROOT_DIR+"/repositories.zip", reposDump); err != nil {
-			log.Fatal(0, "Fail to include 'repositories.zip': %v", err)
+			log.Fatal("Failed to include 'repositories.zip': %v", err)
 		}
 	}
 
 	if err = z.Close(); err != nil {
-		log.Fatal(0, "Fail to save backup archive '%s': %v", archiveName, err)
+		log.Fatal("Failed to save backup archive '%s': %v", archiveName, err)
 	}
 
 	os.RemoveAll(rootDir)
 	log.Info("Backup succeed! Archive is located at: %s", archiveName)
-	log.Shutdown()
+	log.Stop()
 	return nil
 }
diff --git a/internal/cmd/hook.go b/internal/cmd/hook.go
index 1e4c8899..41cf88f2 100644
--- a/internal/cmd/hook.go
+++ b/internal/cmd/hook.go
@@ -16,7 +16,7 @@ import (
 
 	"github.com/unknwon/com"
 	"github.com/urfave/cli"
-	log "gopkg.in/clog.v1"
+	log "unknwon.dev/clog/v2"
 
 	"github.com/gogs/git-module"
 
@@ -129,7 +129,7 @@ func runHookPreReceive(c *cli.Context) error {
 		output, err := git.NewCommand("rev-list", "--max-count=1", oldCommitID, "^"+newCommitID).
 			RunInDir(db.RepoPath(os.Getenv(db.ENV_REPO_OWNER_NAME), os.Getenv(db.ENV_REPO_NAME)))
 		if err != nil {
-			fail("Internal error", "Fail to detect force push: %v", err)
+			fail("Internal error", "Failed to detect force push: %v", err)
 		} else if len(output) > 0 {
 			fail(fmt.Sprintf("Branch '%s' is protected from force push", branchName), "")
 		}
@@ -151,7 +151,7 @@ func runHookPreReceive(c *cli.Context) error {
 	hookCmd.Stdin = buf
 	hookCmd.Stderr = os.Stderr
 	if err := hookCmd.Run(); err != nil {
-		fail("Internal error", "Fail to execute custom pre-receive hook: %v", err)
+		fail("Internal error", "Failed to execute custom pre-receive hook: %v", err)
 	}
 	return nil
 }
@@ -185,7 +185,7 @@ func runHookUpdate(c *cli.Context) error {
 	hookCmd.Stdin = os.Stdin
 	hookCmd.Stderr = os.Stderr
 	if err := hookCmd.Run(); err != nil {
-		fail("Internal error", "Fail to execute custom pre-receive hook: %v", err)
+		fail("Internal error", "Failed to execute custom pre-receive hook: %v", err)
 	}
 	return nil
 }
@@ -229,7 +229,7 @@ func runHookPostReceive(c *cli.Context) error {
 			RepoName:     os.Getenv(db.ENV_REPO_NAME),
 		}
 		if err := db.PushUpdate(options); err != nil {
-			log.Error(2, "PushUpdate: %v", err)
+			log.Error("PushUpdate: %v", err)
 		}
 
 		// Ask for running deliver hook and test pull request tasks
@@ -245,10 +245,10 @@ func runHookPostReceive(c *cli.Context) error {
 		if err == nil {
 			resp.Body.Close()
 			if resp.StatusCode/100 != 2 {
-				log.Error(2, "Fail to trigger task: not 2xx response code")
+				log.Error("Failed to trigger task: not 2xx response code")
 			}
 		} else {
-			log.Error(2, "Fail to trigger task: %v", err)
+			log.Error("Failed to trigger task: %v", err)
 		}
 	}
 
@@ -268,7 +268,7 @@ func runHookPostReceive(c *cli.Context) error {
 	hookCmd.Stdin = buf
 	hookCmd.Stderr = os.Stderr
 	if err := hookCmd.Run(); err != nil {
-		fail("Internal error", "Fail to execute custom post-receive hook: %v", err)
+		fail("Internal error", "Failed to execute custom post-receive hook: %v", err)
 	}
 	return nil
 }
diff --git a/internal/cmd/import.go b/internal/cmd/import.go
index b274d1dd..0f3a2d44 100644
--- a/internal/cmd/import.go
+++ b/internal/cmd/import.go
@@ -58,7 +58,7 @@ func runImportLocale(c *cli.Context) error {
 		setting.CustomConf = c.String("config")
 	}
 
-	setting.NewContext()
+	setting.Init()
 
 	now := time.Now()
 
diff --git a/internal/cmd/restore.go b/internal/cmd/restore.go
index 74f9c759..2dba08d5 100644
--- a/internal/cmd/restore.go
+++ b/internal/cmd/restore.go
@@ -12,8 +12,8 @@ import (
 	"github.com/unknwon/cae/zip"
 	"github.com/unknwon/com"
 	"github.com/urfave/cli"
-	log "gopkg.in/clog.v1"
 	"gopkg.in/ini.v1"
+	log "unknwon.dev/clog/v2"
 
 	"gogs.io/gogs/internal/db"
 	"gogs.io/gogs/internal/setting"
@@ -48,12 +48,12 @@ func runRestore(c *cli.Context) error {
 
 	tmpDir := c.String("tempdir")
 	if !com.IsExist(tmpDir) {
-		log.Fatal(0, "'--tempdir' does not exist: %s", tmpDir)
+		log.Fatal("'--tempdir' does not exist: %s", tmpDir)
 	}
 
 	log.Info("Restore backup from: %s", c.String("from"))
 	if err := zip.ExtractTo(c.String("from"), tmpDir); err != nil {
-		log.Fatal(0, "Failed to extract backup archive: %v", err)
+		log.Fatal("Failed to extract backup archive: %v", err)
 	}
 	archivePath := path.Join(tmpDir, _ARCHIVE_ROOT_DIR)
 	defer os.RemoveAll(archivePath)
@@ -61,22 +61,22 @@ func runRestore(c *cli.Context) error {
 	// Check backup version
 	metaFile := path.Join(archivePath, "metadata.ini")
 	if !com.IsExist(metaFile) {
-		log.Fatal(0, "File 'metadata.ini' is missing")
+		log.Fatal("File 'metadata.ini' is missing")
 	}
 	metadata, err := ini.Load(metaFile)
 	if err != nil {
-		log.Fatal(0, "Failed to load metadata '%s': %v", metaFile, err)
+		log.Fatal("Failed to load metadata '%s': %v", metaFile, err)
 	}
 	backupVersion := metadata.Section("").Key("GOGS_VERSION").MustString("999.0")
 	if version.Compare(setting.AppVersion, backupVersion, "<") {
-		log.Fatal(0, "Current Gogs version is lower than backup version: %s < %s", setting.AppVersion, backupVersion)
+		log.Fatal("Current Gogs version is lower than backup version: %s < %s", setting.AppVersion, backupVersion)
 	}
 	formatVersion := metadata.Section("").Key("VERSION").MustInt()
 	if formatVersion == 0 {
-		log.Fatal(0, "Failed to determine the backup format version from metadata '%s': %s", metaFile, "VERSION is not presented")
+		log.Fatal("Failed to determine the backup format version from metadata '%s': %s", metaFile, "VERSION is not presented")
 	}
 	if formatVersion != _CURRENT_BACKUP_FORMAT_VERSION {
-		log.Fatal(0, "Backup format version found is %d but this binary only supports %d\nThe last known version that is able to import your backup is %s",
+		log.Fatal("Backup format version found is %d but this binary only supports %d\nThe last known version that is able to import your backup is %s",
 			formatVersion, _CURRENT_BACKUP_FORMAT_VERSION, lastSupportedVersionOfFormat[formatVersion])
 	}
 
@@ -86,29 +86,29 @@ func runRestore(c *cli.Context) error {
 	if c.IsSet("config") {
 		setting.CustomConf = c.String("config")
 	} else if !com.IsExist(configFile) {
-		log.Fatal(0, "'--config' is not specified and custom config file is not found in backup")
+		log.Fatal("'--config' is not specified and custom config file is not found in backup")
 	} else {
 		setting.CustomConf = configFile
 	}
-	setting.NewContext()
+	setting.Init()
 	db.LoadConfigs()
 	db.SetEngine()
 
 	// Database
 	dbDir := path.Join(archivePath, "db")
 	if err = db.ImportDatabase(dbDir, c.Bool("verbose")); err != nil {
-		log.Fatal(0, "Failed to import database: %v", err)
+		log.Fatal("Failed to import database: %v", err)
 	}
 
 	// Custom files
 	if !c.Bool("database-only") {
 		if com.IsExist(setting.CustomPath) {
 			if err = os.Rename(setting.CustomPath, setting.CustomPath+".bak"); err != nil {
-				log.Fatal(0, "Failed to backup current 'custom': %v", err)
+				log.Fatal("Failed to backup current 'custom': %v", err)
 			}
 		}
 		if err = os.Rename(path.Join(archivePath, "custom"), setting.CustomPath); err != nil {
-			log.Fatal(0, "Failed to import 'custom': %v", err)
+			log.Fatal("Failed to import 'custom': %v", err)
 		}
 	}
 
@@ -125,11 +125,11 @@ func runRestore(c *cli.Context) error {
 			dirPath := path.Join(setting.AppDataPath, dir)
 			if com.IsExist(dirPath) {
 				if err = os.Rename(dirPath, dirPath+".bak"); err != nil {
-					log.Fatal(0, "Failed to backup current 'data': %v", err)
+					log.Fatal("Failed to backup current 'data': %v", err)
 				}
 			}
 			if err = os.Rename(srcPath, dirPath); err != nil {
-				log.Fatal(0, "Failed to import 'data': %v", err)
+				log.Fatal("Failed to import 'data': %v", err)
 			}
 		}
 	}
@@ -138,11 +138,11 @@ func runRestore(c *cli.Context) error {
 	reposPath := path.Join(archivePath, "repositories.zip")
 	if !c.Bool("exclude-repos") && !c.Bool("database-only") && com.IsExist(reposPath) {
 		if err := zip.ExtractTo(reposPath, path.Dir(setting.RepoRootPath)); err != nil {
-			log.Fatal(0, "Failed to extract 'repositories.zip': %v", err)
+			log.Fatal("Failed to extract 'repositories.zip': %v", err)
 		}
 	}
 
 	log.Info("Restore succeed!")
-	log.Shutdown()
+	log.Stop()
 	return nil
 }
diff --git a/internal/cmd/serv.go b/internal/cmd/serv.go
index 870cf62e..2bcb85ac 100644
--- a/internal/cmd/serv.go
+++ b/internal/cmd/serv.go
@@ -14,7 +14,7 @@ import (
 
 	"github.com/unknwon/com"
 	"github.com/urfave/cli"
-	log "gopkg.in/clog.v1"
+	log "unknwon.dev/clog/v2"
 
 	"gogs.io/gogs/internal/db"
 	"gogs.io/gogs/internal/db/errors"
@@ -42,7 +42,7 @@ func fail(userMessage, logMessage string, args ...interface{}) {
 		if !setting.ProdMode {
 			fmt.Fprintf(os.Stderr, logMessage+"\n", args...)
 		}
-		log.Fatal(3, logMessage, args...)
+		log.Fatal(logMessage, args...)
 	}
 
 	os.Exit(1)
@@ -55,13 +55,14 @@ func setup(c *cli.Context, logPath string, connectDB bool) {
 		setting.CustomConf = c.GlobalString("config")
 	}
 
-	setting.NewContext()
+	setting.Init()
 
-	level := log.TRACE
+	level := log.LevelTrace
 	if setting.ProdMode {
-		level = log.ERROR
+		level = log.LevelError
 	}
-	log.New(log.FILE, log.FileConfig{
+
+	err := log.NewFile(log.FileConfig{
 		Level:    level,
 		Filename: filepath.Join(setting.LogRootPath, logPath),
 		FileRotationConfig: log.FileRotationConfig{
@@ -70,7 +71,11 @@ func setup(c *cli.Context, logPath string, connectDB bool) {
 			MaxDays: 3,
 		},
 	})
-	log.Delete(log.CONSOLE) // Remove primary logger
+	if err != nil {
+		log.Fatal("Failed to init file logger: %v", err)
+		return
+	}
+	log.Remove(log.DefaultConsoleName) // Remove the primary logger
 
 	if !connectDB {
 		return
@@ -156,7 +161,7 @@ func runServ(c *cli.Context) error {
 		if errors.IsUserNotExist(err) {
 			fail("Repository owner does not exist", "Unregistered owner: %s", ownerName)
 		}
-		fail("Internal error", "Fail to get repository owner '%s': %v", ownerName, err)
+		fail("Internal error", "Failed to get repository owner '%s': %v", ownerName, err)
 	}
 
 	repo, err := db.GetRepositoryByName(owner.ID, repoName)
@@ -164,7 +169,7 @@ func runServ(c *cli.Context) error {
 		if errors.IsRepoNotExist(err) {
 			fail(_ACCESS_DENIED_MESSAGE, "Repository does not exist: %s/%s", owner.Name, repoName)
 		}
-		fail("Internal error", "Fail to get repository: %v", err)
+		fail("Internal error", "Failed to get repository: %v", err)
 	}
 	repo.Owner = owner
 
@@ -196,12 +201,12 @@ func runServ(c *cli.Context) error {
 		} else {
 			user, err = db.GetUserByKeyID(key.ID)
 			if err != nil {
-				fail("Internal error", "Fail to get user by key ID '%d': %v", key.ID, err)
+				fail("Internal error", "Failed to get user by key ID '%d': %v", key.ID, err)
 			}
 
 			mode, err := db.UserAccessMode(user.ID, repo)
 			if err != nil {
-				fail("Internal error", "Fail to check access: %v", err)
+				fail("Internal error", "Failed to check access: %v", err)
 			}
 
 			if mode < requestMode {
@@ -265,7 +270,7 @@ func runServ(c *cli.Context) error {
 	gitCmd.Stdin = os.Stdin
 	gitCmd.Stderr = os.Stderr
 	if err = gitCmd.Run(); err != nil {
-		fail("Internal error", "Fail to execute git command: %v", err)
+		fail("Internal error", "Failed to execute git command: %v", err)
 	}
 
 	return nil
diff --git a/internal/cmd/web.go b/internal/cmd/web.go
index ce82391e..20f20af8 100644
--- a/internal/cmd/web.go
+++ b/internal/cmd/web.go
@@ -26,8 +26,8 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/unknwon/com"
 	"github.com/urfave/cli"
-	log "gopkg.in/clog.v1"
 	"gopkg.in/macaron.v1"
+	log "unknwon.dev/clog/v2"
 
 	"gogs.io/gogs/internal/assets/conf"
 	"gogs.io/gogs/internal/assets/public"
@@ -119,7 +119,7 @@ func newMacaron() *macaron.Macaron {
 
 	localeNames, err := conf.AssetDir("conf/locale")
 	if err != nil {
-		log.Fatal(4, "Fail to list locale files: %v", err)
+		log.Fatal("Failed to list locale files: %v", err)
 	}
 	localFiles := make(map[string][]byte)
 	for _, name := range localeNames {
@@ -741,15 +741,15 @@ func runWeb(c *cli.Context) error {
 		// FIXME: add proper implementation of signal capture on all protocols
 		// execute this on SIGTERM or SIGINT: listener.Close()
 		if err = os.Chmod(listenAddr, os.FileMode(setting.UnixSocketPermission)); err != nil {
-			log.Fatal(4, "Failed to set permission of unix socket: %v", err)
+			log.Fatal("Failed to set permission of unix socket: %v", err)
 		}
 		err = http.Serve(listener, m)
 	default:
-		log.Fatal(4, "Invalid protocol: %s", setting.Protocol)
+		log.Fatal("Invalid protocol: %s", setting.Protocol)
 	}
 
 	if err != nil {
-		log.Fatal(4, "Failed to start server: %v", err)
+		log.Fatal("Failed to start server: %v", err)
 	}
 
 	return nil