all logs now have an op field

internal/pkg/pm2/pm2.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/thecodingmachine/gotenberg/internal/pkg/logger"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/standarderror"
 )
 
 const (
@@ -34,8 +35,9 @@ type processManager struct {
 }
 
 func (m *processManager) start(p Process) error {
+	const op = "pm2.start"
 	if err := m.pm2(p, "start"); err != nil {
-		return err
+		return &standarderror.Error{Op: op, Err: err}
 	}
 	p.warmup()
 	if !p.viable() {
@@ -43,14 +45,17 @@ func (m *processManager) start(p Process) error {
 		for attempts < 5 && !p.viable() {
 			if err := m.pm2(p, "restart"); err != nil {
 				m.heuristicState = errorState
-				return err
+				return &standarderror.Error{Op: op, Err: err}
 			}
 			p.warmup()
 			attempts++
 		}
 		if !p.viable() {
 			m.heuristicState = errorState
-			return fmt.Errorf("failed to launch %s", p.Fullname())
+			return &standarderror.Error{
+				Op:      op,
+				Message: fmt.Sprintf("failed to launch %s", p.Fullname()),
+			}
 		}
 	}
 	m.heuristicState = runningState
@@ -58,18 +63,20 @@ func (m *processManager) start(p Process) error {
 }
 
 func (m *processManager) shutdown(p Process) error {
+	const op = "pm2.shutdown"
 	if m.heuristicState != runningState {
 		return nil
 	}
 	if err := m.pm2(p, "stop"); err != nil {
 		m.heuristicState = errorState
-		return err
+		return &standarderror.Error{Op: op, Err: err}
 	}
 	m.heuristicState = stoppedState
 	return nil
 }
 
 func (m *processManager) pm2(p Process, cmdName string) error {
+	const op = "pm2.pm2"
 	cmdArgs := []string{
 		cmdName,
 		p.name(),
@@ -82,35 +89,36 @@ func (m *processManager) pm2(p Process, cmdName string) error {
 		"pm2",
 		cmdArgs...,
 	)
-	m.logger.Debugf("executing command: %v", strings.Join(cmd.Args, " "))
+	m.logger.DebugfOp(op, "executing command: %s", strings.Join(cmd.Args, " "))
 	processStdOut, err := cmd.StdoutPipe()
 	if err != nil {
-		return fmt.Errorf("failed getting stdout from %s: %s", p.Fullname(), err)
+		return &standarderror.Error{Op: op, Err: err}
 	}
 	processStdErr, err := cmd.StderrPipe()
 	if err != nil {
-		return fmt.Errorf("failed getting stderr from %s: %s", p.Fullname(), err)
+		return &standarderror.Error{Op: op, Err: err}
 	}
 	readFromPipe := func(outputType string, reader io.ReadCloser) {
+		readFromPipeOp := fmt.Sprintf("pm2.%s.%s", p.name(), outputType)
 		r := bufio.NewReader(reader)
 		defer reader.Close() // nolint: errcheck
 		for {
 			line, _, err := r.ReadLine()
 			if err != nil {
 				if err != io.EOF {
-					m.logger.Errorf("error reading from %s for process %s", outputType, p.Fullname())
+					m.logger.ErrorOp(readFromPipeOp, err)
 				}
 				break
 			}
 			if len(line) != 0 {
-				m.logger.Debugf("%s %s: %s", p.Fullname(), outputType, string(line))
+				m.logger.DebugfOp(readFromPipeOp, string(line))
 			}
 		}
 	}
 	go readFromPipe("stdout", processStdOut)
 	go readFromPipe("stderr", processStdErr)
 	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("%s %s with PM2: %v", cmdName, p.Fullname(), err)
+		return &standarderror.Error{Op: op, Err: err}
 	}
 	return nil
 }