fix: do not do fancy 3rd party process logging (#3747)

do not write fields et al, let it just roll, otherwise its too noisy,
and we might expose things we are not supposed to.

closes #3741

Signed-off-by: Carlos A Becker <caarlos0@users.noreply.github.com>

internal/exec/exec.go

@@ -102,8 +102,8 @@ func executeCommand(c *command, artifact *artifact.Artifact) error {
 	}
 	var b bytes.Buffer
 	w := gio.Safe(&b)
-	cmd.Stderr = io.MultiWriter(logext.NewWriter(fields, logext.Error), w)
-	cmd.Stdout = io.MultiWriter(logext.NewWriter(fields, logext.Info), w)
+	cmd.Stderr = io.MultiWriter(logext.NewWriter(), w)
+	cmd.Stdout = io.MultiWriter(logext.NewWriter(), w)
 
 	log.WithFields(fields).Info("publishing")
 	if err := cmd.Run(); err != nil {

internal/logext/testdata/TestWriter/debug.txt.golden

@@ -0,0 +1,2 @@
+foo
+bar

internal/logext/writer.go

@@ -1,72 +1,29 @@
 package logext
 
 import (
-	"bytes"
 	"io"
 	"os"
-	"strings"
 
 	"github.com/caarlos0/log"
 )
 
-// Output type of the log output.
-type Output int
-
-const (
-	// Info usually is used with stdout.
-	Info Output = iota
-
-	// Error usually is used with stderr.
-	Error
-)
-
 // NewWriter creates a new log writer.
-func NewWriter(fields log.Fields, out Output) io.Writer {
-	return NewConditionalWriter(fields, out, false)
+func NewWriter() io.Writer {
+	return NewConditionalWriter(false)
 }
 
 // NewConditionalWriter creates a new log writer that only writes when the given condition is met or debug is enabled.
-func NewConditionalWriter(fields log.Fields, out Output, condition bool) io.Writer {
+func NewConditionalWriter(condition bool) io.Writer {
 	if condition || isDebug() {
-		return logWriter{
-			ctx: newLogger(fields),
-			out: out,
+		logger, ok := log.Log.(*log.Logger)
+		if !ok {
+			return os.Stderr
 		}
+		return logger.Writer
 	}
 	return io.Discard
 }
 
-type logWriter struct {
-	ctx *log.Entry
-	out Output
-}
-
-func (w logWriter) Write(p []byte) (int, error) {
-	for _, line := range strings.Split(toString(p), "\n") {
-		switch w.out {
-		case Info:
-			w.ctx.Info(line)
-		case Error:
-			w.ctx.Warn(line)
-		}
-	}
-	return len(p), nil
-}
-
-func newLogger(fields log.Fields) *log.Entry {
-	handler := log.New(currentWriter())
-	handler.IncreasePadding()
-	return handler.WithFields(fields)
-}
-
-func currentWriter() io.Writer {
-	logger, ok := log.Log.(*log.Logger)
-	if !ok {
-		return os.Stderr
-	}
-	return logger.Writer
-}
-
 func isDebug() bool {
 	return logLevel() == log.DebugLevel
 }
@@ -77,7 +34,3 @@ func logLevel() log.Level {
 	}
 	return log.InfoLevel
 }
-
-func toString(b []byte) string {
-	return string(bytes.TrimSuffix(b, []byte("\n")))
-}

internal/logext/writer_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"io"
 	"os"
-	"strconv"
 	"testing"
 
 	"github.com/caarlos0/log"
@@ -18,35 +17,27 @@ func TestWriter(t *testing.T) {
 	lipgloss.SetColorProfile(termenv.Ascii)
 
 	t.Run("info", func(t *testing.T) {
-		for _, out := range []Output{Info, Error} {
-			t.Run(strconv.Itoa(int(out)), func(t *testing.T) {
-				t.Cleanup(func() {
-					log.Log = log.New(os.Stderr)
-				})
-				var b bytes.Buffer
-				log.Log = log.New(&b)
-				l, err := io.WriteString(NewWriter(log.Fields{"foo": "bar"}, out), "foo\nbar\n")
-				require.NoError(t, err)
-				require.Equal(t, 8, l)
-				require.Empty(t, b.String())
-			})
-		}
+		t.Cleanup(func() {
+			log.Log = log.New(os.Stderr)
+		})
+		var b bytes.Buffer
+		log.Log = log.New(&b)
+		l, err := io.WriteString(NewWriter(), "foo\nbar\n")
+		require.NoError(t, err)
+		require.Equal(t, 8, l)
+		require.Empty(t, b.String())
 	})
 
 	t.Run("debug", func(t *testing.T) {
-		for _, out := range []Output{Info, Error} {
-			t.Run(strconv.Itoa(int(out)), func(t *testing.T) {
-				t.Cleanup(func() {
-					log.Log = log.New(os.Stderr)
-				})
-				var b bytes.Buffer
-				log.Log = log.New(&b)
-				log.SetLevel(log.DebugLevel)
-				l, err := io.WriteString(NewWriter(log.Fields{"foo": "bar"}, out), "foo\nbar\n")
-				require.NoError(t, err)
-				require.Equal(t, 8, l)
-				golden.RequireEqualTxt(t, b.Bytes())
-			})
-		}
+		t.Cleanup(func() {
+			log.Log = log.New(os.Stderr)
+		})
+		var b bytes.Buffer
+		log.Log = log.New(&b)
+		log.SetLevel(log.DebugLevel)
+		l, err := io.WriteString(NewWriter(), "foo\nbar\n")
+		require.NoError(t, err)
+		require.Equal(t, 8, l)
+		golden.RequireEqualTxt(t, b.Bytes())
 	})
 }

internal/pipe/before/before.go

@@ -43,8 +43,8 @@ func (Pipe) Run(ctx *context.Context) error {
 		var b bytes.Buffer
 		w := gio.Safe(&b)
 		fields := log.Fields{"hook": step}
-		cmd.Stderr = io.MultiWriter(logext.NewWriter(fields, logext.Error), w)
-		cmd.Stdout = io.MultiWriter(logext.NewWriter(fields, logext.Info), w)
+		cmd.Stderr = io.MultiWriter(logext.NewWriter(), w)
+		cmd.Stdout = io.MultiWriter(logext.NewWriter(), w)
 
 		log.WithFields(fields).Info("running")
 		if err := cmd.Run(); err != nil {

internal/pipe/docker/api.go

@@ -57,8 +57,8 @@ func runCommand(ctx *context.Context, dir, binary string, args ...string) error
 
 	var b bytes.Buffer
 	w := gio.Safe(&b)
-	cmd.Stderr = io.MultiWriter(logext.NewWriter(fields, logext.Error), w)
-	cmd.Stdout = io.MultiWriter(logext.NewWriter(fields, logext.Info), w)
+	cmd.Stderr = io.MultiWriter(logext.NewWriter(), w)
+	cmd.Stdout = io.MultiWriter(logext.NewWriter(), w)
 
 	log.WithFields(fields).WithField("args", args[1:]).Debug("running")
 	if err := cmd.Run(); err != nil {
@@ -80,13 +80,13 @@ func runCommandWithOutput(ctx *context.Context, dir, binary string, args ...stri
 
 	var b bytes.Buffer
 	w := gio.Safe(&b)
-	cmd.Stderr = io.MultiWriter(logext.NewWriter(fields, logext.Error), w)
+	cmd.Stderr = io.MultiWriter(logext.NewWriter(), w)
 
 	log.WithFields(fields).WithField("args", args[1:]).Debug("running")
 	out, err := cmd.Output()
 	if out != nil {
 		// regardless of command success, always print stdout for backward-compatibility with runCommand()
-		_, _ = io.MultiWriter(logext.NewWriter(fields, logext.Error), w).Write(out)
+		_, _ = io.MultiWriter(logext.NewWriter(), w).Write(out)
 	}
 	if err != nil {
 		return nil, fmt.Errorf("%w: %s", err, b.String())

internal/pipe/sbom/sbom.go

@@ -191,8 +191,8 @@ func catalogArtifact(ctx *context.Context, cfg config.SBOM, a *artifact.Artifact
 
 	var b bytes.Buffer
 	w := gio.Safe(&b)
-	cmd.Stderr = io.MultiWriter(logext.NewWriter(fields, logext.Error), w)
-	cmd.Stdout = io.MultiWriter(logext.NewWriter(fields, logext.Info), w)
+	cmd.Stderr = io.MultiWriter(logext.NewWriter(), w)
+	cmd.Stdout = io.MultiWriter(logext.NewWriter(), w)
 
 	log.WithFields(fields).Info("cataloging")
 	if err := cmd.Run(); err != nil {

internal/pipe/sign/sign.go

@@ -219,8 +219,8 @@ func signone(ctx *context.Context, cfg config.Sign, art *artifact.Artifact) ([]*
 	cmd := exec.CommandContext(ctx, cfg.Cmd, args...)
 	var b bytes.Buffer
 	w := gio.Safe(&b)
-	cmd.Stderr = io.MultiWriter(logext.NewConditionalWriter(fields, logext.Error, cfg.Output), w)
-	cmd.Stdout = io.MultiWriter(logext.NewConditionalWriter(fields, logext.Info, cfg.Output), w)
+	cmd.Stderr = io.MultiWriter(logext.NewConditionalWriter(cfg.Output), w)
+	cmd.Stdout = io.MultiWriter(logext.NewConditionalWriter(cfg.Output), w)
 	if stdin != nil {
 		cmd.Stdin = stdin
 	}

internal/shell/shell.go

@@ -27,8 +27,8 @@ func Run(ctx *context.Context, dir string, command, env []string, output bool) e
 	var b bytes.Buffer
 	w := gio.Safe(&b)
 
-	cmd.Stderr = io.MultiWriter(logext.NewConditionalWriter(fields, logext.Error, output), w)
-	cmd.Stdout = io.MultiWriter(logext.NewConditionalWriter(fields, logext.Info, output), w)
+	cmd.Stderr = io.MultiWriter(logext.NewConditionalWriter(output), w)
+	cmd.Stdout = io.MultiWriter(logext.NewConditionalWriter(output), w)
 
 	if dir != "" {
 		cmd.Dir = dir