auto-decode for tdbg workflow show (#9294)

## What changed?

Adds `--decode` flag to tdbg's `wofkflow show` to decode event history
proto payloads to JSON.

## Why?

Make on-call investigation easier.

## How did you test it?
- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [x] added new unit test(s)
- [ ] added new functional test(s)

## Potential risks

The decoder ignores errors; so if it fails, it behaves as before.

Author: stephanos

tools/tdbg/commands.go

@@ -52,6 +52,7 @@ func AdminShowWorkflow(c *cli.Context, clientFactory ClientFactory) error {
 	startEventVerion := int64(c.Int(FlagMinEventVersion))
 	endEventVersion := int64(c.Int(FlagMaxEventVersion))
 	outputFileName := c.String(FlagOutputFilename)
+	decode := c.Bool(FlagDecode)
 
 	client := clientFactory.AdminClient(c)
 	serializer := serialization.NewSerializer()
@@ -116,12 +117,21 @@ func AdminShowWorkflow(c *cli.Context, clientFactory ClientFactory) error {
 			errs = append(errs, err)
 			continue
 		}
+		if decode {
+			data = decodePayloadsInJSON(data)
+		}
 		// nolint:errcheck // assuming that write will succeed.
 		fmt.Fprintln(c.App.Writer, string(data))
 	}
 	// nolint:errcheck // assuming that write will succeed.
 	fmt.Fprintf(c.App.Writer, "======== total batches %v, total blob len: %v ======\n", len(histories), totalSize)
 
+	// Show info to user about the option to decode payloads.
+	if !decode {
+		// nolint:errcheck // assuming that write will succeed.
+		fmt.Fprintf(c.App.ErrWriter, "(use --%s to decode payloads to JSON)\n", FlagDecode)
+	}
+
 	err = errors.Join(errs...)
 	if err != nil {
 		return err
@@ -133,6 +143,9 @@ func AdminShowWorkflow(c *cli.Context, clientFactory ClientFactory) error {
 		if err != nil {
 			return fmt.Errorf("unable to serialize History data: %s", err)
 		}
+		if decode {
+			data = decodePayloadsInJSON(data)
+		}
 		if err := os.WriteFile(outputFileName, data, 0666); err != nil {
 			return fmt.Errorf("unable to write History data file: %s", err)
 		}
@@ -473,15 +486,15 @@ func AdminListShardTasks(c *cli.Context, clientFactory ClientFactory, registry t
 
 	ctx, cancel := newContext(c)
 	defer cancel()
-	paginationFunc := func(paginationToken []byte) ([]interface{}, []byte, error) {
+	paginationFunc := func(paginationToken []byte) ([]any, []byte, error) {
 		req.NextPageToken = paginationToken
 		response, err := client.ListHistoryTasks(ctx, req)
 		if err != nil {
 			return nil, nil, err
 		}
 		token := response.NextPageToken
 
-		var items []interface{}
+		var items []any
 		for _, task := range response.Tasks {
 			items = append(items, task)
 		}

tools/tdbg/decode_commands.go

@@ -10,9 +10,6 @@ import (
 	"github.com/urfave/cli/v2"
 	"go.temporal.io/server/common/codec"
 	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
 )
 
 func AdminDecodeProto(c *cli.Context) error {
@@ -60,14 +57,9 @@ func AdminDecodeProto(c *cli.Context) error {
 		return fmt.Errorf("missing required parameter data flag")
 	}
 
-	messageType, err := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(protoType))
+	message, err := unmarshalProtoByTypeName(protoType, protoData)
 	if err != nil {
-		return fmt.Errorf("unable to find %s type: %w", protoType, err)
-	}
-
-	message := messageType.New().Interface()
-	if err = proto.Unmarshal(protoData, message); err != nil {
-		return fmt.Errorf("unable to unmarshal to %s", protoType)
+		return err
 	}
 
 	encoder := codec.NewJSONPBIndentEncoder(" ")

tools/tdbg/flags.go

@@ -75,4 +75,5 @@ var (
 	FlagMinPass                    = "min-pass"
 	FlagVisibilityQuery            = "query"
 	FlagJobID                      = "job-id"
+	FlagDecode                     = "decode"
 )

tools/tdbg/proto_decoder.go

@@ -0,0 +1,128 @@
+package tdbg
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"go.temporal.io/server/common/codec"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// decodePayloadsInJSON parses JSON data, finds Payload objects, and makes them
+// human-readable: metadata bytes are decoded from base64 to strings, and data
+// is decoded based on the encoding (binary/protobuf, json/plain, etc.).
+// If data decoding fails, the data field is left as its original base64 string.
+func decodePayloadsInJSON(data []byte) []byte {
+	var parsed any
+	if err := json.Unmarshal(data, &parsed); err != nil {
+		return data
+	}
+	encoder := codec.NewJSONPBEncoder()
+	decodePayloadsRecursive(parsed, encoder)
+	result, err := json.Marshal(parsed)
+	if err != nil {
+		return data
+	}
+	return result
+}
+
+func decodePayloadsRecursive(v any, encoder codec.JSONPBEncoder) {
+	switch val := v.(type) {
+	case map[string]any:
+		tryDecodePayloadJSON(val, encoder)
+		for _, child := range val {
+			decodePayloadsRecursive(child, encoder)
+		}
+	case []any:
+		for _, item := range val {
+			decodePayloadsRecursive(item, encoder)
+		}
+	}
+}
+
+func tryDecodePayloadJSON(obj map[string]any, encoder codec.JSONPBEncoder) {
+	metadata, ok := obj["metadata"].(map[string]any)
+	if !ok {
+		return
+	}
+
+	// Decode all metadata bytes values from base64 to strings.
+	for key, val := range metadata {
+		b64, ok := val.(string)
+		if !ok {
+			continue
+		}
+		decoded, err := base64.StdEncoding.DecodeString(b64)
+		if err != nil {
+			continue
+		}
+		metadata[key] = string(decoded)
+	}
+
+	encoding, ok := metadata["encoding"].(string)
+	if !ok {
+		encoding = ""
+	}
+	messageType, ok := metadata["messageType"].(string)
+	if !ok {
+		messageType = ""
+	}
+
+	dataB64, ok := obj["data"].(string)
+	if !ok {
+		return
+	}
+
+	// For binary/protobuf with a known messageType, unmarshal and re-encode as JSON.
+	if messageType != "" && encoding == "binary/protobuf" {
+		dataBytes, err := base64.StdEncoding.DecodeString(dataB64)
+		if err != nil {
+			return
+		}
+		msg, err := unmarshalProtoByTypeName(messageType, dataBytes)
+		if err != nil {
+			return
+		}
+		jsonBytes, err := encoder.Encode(msg)
+		if err != nil {
+			return
+		}
+		var decoded any
+		if err := json.Unmarshal(jsonBytes, &decoded); err != nil {
+			return
+		}
+		obj["data"] = decoded
+		return
+	}
+
+	// For JSON-based encodings, base64-decode and parse as JSON.
+	if strings.HasPrefix(encoding, "json/") {
+		dataBytes, err := base64.StdEncoding.DecodeString(dataB64)
+		if err != nil {
+			return
+		}
+		var decoded any
+		if err := json.Unmarshal(dataBytes, &decoded); err != nil {
+			return
+		}
+		obj["data"] = decoded
+	}
+}
+
+// unmarshalProtoByTypeName resolves a proto type by its full name from the
+// global registry and unmarshals the given bytes into it.
+func unmarshalProtoByTypeName(typeName string, data []byte) (proto.Message, error) {
+	mt, err := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(typeName))
+	if err != nil {
+		return nil, fmt.Errorf("unable to find %s type: %w", typeName, err)
+	}
+	msg := mt.New().Interface()
+	if err := proto.Unmarshal(data, msg); err != nil {
+		return nil, fmt.Errorf("unable to unmarshal to %s: %w", typeName, err)
+	}
+	return msg, nil
+}