Merge pull request #48 from pior/naming

Simplify runnable naming and add FuncNamed

Author: pior

README.md

@@ -103,7 +103,7 @@ Components with dependencies will be stopped before their dependencies.
 
 Example with three components:
 ```go
-g := runnable.Manager(nil)
+g := runnable.NewManager()
 g.Add(jobQueue)
 g.Add(httpServer, jobQueue) // jobs is a dependency
 g.Add(monitor)
@@ -115,20 +115,20 @@ runnable.Run(g.Build())
   <summary markdown="span">Logs of a demo app</summary>
 
 ```shell
-$ go run ./cmd/example
-[RUNNABLE] 2020/10/22 22:42:26 INFO manager: main.JobQueue started
-[RUNNABLE] 2020/10/22 22:42:26 INFO manager: runnable.httpServer started
-[RUNNABLE] 2020/10/22 22:42:26 INFO manager: main.Monitor started
+$ go run ./examples/example
+level=INFO msg=started runnable=manager/JobQueue
+level=INFO msg=started runnable=manager/httpserver
+level=INFO msg=started runnable=manager/Monitor
 ...
-^C[RUNNABLE] 2020/10/22 22:42:34 INFO signal: received signal interrupt
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: starting shutdown (context cancelled)
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: runnable.httpServer cancelled
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: main.Monitor cancelled
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: main.Monitor stopped
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: runnable.httpServer stopped
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: main.JobQueue cancelled
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: main.JobQueue stopped
-[RUNNABLE] 2020/10/22 22:42:34 INFO manager: shutdown complete
+^Clevel=INFO msg="received signal" runnable=signal/manager signal=interrupt
+level=INFO msg="starting shutdown" runnable=manager reason="context cancelled"
+level=INFO msg=cancelled runnable=manager/httpserver
+level=INFO msg=cancelled runnable=manager/Monitor
+level=INFO msg=stopped runnable=manager/Monitor
+level=INFO msg=stopped runnable=manager/httpserver
+level=INFO msg=cancelled runnable=manager/JobQueue
+level=INFO msg=stopped runnable=manager/JobQueue
+level=INFO msg="shutdown complete" runnable=manager
 ```
 
 </details>

closer.go

@@ -6,40 +6,41 @@ import (
 
 // Closer returns a runnable intended to call a Close method on shutdown.
 func Closer(c interface{ Close() }) Runnable {
-	return &closer{baseWrapper{"closer", c}, c, func(ctx context.Context) error {
+	return &closer{"closer/" + runnableName(c), func(ctx context.Context) error {
 		c.Close()
 		return nil
 	}}
 }
 
-// Closer returns a runnable intended to call a Close method on shutdown.
+// CloserErr returns a runnable intended to call a Close method on shutdown.
 func CloserErr(c interface{ Close() error }) Runnable {
-	return &closer{baseWrapper{"closer", c}, c, func(ctx context.Context) error {
+	return &closer{"closer/" + runnableName(c), func(ctx context.Context) error {
 		return c.Close()
 	}}
 }
 
-// Closer returns a runnable intended to call a Close method on shutdown.
+// CloserCtx returns a runnable intended to call a Close method on shutdown.
 func CloserCtx(c interface{ Close(context.Context) }) Runnable {
-	return &closer{baseWrapper{"closer", c}, c, func(ctx context.Context) error {
+	return &closer{"closer/" + runnableName(c), func(ctx context.Context) error {
 		c.Close(ctx)
 		return nil
 	}}
 }
 
-// Closer returns a runnable intended to call a Close method on shutdown.
+// CloserCtxErr returns a runnable intended to call a Close method on shutdown.
 func CloserCtxErr(c interface{ Close(context.Context) error }) Runnable {
-	return &closer{baseWrapper{"closer", c}, c, func(ctx context.Context) error {
+	return &closer{"closer/" + runnableName(c), func(ctx context.Context) error {
 		return c.Close(ctx)
 	}}
 }
 
 type closer struct {
-	baseWrapper
-	c       any
+	name    string
 	closeFn func(context.Context) error
 }
 
+func (c *closer) runnableName() string { return c.name }
+
 func (c *closer) Run(ctx context.Context) error {
 	<-ctx.Done()
 	err := c.closeFn(ctx)

every.go

@@ -8,18 +8,20 @@ import (
 // Every returns a runnable that will periodically run the runnable passed in argument.
 func Every(runnable Runnable, period time.Duration) Runnable {
 	return &every{
-		baseWrapper{"every-" + period.String(), runnable},
-		runnable,
-		period,
+		name:     "every-" + period.String() + "/" + runnableName(runnable),
+		runnable: runnable,
+		period:   period,
 	}
 }
 
 type every struct {
-	baseWrapper
+	name     string
 	runnable Runnable
 	period   time.Duration
 }
 
+func (e *every) runnableName() string { return e.name }
+
 func (e *every) Run(ctx context.Context) (err error) {
 	ticker := time.NewTicker(e.period)
 

example_test.go

@@ -65,7 +65,7 @@ func Example() {
 	}
 	g.Add(runnable.HTTPServer(server), jobs)
 
-	task := runnable.Func(func(ctx context.Context) error {
+	task := runnable.FuncNamed("enqueue", func(ctx context.Context) error {
 		_, _ = http.Post("http://127.0.0.1:8080/?id=1", "test/plain", nil)
 		_, _ = http.Post("http://127.0.0.1:8080/?id=2", "test/plain", nil)
 		_, _ = http.Post("http://127.0.0.1:8080/?id=3", "test/plain", nil)
@@ -81,12 +81,12 @@ func Example() {
 
 	// level=INFO msg=started runnable=manager/Jobs
 	// level=INFO msg=started runnable=manager/httpserver
-	// level=INFO msg=started runnable=manager/RunnableFunc
+	// level=INFO msg=started runnable=manager/enqueue
 	// level=INFO msg=started runnable=manager/every-1h0m0s/CleanupTask
 	// level=INFO msg=listening runnable=httpserver addr=127.0.0.1:8080
 	// Starting job 1
 	// Completed job 1
 	// ...
-	// level=INFO msg="starting shutdown" runnable=manager reason="RunnableFunc died"
+	// level=INFO msg="starting shutdown" runnable=manager reason="enqueue died"
 	// level=INFO msg="shutdown complete" runnable=manager
 }

func.go

@@ -1,16 +1,30 @@
 package runnable
 
-import "context"
+import (
+	"context"
+	"reflect"
+	"runtime"
+)
 
+// RunnableFunc is a function that implements the Runnable contract.
 type RunnableFunc func(context.Context) error
 
 type funcRunnable struct {
-	baseWrapper
-	fn RunnableFunc
+	name string
+	fn   RunnableFunc
 }
 
+func (f *funcRunnable) runnableName() string { return f.name }
+
+// Func returns a Runnable from a function. The name is derived from the function using reflection.
 func Func(fn RunnableFunc) Runnable {
-	return &funcRunnable{baseWrapper{"", fn}, fn}
+	name := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
+	return &funcRunnable{name, fn}
+}
+
+// FuncNamed returns a named Runnable from a function.
+func FuncNamed(name string, fn RunnableFunc) Runnable {
+	return &funcRunnable{name, fn}
 }
 
 func (f *funcRunnable) Run(ctx context.Context) error {

manager.go

@@ -16,6 +16,12 @@ type AppManager interface {
 // ManagerOption configures the behavior of a Manager.
 type ManagerOption func(*manager)
 
+func ManagerName(name string) ManagerOption {
+	return func(m *manager) {
+		m.name = name
+	}
+}
+
 func ManagerShutdownTimeout(dur time.Duration) ManagerOption {
 	return func(m *manager) {
 		m.shutdownTimeout = dur
@@ -26,6 +32,7 @@ func ManagerShutdownTimeout(dur time.Duration) ManagerOption {
 // Runnables can declare a dependency on another runnable. Dependencies are started first and stopped last.
 func NewManager(opts ...ManagerOption) AppManager {
 	m := &manager{
+		name:            "manager",
 		shutdownTimeout: 10 * time.Second,
 	}
 
@@ -40,10 +47,13 @@ func NewManager(opts ...ManagerOption) AppManager {
 }
 
 type manager struct {
+	name            string
 	containers      []*managerContainer
 	shutdownTimeout time.Duration
 }
 
+func (m *manager) runnableName() string { return m.name }
+
 func (m *manager) Add(runnable Runnable, dependencies ...Runnable) {
 	container := m.insertRunnable(runnable)
 	for _, dep := range dependencies {
@@ -80,15 +90,15 @@ func (m *manager) Run(ctx context.Context) error {
 	// run the runnables in Go routines.
 	for _, c := range m.containers {
 		c.launch(completedChan, dying)
-		logger.Info("started", "runnable", "manager/"+c.name())
+		logger.Info("started", "runnable", m.runnableName()+"/"+c.name())
 	}
 
 	// block until group is cancelled, or a runnable dies.
 	select {
 	case <-ctx.Done():
-		logger.Info("starting shutdown", "runnable", "manager", "reason", "context cancelled")
+		logger.Info("starting shutdown", "runnable", m.runnableName(), "reason", "context cancelled")
 	case c := <-dying:
-		logger.Info("starting shutdown", "runnable", "manager", "reason", c.name()+" died")
+		logger.Info("starting shutdown", "runnable", m.runnableName(), "reason", c.name()+" died")
 	}
 
 	// starting shutdown
@@ -117,7 +127,7 @@ func (m *manager) Run(ctx context.Context) error {
 			}
 
 			if !cancelled.contains(c) {
-				logger.Info("cancelled", "runnable", "manager/"+c.name())
+				logger.Info("cancelled", "runnable", m.runnableName()+"/"+c.name())
 				c.shutdown()
 				cancelled.insert(c)
 			}
@@ -129,9 +139,9 @@ func (m *manager) Run(ctx context.Context) error {
 			completed.insert(c)
 
 			if c.err == nil || errors.Is(c.err, context.Canceled) {
-				logger.Info("stopped", "runnable", "manager/"+c.name())
+				logger.Info("stopped", "runnable", m.runnableName()+"/"+c.name())
 			} else {
-				logger.Info("stopped with error", "runnable", "manager/"+c.name(), "error", c.err)
+				logger.Info("stopped with error", "runnable", m.runnableName()+"/"+c.name(), "error", c.err)
 			}
 
 			if len(completed) == len(m.containers) {
@@ -146,15 +156,15 @@ func (m *manager) Run(ctx context.Context) error {
 	errs := []string{}
 	for _, c := range m.containers {
 		if !completed.contains(c) {
-			logger.Info("still running", "runnable", "manager/"+c.name())
+			logger.Info("still running", "runnable", m.runnableName()+"/"+c.name())
 			errs = append(errs, fmt.Sprintf("%s is still running", c.name()))
 		}
 		if c.err != nil && !errors.Is(c.err, context.Canceled) {
 			errs = append(errs, fmt.Sprintf("%s crashed with %+v", c.name(), c.err))
 		}
 	}
 
-	logger.Info("shutdown complete", "runnable", "manager")
+	logger.Info("shutdown complete", "runnable", m.runnableName())
 
 	if len(errs) != 0 {
 		return fmt.Errorf("manager: %s", strings.Join(errs, ", "))

manager_container.go

@@ -32,7 +32,7 @@ func (c *managerContainer) insertUser(container *managerContainer) {
 }
 
 func (c *managerContainer) name() string {
-	return findName(c.runnable)
+	return runnableName(c.runnable)
 }
 
 func (c *managerContainer) launch(completed chan *managerContainer, dying chan *managerContainer) {

recover.go

@@ -22,15 +22,17 @@ func (e *PanicError) Unwrap() error {
 
 // Recover returns a runnable that recovers when a runnable panics and return an error to represent this panic.
 func Recover(runnable Runnable) Runnable {
-	return &RecoverRunner{baseWrapper{"recover", runnable}, runnable}
+	return &recoverRunner{"recover/" + runnableName(runnable), runnable}
 }
 
-type RecoverRunner struct {
-	baseWrapper
+type recoverRunner struct {
+	name     string
 	runnable Runnable
 }
 
-func (r *RecoverRunner) Run(ctx context.Context) (err error) {
+func (r *recoverRunner) runnableName() string { return r.name }
+
+func (r *recoverRunner) Run(ctx context.Context) (err error) {
 	defer func() {
 		if value := recover(); value != nil {
 			err = &PanicError{value}

restart.go

@@ -51,21 +51,23 @@ func Restart(runnable Runnable, opts ...RestartOption) Runnable {
 	if cfg.crashBackoffDelayFn == nil {
 		cfg.crashBackoffDelayFn = crashBackoffDelay
 	}
-	return &restart{baseWrapper{"restart", runnable}, runnable, cfg}
+	return &restart{"restart/" + runnableName(runnable), runnable, cfg}
 }
 
 type restart struct {
-	baseWrapper
+	name     string
 	runnable Runnable
 	cfg      restartConfig
 }
 
+func (r *restart) runnableName() string { return r.name }
+
 func (r *restart) Run(ctx context.Context) error {
 	restartCount := 0
 	crashCount := 0
 
 	for {
-		logger.Info("starting", "runnable", findName(r), "restart", restartCount, "crash", crashCount)
+		logger.Info("starting", "runnable", r.name, "restart", restartCount, "crash", crashCount)
 		err := r.runnable.Run(ctx)
 		isCrash := err != nil
 
@@ -74,12 +76,12 @@ func (r *restart) Run(ctx context.Context) error {
 		}
 
 		if r.cfg.restartLimit > 0 && restartCount >= r.cfg.restartLimit {
-			logger.Info("not restarting", "runnable", findName(r), "reason", "restart limit", "limit", r.cfg.restartLimit)
+			logger.Info("not restarting", "runnable", r.name, "reason", "restart limit", "limit", r.cfg.restartLimit)
 			return err
 		}
 
 		if r.cfg.crashLimit > 0 && crashCount >= r.cfg.crashLimit {
-			logger.Info("not restarting", "runnable", findName(r), "reason", "crash limit", "limit", r.cfg.crashLimit)
+			logger.Info("not restarting", "runnable", r.name, "reason", "crash limit", "limit", r.cfg.crashLimit)
 			return err
 		}