lang: funcs: dage: Move much logging behind debug flag

Most of this logging isn't useful for ordinary usage. Hide it for now.
Eventually when we have a fancy logging system (curses-like) we can
bring back more information on the state of everything.

lang/funcs/dage/dage.go

@@ -727,7 +727,9 @@ func (obj *Engine) process(ctx context.Context) (reterr error) {
 		// preempted and that future executions of this function can be
 		// resumed. We must return with an error to let folks know that
 		// we were interrupted.
+		if obj.Debug {
 			obj.Logf("send to func `%s`", node)
+		}
 		select {
 		case node.input <- st: // send to function
 			obj.statsMutex.Lock()
@@ -968,7 +970,9 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 		if err == nil { // a nil error won't cause ag to shutdown below
 			panic("expected error, not nil")
 		}
+		if obj.Debug {
 			obj.Logf("process break")
+		}
 		select {
 		case obj.ag <- err: // send error to aggregate channel
 		case <-ctx.Done():
@@ -1029,7 +1033,9 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 					// run again from a wake-up, or we exit.
 					select {
 					case <-obj.wakeChan: // wait until something has actually woken up...
+						if obj.Debug {
 							obj.Logf("process wakeup...")
+						}
 						// loop!
 					case <-ctxFn.Done():
 						errFn = context.Canceled
@@ -1049,7 +1055,9 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 				chFn = true
 
 			case <-obj.pauseChan:
+				if obj.Debug {
 					obj.Logf("pausing...")
+				}
 				chPause = true
 
 			case <-mainCtx.Done(): // when asked to exit
@@ -1105,7 +1113,9 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 		if errProcess != nil && !pausedProcess {
 			select {
 			case <-obj.pauseChan:
+				if obj.Debug {
 					obj.Logf("lower pausing...")
+				}
 
 			// do we want this exit case? YES
 			case <-mainCtx.Done(): // when asked to exit
@@ -1127,8 +1137,10 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 		// no exit case from here, must be fully running or paused...
 		select {
 		case obj.pausedChan <- struct{}{}:
+			if obj.Debug {
 				obj.Logf("paused!")
 			}
+		}
 
 		//
 		// the graph changes shape right here... we are locked right now
@@ -1137,8 +1149,10 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 		// wait until resumed/unlocked
 		select {
 		case <-obj.resumeChan:
+			if obj.Debug {
 				obj.Logf("resuming...")
 			}
+		}
 
 		// Do any cleanup needed from delete vertex. Or do we?
 		// We've ascertained that while we want this stuff to shutdown,
@@ -1260,14 +1274,18 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 					if !exists { // first value received
 						// RACE: do this AFTER value is present!
 						//node.loaded = true // not yet please
+						if obj.Debug {
 							obj.Logf("func `%s` started", node)
+						}
 					} else if value.Cmp(cached) == nil {
 						// skip if new value is same as previous
 						// if this happens often, it *might* be
 						// a bug in the function implementation
 						// FIXME: do we need to disable engine
 						// caching when using hysteresis?
+						if obj.Debug {
 							obj.Logf("func `%s` skipped", node)
+						}
 						continue
 					}
 					obj.tableMutex.Lock()
@@ -1322,7 +1340,9 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 			wg.Add(1)
 			go func(node *state) {
 				defer wg.Done()
+				if obj.Debug {
 					obj.Logf("resend to func `%s`", node)
+				}
 				obj.wake("resend") // new value, so send wake up
 			}(node)
 		}
@@ -1342,8 +1362,10 @@ func (obj *Engine) Run(ctx context.Context) (reterr error) {
 		// no exit case from here, must be fully running or paused...
 		select {
 		case obj.resumedChan <- struct{}{}:
+			if obj.Debug {
 				obj.Logf("resumed!")
 			}
+		}
 
 	} // end for
 }