Marko Tikvić / webutility

Browse Code »

Commit e2880d3fb1868efdd79b800054a2a22ad0b43d45

Authored by Marko Tikvić 2020-09-29 15:44:28 +0200

1 parent 62a0d7a8a7

Exists in master

integraded golloger

Showing 5 changed files with 308 additions and 5 deletions Show diff stats

gologger/http_logs.go

Diff comments View file @e2880d3

File was created	1	package gologger
	2
	3	import (
	4	"bytes"
	5	"fmt"
	6	"net/http"
	7	"net/http/httputil"
	8	"os"
	9	"strings"
	10	"time"
	11	)
	12
	13	const splitLine = "=============================================================="
	14
	15	// LogHTTPRequest ...
	16	func (l Logger) LogHTTPRequest(req http.Request, userID string) string {
	17	if userID == "" {
	18	userID = "-"
	19	}
	20
	21	var b strings.Builder
	22
	23	b.WriteString("Request:\n")
	24	// CLF-like header
	25	fmt.Fprintf(&b, "%s %s %s\n", req.RemoteAddr, userID, time.Now().Format(dateTimeFormat))
	26
	27	body, err := httputil.DumpRequest(req, true)
	28	if err != nil {
	29	fmt.Fprintf(os.Stderr, "%v\n", err)
	30	}
	31
	32	const sepStr = "\r\n\r\n"
	33	sepIndex := bytes.Index(body, []byte(sepStr))
	34	if sepIndex == -1 {
	35	b.WriteString(string(body) + "\n\n")
	36	} else {
	37	sepIndex += len(sepStr)
	38	payload, _ := printJSON(body[sepIndex:])
	39	b.WriteString(string(body[:sepIndex]) + string(payload) + "\n\n")
	40	}
	41
	42	return b.String()
	43	}
	44
	45	// LogHTTPResponse ...
	46	func (l *Logger) LogHTTPResponse(data []byte, status int, startTime time.Time) string {
	47	duration := time.Now().Sub(startTime)
	48	jsonData, _ := printJSON(data)
	49	return fmt.Sprintf("Response:\n%d %v %dB\n%s\n%s\n\n", status, duration, len(data), jsonData, splitLine)
	50	}
	51
	52	// CombineHTTPLogs ...
	53	func (l *Logger) CombineHTTPLogs(in string, out string) {
	54	if l.outputFile == nil {
	55	return
	56	}
	57
	58	l.mu.Lock()
	59	defer l.mu.Unlock()
	60
	61	msg := in + out
	62	if l.shouldSplit(len(msg)) {
	63	l.split()
	64	}
	65	l.outputFile.WriteString(msg)
	66	}
	67

gologger/main.go

Diff comments View file @e2880d3

File was created	1	package gologger
	2
	3	import (
	4	"bytes"
	5	"encoding/json"
	6	"fmt"
	7	"os"
	8	"path/filepath"
	9	"strings"
	10	"sync"
	11	"time"
	12	)
	13
	14	const dateTimeFormat = "2006-01-02 15:04:05"
	15
	16	// Block ...
	17	const (
	18	MaxLogSize5MB int64 = 5 * 1024 * 1024
	19	MaxLogSize1MB int64 = 1 * 1024 * 1024
	20	MaxLogSize500KB int64 = 500 * 1024
	21	MaxLogSize100KB int64 = 100 * 1024
	22	MaxLogSize512B int64 = 512
	23	)
	24
	25	// Logger ...
	26	type Logger struct {
	27	mu *sync.Mutex
	28	outputFile *os.File
	29
	30	outputFileName string
	31	fullName string
	32	maxFileSize int64
	33
	34	splitCount int
	35
	36	directory string
	37	}
	38
	39	// New ...
	40	func New(name, dir string, maxFileSize int64) (logger *Logger, err error) {
	41	logger = &Logger{}
	42
	43	logger.outputFileName = name
	44	logger.mu = &sync.Mutex{}
	45	logger.maxFileSize = maxFileSize
	46	logger.directory = dir
	47
	48	err = os.Mkdir(dir, os.ModePerm)
	49	if err != nil {
	50	if !os.IsExist(err) {
	51	return nil, err
	52	}
	53	}
	54
	55	date := strings.Replace(time.Now().Format(dateTimeFormat), ":", ".", -1)
	56	logger.outputFileName += " " + date
	57	logger.fullName = logger.outputFileName + ".txt"
	58	path := filepath.Join(dir, logger.fullName)
	59	if logger.outputFile, err = os.Create(path); err != nil {
	60	return nil, err
	61	}
	62
	63	return logger, nil
	64	}
	65
	66	// Log ...
	67	func (l *Logger) Log(format string, v ...interface{}) {
	68	if l.outputFile == nil {
	69	return
	70	}
	71
	72	l.mu.Lock()
	73	defer l.mu.Unlock()
	74
	75	msg := fmt.Sprintf(format, v...)
	76	s := time.Now().Format(dateTimeFormat) + ": " + msg + "\n"
	77	if l.shouldSplit(len(s)) {
	78	l.split()
	79	}
	80	l.outputFile.WriteString(s)
	81	}
	82
	83	// Print ...
	84	func (l *Logger) Print(format string, v ...interface{}) {
	85	msg := fmt.Sprintf(format, v...)
	86	fmt.Printf("%s: %s\n", time.Now().Format(dateTimeFormat), msg)
	87	}
	88
	89	// Trace ...
	90	func (l *Logger) Trace(format string, v ...interface{}) string {
	91	if l.outputFile == nil {
	92	return ""
	93	}
	94
	95	l.mu.Lock()
	96	defer l.mu.Unlock()
	97
	98	s := getTrace(format, v...) + "\n"
	99
	100	if l.shouldSplit(len(s)) {
	101	l.split()
	102	}
	103	l.outputFile.WriteString(s)
	104
	105	return s
	106	}
	107
	108	// PrintTrace ...
	109	func (l *Logger) PrintTrace(format string, v ...interface{}) {
	110	s := getTrace(format, v...)
	111	fmt.Printf("%s\n", s)
	112	}
	113
	114	// PrintAndTrace ...
	115	func (l *Logger) PrintAndTrace(format string, v ...interface{}) {
	116	t := l.Trace(format, v...)
	117	fmt.Println(t)
	118	}
	119
	120	// Close ...
	121	func (l *Logger) Close() error {
	122	if l.outputFile == nil {
	123	return nil
	124	}
	125
	126	return l.outputFile.Close()
	127	}
	128
	129	func (l *Logger) split() error {
	130	if l.outputFile == nil {
	131	return nil
	132	}
	133
	134	// close old file
	135	err := l.outputFile.Close()
	136	if err != nil {
	137	return err
	138	}
	139
	140	// open new file
	141	l.splitCount++
	142	path := filepath.Join(l.directory, l.outputFileName+fmt.Sprintf("(%d)", l.splitCount)+".txt")
	143	l.outputFile, err = os.Create(path)
	144
	145	return err
	146	}
	147
	148	func (l *Logger) shouldSplit(nextEntrySize int) bool {
	149	stats, _ := l.outputFile.Stat()
	150	return int64(nextEntrySize) >= (l.maxFileSize - stats.Size())
	151	}
	152
	153	func printJSON(in []byte) (out []byte, err error) {
	154	var buf bytes.Buffer
	155	err = json.Indent(&buf, in, "", " ")
	156	return buf.Bytes(), err
	157	}
	158
	159	// GetOutDir ...
	160	func (l *Logger) GetOutDir() string {
	161	return l.directory
	162	}
	163

gologger/tracing.go

Diff comments View file @e2880d3

File was created	1	package gologger
	2
	3	import (
	4	"fmt"
	5	"math"
	6	"runtime"
	7	"strings"
	8	"time"
	9	)
	10
	11	// getCallStack
	12	func getCallStack() (stack []string) {
	13	const (
	14	maxStackDepth = 10000
	15	skipRuntime = 2 // skip runtime and startup
	16	skipCallers = 2
	17	thisPackage = "gologger"
	18	)
	19
	20	callers := make([]uintptr, maxStackDepth) // min 1
	21
	22	stackDepth := runtime.Callers(skipCallers, callers)
	23	frames := runtime.CallersFrames(callers)
	24
	25	for i := 0; i < skipRuntime; i++ {
	26	frames.Next()
	27	}
	28
	29	for i := 0; i < stackDepth-skipRuntime-skipCallers; i++ {
	30	frame, next := frames.Next()
	31	if !strings.Contains(frame.File, thisPackage) {
	32	stack = append(stack, fmt.Sprintf("[%s %d]", frame.File, frame.Line))
	33	}
	34	if !next {
	35	break
	36	}
	37	}
	38
	39	reverseStack(stack)
	40
	41	return stack
	42	}
	43
	44	// in place
	45	func reverseStack(stack []string) {
	46	middle := int(math.Floor(float64(len(stack)) / 2.0))
	47
	48	lastIndex := len(stack) - 1
	49	for i := 0; i < middle; i++ {
	50	stack[i], stack[lastIndex] = stack[lastIndex], stack[i]
	51	lastIndex--
	52	}
	53	}
	54
	55	func getTrace(format string, v ...interface{}) (t string) {
	56	stack := getCallStack()
	57
	58	t = time.Now().Format(dateTimeFormat) + ":\n"
	59	for _, s := range stack {
	60	t += s + "\n"
	61	}
	62	t += fmt.Sprintf(format, v...) + "\n"
	63
	64	return t
	65	}
	66

http.go

Diff comments View file @e2880d3

 package webutility
 import (
 	"encoding/json"
 	"fmt"
 	"net/http"
 )
 // StatusRecorder ...
 type StatusRecorder struct {
 	writer http.ResponseWriter
 	status int
 	size   int
+	data   []byte
 }
 // NewStatusRecorder ...
 func NewStatusRecorder(w http.ResponseWriter) *StatusRecorder {
 	return &StatusRecorder{
 		writer: w,
 		status: 0,
 		size:   0,
+		data:   nil,
 	}
 }
 // WriteHeader is a wrapper http.ResponseWriter interface
 func (r *StatusRecorder) WriteHeader(code int) {
 	r.status = code
 	r.writer.WriteHeader(code)
 }
 // Write is a wrapper for http.ResponseWriter interface
 func (r *StatusRecorder) Write(in []byte) (int, error) {
 	r.size = len(in)
+	if r.status >= 400 {
+		r.data = make([]byte, len(in))
+		copy(r.data, in)
+	}
 	return r.writer.Write(in)
 }
 // Header is a wrapper for http.ResponseWriter interface
 func (r *StatusRecorder) Header() http.Header {
 	return r.writer.Header()
 }
 // Status ...
 func (r *StatusRecorder) Status() int {
 	return r.status
 }
 // Size ...
 func (r *StatusRecorder) Size() int {
 	return r.size
 }
+// Size ...
+func (r *StatusRecorder) Data() []byte {
+	return r.data
+}
 // NotFoundHandlerFunc writes HTTP error 404 to w.
 func NotFoundHandlerFunc(w http.ResponseWriter, req *http.Request) {
 	SetAccessControlHeaders(w)
 	SetContentType(w, "application/json")
 	NotFound(w, req, fmt.Sprintf("Resource you requested was not found: %s", req.URL.String()))
 }
 // SetContentType must be called before SetResponseStatus (w.WriteHeader) (?)
 func SetContentType(w http.ResponseWriter, ctype string) {
 	w.Header().Set("Content-Type", ctype)
 }
 // SetResponseStatus ...
 func SetResponseStatus(w http.ResponseWriter, status int) {
 	w.WriteHeader(status)
 }
 // WriteResponse ...
 func WriteResponse(w http.ResponseWriter, content []byte) {
 	w.Write(content)
 }
 // SetAccessControlHeaders set's default headers for an HTTP response.
 func SetAccessControlHeaders(w http.ResponseWriter) {
 	w.Header().Set("Access-Control-Allow-Origin", "*")
 	w.Header().Set("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS")
 	w.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
 }
 // GetLocale ...
 func GetLocale(req *http.Request, dflt string) string {
 	loc := req.FormValue("locale")
 	if loc == "" {
 		return dflt
 	}
 	return loc
 }
 // Success ...
 func Success(w http.ResponseWriter, payload interface{}, code int) {
 	w.WriteHeader(code)
 	if payload != nil {
 		json.NewEncoder(w).Encode(payload)
 	}
 }
 // OK ...
 func OK(w http.ResponseWriter, payload interface{}) {
 	SetContentType(w, "application/json")
 	Success(w, payload, http.StatusOK)
 }
 // Created ...
 func Created(w http.ResponseWriter, payload interface{}) {
 	SetContentType(w, "application/json")
 	Success(w, payload, http.StatusCreated)
 }
 type weberror struct {
 	Request string `json:"request"`
 	Error   string `json:"error"`
 	//Code    int64  `json:"code"` TODO
 }
 // Error ...
 func Error(w http.ResponseWriter, r *http.Request, code int, err string) {
 	werr := weberror{Error: err, Request: r.Method + " " + r.RequestURI}
 	w.WriteHeader(code)
 	json.NewEncoder(w).Encode(werr)
 }
 // BadRequest ...
 func BadRequest(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusBadRequest, err)
 }
 // Unauthorized ...
 func Unauthorized(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusUnauthorized, err)
 }
 // Forbidden ...
 func Forbidden(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusForbidden, err)
 }
 // NotFound ...
 func NotFound(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusNotFound, err)
 }
 // Conflict ...
 func Conflict(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusConflict, err)
 }
 // InternalServerError ...
 func InternalServerError(w http.ResponseWriter, r *http.Request, err string) {
 	SetContentType(w, "application/json")
 	Error(w, r, http.StatusInternalServerError, err)
 }
 func SetHeader(r *http.Request, key, val string) {
 	r.Header.Set(key, val)
 }
 func AddHeader(r *http.Request, key, val string) {
 	r.Header.Add(key, val)
 }
 func GetHeader(r *http.Request, key string) string {
 	return r.Header.Get(key)
 }
 func ClientUTCOffset(req *http.Request) int64 {
 	return StringToInt64(GetHeader(req, "X-Timezone-Offset"))
 }

middleware/middleware.go

Diff comments View file @e2880d3

 package middleware
 import (
 	"net/http"
 	"time"
 	"git.to-net.rs/marko.tikvic/gologger"
 	web "git.to-net.rs/marko.tikvic/webutility"
 )
 var httpLogger *gologger.Logger
 func SetAccessControlHeaders(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		web.SetAccessControlHeaders(w)
 		h(w, req)
 	}
 }
 // IgnoreOptionsRequests ...
 func IgnoreOptionsRequests(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		if req.Method == http.MethodOptions {
 			return
 		}
 		h(w, req)
 	}
 }
 // ParseForm ...
 func ParseForm(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		err := req.ParseForm()
 		if err != nil {
 			web.BadRequest(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }
 // ParseMultipartForm ...
 func ParseMultipartForm(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		err := req.ParseMultipartForm(32 << 20)
 		if err != nil {
 			web.BadRequest(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }
 // SetLogger ...
 func SetLogger(logger *gologger.Logger) {
 	httpLogger = logger
 }
 func StartLogging(filename, dir string) (err error) {
 	if httpLogger, err = gologger.New(filename, dir, gologger.MaxLogSize1MB); err != nil {
 		return err
 	}
 	return nil
 }
 func CloseLogger() {
 	httpLogger.Close()
 }
 // LogHTTP ...
-func LogHTTP(h http.HandlerFunc) http.HandlerFunc {
+func LogHTTP(hfunc http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		if httpLogger == nil {
-			h(w, req)
+			hfunc(w, req)
 			return
 		}
 		t1 := time.Now()
 		claims, _ := web.GetTokenClaims(req)
 		in := httpLogger.LogHTTPRequest(req, claims.Username)
 		rec := web.NewStatusRecorder(w)
-		h(rec, req)
+		hfunc(rec, req)
-		t2 := time.Now()
+		out := httpLogger.LogHTTPResponse(rec.Data(), rec.Status(), t1)
-		out := httpLogger.LogHTTPResponse(rec.Status(), t2.Sub(t1), rec.Size())
 		httpLogger.CombineHTTPLogs(in, out)
 	}
 }
 // Auth ...
 func Auth(roles string, h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		if _, err := web.AuthCheck(req, roles); err != nil {
 			web.Unauthorized(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }