mirror of
https://github.com/kataras/iris.git
synced 2025-01-23 10:41:03 +01:00
129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
package logger
|
|
|
|
import (
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/kataras/iris"
|
|
"github.com/kataras/iris/config"
|
|
"github.com/kataras/iris/logger"
|
|
)
|
|
|
|
// Options are the options of the logger middlweare
|
|
// contains 5 bools
|
|
// Latency, Status, IP, Method, Path
|
|
// if set to true then these will print
|
|
type Options struct {
|
|
// Latency displays latency (bool)
|
|
Latency bool
|
|
// Status displays status code (bool)
|
|
Status bool
|
|
// IP displays request's remote address (bool)
|
|
IP bool
|
|
// Method displays the http method (bool)
|
|
Method bool
|
|
// Path displays the request path (bool)
|
|
Path bool
|
|
}
|
|
|
|
// DefaultOptions returns an options which all properties are true
|
|
func DefaultOptions() Options {
|
|
return Options{true, true, true, true, true}
|
|
}
|
|
|
|
type loggerMiddleware struct {
|
|
*logger.Logger
|
|
options Options
|
|
}
|
|
|
|
// Serve serves the middleware
|
|
func (l *loggerMiddleware) Serve(ctx *iris.Context) {
|
|
//all except latency to string
|
|
var date, status, ip, method, path string
|
|
var latency time.Duration
|
|
var startTime, endTime time.Time
|
|
path = ctx.PathString()
|
|
method = ctx.MethodString()
|
|
|
|
if l.options.Latency {
|
|
startTime = time.Now()
|
|
}
|
|
|
|
ctx.Next()
|
|
if l.options.Latency {
|
|
//no time.Since in order to format it well after
|
|
endTime = time.Now()
|
|
date = endTime.Format("01/02 - 15:04:05")
|
|
latency = endTime.Sub(startTime)
|
|
}
|
|
|
|
if l.options.Status {
|
|
status = strconv.Itoa(ctx.Response.StatusCode())
|
|
}
|
|
|
|
if l.options.IP {
|
|
ip = ctx.RemoteAddr()
|
|
}
|
|
|
|
if !l.options.Method {
|
|
method = ""
|
|
}
|
|
|
|
if !l.options.Path {
|
|
path = ""
|
|
}
|
|
|
|
//finally print the logs
|
|
if l.options.Latency {
|
|
l.Printf("%s %v %4v %s %s %s", date, status, latency, ip, method, path)
|
|
} else {
|
|
l.Printf("%s %v %s %s %s", date, status, ip, method, path)
|
|
}
|
|
|
|
}
|
|
|
|
func newLoggerMiddleware(loggerCfg config.Logger, options ...Options) *loggerMiddleware {
|
|
loggerCfg = config.DefaultLogger().MergeSingle(loggerCfg)
|
|
|
|
l := &loggerMiddleware{Logger: logger.New(loggerCfg)}
|
|
|
|
if len(options) > 0 {
|
|
l.options = options[0]
|
|
} else {
|
|
l.options = DefaultOptions()
|
|
}
|
|
|
|
return l
|
|
}
|
|
|
|
//all bellow are just for flexibility
|
|
|
|
// DefaultHandler returns the logger middleware with the default settings
|
|
func DefaultHandler(options ...Options) iris.Handler {
|
|
loggerCfg := config.DefaultLogger()
|
|
return newLoggerMiddleware(loggerCfg, options...)
|
|
}
|
|
|
|
// Default returns the logger middleware as HandlerFunc with the default settings
|
|
func Default(options ...Options) iris.HandlerFunc {
|
|
return DefaultHandler(options...).Serve
|
|
}
|
|
|
|
// CustomHandler returns the logger middleware with customized settings
|
|
// accepts 3 parameters
|
|
// first parameter is the writer (io.Writer)
|
|
// second parameter is the prefix of which the message will follow up
|
|
// third parameter is the logger.Options
|
|
func CustomHandler(loggerCfg config.Logger, options ...Options) iris.Handler {
|
|
return newLoggerMiddleware(loggerCfg, options...)
|
|
}
|
|
|
|
// Custom returns the logger middleware as HandlerFunc with customized settings
|
|
// accepts 3 parameters
|
|
// first parameter is the writer (io.Writer)
|
|
// second parameter is the prefix of which the message will follow up
|
|
// third parameter is the logger.Options
|
|
func Custom(loggerCfg config.Logger, options ...Options) iris.HandlerFunc {
|
|
return CustomHandler(loggerCfg, options...).Serve
|
|
}
|