Add a new method that returns the fields

This is helpful for those who wish to use their own output
or logging.

Author: aaronvb

logrequest.go

@@ -23,6 +23,16 @@ type statusWriter struct {
 	statusCode int
 }
 
+type RequestFields struct {
+	Method        string
+	Url           string
+	RemoteAddress string
+	Protocol      string
+	Time          time.Time
+	Duration      time.Duration
+	StatusCode    int
+}
+
 // ToLogger will print the Started and Completed request info to the passed logger
 func (lr LogRequest) ToLogger(logger *log.Logger) {
 	if lr.Timestamp {
@@ -67,6 +77,23 @@ func (lr LogRequest) ToString() map[string]string {
 	return ts
 }
 
+// ToFields returns a RequestFields struct which contains each field that is
+// used in the request.
+func (lr LogRequest) ToFields() RequestFields {
+	sw, completedDuration := lr.parseRequest()
+
+	rf := RequestFields{}
+	rf.Method = lr.Request.Method
+	rf.Url = lr.Request.URL.RequestURI()
+	rf.RemoteAddress = lr.Request.RemoteAddr
+	rf.Protocol = lr.Request.Proto
+	rf.Time = time.Now()
+	rf.Duration = completedDuration
+	rf.StatusCode = sw.statusCode
+
+	return rf
+}
+
 // parseRequest will time the request and retrieve the status from the
 // ResponseWriter. Returns the statusWriter struct and the duration
 // of the request.

logrequest_test.go

@@ -172,10 +172,55 @@ func TestToStringWithOptionals(t *testing.T) {
 	}
 }
 
+func TestToFields(t *testing.T) {
+	tables := []struct {
+		statusCode     int
+		method         string
+		path           string
+		expectedFields RequestFields
+	}{
+		{http.StatusOK, http.MethodGet, "/foo", RequestFields{Method: http.MethodGet, Url: "/foo", StatusCode: http.StatusOK}},
+		{http.StatusUnauthorized, http.MethodPost, "/bar/create", RequestFields{Method: http.MethodPost, Url: "/bar/create", StatusCode: http.StatusUnauthorized}},
+		{http.StatusNotFound, http.MethodGet, "/hello/world", RequestFields{Method: http.MethodGet, Url: "/hello/world", StatusCode: http.StatusNotFound}},
+		{http.StatusInternalServerError, http.MethodGet, "/", RequestFields{Method: http.MethodGet, Url: "/", StatusCode: http.StatusInternalServerError}},
+		{http.StatusServiceUnavailable, http.MethodPut, "/foo/update", RequestFields{Method: http.MethodPut, Url: "/foo/update", StatusCode: http.StatusServiceUnavailable}},
+	}
+
+	for _, table := range tables {
+		app := &application{}
+
+		req, err := http.NewRequest(table.method, table.path, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		testHandler := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+			rw.WriteHeader(table.statusCode)
+		})
+
+		rr := httptest.NewRecorder()
+		handler := app.logRequestToFields(testHandler)
+		handler.ServeHTTP(rr, req)
+
+		if app.RequestFields.StatusCode != table.expectedFields.StatusCode {
+			t.Errorf("Expected field was incorrect, %d should be %d", app.RequestFields.StatusCode, table.expectedFields.StatusCode)
+		}
+
+		if app.RequestFields.Method != table.expectedFields.Method {
+			t.Errorf("Expected field was incorrect, %s should be %s", app.RequestFields.Method, table.expectedFields.Method)
+		}
+
+		if app.RequestFields.Url != table.expectedFields.Url {
+			t.Errorf("Expected field was incorrect, %s should be %s", app.RequestFields.Url, table.expectedFields.Url)
+		}
+	}
+}
+
 // Helpers
 
 type application struct {
 	infoLog *log.Logger
+	RequestFields
 }
 
 func (app *application) logRequestToLogger(next http.Handler) http.Handler {
@@ -207,3 +252,10 @@ func (app *application) logRequestToStringWithOptionals(next http.Handler) http.
 		app.infoLog.Println(lr.ToString()["completed"])
 	})
 }
+
+func (app *application) logRequestToFields(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		lr := LogRequest{Request: r, Writer: w, Handler: next}
+		app.RequestFields = lr.ToFields()
+	})
+}