Replace multi line formatting to single line formatting for kpt logs (#326)

* Replace MultiLineFormatter with a SingleLineFormatter

- Remove \n and \t from render errors
- Use single line for function results

* Fix upgrade cli unit test

* Add unit tests to cover new code

* fix duplicated literal and add unit tests for kpt errors.go

* Update TestSingleLineFormatter unit test in runner_test.go

Author: kushnaidu

internal/kpt/errors/errors.go

@@ -1,4 +1,4 @@
-// Copyright 2021 The kpt and Nephio Authors
+// Copyright 2021,2025 The kpt and Nephio Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -93,7 +93,7 @@ func (e *Error) Error() string {
 		var wrappedErr *Error
 		if As(e.Err, &wrappedErr) {
 			if !wrappedErr.Zero() {
-				pad(b, ":\n\t")
+				pad(b, ": ")
 				b.WriteString(wrappedErr.Error())
 			}
 		} else {

internal/kpt/errors/errors_test.go

@@ -0,0 +1,52 @@
+// Copyright 2025 The kpt and Nephio Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package errors
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/nephio-project/porch/internal/kpt/types"
+)
+
+func TestErrorFormatting(t *testing.T) {
+	baseErr := errors.New("base error")
+
+	e := &Error{
+		Op:    "pkg.get",
+		Path:  types.UniquePath("/workspace/my-pkg"),
+		Fn:    "my-fn",
+		Repo:  "github.com/example/repo",
+		Class: InvalidParam,
+		Err:   baseErr,
+	}
+
+	got := e.Error()
+	wantSubstrings := []string{
+		"pkg.get",
+		"pkg /workspace/my-pkg",
+		"fn my-fn",
+		"repo github.com/example/repo",
+		"invalid parameter value",
+		"base error",
+	}
+
+	for _, substr := range wantSubstrings {
+		if !strings.Contains(got, substr) {
+			t.Errorf("Expected error string to contain %q, got: %q", substr, got)
+		}
+	}
+}

internal/kpt/fnruntime/fnerrors.go

@@ -45,13 +45,13 @@ type ExecError struct {
 func (fe *ExecError) String() string {
 	var b strings.Builder
 
-	errLines := &MultiLineFormatter{
-		Title:          "Stderr",
-		Lines:          strings.Split(fe.Stderr, "\n"),
-		UseQuote:       true,
-		TruncateOutput: fe.TruncateOutput,
+	errLine := &SingleLineFormatter{
+		Title:     "[Stderr]",
+		Lines:     strings.Split(fe.Stderr, "\n"),
+		UseQuote:  false,
+		Separator: ", ",
 	}
-	b.WriteString(errLines.String())
+	b.WriteString(errLine.String())
 	b.WriteString(fmt.Sprintf("  Exit Code: %d\n", fe.ExitCode))
 	return b.String()
 }

internal/kpt/fnruntime/runner.go

@@ -449,10 +449,11 @@ func printFnResult(ctx context.Context, fnResult *fnresult.Result, opt *printer.
 		for _, item := range fnResult.Results {
 			lines = append(lines, item.String())
 		}
-		ri := &MultiLineFormatter{
-			Title:          "Results",
-			Lines:          lines,
-			TruncateOutput: printer.TruncateOutput,
+		ri := &SingleLineFormatter{
+			Title:     "[Results]",
+			Lines:     lines,
+			UseQuote:  false,
+			Separator: ", ",
 		}
 		pr.OptPrintf(opt, "%s", ri.String())
 	}
@@ -470,13 +471,13 @@ func printFnExecErr(ctx context.Context, fnErr *ExecError) {
 func printFnStderr(ctx context.Context, stdErr string) {
 	pr := printer.FromContextOrDie(ctx)
 	if len(stdErr) > 0 {
-		errLines := &MultiLineFormatter{
-			Title:          "Stderr",
-			Lines:          strings.Split(stdErr, "\n"),
-			UseQuote:       true,
-			TruncateOutput: printer.TruncateOutput,
+		errLine := &SingleLineFormatter{
+			Title:     "Stderr",
+			Lines:     strings.Split(stdErr, "\n"),
+			UseQuote:  false,
+			Separator: ", ",
 		}
-		pr.Printf("%s", errLines.String())
+		pr.Printf("%s", errLine.String())
 	}
 }
 
@@ -514,63 +515,27 @@ func enforcePathInvariants(nodes []*yaml.RNode) error {
 	return nil
 }
 
-// MultiLineFormatter knows how to format multiple lines in pretty format
-// that can be displayed to an end user.
-type MultiLineFormatter struct {
-	// Title under which lines need to be printed
-	Title string
-
-	// Lines to be printed on the CLI.
-	Lines []string
-
-	// TruncateOuput determines if output needs to be truncated or not.
-	TruncateOutput bool
-
-	// MaxLines to be printed if truncation is enabled.
-	MaxLines int
-
-	// UseQuote determines if line needs to be quoted or not
-	UseQuote bool
+type SingleLineFormatter struct {
+	Title     string   // Label for the output
+	Lines     []string // Lines to be joined
+	UseQuote  bool     // Whether to quote each line
+	Separator string   // Separator between lines (e.g., comma, space)
 }
 
-// String returns multiline string.
-func (ri *MultiLineFormatter) String() string {
-	if ri.MaxLines == 0 {
-		ri.MaxLines = FnExecErrorTruncateLines
-	}
+func (sf *SingleLineFormatter) String() string {
 	strInterpolator := "%s"
-	if ri.UseQuote {
+	if sf.UseQuote {
 		strInterpolator = "%q"
 	}
 
-	var b strings.Builder
-
-	b.WriteString(fmt.Sprintf("  %s:\n", ri.Title))
-	lineIndent := strings.Repeat(" ", FnExecErrorIndentation+2)
-	if !ri.TruncateOutput {
-		// stderr string should have indentations
-		for _, s := range ri.Lines {
-			// suppress newlines to avoid poor formatting
-			s = strings.ReplaceAll(s, "\n", " ")
-			b.WriteString(fmt.Sprintf(lineIndent+strInterpolator+"\n", s))
-		}
-		return b.String()
-	}
-	printedLines := 0
-	for i, s := range ri.Lines {
-		if i >= ri.MaxLines {
-			break
-		}
-		// suppress newlines to avoid poor formatting
-		s = strings.ReplaceAll(s, "\n", " ")
-		b.WriteString(fmt.Sprintf(lineIndent+strInterpolator+"\n", s))
-		printedLines++
+	var formattedLines []string
+	for _, line := range sf.Lines {
+		line = strings.ReplaceAll(line, "\n", " ")
+		line = strings.TrimSpace(line)
+		formattedLines = append(formattedLines, fmt.Sprintf(strInterpolator, line))
 	}
-	truncatedLines := len(ri.Lines) - printedLines
-	if truncatedLines > 0 {
-		b.WriteString(fmt.Sprintf(lineIndent+"...(%d line(s) truncated, use '--truncate-output=false' to disable)\n", truncatedLines))
-	}
-	return b.String()
+
+	return fmt.Sprintf("%s: %s", sf.Title, strings.Join(formattedLines, sf.Separator))
 }
 
 func newFnConfig(fsys filesys.FileSystem, f *kptfilev1.Function, pkgPath types.UniquePath) (*yaml.RNode, error) {

internal/kpt/fnruntime/runner_test.go

@@ -98,58 +98,55 @@ data: {foo: bar}
 		})
 	}
 }
-
-func TestMultilineFormatter(t *testing.T) {
+func TestSingleLineFormatter(t *testing.T) {
 	type testcase struct {
-		ml       *MultiLineFormatter
+		sf       *SingleLineFormatter
 		expected string
 	}
 
 	testcases := map[string]testcase{
-		"multiline should format lines and truncate": {
-			ml: &MultiLineFormatter{
-				Title: "Results",
-				Lines: []string{
-					"line-1",
-					"line-2",
-					"line-3",
-					"line-4",
-					"line-5",
-				},
-				MaxLines:       3,
-				TruncateOutput: true,
+		"single line without quotes and comma separator": {
+			sf: &SingleLineFormatter{
+				Title:     "Summary",
+				Lines:     []string{"line1", "line2", "line3"},
+				UseQuote:  false,
+				Separator: ", ",
 			},
-			expected: `  Results:
-    line-1
-    line-2
-    line-3
-    ...(2 line(s) truncated, use '--truncate-output=false' to disable)
-`,
+			expected: `Summary: line1, line2, line3`,
 		},
-		"multiline should format without truncate": {
-			ml: &MultiLineFormatter{
-				Title: "Results",
-				Lines: []string{
-					"line-1",
-					"line-2",
-					"line-3",
-					"line-4",
-					"line-5",
-				},
+		"single line with quotes and space separator": {
+			sf: &SingleLineFormatter{
+				Title:     "Summary",
+				Lines:     []string{"line1", "line2", "line3"},
+				UseQuote:  true,
+				Separator: " ",
 			},
-			expected: `  Results:
-    line-1
-    line-2
-    line-3
-    line-4
-    line-5
-`,
+			expected: `Summary: "line1" "line2" "line3"`,
+		},
+		"single line with newline suppression": {
+			sf: &SingleLineFormatter{
+				Title:     "Summary",
+				Lines:     []string{"line1\n", "line2\nextra", "line3"},
+				UseQuote:  false,
+				Separator: ", ",
+			},
+			expected: `Summary: line1, line2 extra, line3`,
+		},
+		"empty lines": {
+			sf: &SingleLineFormatter{
+				Title:     "Empty",
+				Lines:     []string{},
+				UseQuote:  false,
+				Separator: ", ",
+			},
+			expected: `Empty: `,
 		},
 	}
+
 	for name, c := range testcases {
 		c := c
 		t.Run(name, func(t *testing.T) {
-			assert.Equal(t, c.expected, c.ml.String())
+			assert.Equal(t, c.expected, c.sf.String())
 		})
 	}
 }

pkg/cli/commands/rpkg/push/command.go

@@ -181,10 +181,11 @@ func (r *runner) printFnResult(fnResult *porchapi.Result, opt *printer.Options)
 		for _, item := range fnResult.Results {
 			lines = append(lines, str(item))
 		}
-		ri := &fnruntime.MultiLineFormatter{
-			Title:          "Results",
-			Lines:          lines,
-			TruncateOutput: printer.TruncateOutput,
+		ri := &fnruntime.SingleLineFormatter{
+			Title:     "[Results]",
+			Lines:     lines,
+			UseQuote:  false,
+			Separator: ", ",
 		}
 		r.printer.OptPrintf(opt, "%s", ri.String())
 	}