149 lines
2.9 KiB
Go
149 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
// some headers not worth logging
|
|
var (
|
|
hdrsToNotLog = []string{
|
|
"Accept-Language",
|
|
"Cache-Control",
|
|
"Cf-Ray",
|
|
"CF-Visitor",
|
|
"CF-Connecting-IP",
|
|
"Cdn-Loop",
|
|
"Cookie",
|
|
"Connection",
|
|
"Dnt",
|
|
"If-Modified-Since",
|
|
"Sec-Fetch-Dest",
|
|
"Sec-Ch-Ua-Mobile",
|
|
// "Sec-Ch-Ua",
|
|
"Sec-Ch-Ua-Platform",
|
|
"Sec-Fetch-Site",
|
|
"Sec-Fetch-Mode",
|
|
"Sec-Fetch-User",
|
|
"Upgrade-Insecure-Requests",
|
|
"X-Request-Start",
|
|
"X-Forwarded-For",
|
|
"X-Forwarded-Proto",
|
|
"X-Forwarded-Host",
|
|
}
|
|
hdrsToNotLogMap map[string]bool
|
|
)
|
|
|
|
type LogFile struct {
|
|
handle *os.File
|
|
logger *log.Logger
|
|
path string
|
|
}
|
|
|
|
type LogFileRec struct {
|
|
Method string `json:"method"`
|
|
IpAddr string `json:"ipAddr"`
|
|
Url string `json:"url"`
|
|
}
|
|
|
|
func newFileLogger(path string) (*LogFile, error) {
|
|
f, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &LogFile{
|
|
handle: f,
|
|
logger: log.New(f, "", 0),
|
|
path: path,
|
|
}, nil
|
|
}
|
|
|
|
func (f *LogFile) Close() error {
|
|
if f == nil {
|
|
return nil
|
|
}
|
|
err := f.handle.Close()
|
|
f.handle = nil
|
|
return err
|
|
}
|
|
|
|
func extractFirstFragment(header *http.Header, headerName string) string {
|
|
s := header.Get(headerName)
|
|
if len(strings.TrimSpace(s)) == 0 {
|
|
return s
|
|
}
|
|
fragments := strings.Split(s, ",")
|
|
return strings.TrimSpace(fragments[0])
|
|
}
|
|
|
|
// Get Ip Address of the client
|
|
func extractIpAddress(r *http.Request) string {
|
|
var ipAddr string
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
possibleIpHeaders := []string{"CF-Connecting-IP", "X-Real-Ip", "X-Forwarded-For"}
|
|
for _, header := range possibleIpHeaders {
|
|
ipAddr = extractFirstFragment(&r.Header, header)
|
|
if len(strings.TrimSpace(ipAddr)) != 0 {
|
|
return ipAddr
|
|
}
|
|
}
|
|
// pull ip from Request.RemoteAddr
|
|
if len(strings.TrimSpace(r.RemoteAddr)) != 0 {
|
|
index := strings.LastIndex(r.RemoteAddr, ";")
|
|
if index == -1 {
|
|
return r.RemoteAddr
|
|
}
|
|
ipAddr = r.RemoteAddr[:index]
|
|
}
|
|
return ipAddr
|
|
}
|
|
|
|
func canSkipExtraHeaders(r *http.Request) bool {
|
|
ref := r.Header.Get("Referer")
|
|
if len(strings.TrimSpace(ref)) == 0 {
|
|
return false
|
|
}
|
|
return strings.Contains(ref, r.Host)
|
|
}
|
|
|
|
func shouldLogHeader(s string) bool {
|
|
if hdrsToNotLogMap == nil {
|
|
hdrsToNotLogMap = map[string]bool{}
|
|
for _, h := range hdrsToNotLog {
|
|
h = strings.ToLower(h)
|
|
hdrsToNotLogMap[h] = true
|
|
}
|
|
}
|
|
s = strings.ToLower(s)
|
|
return !hdrsToNotLogMap[s]
|
|
}
|
|
|
|
func (f *LogFile) WriteLog(r *http.Request) error {
|
|
if f == nil {
|
|
return nil
|
|
}
|
|
var rec = make(map[string]string)
|
|
rec["method"] = r.Method
|
|
rec["requestUri"] = r.RequestURI
|
|
rec["Host"] = r.Host
|
|
rec["ipAddr"] = extractIpAddress(r)
|
|
if !canSkipExtraHeaders(r) {
|
|
for key, val := range r.Header {
|
|
if shouldLogHeader(key) && len(val) > 0 {
|
|
rec[key] = val[0]
|
|
}
|
|
}
|
|
}
|
|
b, err := json.Marshal(rec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f.logger.Println(string(b))
|
|
return nil
|
|
}
|