Add details flag

This will print all headers in a table under the incoming request
when the --details flag is passed to the CLI.

Header keys are sorted alphabetically.

Default option for the flag is set to false.

Author: aaronvb

cmd/protocol.go

@@ -20,7 +20,7 @@ func init() {
 }
 
 func http(cmd *cobra.Command, args []string) {
-	renderer := &renderer.Printer{Port: Port, Addr: Address, BuildInfo: BuildInfo}
+	renderer := &renderer.Printer{Port: Port, Addr: Address, BuildInfo: BuildInfo, Details: Details}
 	httpServer := server.Http{Addr: Address, Port: Port, ResponseCode: ResponseCode, Output: renderer}
 	httpServer.Start()
 }

cmd/root.go

@@ -8,6 +8,7 @@ var (
 	Port         int
 	ResponseCode int
 	BuildInfo    map[string]string
+	Details      bool
 )
 
 var rootCmd = &cobra.Command{
@@ -26,4 +27,5 @@ func init() {
 	rootCmd.PersistentFlags().IntVarP(&Port, "port", "p", 8080, "sets the port for the endpoint")
 	rootCmd.PersistentFlags().StringVarP(&Address, "address", "a", "localhost", "sets the address for the endpoint")
 	rootCmd.PersistentFlags().IntVarP(&ResponseCode, "response_code", "r", 200, "sets the response code")
+	rootCmd.PersistentFlags().BoolVar(&Details, "details", false, "shows header details in the request")
 }

pkg/renderer/printer.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"sort"
+	"strings"
 
 	"github.com/aaronvb/logrequest"
 	"github.com/pterm/pterm"
@@ -21,6 +23,9 @@ type Printer struct {
 
 	// Contains build info
 	BuildInfo map[string]string
+
+	// Determines if header details should be shown with the request
+	Details bool
 }
 
 // Start renders the initial header and the spinner. The Spinner should be consistent during
@@ -63,7 +68,7 @@ func (p *Printer) Fatal(err error) {
 }
 
 // IncomingRequest handles the output for incoming requests to the server.
-func (p *Printer) IncomingRequest(fields logrequest.RequestFields, params string) {
+func (p *Printer) IncomingRequest(fields logrequest.RequestFields, params string, headers map[string][]string) {
 	p.Spinner.Stop()
 	prefix := pterm.Prefix{
 		Text:  fields.Method,
@@ -72,6 +77,12 @@ func (p *Printer) IncomingRequest(fields logrequest.RequestFields, params string
 
 	text := p.incomingRequestText(fields, params)
 	pterm.Info.WithPrefix(prefix).Println(text)
+
+	if p.Details {
+		table := p.incomingRequestHeadersTable(headers)
+		pterm.Printf("%s\n\n", table)
+	}
+
 	p.startSpinner()
 }
 
@@ -85,6 +96,35 @@ func (p *Printer) incomingRequestText(fields logrequest.RequestFields, params st
 	return text
 }
 
+// incomingRequestHeadersTable constructs the headers table string.
+// This takes the headers map from the request and sorts it alphabetically by key.
+func (p *Printer) incomingRequestHeadersTable(headers map[string][]string) string {
+	keys := make([]string, 0, len(headers))
+	for key := range headers {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+
+	var headersFormatted [][]string
+
+	headerRow := []string{"Header", "Value"}
+	headersFormatted = append(headersFormatted, headerRow)
+
+	for _, key := range keys {
+		value := strings.Join(headers[key], ",")
+		headersRow := []string{key, value}
+		headersFormatted = append(headersFormatted, headersRow)
+	}
+
+	headersTable, err := pterm.DefaultTable.WithHasHeader().WithData(headersFormatted).Srender()
+	if err != nil {
+		pterm.Error.WithShowLineNumber(false).Println(err)
+	}
+
+	return headersTable
+}
+
 // Create the spinner which will be displayed at the bottom.
 func (p *Printer) startSpinner() {
 	listeningText := pterm.DefaultBasicText.

pkg/renderer/printer_test.go

@@ -34,3 +34,27 @@ func TestIncomingRequestText(t *testing.T) {
 		t.Errorf("Expected %s, got %s", expected, result)
 	}
 }
+
+func TestIncomingRequestHeadersTables(t *testing.T) {
+	pterm.DisableColor()
+	printer := Printer{}
+	headers := map[string][]string{
+		"hello": {"world", "foobar"},
+		"foo":   {"bar"},
+	}
+	result := printer.incomingRequestHeadersTable(headers)
+
+	headersForTable := [][]string{}
+	headersForTable = append(headersForTable, []string{"Header", "Value"})
+	headersForTable = append(headersForTable, []string{"foo", "bar"})
+	headersForTable = append(headersForTable, []string{"hello", "world,foobar"})
+
+	expected, err := pterm.DefaultTable.WithHasHeader().WithData(headersForTable).Srender()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if result != expected {
+		t.Errorf("Expected %s, got %s", expected, result)
+	}
+}

pkg/renderer/renderer.go

@@ -18,5 +18,5 @@ type Renderer interface {
 	// Fatal is used when we need to display a message and should always exit the CLI.
 	Fatal(error)
 
-	IncomingRequest(logrequest.RequestFields, string)
+	IncomingRequest(logrequest.RequestFields, string, map[string][]string)
 }

pkg/server/http.go

@@ -63,6 +63,6 @@ func (s *Http) logRequest(next http.Handler) http.Handler {
 		lr := logrequest.LogRequest{Request: r, Writer: w, Handler: next}
 		fields := lr.ToFields()
 		params := logparams.LogParams{Request: r, HidePrefix: true}
-		s.Output.IncomingRequest(fields, params.ToString())
+		s.Output.IncomingRequest(fields, params.ToString(), r.Header)
 	})
 }

pkg/server/http_test.go

@@ -12,16 +12,18 @@ import (
 )
 
 type MockPrinter struct {
-	fields logrequest.RequestFields
-	params string
+	fields  logrequest.RequestFields
+	params  string
+	headers map[string][]string
 }
 
 func (mp *MockPrinter) Fatal(error)              {}
 func (mp *MockPrinter) Start()                   {}
 func (mp *MockPrinter) ErrorLogger() *log.Logger { return log.New(os.Stderr, "", 0) }
-func (mp *MockPrinter) IncomingRequest(fields logrequest.RequestFields, params string) {
+func (mp *MockPrinter) IncomingRequest(fields logrequest.RequestFields, params string, headers map[string][]string) {
 	mp.fields = fields
 	mp.params = params
+	mp.headers = headers
 }
 
 func TestResponseCodeFlag(t *testing.T) {
@@ -97,3 +99,39 @@ func TestLogRequest(t *testing.T) {
 		}
 	}
 }
+
+func TestLogRequestHeaders(t *testing.T) {
+	headers := map[string]string{
+		"Content-Type": "application/json",
+		"Foo":          "bar",
+		"Bearer":       "hello!",
+	}
+
+	renderer := &MockPrinter{}
+	httpServer := Http{ResponseCode: 200, Output: renderer}
+	srv := httptest.NewServer(httpServer.routes())
+	defer srv.Close()
+
+	req, err := http.NewRequest(http.MethodGet, srv.URL, nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Error(err)
+	}
+
+	defer resp.Body.Close()
+
+	for key, value := range headers {
+		result := renderer.headers[key][0]
+		if value != result {
+			t.Errorf("Expected %s, got %s", value, result)
+		}
+	}
+}