Revert "Improve trace logging for pulls and processes (go-gitea#22633) (go-gitea#22812)"

This reverts commit e423858.

Refs: https://codeberg.org/forgejo/forgejo/issues/395

Author: Loïc Dachary

models/issues/pull.go

@@ -9,7 +9,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"strconv"
 	"strings"
 
 	"code.gitea.io/gitea/models/db"
@@ -134,27 +133,6 @@ const (
 	PullRequestStatusAncestor
 )
 
-func (status PullRequestStatus) String() string {
-	switch status {
-	case PullRequestStatusConflict:
-		return "CONFLICT"
-	case PullRequestStatusChecking:
-		return "CHECKING"
-	case PullRequestStatusMergeable:
-		return "MERGEABLE"
-	case PullRequestStatusManuallyMerged:
-		return "MANUALLY_MERGED"
-	case PullRequestStatusError:
-		return "ERROR"
-	case PullRequestStatusEmpty:
-		return "EMPTY"
-	case PullRequestStatusAncestor:
-		return "ANCESTOR"
-	default:
-		return strconv.Itoa(int(status))
-	}
-}
-
 // PullRequestFlow the flow of pull request
 type PullRequestFlow int
 
@@ -226,42 +204,6 @@ func DeletePullsByBaseRepoID(ctx context.Context, repoID int64) error {
 	return err
 }
 
-// ColorFormat writes a colored string to identify this struct
-func (pr *PullRequest) ColorFormat(s fmt.State) {
-	if pr == nil {
-		log.ColorFprintf(s, "PR[%d]%s#%d[%s...%s:%s]",
-			log.NewColoredIDValue(0),
-			log.NewColoredValue("<nil>/<nil>"),
-			log.NewColoredIDValue(0),
-			log.NewColoredValue("<nil>"),
-			log.NewColoredValue("<nil>/<nil>"),
-			log.NewColoredValue("<nil>"),
-		)
-		return
-	}
-
-	log.ColorFprintf(s, "PR[%d]", log.NewColoredIDValue(pr.ID))
-	if pr.BaseRepo != nil {
-		log.ColorFprintf(s, "%s#%d[%s...", log.NewColoredValue(pr.BaseRepo.FullName()),
-			log.NewColoredIDValue(pr.Index), log.NewColoredValue(pr.BaseBranch))
-	} else {
-		log.ColorFprintf(s, "Repo[%d]#%d[%s...", log.NewColoredIDValue(pr.BaseRepoID),
-			log.NewColoredIDValue(pr.Index), log.NewColoredValue(pr.BaseBranch))
-	}
-	if pr.HeadRepoID == pr.BaseRepoID {
-		log.ColorFprintf(s, "%s]", log.NewColoredValue(pr.HeadBranch))
-	} else if pr.HeadRepo != nil {
-		log.ColorFprintf(s, "%s:%s]", log.NewColoredValue(pr.HeadRepo.FullName()), log.NewColoredValue(pr.HeadBranch))
-	} else {
-		log.ColorFprintf(s, "Repo[%d]:%s]", log.NewColoredIDValue(pr.HeadRepoID), log.NewColoredValue(pr.HeadBranch))
-	}
-}
-
-// String represents the pr as a simple string
-func (pr *PullRequest) String() string {
-	return log.ColorFormatAsString(pr)
-}
-
 // MustHeadUserName returns the HeadRepo's username if failed return blank
 func (pr *PullRequest) MustHeadUserName() string {
 	if err := pr.LoadHeadRepo(); err != nil {
@@ -313,7 +255,7 @@ func (pr *PullRequest) LoadHeadRepoCtx(ctx context.Context) (err error) {
 
 		pr.HeadRepo, err = repo_model.GetRepositoryByIDCtx(ctx, pr.HeadRepoID)
 		if err != nil && !repo_model.IsErrRepoNotExist(err) { // Head repo maybe deleted, but it should still work
-			return fmt.Errorf("pr[%d].LoadHeadRepo[%d]: %w", pr.ID, pr.HeadRepoID, err)
+			return fmt.Errorf("getRepositoryByID(head): %w", err)
 		}
 		pr.isHeadRepoLoaded = true
 	}
@@ -348,7 +290,7 @@ func (pr *PullRequest) LoadBaseRepoCtx(ctx context.Context) (err error) {
 
 	pr.BaseRepo, err = repo_model.GetRepositoryByIDCtx(ctx, pr.BaseRepoID)
 	if err != nil {
-		return fmt.Errorf("pr[%d].LoadBaseRepo[%d]: %w", pr.ID, pr.BaseRepoID, err)
+		return fmt.Errorf("repo_model.GetRepositoryByID(base): %w", err)
 	}
 	return nil
 }

modules/log/colors.go

@@ -384,13 +384,6 @@ func (cv *ColoredValue) Format(s fmt.State, c rune) {
 	s.Write(*cv.resetBytes)
 }
 
-// ColorFormatAsString returns the result of the ColorFormat without the color
-func ColorFormatAsString(colorVal ColorFormatted) string {
-	s := new(strings.Builder)
-	_, _ = ColorFprintf(&protectedANSIWriter{w: s, mode: removeColor}, "%-v", colorVal)
-	return s.String()
-}
-
 // SetColorBytes will allow a user to set the colorBytes of a colored value
 func (cv *ColoredValue) SetColorBytes(colorBytes []byte) {
 	cv.colorBytes = &colorBytes

modules/log/log.go

@@ -10,8 +10,6 @@ import (
 	"runtime"
 	"strings"
 	"sync"
-
-	"code.gitea.io/gitea/modules/process"
 )
 
 type loggerMap struct {
@@ -288,15 +286,6 @@ func (l *LoggerAsWriter) Log(msg string) {
 }
 
 func init() {
-	process.Trace = func(start bool, pid process.IDType, description string, parentPID process.IDType, typ string) {
-		if start && parentPID != "" {
-			Log(1, TRACE, "Start %s: %s (from %s) (%s)", NewColoredValue(pid, FgHiYellow), description, NewColoredValue(parentPID, FgYellow), NewColoredValue(typ, Reset))
-		} else if start {
-			Log(1, TRACE, "Start %s: %s (%s)", NewColoredValue(pid, FgHiYellow), description, NewColoredValue(typ, Reset))
-		} else {
-			Log(1, TRACE, "Done %s: %s", NewColoredValue(pid, FgHiYellow), NewColoredValue(description, Reset))
-		}
-	}
 	_, filename, _, _ := runtime.Caller(0)
 	prefix = strings.TrimSuffix(filename, "modules/log/log.go")
 	if prefix == filename {

modules/process/manager.go

@@ -7,7 +7,6 @@ package process
 
 import (
 	"context"
-	"log"
 	"runtime/pprof"
 	"strconv"
 	"sync"
@@ -45,18 +44,6 @@ type IDType string
 // - it is simply an alias for context.CancelFunc and is only for documentary purposes
 type FinishedFunc = context.CancelFunc
 
-var Trace = defaultTrace // this global can be overridden by particular logging packages - thus avoiding import cycles
-
-func defaultTrace(start bool, pid IDType, description string, parentPID IDType, typ string) {
-	if start && parentPID != "" {
-		log.Printf("start process %s: %s (from %s) (%s)", pid, description, parentPID, typ)
-	} else if start {
-		log.Printf("start process %s: %s (%s)", pid, description, typ)
-	} else {
-		log.Printf("end process %s: %s", pid, description)
-	}
-}
-
 // Manager manages all processes and counts PIDs.
 type Manager struct {
 	mutex sync.Mutex
@@ -168,7 +155,6 @@ func (pm *Manager) Add(ctx context.Context, description string, cancel context.C
 
 	pm.processMap[pid] = process
 	pm.mutex.Unlock()
-	Trace(true, pid, description, parentPID, processType)
 
 	pprofCtx := pprof.WithLabels(ctx, pprof.Labels(DescriptionPProfLabel, description, PPIDPProfLabel, string(parentPID), PIDPProfLabel, string(pid), ProcessTypePProfLabel, processType))
 	if currentlyRunning {
@@ -200,12 +186,18 @@ func (pm *Manager) nextPID() (start time.Time, pid IDType) {
 	return start, pid
 }
 
+// Remove a process from the ProcessManager.
+func (pm *Manager) Remove(pid IDType) {
+	pm.mutex.Lock()
+	delete(pm.processMap, pid)
+	pm.mutex.Unlock()
+}
+
 func (pm *Manager) remove(process *process) {
 	pm.mutex.Lock()
 	defer pm.mutex.Unlock()
 	if p := pm.processMap[process.PID]; p == process {
 		delete(pm.processMap, process.PID)
-		Trace(false, process.PID, process.Description, process.ParentPID, process.Type)
 	}
 }
 

modules/process/manager_test.go

@@ -83,7 +83,7 @@ func TestManager_Remove(t *testing.T) {
 
 	assert.NotEqual(t, GetContext(p1Ctx).GetPID(), GetContext(p2Ctx).GetPID(), "expected to get different pids got %s == %s", GetContext(p2Ctx).GetPID(), GetContext(p1Ctx).GetPID())
 
-	finished()
+	pm.Remove(GetPID(p2Ctx))
 
 	_, exists := pm.processMap[GetPID(p2Ctx)]
 	assert.False(t, exists, "PID %d is in the list but shouldn't", GetPID(p2Ctx))

routers/web/repo/pull.go

@@ -912,54 +912,59 @@ func MergePullRequest(ctx *context.Context) {
 	pr := issue.PullRequest
 	pr.Issue = issue
 	pr.Issue.Repo = ctx.Repo.Repository
-	manualMerge := repo_model.MergeStyle(form.Do) == repo_model.MergeStyleManuallyMerged
+	manuallMerge := repo_model.MergeStyle(form.Do) == repo_model.MergeStyleManuallyMerged
 	forceMerge := form.ForceMerge != nil && *form.ForceMerge
 
 	// start with merging by checking
-	if err := pull_service.CheckPullMergable(ctx, ctx.Doer, &ctx.Repo.Permission, pr, manualMerge, forceMerge); err != nil {
-		switch {
-		case errors.Is(err, pull_service.ErrIsClosed):
+	if err := pull_service.CheckPullMergable(ctx, ctx.Doer, &ctx.Repo.Permission, pr, manuallMerge, forceMerge); err != nil {
+		if errors.Is(err, pull_service.ErrIsClosed) {
 			if issue.IsPull {
 				ctx.Flash.Error(ctx.Tr("repo.pulls.is_closed"))
+				ctx.Redirect(issue.Link())
 			} else {
 				ctx.Flash.Error(ctx.Tr("repo.issues.closed_title"))
+				ctx.Redirect(issue.Link())
 			}
-		case errors.Is(err, pull_service.ErrUserNotAllowedToMerge):
+		} else if errors.Is(err, pull_service.ErrUserNotAllowedToMerge) {
 			ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
-		case errors.Is(err, pull_service.ErrHasMerged):
+			ctx.Redirect(issue.Link())
+		} else if errors.Is(err, pull_service.ErrHasMerged) {
 			ctx.Flash.Error(ctx.Tr("repo.pulls.has_merged"))
-		case errors.Is(err, pull_service.ErrIsWorkInProgress):
+			ctx.Redirect(issue.Link())
+		} else if errors.Is(err, pull_service.ErrIsWorkInProgress) {
 			ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_wip"))
-		case errors.Is(err, pull_service.ErrNotMergableState):
+			ctx.Redirect(issue.Link())
+		} else if errors.Is(err, pull_service.ErrNotMergableState) {
 			ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
-		case models.IsErrDisallowedToMerge(err):
+			ctx.Redirect(issue.Link())
+		} else if models.IsErrDisallowedToMerge(err) {
 			ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
-		case asymkey_service.IsErrWontSign(err):
-			ctx.Flash.Error(err.Error()) // has no translation ...
-		case errors.Is(err, pull_service.ErrDependenciesLeft):
+			ctx.Redirect(issue.Link())
+		} else if asymkey_service.IsErrWontSign(err) {
+			ctx.Flash.Error(err.Error()) // has not translation ...
+			ctx.Redirect(issue.Link())
+		} else if errors.Is(err, pull_service.ErrDependenciesLeft) {
 			ctx.Flash.Error(ctx.Tr("repo.issues.dependency.pr_close_blocked"))
-		default:
+			ctx.Redirect(issue.Link())
+		} else {
 			ctx.ServerError("WebCheck", err)
-			return
 		}
-
-		ctx.Redirect(issue.Link())
 		return
 	}
 
 	// handle manually-merged mark
-	if manualMerge {
+	if manuallMerge {
 		if err := pull_service.MergedManually(pr, ctx.Doer, ctx.Repo.GitRepo, form.MergeCommitID); err != nil {
-			switch {
-
-			case models.IsErrInvalidMergeStyle(err):
+			if models.IsErrInvalidMergeStyle(err) {
 				ctx.Flash.Error(ctx.Tr("repo.pulls.invalid_merge_option"))
-			case strings.Contains(err.Error(), "Wrong commit ID"):
+				ctx.Redirect(issue.Link())
+			} else if strings.Contains(err.Error(), "Wrong commit ID") {
 				ctx.Flash.Error(ctx.Tr("repo.pulls.wrong_commit_id"))
-			default:
+				ctx.Redirect(issue.Link())
+			} else {
 				ctx.ServerError("MergedManually", err)
-				return
 			}
+			return
 		}
 
 		ctx.Redirect(issue.Link())

services/automerge/automerge.go

@@ -165,7 +165,7 @@ func getPullRequestsByHeadSHA(ctx context.Context, sha string, repo *repo_model.
 
 func handlePull(pullID int64, sha string) {
 	ctx, _, finished := process.GetManager().AddContext(graceful.GetManager().HammerContext(),
-		fmt.Sprintf("Handle AutoMerge of PR[%d] with sha[%s]", pullID, sha))
+		fmt.Sprintf("Handle AutoMerge of pull[%d] with sha[%s]", pullID, sha))
 	defer finished()
 
 	pr, err := issues_model.GetPullRequestByID(ctx, pullID)
@@ -177,7 +177,7 @@ func handlePull(pullID int64, sha string) {
 	// Check if there is a scheduled pr in the db
 	exists, scheduledPRM, err := pull_model.GetScheduledMergeByPullID(ctx, pr.ID)
 	if err != nil {
-		log.Error("%-v GetScheduledMergeByPullID: %v", pr, err)
+		log.Error("pull[%d] GetScheduledMergeByPullID: %v", pr.ID, err)
 		return
 	}
 	if !exists {
@@ -189,54 +189,54 @@ func handlePull(pullID int64, sha string) {
 	// did not succeed or was not finished yet.
 
 	if err = pr.LoadHeadRepoCtx(ctx); err != nil {
-		log.Error("%-v LoadHeadRepo: %v", pr, err)
+		log.Error("pull[%d] LoadHeadRepoCtx: %v", pr.ID, err)
 		return
 	}
 
 	headGitRepo, err := git.OpenRepository(ctx, pr.HeadRepo.RepoPath())
 	if err != nil {
-		log.Error("OpenRepository %-v: %v", pr.HeadRepo, err)
+		log.Error("OpenRepository: %v", err)
 		return
 	}
 	defer headGitRepo.Close()
 
 	headBranchExist := headGitRepo.IsBranchExist(pr.HeadBranch)
 
 	if pr.HeadRepo == nil || !headBranchExist {
-		log.Warn("Head branch of auto merge %-v does not exist [HeadRepoID: %d, Branch: %s]", pr, pr.HeadRepoID, pr.HeadBranch)
+		log.Warn("Head branch of auto merge pr does not exist [HeadRepoID: %d, Branch: %s, PR ID: %d]", pr.HeadRepoID, pr.HeadBranch, pr.ID)
 		return
 	}
 
 	// Check if all checks succeeded
 	pass, err := pull_service.IsPullCommitStatusPass(ctx, pr)
 	if err != nil {
-		log.Error("%-v IsPullCommitStatusPass: %v", pr, err)
+		log.Error("IsPullCommitStatusPass: %v", err)
 		return
 	}
 	if !pass {
-		log.Info("Scheduled auto merge %-v has unsuccessful status checks", pr)
+		log.Info("Scheduled auto merge pr has unsuccessful status checks [PullID: %d]", pr.ID)
 		return
 	}
 
 	// Merge if all checks succeeded
 	doer, err := user_model.GetUserByIDCtx(ctx, scheduledPRM.DoerID)
 	if err != nil {
-		log.Error("Unable to get scheduled User[%d]: %v", scheduledPRM.DoerID, err)
+		log.Error("GetUserByIDCtx: %v", err)
 		return
 	}
 
 	perm, err := access_model.GetUserRepoPermission(ctx, pr.HeadRepo, doer)
 	if err != nil {
-		log.Error("GetUserRepoPermission %-v: %v", pr.HeadRepo, err)
+		log.Error("GetUserRepoPermission: %v", err)
 		return
 	}
 
 	if err := pull_service.CheckPullMergable(ctx, doer, &perm, pr, false, false); err != nil {
 		if errors.Is(pull_service.ErrUserNotAllowedToMerge, err) {
-			log.Info("%-v was scheduled to automerge by an unauthorized user", pr)
+			log.Info("PR %d was scheduled to automerge by an unauthorized user", pr.ID)
 			return
 		}
-		log.Error("%-v CheckPullMergable: %v", pr, err)
+		log.Error("pull[%d] CheckPullMergable: %v", pr.ID, err)
 		return
 	}
 
@@ -245,13 +245,13 @@ func handlePull(pullID int64, sha string) {
 		baseGitRepo = headGitRepo
 	} else {
 		if err = pr.LoadBaseRepoCtx(ctx); err != nil {
-			log.Error("%-v LoadBaseRepo: %v", pr, err)
+			log.Error("LoadBaseRepoCtx: %v", err)
 			return
 		}
 
 		baseGitRepo, err = git.OpenRepository(ctx, pr.BaseRepo.RepoPath())
 		if err != nil {
-			log.Error("OpenRepository %-v: %v", pr.BaseRepo, err)
+			log.Error("OpenRepository: %v", err)
 			return
 		}
 		defer baseGitRepo.Close()