2022-05-28 05:42:28 +03:00
|
|
|
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
2014-08-29 21:49:50 +04:00
|
|
|
// Use of this source code is governed by a MIT style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2014-06-18 03:42:34 +04:00
|
|
|
package gin
|
|
|
|
|
|
|
|
import (
|
2015-04-07 19:37:17 +03:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2018-08-14 04:51:56 +03:00
|
|
|
"net/http"
|
2016-12-03 12:10:40 +03:00
|
|
|
"os"
|
2014-06-18 03:42:34 +04:00
|
|
|
"time"
|
2016-12-03 12:10:40 +03:00
|
|
|
|
2016-12-04 04:50:02 +03:00
|
|
|
"github.com/mattn/go-isatty"
|
2014-06-18 03:42:34 +04:00
|
|
|
)
|
|
|
|
|
2019-03-18 06:12:30 +03:00
|
|
|
type consoleColorModeValue int
|
|
|
|
|
|
|
|
const (
|
|
|
|
autoColor consoleColorModeValue = iota
|
|
|
|
disableColor
|
|
|
|
forceColor
|
|
|
|
)
|
|
|
|
|
2019-08-29 03:32:22 +03:00
|
|
|
const (
|
|
|
|
green = "\033[97;42m"
|
|
|
|
white = "\033[90;47m"
|
|
|
|
yellow = "\033[90;43m"
|
|
|
|
red = "\033[97;41m"
|
|
|
|
blue = "\033[97;44m"
|
|
|
|
magenta = "\033[97;45m"
|
|
|
|
cyan = "\033[97;46m"
|
|
|
|
reset = "\033[0m"
|
2014-10-09 03:40:42 +04:00
|
|
|
)
|
|
|
|
|
2019-08-29 03:32:22 +03:00
|
|
|
var consoleColorMode = autoColor
|
|
|
|
|
2018-12-12 04:05:16 +03:00
|
|
|
// LoggerConfig defines the config for Logger middleware.
|
|
|
|
type LoggerConfig struct {
|
|
|
|
// Optional. Default value is gin.defaultLogFormatter
|
|
|
|
Formatter LogFormatter
|
|
|
|
|
|
|
|
// Output is a writer where logs are written.
|
|
|
|
// Optional. Default value is gin.DefaultWriter.
|
|
|
|
Output io.Writer
|
|
|
|
|
2022-03-23 16:35:09 +03:00
|
|
|
// SkipPaths is an url path array which logs are not written.
|
2018-12-12 04:05:16 +03:00
|
|
|
// Optional.
|
2018-12-20 12:54:08 +03:00
|
|
|
SkipPaths []string
|
2018-12-12 04:05:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// LogFormatter gives the signature of the formatter function passed to LoggerWithFormatter
|
|
|
|
type LogFormatter func(params LogFormatterParams) string
|
|
|
|
|
|
|
|
// LogFormatterParams is the structure any formatter will be handed when time to log comes
|
|
|
|
type LogFormatterParams struct {
|
2018-12-25 18:27:24 +03:00
|
|
|
Request *http.Request
|
|
|
|
|
|
|
|
// TimeStamp shows the time after the server returns a response.
|
|
|
|
TimeStamp time.Time
|
|
|
|
// StatusCode is HTTP response code.
|
|
|
|
StatusCode int
|
|
|
|
// Latency is how much time the server cost to process a certain request.
|
|
|
|
Latency time.Duration
|
|
|
|
// ClientIP equals Context's ClientIP method.
|
|
|
|
ClientIP string
|
|
|
|
// Method is the HTTP method given to the request.
|
|
|
|
Method string
|
|
|
|
// Path is a path the client requests.
|
|
|
|
Path string
|
|
|
|
// ErrorMessage is set if error has occurred in processing the request.
|
2018-12-12 04:05:16 +03:00
|
|
|
ErrorMessage string
|
2021-12-02 13:00:24 +03:00
|
|
|
// isTerm shows whether gin's output descriptor refers to a terminal.
|
2019-03-18 06:12:30 +03:00
|
|
|
isTerm bool
|
2019-02-22 08:12:05 +03:00
|
|
|
// BodySize is the size of the Response Body
|
|
|
|
BodySize int
|
2019-03-07 04:47:31 +03:00
|
|
|
// Keys are the keys set on the request's context.
|
2022-03-21 04:43:17 +03:00
|
|
|
Keys map[string]any
|
2018-12-12 04:05:16 +03:00
|
|
|
}
|
|
|
|
|
2019-02-22 11:48:55 +03:00
|
|
|
// StatusCodeColor is the ANSI color for appropriately logging http status code to a terminal.
|
|
|
|
func (p *LogFormatterParams) StatusCodeColor() string {
|
|
|
|
code := p.StatusCode
|
|
|
|
|
|
|
|
switch {
|
2023-09-27 10:17:11 +03:00
|
|
|
case code >= http.StatusContinue && code < http.StatusOK:
|
|
|
|
return white
|
2019-02-22 11:48:55 +03:00
|
|
|
case code >= http.StatusOK && code < http.StatusMultipleChoices:
|
|
|
|
return green
|
|
|
|
case code >= http.StatusMultipleChoices && code < http.StatusBadRequest:
|
|
|
|
return white
|
|
|
|
case code >= http.StatusBadRequest && code < http.StatusInternalServerError:
|
|
|
|
return yellow
|
|
|
|
default:
|
|
|
|
return red
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// MethodColor is the ANSI color for appropriately logging http method to a terminal.
|
|
|
|
func (p *LogFormatterParams) MethodColor() string {
|
|
|
|
method := p.Method
|
|
|
|
|
|
|
|
switch method {
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodGet:
|
2019-02-22 11:48:55 +03:00
|
|
|
return blue
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodPost:
|
2019-02-22 11:48:55 +03:00
|
|
|
return cyan
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodPut:
|
2019-02-22 11:48:55 +03:00
|
|
|
return yellow
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodDelete:
|
2019-02-22 11:48:55 +03:00
|
|
|
return red
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodPatch:
|
2019-02-22 11:48:55 +03:00
|
|
|
return green
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodHead:
|
2019-02-22 11:48:55 +03:00
|
|
|
return magenta
|
2019-11-29 02:50:49 +03:00
|
|
|
case http.MethodOptions:
|
2019-02-22 11:48:55 +03:00
|
|
|
return white
|
|
|
|
default:
|
|
|
|
return reset
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ResetColor resets all escape attributes.
|
|
|
|
func (p *LogFormatterParams) ResetColor() string {
|
|
|
|
return reset
|
|
|
|
}
|
|
|
|
|
2019-03-18 06:12:30 +03:00
|
|
|
// IsOutputColor indicates whether can colors be outputted to the log.
|
|
|
|
func (p *LogFormatterParams) IsOutputColor() bool {
|
|
|
|
return consoleColorMode == forceColor || (consoleColorMode == autoColor && p.isTerm)
|
|
|
|
}
|
|
|
|
|
2018-12-12 04:05:16 +03:00
|
|
|
// defaultLogFormatter is the default log format function Logger middleware uses.
|
|
|
|
var defaultLogFormatter = func(param LogFormatterParams) string {
|
|
|
|
var statusColor, methodColor, resetColor string
|
2019-03-18 06:12:30 +03:00
|
|
|
if param.IsOutputColor() {
|
2019-02-22 11:48:55 +03:00
|
|
|
statusColor = param.StatusCodeColor()
|
|
|
|
methodColor = param.MethodColor()
|
|
|
|
resetColor = param.ResetColor()
|
2018-12-12 04:05:16 +03:00
|
|
|
}
|
|
|
|
|
2019-03-28 09:14:00 +03:00
|
|
|
if param.Latency > time.Minute {
|
2021-05-04 17:38:14 +03:00
|
|
|
param.Latency = param.Latency.Truncate(time.Second)
|
2019-03-28 09:14:00 +03:00
|
|
|
}
|
2020-03-07 16:51:33 +03:00
|
|
|
return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %#v\n%s",
|
2018-12-12 04:05:16 +03:00
|
|
|
param.TimeStamp.Format("2006/01/02 - 15:04:05"),
|
|
|
|
statusColor, param.StatusCode, resetColor,
|
|
|
|
param.Latency,
|
|
|
|
param.ClientIP,
|
|
|
|
methodColor, param.Method, resetColor,
|
|
|
|
param.Path,
|
|
|
|
param.ErrorMessage,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2017-08-16 06:55:50 +03:00
|
|
|
// DisableConsoleColor disables color output in the console.
|
2016-12-21 09:24:01 +03:00
|
|
|
func DisableConsoleColor() {
|
2019-03-18 06:12:30 +03:00
|
|
|
consoleColorMode = disableColor
|
2016-12-21 09:24:01 +03:00
|
|
|
}
|
|
|
|
|
2019-02-20 16:14:16 +03:00
|
|
|
// ForceConsoleColor force color output in the console.
|
|
|
|
func ForceConsoleColor() {
|
2019-03-18 06:12:30 +03:00
|
|
|
consoleColorMode = forceColor
|
2019-02-20 16:14:16 +03:00
|
|
|
}
|
|
|
|
|
2022-03-23 16:35:09 +03:00
|
|
|
// ErrorLogger returns a HandlerFunc for any error type.
|
2014-06-30 05:59:21 +04:00
|
|
|
func ErrorLogger() HandlerFunc {
|
2015-05-12 16:22:13 +03:00
|
|
|
return ErrorLoggerT(ErrorTypeAny)
|
2014-07-08 02:16:41 +04:00
|
|
|
}
|
|
|
|
|
2022-03-23 16:35:09 +03:00
|
|
|
// ErrorLoggerT returns a HandlerFunc for a given error type.
|
2015-05-23 02:59:36 +03:00
|
|
|
func ErrorLoggerT(typ ErrorType) HandlerFunc {
|
2014-06-30 05:59:21 +04:00
|
|
|
return func(c *Context) {
|
|
|
|
c.Next()
|
2016-04-14 19:02:29 +03:00
|
|
|
errors := c.Errors.ByType(typ)
|
|
|
|
if len(errors) > 0 {
|
|
|
|
c.JSON(-1, errors)
|
2014-06-30 06:04:45 +04:00
|
|
|
}
|
2014-06-30 05:59:21 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-16 06:55:50 +03:00
|
|
|
// Logger instances a Logger middleware that will write the logs to gin.DefaultWriter.
|
2021-12-02 13:00:24 +03:00
|
|
|
// By default, gin.DefaultWriter = os.Stdout.
|
2014-06-18 03:42:34 +04:00
|
|
|
func Logger() HandlerFunc {
|
2018-12-12 04:05:16 +03:00
|
|
|
return LoggerWithConfig(LoggerConfig{})
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoggerWithFormatter instance a Logger middleware with the specified log format function.
|
|
|
|
func LoggerWithFormatter(f LogFormatter) HandlerFunc {
|
|
|
|
return LoggerWithConfig(LoggerConfig{
|
|
|
|
Formatter: f,
|
|
|
|
})
|
2015-04-07 19:37:17 +03:00
|
|
|
}
|
2014-07-06 20:26:40 +04:00
|
|
|
|
2018-11-05 09:17:04 +03:00
|
|
|
// LoggerWithWriter instance a Logger middleware with the specified writer buffer.
|
2015-05-29 22:03:41 +03:00
|
|
|
// Example: os.Stdout, a file opened in write mode, a socket...
|
2015-07-22 17:02:36 +03:00
|
|
|
func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc {
|
2018-12-12 04:05:16 +03:00
|
|
|
return LoggerWithConfig(LoggerConfig{
|
2018-12-20 12:54:08 +03:00
|
|
|
Output: out,
|
|
|
|
SkipPaths: notlogged,
|
2018-12-12 04:05:16 +03:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoggerWithConfig instance a Logger middleware with config.
|
|
|
|
func LoggerWithConfig(conf LoggerConfig) HandlerFunc {
|
|
|
|
formatter := conf.Formatter
|
|
|
|
if formatter == nil {
|
|
|
|
formatter = defaultLogFormatter
|
|
|
|
}
|
|
|
|
|
|
|
|
out := conf.Output
|
|
|
|
if out == nil {
|
|
|
|
out = DefaultWriter
|
|
|
|
}
|
|
|
|
|
2018-12-20 12:54:08 +03:00
|
|
|
notlogged := conf.SkipPaths
|
2018-12-12 04:05:16 +03:00
|
|
|
|
2016-12-03 12:10:40 +03:00
|
|
|
isTerm := true
|
2016-12-03 19:30:59 +03:00
|
|
|
|
2019-03-18 06:12:30 +03:00
|
|
|
if w, ok := out.(*os.File); !ok || os.Getenv("TERM") == "dumb" ||
|
|
|
|
(!isatty.IsTerminal(w.Fd()) && !isatty.IsCygwinTerminal(w.Fd())) {
|
2016-12-04 04:50:02 +03:00
|
|
|
isTerm = false
|
2016-12-03 12:10:40 +03:00
|
|
|
}
|
|
|
|
|
2015-07-22 17:02:36 +03:00
|
|
|
var skip map[string]struct{}
|
|
|
|
|
|
|
|
if length := len(notlogged); length > 0 {
|
|
|
|
skip = make(map[string]struct{}, length)
|
|
|
|
|
|
|
|
for _, path := range notlogged {
|
|
|
|
skip[path] = struct{}{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-18 03:42:34 +04:00
|
|
|
return func(c *Context) {
|
|
|
|
// Start timer
|
2014-07-04 02:25:12 +04:00
|
|
|
start := time.Now()
|
2015-04-08 00:49:53 +03:00
|
|
|
path := c.Request.URL.Path
|
2017-07-10 11:41:20 +03:00
|
|
|
raw := c.Request.URL.RawQuery
|
2014-06-18 03:42:34 +04:00
|
|
|
|
|
|
|
// Process request
|
|
|
|
c.Next()
|
|
|
|
|
2015-07-22 17:02:36 +03:00
|
|
|
// Log only when path is not being skipped
|
|
|
|
if _, ok := skip[path]; !ok {
|
2018-12-12 04:05:16 +03:00
|
|
|
param := LogFormatterParams{
|
|
|
|
Request: c.Request,
|
2019-03-18 06:12:30 +03:00
|
|
|
isTerm: isTerm,
|
2019-03-07 04:47:31 +03:00
|
|
|
Keys: c.Keys,
|
2016-12-03 12:10:40 +03:00
|
|
|
}
|
2018-12-12 04:05:16 +03:00
|
|
|
|
|
|
|
// Stop timer
|
|
|
|
param.TimeStamp = time.Now()
|
|
|
|
param.Latency = param.TimeStamp.Sub(start)
|
|
|
|
|
|
|
|
param.ClientIP = c.ClientIP()
|
|
|
|
param.Method = c.Request.Method
|
|
|
|
param.StatusCode = c.Writer.Status()
|
|
|
|
param.ErrorMessage = c.Errors.ByType(ErrorTypePrivate).String()
|
2015-07-22 17:02:36 +03:00
|
|
|
|
2019-02-22 08:12:05 +03:00
|
|
|
param.BodySize = c.Writer.Size()
|
|
|
|
|
2017-07-10 11:41:20 +03:00
|
|
|
if raw != "" {
|
|
|
|
path = path + "?" + raw
|
|
|
|
}
|
|
|
|
|
2018-12-12 04:05:16 +03:00
|
|
|
param.Path = path
|
|
|
|
|
2019-01-20 03:39:09 +03:00
|
|
|
fmt.Fprint(out, formatter(param))
|
2015-07-22 17:02:36 +03:00
|
|
|
}
|
2014-06-18 03:42:34 +04:00
|
|
|
}
|
|
|
|
}
|