Add logging to file option

Accepts a CLI flag `--log <filename>` which will write the CLI
output to a log file.

Author: aaronvb

cmd/root.go

@@ -9,6 +9,7 @@ var (
 	ResponseCode int
 	BuildInfo    map[string]string
 	Details      bool
+	LogFile      string
 )
 
 var rootCmd = &cobra.Command{
@@ -28,4 +29,5 @@ func init() {
 	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")
+	rootCmd.PersistentFlags().StringVar(&LogFile, "log", "", "writes incoming requests to the specified log file (example: --log rh.log)")
 }

pkg/renderer/logger.go

@@ -0,0 +1,110 @@
+package renderer
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/aaronvb/logrequest"
+	"github.com/pterm/pterm"
+)
+
+// Logger outputs to a log file.
+type Logger struct {
+	// File points to the file that we write to.
+	File string
+
+	// Fields for startText
+	Port int
+	Addr string
+}
+
+// Start writes the initial server start to the log file.
+func (l *Logger) Start() {
+	if l.File == "" {
+		return
+	}
+
+	f, err := os.OpenFile(l.File, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		l.Fatal(err)
+	}
+
+	defer f.Close()
+
+	str := fmt.Sprintf("%s: %s\n", time.Now().Format("2006/02/01 15:04:05"), l.startText())
+	f.WriteString(str)
+}
+
+func (l *Logger) startText() string {
+	return fmt.Sprintf("Listening on http://%s:%d", l.Addr, l.Port)
+}
+
+// Fatal will use the Error prefix to render the error and then exit the CLI.
+func (l *Logger) Fatal(err error) {
+	pterm.Error.WithShowLineNumber(false).Println(err)
+	os.Exit(1)
+}
+
+// IncomingRequest writes the incoming requests to the log file.
+func (l *Logger) IncomingRequest(fields logrequest.RequestFields, params string) {
+	if l.File == "" {
+		return
+	}
+
+	f, err := os.OpenFile(l.File, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		l.Fatal(err)
+	}
+
+	defer f.Close()
+
+	str := fmt.Sprintf("%s: %s\n", time.Now().Format("2006/02/01 15:04:05"), l.incomingRequestText(fields, params))
+	f.WriteString(str)
+}
+
+func (l *Logger) incomingRequestText(fields logrequest.RequestFields, params string) string {
+	return fmt.Sprintf("%s %s %s", fields.Method, fields.Url, params)
+}
+
+// IncomingRequestHeaders writes the incoming request headers to the log file
+func (l *Logger) IncomingRequestHeaders(headers map[string][]string) {
+	if l.File == "" {
+		return
+	}
+
+	f, err := os.OpenFile(l.File, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		l.Fatal(err)
+	}
+
+	defer f.Close()
+
+	headersWithJoinedValues, keys := l.incomingRequestHeaders(headers)
+
+	for _, key := range keys {
+		str := fmt.Sprintf("%s: %s: %s\n", time.Now().Format("2006/02/01 15:04:05"), key, headersWithJoinedValues[key])
+		f.WriteString(str)
+	}
+}
+
+// incomingRequestHeaders takes the headers from the request, sorts them alphabetically,
+// joins the values, and creates a new map
+func (l *Logger) incomingRequestHeaders(headers map[string][]string) (map[string]string, []string) {
+	headersWithJoinedValues := make(map[string]string)
+	for key, val := range headers {
+		value := strings.Join(val, ",")
+		headersWithJoinedValues[key] = value
+	}
+
+	keys := make([]string, 0, len(headers))
+	for key := range headers {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+
+	return headersWithJoinedValues, keys
+}

pkg/renderer/logger_test.go

@@ -0,0 +1,59 @@
+package renderer
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/aaronvb/logrequest"
+)
+
+func TestLoggerStartText(t *testing.T) {
+	logger := Logger{Port: 123, Addr: "foo.bar"}
+	text := logger.startText()
+	expected := fmt.Sprintf("Listening on http://%s:%d", logger.Addr, logger.Port)
+
+	if text != expected {
+		t.Errorf("Expected %s, got %s", expected, text)
+	}
+}
+
+func TestLoggerIncomingRequest(t *testing.T) {
+	logger := Logger{}
+	fields := logrequest.RequestFields{
+		Method: "GET",
+		Url:    "/foobar",
+	}
+	params := "{\"foo\" => \"bar\"}"
+	text := logger.incomingRequestText(fields, params)
+	expected := fmt.Sprintf("%s %s %s", fields.Method, fields.Url, params)
+
+	if text != expected {
+		t.Errorf("Expected %s, got %s", expected, text)
+	}
+}
+
+func TestIncomingRequestHeadersText(t *testing.T) {
+	logger := Logger{}
+	headers := map[string][]string{
+		"hello": {"world", "foobar"},
+		"foo":   {"bar"},
+	}
+	exepectedHeaders := map[string]string{
+		"hello": "world,foobar",
+		"foo":   "bar",
+	}
+	expectedSortedKeys := []string{
+		"foo", "hello",
+	}
+
+	headersWithJoinedValues, keys := logger.incomingRequestHeaders(headers)
+
+	if !reflect.DeepEqual(headersWithJoinedValues, exepectedHeaders) {
+		t.Errorf("Expected %s, got %s", exepectedHeaders, headersWithJoinedValues)
+	}
+
+	if !reflect.DeepEqual(keys, expectedSortedKeys) {
+		t.Errorf("Expected %s, got %s", expectedSortedKeys, keys)
+	}
+}

pkg/renderer/printer.go

@@ -23,7 +23,12 @@ type Printer struct {
 	// Contains build info
 	BuildInfo map[string]string
 
-	// Determines if header details should be shown with the request
+	// Log file location for the CLI header that shows the user
+	// the entered log file location. Not used for writing to
+	LogFile string
+
+	// Details used in the header to show the user if they passed
+	// the flag.
 	Details bool
 }
 
@@ -54,6 +59,9 @@ func (p *Printer) startText() string {
 	if p.Details {
 		text = fmt.Sprintf("%s\nDetails: %t", text, p.Details)
 	}
+	if p.LogFile != "" {
+		text = fmt.Sprintf("%s\nLog: %s", text, p.LogFile)
+	}
 
 	return text
 }
@@ -66,7 +74,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, headers map[string][]string) {
+func (p *Printer) IncomingRequest(fields logrequest.RequestFields, params string) {
 	p.Spinner.Stop()
 	prefix := pterm.Prefix{
 		Text:  fields.Method,

pkg/renderer/printer_test.go

@@ -36,6 +36,23 @@ func TestStartTextWithDetails(t *testing.T) {
 	}
 }
 
+func TestStartTextWithLogFile(t *testing.T) {
+	pterm.DisableColor()
+	printer := Printer{
+		Addr:      "localhost",
+		Port:      8080,
+		BuildInfo: map[string]string{"version": "dev"},
+		LogFile:   "rh.log"}
+	result := printer.startText()
+	expected := fmt.Sprintf(
+		"Request Hole %s\nListening on http://%s:%d\nLog: %s", "dev",
+		printer.Addr, printer.Port, printer.LogFile)
+
+	if result != expected {
+		t.Errorf("Expected %s, got %s", expected, result)
+	}
+}
+
 func TestIncomingRequestText(t *testing.T) {
 	pterm.DisableColor()
 	printer := Printer{}

pkg/server/http.go

@@ -25,13 +25,19 @@ type Http struct {
 
 	// Output is the Renderer interface.
 	Output renderer.Renderer
+
+	// LogOutput
+	LogOutput renderer.Renderer
+
 	// Determines if header details should be shown with the request
 	Details bool
 }
 
 // Start will start the HTTP server.
 func (s *Http) Start() {
 	s.Output.Start()
+	s.LogOutput.Start()
+
 	addr := fmt.Sprintf("%s:%d", s.Addr, s.Port)
 	errorLog := log.New(&renderer.PrinterLog{Prefix: pterm.Error}, "", 0)
 
@@ -68,7 +74,10 @@ 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(), r.Header)
+
+		s.Output.IncomingRequest(fields, params.ToString())
+		s.LogOutput.IncomingRequest(fields, params.ToString())
+
 		if s.Details {
 			s.Output.IncomingRequestHeaders(r.Header)
 			s.LogOutput.IncomingRequestHeaders(r.Header)

pkg/server/http_test.go

@@ -15,7 +15,6 @@ type MockPrinter struct {
 	headers map[string][]string
 }
 
-func (mp *MockPrinter) IncomingRequest(fields logrequest.RequestFields, params string, headers map[string][]string) {
 func (mp *MockPrinter) Fatal(error) {}
 func (mp *MockPrinter) Start()      {}
 
@@ -33,7 +32,7 @@ func TestResponseCodeFlag(t *testing.T) {
 
 	renderer := &MockPrinter{}
 	for _, respCode := range tests {
-		httpServer := Http{ResponseCode: respCode, Output: renderer}
+		httpServer := Http{ResponseCode: respCode, Output: renderer, LogOutput: renderer}
 		srv := httptest.NewServer(httpServer.routes())
 		req, err := http.NewRequest(http.MethodGet, srv.URL+"/", nil)
 		if err != nil {
@@ -66,7 +65,7 @@ func TestLogRequest(t *testing.T) {
 		{http.MethodGet, "/foo/bar?hello=world", "", "{\"hello\" => \"world\"}"},
 	}
 	renderer := &MockPrinter{}
-	httpServer := Http{ResponseCode: 200, Output: renderer}
+	httpServer := Http{ResponseCode: 200, Output: renderer, LogOutput: renderer}
 	srv := httptest.NewServer(httpServer.routes())
 	defer srv.Close()
 
@@ -110,7 +109,7 @@ func TestLogRequestHeaders(t *testing.T) {
 	}
 
 	renderer := &MockPrinter{}
-	httpServer := Http{ResponseCode: 200, Output: renderer}
+	httpServer := Http{ResponseCode: 200, Output: renderer, LogOutput: renderer, Details: true}
 	srv := httptest.NewServer(httpServer.routes())
 	defer srv.Close()