chore: debug level executor logs

cmd/joj3/log.go

@@ -96,6 +96,12 @@ func setupSlog(logPath string) error {
 		Level: stderrLogLevel,
 	})
 	handlers = append(handlers, stderrHandler)
+	if runningTest {
+		stderrJSONHandler := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{
+			Level: stderrLogLevel,
+		})
+		handlers = append(handlers, stderrJSONHandler)
+	}
 	// Create a multi-handler
 	multiHandler := &multiHandler{handlers: handlers}
 	multiHandlerWithAttrs := multiHandler.WithAttrs(

internal/parser/diff/parser.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/criyle/go-judge/envexec"
 	"github.com/joint-online-judge/JOJ3/internal/stage"
 )
 
@@ -36,15 +35,6 @@ type Conf struct {
 	}
 }
 
-type DiffParserSummary struct {
-	Status     stage.Status
-	ExitStatus int
-	Error      string
-	Time       uint64
-	Memory     uint64
-	RunTime    uint64
-}
-
 type Diff struct{}
 
 func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
@@ -60,25 +50,10 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 
 	var res []stage.ParserResult
 	forceQuit := false
-	var summary DiffParserSummary
-	summary.Status = stage.Status(envexec.StatusAccepted)
 	for i, caseConf := range conf.Cases {
 		result := results[i]
 		score := 0
 		comment := ""
-		if result.Status != stage.Status(envexec.StatusAccepted) &&
-			summary.Status == stage.Status(envexec.StatusAccepted) {
-			summary.Status = result.Status
-		}
-		if result.ExitStatus != 0 && summary.ExitStatus == 0 {
-			summary.ExitStatus = result.ExitStatus
-		}
-		if result.Error != "" && summary.Error == "" {
-			summary.Error = result.Error
-		}
-		summary.Time += result.Time
-		summary.Memory += result.Memory
-		summary.RunTime += result.RunTime
 		for _, output := range caseConf.Outputs {
 			answer, err := os.ReadFile(output.AnswerPath)
 			if err != nil {
@@ -124,22 +99,11 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 				}
 			}
 		}
-		caseSummary := DiffParserSummary{
-			Status:     result.Status,
-			ExitStatus: result.ExitStatus,
-			Error:      result.Error,
-			Time:       result.Time,
-			Memory:     result.Memory,
-			RunTime:    result.RunTime,
-		}
-		slog.Debug("diff parser case parse done",
-			"case", i, "caseSummary", caseSummary)
 		res = append(res, stage.ParserResult{
 			Score:   score,
 			Comment: comment,
 		})
 	}
-	slog.Debug("diff parser run done", "diffParserSummary", summary)
 
 	return res, forceQuit, nil
 }

internal/stage/model.go

@@ -121,25 +121,26 @@ type ExecutorResult struct {
 	Buffs map[string][]byte `json:"-"`
 }
 
+type ExecutorResultSummary struct {
+	Status     Status            `json:"status"`
+	ExitStatus int               `json:"exitStatus"`
+	Error      string            `json:"error,omitempty"`
+	Time       uint64            `json:"time"`
+	Memory     uint64            `json:"memory"`
+	RunTime    uint64            `json:"runTime"`
+	Files      map[string]string `json:"files,omitempty"`
+	FileIDs    map[string]string `json:"fileIds,omitempty"`
+	FileError  []FileError       `json:"fileError,omitempty"`
+}
+
 func (r ExecutorResult) String() string {
-	type Result struct {
+	d := ExecutorResultSummary{
-		Status     Status
-		ExitStatus int
-		Error      string
-		Time       uint64
-		RunTime    uint64
-		Memory     envexec.Size
-		Files      map[string]string
-		FileIDs    map[string]string
-		FileError  []FileError
-	}
-	d := Result{
 		Status:     r.Status,
 		ExitStatus: r.ExitStatus,
 		Error:      r.Error,
 		Time:       r.Time,
+		Memory:     r.Memory,
 		RunTime:    r.RunTime,
-		Memory:     envexec.Size(r.Memory),
 		Files:      make(map[string]string),
 		FileIDs:    r.FileIDs,
 		FileError:  r.FileError,
@@ -150,6 +151,45 @@ func (r ExecutorResult) String() string {
 	return fmt.Sprintf("%+v", d)
 }
 
+func (r ExecutorResult) MarshalJSON() ([]byte, error) {
+	d := ExecutorResultSummary{
+		Status:     r.Status,
+		ExitStatus: r.ExitStatus,
+		Error:      r.Error,
+		Time:       r.Time,
+		Memory:     r.Memory,
+		RunTime:    r.RunTime,
+		Files:      make(map[string]string),
+		FileIDs:    r.FileIDs,
+		FileError:  r.FileError,
+	}
+	for k, v := range r.Files {
+		d.Files[k] = "len:" + strconv.Itoa(len(v))
+	}
+	return json.Marshal(d)
+}
+
+func SummarizeExecutorResults(results []ExecutorResult) ExecutorResultSummary {
+	var summary ExecutorResultSummary
+	summary.Status = Status(envexec.StatusAccepted)
+	for _, result := range results {
+		if result.Status != Status(envexec.StatusAccepted) &&
+			summary.Status == Status(envexec.StatusAccepted) {
+			summary.Status = result.Status
+		}
+		if result.ExitStatus != 0 && summary.ExitStatus == 0 {
+			summary.ExitStatus = result.ExitStatus
+		}
+		if result.Error != "" && summary.Error == "" {
+			summary.Error = result.Error
+		}
+		summary.Time += result.Time
+		summary.Memory += result.Memory
+		summary.RunTime += result.RunTime
+	}
+	return summary
+}
+
 type StageExecutor struct {
 	Name string
 	Cmds []Cmd

internal/stage/run.go

@@ -12,30 +12,65 @@ func Run(stages []Stage) (stageResults []StageResult, forceQuit bool, err error)
 	slog.Info("stage run start")
 	for _, stage := range stages {
 		slog.Info("stage start", "name", stage.Name)
-		slog.Info("executor run start", "name", stage.Executor.Name)
+		slog.Info(
-		slog.Debug("executor run start", "name", stage.Executor.Name,
+			"executor run start",
-			"cmds", stage.Executor.Cmds)
+			"stageName", stage.Name,
+			"name", stage.Executor.Name,
+		)
+		slog.Debug(
+			"executor run start",
+			"stageName", stage.Name,
+			"name", stage.Executor.Name,
+			"cmds", stage.Executor.Cmds,
+		)
 		executor, ok := executorMap[stage.Executor.Name]
 		if !ok {
-			slog.Error("executor not found", "name", stage.Executor.Name)
+			slog.Error(
+				"executor not found",
+				"stageName", stage.Name,
+				"name", stage.Executor.Name,
+			)
 			err = fmt.Errorf("executor not found: %s", stage.Executor.Name)
 			return
 		}
 		executorResults, err = executor.Run(stage.Executor.Cmds)
 		if err != nil {
-			slog.Error("executor run error", "name", stage.Executor.Name, "error", err)
+			slog.Error(
+				"executor run error",
+				"stageName", stage.Name,
+				"name", stage.Executor.Name,
+				"error", err,
+			)
 			return
 		}
-		slog.Debug("executor run done", "results", executorResults)
+		slog.Debug(
+			"executor run done",
+			"stageName", stage.Name,
+			"name", stage.Executor.Name,
+			"results", executorResults,
+			"summary", SummarizeExecutorResults(executorResults),
+		)
 		parserResults = []ParserResult{}
 		forceQuit = false
 		for _, stageParser := range stage.Parsers {
-			slog.Info("parser run start", "name", stageParser.Name)
+			slog.Info(
-			slog.Debug("parser run start", "name", stageParser.Name,
+				"parser run start",
-				"conf", stageParser.Conf)
+				"stageName", stage.Name,
+				"name", stageParser.Name,
+			)
+			slog.Debug(
+				"parser run start",
+				"stageName", stage.Name,
+				"name", stageParser.Name,
+				"conf", stageParser.Conf,
+			)
 			parser, ok := parserMap[stageParser.Name]
 			if !ok {
-				slog.Error("parser not found", "name", stageParser.Name)
+				slog.Error(
+					"parser not found",
+					"stageName", stage.Name,
+					"name", stageParser.Name,
+				)
 				err = fmt.Errorf("parser not found: %s", stageParser.Name)
 				return
 			}
@@ -43,14 +78,28 @@ func Run(stages []Stage) (stageResults []StageResult, forceQuit bool, err error)
 			tmpParserResults, parserForceQuit, err = parser.Run(
 				executorResults, stageParser.Conf)
 			if err != nil {
-				slog.Error("parser run error", "name", stageParser.Name, "error", err)
+				slog.Error(
+					"parser run error",
+					"stageName", stage.Name,
+					"name", stageParser.Name,
+					"error", err,
+				)
 				return
 			}
 			if parserForceQuit {
-				slog.Error("parser force quit", "name", stageParser.Name)
+				slog.Error(
+					"parser force quit",
+					"stageName", stage.Name,
+					"name", stageParser.Name,
+				)
 			}
 			forceQuit = forceQuit || parserForceQuit
-			slog.Debug("parser run done", "results", tmpParserResults)
+			slog.Debug(
+				"parser run done",
+				"stageName", stage.Name,
+				"name", stageParser.Name,
+				"results", tmpParserResults,
+			)
 			if len(parserResults) == 0 {
 				parserResults = tmpParserResults
 			} else {