Merge pull request #33 from nxtcoder17/feat/improve-error-handling

feat: improves error handling and visibility

Author: nxtcoder17

cmd/run/completions.go

@@ -6,21 +6,13 @@ import (
 	"io"
 	"log/slog"
 
+	"github.com/nxtcoder17/go.pkgs/log"
 	"github.com/nxtcoder17/runfile/parser"
+	"github.com/nxtcoder17/runfile/types"
 )
 
-func generateShellCompletion(_ context.Context, writer io.Writer, rfpath string) error {
-	// if c.NArg() > 0 {
-	// 	return nil
-	// }
-
-	// runfilePath, err := locateRunfile(c)
-	// if err != nil {
-	// 	slog.Error("locating runfile", "err", err)
-	// 	panic(err)
-	// }
-
-	runfile, err := parser.ParseRunfile(rfpath)
+func generateShellCompletion(ctx context.Context, writer io.Writer, rfpath string) error {
+	runfile, err := parser.ParseRunfile(types.NewContext(ctx, log.New()), rfpath)
 	if err != nil {
 		slog.Error("parsing, got", "err", err)
 		panic(err)
@@ -30,17 +22,5 @@ func generateShellCompletion(_ context.Context, writer io.Writer, rfpath string)
 		fmt.Fprintf(writer, "%s\n", k)
 	}
 
-	// m, err := runfile.ParseIncludes()
-	// if err != nil {
-	// 	slog.Error("parsing, got", "err", err)
-	// 	panic(err)
-	// }
-
-	// for k, v := range m {
-	// 	for tn := range v.Runfile.Tasks {
-	// 		fmt.Fprintf(writer, "%s:%s\n", k, tn)
-	// 	}
-	// }
-
 	return nil
 }

cmd/run/main.go

@@ -15,6 +15,7 @@ import (
 	"github.com/nxtcoder17/go.pkgs/log"
 	"github.com/nxtcoder17/runfile/errors"
 	"github.com/nxtcoder17/runfile/runner"
+	"github.com/nxtcoder17/runfile/types"
 
 	"github.com/nxtcoder17/runfile/parser"
 	"github.com/urfave/cli/v3"
@@ -68,6 +69,14 @@ func main() {
 			&cli.BoolFlag{
 				Name:  "debug",
 				Value: false,
+				Action: func(ctx context.Context, c *cli.Command, b bool) error {
+					v := "false"
+					if b {
+						v = "true"
+					}
+					os.Setenv("RUNFILE_DEBUG", v)
+					return nil
+				},
 			},
 
 			&cli.BoolFlag{
@@ -146,18 +155,6 @@ func main() {
 				return nil
 			}
 
-			runfilePath, err := locateRunfile(c)
-			if err != nil {
-				slog.Error("locating runfile, got", "err", err)
-				return err
-			}
-
-			rf, err2 := parser.ParseRunfile(runfilePath)
-			if err2 != nil {
-				slog.Error("parsing runfile, got", "err", err2)
-				panic(err2)
-			}
-
 			kv := make(map[string]string)
 
 			// INFO: for supporting flags that have been suffixed post arguments
@@ -197,21 +194,40 @@ func main() {
 				ShowDebugLogs: debug,
 			})
 
-			return runner.Run(runner.NewContext(ctx, logger), rf, runner.RunArgs{
+			runfilePath, err := locateRunfile(c)
+			if err != nil {
+				slog.Error("locating runfile, got", "err", err)
+				return err
+			}
+
+			rf, err2 := parser.ParseRunfile(types.NewContext(ctx, logger), runfilePath)
+			if err2 != nil {
+				slog.Error("parsing runfile, got", "err", err2)
+				panic(err2)
+			}
+
+			if err := runner.Run(types.NewContext(ctx, logger), rf, runner.RunArgs{
 				Tasks:             args,
 				ExecuteInParallel: parallel,
 				Watch:             watch,
 				Debug:             debug,
 				KVs:               kv,
-			})
+			}); err != nil {
+				errm, ok := err.(*errors.Error)
+				slog.Debug("got", "err", err)
+				if ok {
+					if errm != nil {
+						// errm.Error()
+						// TODO: change it to a better logging
+						// slog.Error("got", "err", errm)
+						errm.Log()
+					}
+				} else {
+					slog.Error("got", "err", err)
+				}
+			}
 
-			// return rf.Run(runfile.NewContext(ctx, logger), runfile.RunArgs{
-			// 	Tasks:             args,
-			// 	ExecuteInParallel: parallel,
-			// 	Watch:             watch,
-			// 	Debug:             debug,
-			// 	KVs:               kv,
-			// })
+			return nil
 		},
 	}
 
@@ -224,18 +240,7 @@ func main() {
 	}()
 
 	if err := cmd.Run(ctx, os.Args); err != nil {
-		errm, ok := err.(*errors.Error)
-		slog.Debug("got", "err", err)
-		if ok {
-			if errm != nil {
-				// errm.Error()
-				// TODO: change it to a better logging
-				// slog.Error("got", "err", errm)
-				errm.Log()
-			}
-		} else {
-			slog.Error("got", "err", err)
-		}
+		slog.Error("while running cmd, got", "err", err)
 	}
 }
 

errors/errors.go

@@ -1,50 +1,112 @@
 package errors
 
 import (
+	"errors"
 	"fmt"
 	"log/slog"
+	"os"
 	"runtime"
+
+	"github.com/nxtcoder17/runfile/types"
 )
 
 type Error struct {
 	msg string
-	// kv is a slice of slog Attributes i.e. ("key", "value")
-	keys []string
-	// kv   map[string]any
+
+	taskName string
+
 	kv []any
 
 	traces []string
 
 	err error
 }
 
+func (e *Error) GetWrappedErrorString() string {
+	if e.err == nil {
+		return ""
+	}
+
+	return "\nfailed with error:\n" + e.err.Error()
+}
+
+func (e *Error) resolveTaskName() string {
+	if e.taskName != "" {
+		return e.taskName
+	}
+	for i := 0; i < len(e.kv)-1; i += 2 { // assume kv is key/value pairs
+		if key, ok := e.kv[i].(string); ok && key == "task" {
+			if val, ok := e.kv[i+1].(string); ok {
+				return val
+			}
+		}
+	}
+	return ""
+}
+
 // Error implements error.
 func (e *Error) Error() string {
-	return fmt.Sprintf("%v {%#v}", e.err, e.kv)
+	return e.err.Error()
+	// return fmt.Sprintf("%v {%#v}", e.err, e.kv)
+}
+
+func (e *Error) WithTaskName(tn string) *Error {
+	e.taskName = tn
+	return e
+}
+
+func (e *Error) WithCtx(ctx types.Context) *Error {
+	return e.WithTaskName(ctx.TaskName)
+}
+
+func (e *Error) GetTaskName() string {
+	return e.taskName
 }
 
 func (e *Error) Log() {
+	fmt.Fprintf(os.Stderr, "%s%s%s\n", types.GetErrorStyledPrefix(e.resolveTaskName()), e.msg, e.GetWrappedErrorString())
+	if os.Getenv("RUNFILE_DEBUG") == "true" {
+		e.InspectLog()
+	}
+}
+
+func (e *Error) InspectLog() {
 	args := make([]any, 0, len(e.kv))
 	args = append(args, e.kv...)
+
+	// b, _ := json.MarshalIndent(e.traces, "", "  ")
+	// args = append(args, "traces", string(b))
+
 	args = append(args, "traces", e.traces)
 	slog.Error(e.msg, args...)
 }
 
 var _ error = (*Error)(nil)
 
 func Err(msg string) *Error {
-	return &Error{msg: msg}
+	_, file, line, _ := runtime.Caller(1)
+	e := &Error{msg: msg}
+	e.traces = append(e.traces, fmt.Sprintf("%s:%d", file, line))
+	return e
 }
 
 func (e *Error) Wrap(err error) *Error {
 	_, file, line, _ := runtime.Caller(1)
 	e.traces = append(e.traces, fmt.Sprintf("%s:%d", file, line))
-	e.err = err
+	if e.err != nil {
+		e.err = errors.Join(e.err, err)
+	} else {
+		e.err = err
+	}
 	return e
 }
 
 func (e *Error) WrapStr(msg string) *Error {
-	e.err = fmt.Errorf(msg)
+	if e.err != nil {
+		e.err = errors.Join(e.err, fmt.Errorf(msg))
+	} else {
+		e.err = fmt.Errorf(msg)
+	}
 	return e
 }
 
@@ -57,7 +119,12 @@ func (e *Error) KV(kv ...any) *Error {
 	// 	// e.keys = append(e.keys, kv[i].(string))
 	// 	e.kv[kv[i].(string)] = kv[i+1]
 	// }
+	if len(kv) == 0 {
+		return e
+	}
+	_, file, line, _ := runtime.Caller(1)
 	e.kv = append(e.kv, kv...)
+	e.traces = append(e.traces, fmt.Sprintf("%s:%d", file, line))
 
 	return e
 }
@@ -82,9 +149,17 @@ var (
 	ErrParseDotEnv   = Err("failed to parse dotenv file")
 	ErrInvalidDotEnv = Err("invalid dotenv file")
 
-	ErrInvalidEnvVar       = Err("invalid env var")
-	ErrRequiredEnvVar      = Err("required env var")
-	ErrInvalidDefaultValue = Err("invalid default value for env var")
+	ErrInvalidEnvVar = func(k string) *Error {
+		return Err(fmt.Sprintf("invalid env var (%s)", k))
+	}
+
+	ErrRequiredEnvVar = func(k string) *Error {
+		return Err(fmt.Sprintf("required env var (%s)", k))
+	}
+
+	ErrInvalidDefaultValue = func(k string, v any) *Error {
+		return Err(fmt.Sprintf("invalid default value for env var (%s),default: %v", k, v))
+	}
 
 	ErrEvalEnvVarSh = Err("failed while executing env-var sh script")
 

examples/Runfile.yml

@@ -66,7 +66,8 @@ tasks:
       k4:
         default:
           sh: |+
-           console.log('1234' == '23344')
+            echo "1234"
+            # console.log('1234' == '23344')
     cmd: 
       - run: cook
       - console.log(process.env.k4)

examples/run1/Runfile

@@ -5,8 +5,8 @@ tasks:
   echo:
     cmd:
       - echo "hello from run1"
-      - if: gt 1 0
-        cmd: echo "hello after condition check"
+      # - if: gt 1 0
+      - echo "hello after condition check"
 
   node:shell:
     interactive: true