From 40b59537eb0edcfc8f2732c99da1ea725919b78b Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Tue, 10 May 2022 13:05:04 -0400
Subject: [PATCH] feat(container): automatic debugging on errors (#11915)

* feat(container): automatic debugging on errors

* tests

* group deps

* fix test errors

Co-authored-by: Aleksandr Bezobchuk <alexanderbez@users.noreply.github.com>
---
 baseapp/custom_txhandler_test.go |   3 +-
 container/build.go               |  38 ++++++++++-
 container/container_test.go      |  32 ++++++++++
 container/debug.go               | 106 +++++++++++++++++++++++++++++--
 go.mod                           |   2 -
 5 files changed, 169 insertions(+), 12 deletions(-)

diff --git a/baseapp/custom_txhandler_test.go b/baseapp/custom_txhandler_test.go
index cd6efbbdfd..78e4c8befe 100644
--- a/baseapp/custom_txhandler_test.go
+++ b/baseapp/custom_txhandler_test.go
@@ -4,9 +4,10 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/tendermint/tendermint/crypto/tmhash"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/tx"
-	"github.com/tendermint/tendermint/crypto/tmhash"
 )
 
 type handlerFun func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error)
diff --git a/container/build.go b/container/build.go
index 92edaaff20..b340b2a603 100644
--- a/container/build.go
+++ b/container/build.go
@@ -9,9 +9,13 @@ package container
 // Ex:
 //  var x int
 //  Build(Provide(func() int { return 1 }), &x)
+//
+// Build uses the debug mode provided by AutoDebug which means there will be
+// verbose debugging information if there is an error and nothing upon success.
+// Use BuildDebug to configure debug behavior.
 func Build(containerOption Option, outputs ...interface{}) error {
 	loc := LocationFromCaller(1)
-	return build(loc, nil, containerOption, outputs...)
+	return build(loc, AutoDebug(), containerOption, outputs...)
 }
 
 // BuildDebug is a version of Build which takes an optional DebugOption for
@@ -27,10 +31,38 @@ func build(loc Location, debugOpt DebugOption, option Option, outputs ...interfa
 		return err
 	}
 
+	// debug cleanup
+	defer func() {
+		for _, f := range cfg.cleanup {
+			f()
+		}
+	}()
+
+	err = doBuild(cfg, loc, debugOpt, option, outputs...)
+	if err != nil {
+		if cfg.onError != nil {
+			err2 := cfg.onError.applyConfig(cfg)
+			if err2 != nil {
+				return err2
+			}
+		}
+		return err
+	} else {
+		if cfg.onSuccess != nil {
+			err2 := cfg.onSuccess.applyConfig(cfg)
+			if err2 != nil {
+				return err2
+			}
+		}
+		return nil
+	}
+}
+
+func doBuild(cfg *debugConfig, loc Location, debugOpt DebugOption, option Option, outputs ...interface{}) error {
 	defer cfg.generateGraph() // always generate graph on exit
 
 	if debugOpt != nil {
-		err = debugOpt.applyConfig(cfg)
+		err := debugOpt.applyConfig(cfg)
 		if err != nil {
 			return err
 		}
@@ -39,7 +71,7 @@ func build(loc Location, debugOpt DebugOption, option Option, outputs ...interfa
 	cfg.logf("Registering providers")
 	cfg.indentLogger()
 	ctr := newContainer(cfg)
-	err = option.apply(ctr)
+	err := option.apply(ctr)
 	if err != nil {
 		cfg.logf("Failed registering providers because of: %+v", err)
 		return err
diff --git a/container/container_test.go b/container/container_test.go
index 6cc8399cfb..e393b91e24 100644
--- a/container/container_test.go
+++ b/container/container_test.go
@@ -580,3 +580,35 @@ func TestLogging(t *testing.T) {
 	require.NoError(t, err)
 	require.Contains(t, string(graphfileContents), "<svg")
 }
+
+func TestConditionalDebugging(t *testing.T) {
+	logs := ""
+	success := false
+	conditionalDebugOpt := container.DebugOptions(
+		container.OnError(container.Logger(func(s string) {
+			logs += s + "\n"
+		})),
+		container.OnSuccess(container.DebugCleanup(func() {
+			success = true
+		})))
+
+	var input TestInput
+	require.Error(t, container.BuildDebug(
+		conditionalDebugOpt,
+		container.Options(),
+		&input,
+	))
+	require.Contains(t, logs, `Initializing logger`)
+	require.Contains(t, logs, `Registering providers`)
+	require.Contains(t, logs, `Registering outputs`)
+	require.False(t, success)
+
+	logs = ""
+	success = false
+	require.NoError(t, container.BuildDebug(
+		conditionalDebugOpt,
+		container.Options(),
+	))
+	require.Empty(t, logs)
+	require.True(t, success)
+}
diff --git a/container/debug.go b/container/debug.go
index 26862c08c5..2c9cb8cc11 100644
--- a/container/debug.go
+++ b/container/debug.go
@@ -62,21 +62,93 @@ func Logger(logger func(string)) DebugOption {
 	return debugOption(func(c *debugConfig) error {
 		logger("Initializing logger")
 		c.loggers = append(c.loggers, logger)
+
+		// send conditional log messages batched for onError/onSuccess cases
+		if c.logBuf != nil {
+			for _, s := range *c.logBuf {
+				logger(s)
+			}
+		}
+
 		return nil
 	})
 }
 
+const (
+	debugContainerSvg = "debug_container.svg"
+	debugContainerDot = "debug_container.dot"
+)
+
 // Debug is a default debug option which sends log output to stdout, dumps
-// the container in the graphviz DOT format to stdout, and to the file
-// container_dump.svg.
+// the container in the graphviz DOT and SVG formats to debug_container.dot
+// and debug_container.svg respectively.
 func Debug() DebugOption {
 	return DebugOptions(
 		StdoutLogger(),
-		LogVisualizer(),
-		FileVisualizer("container_dump.svg", "svg"),
+		FileVisualizer(debugContainerSvg, "svg"),
+		FileVisualizer(debugContainerDot, "dot"),
 	)
 }
 
+func (d *debugConfig) initLogBuf() {
+	if d.logBuf == nil {
+		d.logBuf = &[]string{}
+		d.loggers = append(d.loggers, func(s string) {
+			*d.logBuf = append(*d.logBuf, s)
+		})
+	}
+}
+
+// OnError is a debug option that allows setting debug options that are
+// conditional on an error happening. Any loggers added error will
+// receive the full dump of logs since the start of container processing.
+func OnError(option DebugOption) DebugOption {
+	return debugOption(func(config *debugConfig) error {
+		config.initLogBuf()
+		config.onError = option
+		return nil
+	})
+}
+
+// OnSuccess is a debug option that allows setting debug options that are
+// conditional on successful container resolution. Any loggers added on success
+// will receive the full dump of logs since the start of container processing.
+func OnSuccess(option DebugOption) DebugOption {
+	return debugOption(func(config *debugConfig) error {
+		config.initLogBuf()
+		config.onSuccess = option
+		return nil
+	})
+}
+
+// DebugCleanup specifies a clean-up function to be called at the end of
+// processing to clean up any resources that may be used during debugging.
+func DebugCleanup(cleanup func()) DebugOption {
+	return debugOption(func(config *debugConfig) error {
+		config.cleanup = append(config.cleanup, cleanup)
+		return nil
+	})
+}
+
+// AutoDebug does the same thing as Debug when there is an error and deletes
+// the debug_container.dot and debug_container.dot if they exist when there
+// is no error. This is the default debug mode of Run.
+func AutoDebug() DebugOption {
+	return DebugOptions(
+		OnError(Debug()),
+		OnSuccess(DebugCleanup(func() {
+			deleteIfExists(debugContainerSvg)
+			deleteIfExists(debugContainerDot)
+		})),
+	)
+}
+
+func deleteIfExists(filename string) {
+	if _, err := os.Stat(filename); err == nil {
+		_ = os.Remove(filename)
+	}
+}
+
 // DebugOptions creates a debug option which bundles together other debug options.
 func DebugOptions(options ...DebugOption) DebugOption {
 	return debugOption(func(c *debugConfig) error {
@@ -94,12 +166,18 @@ type debugConfig struct {
 	// logging
 	loggers   []func(string)
 	indentStr string
+	logBuf    *[]string // a log buffer for onError/onSuccess processing
 
 	// graphing
 	graphviz      *graphviz.Graphviz
 	graph         *cgraph.Graph
 	visualizers   []func(string)
 	logVisualizer bool
+
+	// extra processing
+	onError   DebugOption
+	onSuccess DebugOption
+	cleanup   []func()
 }
 
 type debugOption func(*debugConfig) error
@@ -210,7 +288,7 @@ func (c *debugConfig) locationGraphNode(location Location, key *moduleKey) (*cgr
 }
 
 func (c *debugConfig) typeGraphNode(typ reflect.Type) (*cgraph.Node, error) {
-	node, found, err := c.findOrCreateGraphNode(c.graph, typ.String())
+	node, found, err := c.findOrCreateGraphNode(c.graph, moreUsefulTypeString(typ))
 	if err != nil {
 		return nil, err
 	}
@@ -223,6 +301,22 @@ func (c *debugConfig) typeGraphNode(typ reflect.Type) (*cgraph.Node, error) {
 	return node, err
 }
 
+// moreUsefulTypeString is more useful than reflect.Type.String()
+func moreUsefulTypeString(ty reflect.Type) string {
+	switch ty.Kind() {
+	case reflect.Struct, reflect.Interface:
+		return fmt.Sprintf("%s.%s", ty.PkgPath(), ty.Name())
+	case reflect.Pointer:
+		return fmt.Sprintf("*%s", moreUsefulTypeString(ty.Elem()))
+	case reflect.Map:
+		return fmt.Sprintf("map[%s]%s", moreUsefulTypeString(ty.Key()), moreUsefulTypeString(ty.Elem()))
+	case reflect.Slice:
+		return fmt.Sprintf("[]%s", moreUsefulTypeString(ty.Elem()))
+	default:
+		return ty.String()
+	}
+}
+
 func (c *debugConfig) findOrCreateGraphNode(subGraph *cgraph.Graph, name string) (node *cgraph.Node, found bool, err error) {
 	node, err = c.graph.Node(name)
 	if err != nil {
@@ -246,7 +340,7 @@ func (c *debugConfig) moduleSubGraph(key *moduleKey) *cgraph.Graph {
 	if key != nil {
 		gname := fmt.Sprintf("cluster_%s", key.name)
 		graph = c.graph.SubGraph(gname, 1)
-		graph.SetLabel(fmt.Sprintf("ModuleKey: %s", key.name))
+		graph.SetLabel(fmt.Sprintf("Module: %s", key.name))
 	}
 	return graph
 }
diff --git a/go.mod b/go.mod
index 2ed78e1fbc..9dd5dd4664 100644
--- a/go.mod
+++ b/go.mod
@@ -61,8 +61,6 @@ require (
 	sigs.k8s.io/yaml v1.3.0
 )
 
-require github.com/google/uuid v1.3.0
-
 require (
 	cloud.google.com/go v0.100.2 // indirect
 	cloud.google.com/go/compute v1.5.0 // indirect