Revert the NewDefaultEventHandler and add deprecation note

cmd/grpcurl/grpcurl.go

@@ -671,7 +671,12 @@ func main() {
 		if err != nil {
 			fail(err, "Failed to construct request parser and formatter for %q", *format)
 		}
-		h := grpcurl.NewDefaultEventHandler(os.Stdout, descSource, formatter, verbosityLevel)
+		h := &grpcurl.DefaultEventHandler{
+			Out:            os.Stdout,
+			DescSource:     descSource,
+			Formatter:      formatter,
+			VerbosityLevel: verbosityLevel,
+		}
 
 		err = grpcurl.InvokeRPC(ctx, descSource, cc, symbol, append(addlHeaders, rpcHeaders...), h, rf.Next)
 		if err != nil {

format.go

@@ -409,13 +409,13 @@ func RequestParserAndFormatterFor(format Format, descSource DescriptorSource, em
 // safe for use with InvokeRPC as long as NumResponses and Status are not read
 // until the call to InvokeRPC completes.
 type DefaultEventHandler struct {
-	out        io.Writer
+	Out        io.Writer
-	descSource DescriptorSource
+	DescSource DescriptorSource
-	formatter  func(proto.Message) (string, error)
+	Formatter  func(proto.Message) (string, error)
 	// 0 = default
 	// 1 = verbose
 	// 2 = very verbose
-	verbosityLevel int
+	VerbosityLevel int
 
 	// NumResponses is the number of responses that have been received.
 	NumResponses int
@@ -427,57 +427,66 @@ type DefaultEventHandler struct {
 // NewDefaultEventHandler returns an InvocationEventHandler that logs events to
 // the given output. If verbose is true, all events are logged. Otherwise, only
 // response messages are logged.
-func NewDefaultEventHandler(out io.Writer, descSource DescriptorSource, formatter Formatter, verbosityLevel int) *DefaultEventHandler {
+//
+// Deprecated: NewDefaultEventHandler exists for compatability.
+// It doesn't allow fine control over the `VerbosityLevel`
+// and provides only 0 and 1 options (which corresponds to the `verbose` argument).
+// Use DefaultEventHandler{} initializer directly.
+func NewDefaultEventHandler(out io.Writer, descSource DescriptorSource, formatter Formatter, verbose bool) *DefaultEventHandler {
+	verbosityLevel := 0
+	if verbose {
+		verbosityLevel = 1
+	}
 	return &DefaultEventHandler{
-		out:            out,
+		Out:            out,
-		descSource:     descSource,
+		DescSource:     descSource,
-		formatter:      formatter,
+		Formatter:      formatter,
-		verbosityLevel: verbosityLevel,
+		VerbosityLevel: verbosityLevel,
 	}
 }
 
 var _ InvocationEventHandler = (*DefaultEventHandler)(nil)
 
 func (h *DefaultEventHandler) OnResolveMethod(md *desc.MethodDescriptor) {
-	if h.verbosityLevel > 0 {
+	if h.VerbosityLevel > 0 {
-		txt, err := GetDescriptorText(md, h.descSource)
+		txt, err := GetDescriptorText(md, h.DescSource)
 		if err == nil {
-			fmt.Fprintf(h.out, "\nResolved method descriptor:\n%s\n", txt)
+			fmt.Fprintf(h.Out, "\nResolved method descriptor:\n%s\n", txt)
 		}
 	}
 }
 
 func (h *DefaultEventHandler) OnSendHeaders(md metadata.MD) {
-	if h.verbosityLevel > 0 {
+	if h.VerbosityLevel > 0 {
-		fmt.Fprintf(h.out, "\nRequest metadata to send:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.Out, "\nRequest metadata to send:\n%s\n", MetadataToString(md))
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveHeaders(md metadata.MD) {
-	if h.verbosityLevel > 0 {
+	if h.VerbosityLevel > 0 {
-		fmt.Fprintf(h.out, "\nResponse headers received:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.Out, "\nResponse headers received:\n%s\n", MetadataToString(md))
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveResponse(resp proto.Message) {
 	h.NumResponses++
-	if h.verbosityLevel > 1 {
+	if h.VerbosityLevel > 1 {
-		fmt.Fprintf(h.out, "\nEstimated response size: %d bytes\n", proto.Size(resp))
+		fmt.Fprintf(h.Out, "\nEstimated response size: %d bytes\n", proto.Size(resp))
 	}
-	if h.verbosityLevel > 0 {
+	if h.VerbosityLevel > 0 {
-		fmt.Fprint(h.out, "\nResponse contents:\n")
+		fmt.Fprint(h.Out, "\nResponse contents:\n")
 	}
-	if respStr, err := h.formatter(resp); err != nil {
+	if respStr, err := h.Formatter(resp); err != nil {
-		fmt.Fprintf(h.out, "Failed to format response message %d: %v\n", h.NumResponses, err)
+		fmt.Fprintf(h.Out, "Failed to format response message %d: %v\n", h.NumResponses, err)
 	} else {
-		fmt.Fprintln(h.out, respStr)
+		fmt.Fprintln(h.Out, respStr)
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveTrailers(stat *status.Status, md metadata.MD) {
 	h.Status = stat
-	if h.verbosityLevel > 0 {
+	if h.VerbosityLevel > 0 {
-		fmt.Fprintf(h.out, "\nResponse trailers received:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.Out, "\nResponse trailers received:\n%s\n", MetadataToString(md))
 	}
 }
 

format_test.go

@@ -135,7 +135,12 @@ func TestHandler(t *testing.T) {
 				}
 
 				var buf bytes.Buffer
-				h := NewDefaultEventHandler(&buf, source, formatter, verbosityLevel)
+				h := &DefaultEventHandler{
+					Out:            &buf,
+					DescSource:     source,
+					Formatter:      formatter,
+					VerbosityLevel: verbosityLevel,
+				}
 
 				h.OnResolveMethod(md)
 				h.OnSendHeaders(reqHeaders)