logparams

This is a Go middleware log output that prints parameters if present in the HTTP request. Currently supports PostForm, query params, and JSON body.

The output can be a string or printed directly to the logger. Recommend using with middleware, see example below.

Install

go get -u github.com/aaronvb/logparams

Usage

Using logger:

var logger log.Logger{}
lp := logparams.LogParams{Request: r}
lp.ToLogger(&logger)

Output to a string:

lp := logparams.LogParams{Request: r}
lp.ToString()

Result:

Parameters: {"foo" => "bar", "hello" => "world"}

Returning data in struct:

lp := logparams.LogParams{Request: r}
lp.ToFields()

type ParamFields struct {
	Form      map[string]string
	Query     map[string]string
	Json      map[string]interface{}
	JsonArray []map[string]interface{}
}

Middleware Example (using gorilla/mux)

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/aaronvb/logparams"

	"github.com/gorilla/mux"
)

type application struct {
	errorLog *log.Logger
	infoLog  *log.Logger
}

func main() {
	infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime)
	errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)

	app := &application{
		errorLog: errorLog,
		infoLog:  infoLog,
	}

	srv := &http.Server{
		Addr:     ":8080",
		ErrorLog: errorLog,
		Handler:  app.routes(),
	}

	infoLog.Printf("Starting server on %s", ":8080")
	err := srv.ListenAndServe()
	errorLog.Fatal(err)
}

func (app *application) routes() http.Handler {
	r := mux.NewRouter()
	r.HandleFunc("/foobar", app.foobar).Methods("POST")

	// Middleware
	r.Use(app.logRequest)
	r.Use(app.logParams)

	return r
}

func (app *application) foobar(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Hello world")
}

// Middleware

func (app *application) logRequest(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		app.infoLog.Printf("%s - %s", r.Method, r.URL.RequestURI())

		next.ServeHTTP(w, r)
	})
}

func (app *application) logParams(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		lp := logparams.LogParams{Request: r}
		lp.ToLogger(app.infoLog)
		next.ServeHTTP(w, r)
	})
}

> go run main.go
INFO	2020/03/22 11:14:49 Starting server on :8080
INFO	2020/03/22 11:14:51 POST - /foobar
INFO	2020/03/22 11:15:18 Parameters: {"foo" => "bar"}

Optional Values

• ShowEmpty (bool) will return an empty string, or not print to logger, if there are no parameters. Default is to false if struct arg is not passed.

• ShowPassword (bool) will show the password and password_confirmation parameters. Default is false if not explicitly passed(DO NOT RECOMMEND).

• HidePrefix (bool) will hide the Parameters: prefix in the output. Default is to false if struct arg is not passed.