fiberlogrus

README

Logrus logger middleware

Logger middleware for Fiber that logs HTTP request/response details.

Use your configured logrus logger instance or global logrus instance to handle logging in a structured way.

Table of Contents

• Getting started
• Signatures
• Examples

Getting started

$ go get github.com/mikhail-bigun/fiberlogrus

Signatures

func New(config ...Config) fiber.Handler

Examples

Import required packages

import (
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	"github.com/mikhail-bigun/fiberlogrus"
)

Default config

Using with a default config, it will call global logrus instance to log the requests

app := fiber.New()

app.Use(fiberlogrus.New())

// ConfigDefault is the default config
var ConfigDefault Config = Config{
	Logger: nil,
	Tags: []string{
		TagStatus,
		TagLatency,
		TagMethod,
		TagPath,
	},
}

Use logger instance and configure tags

logger := logrus.New()
// you can also provide logger with a desired formatter
// logger.SetFormatter(&logrus.JSONFormatter{})

app.Use(
	fiberlogrus.New(
		fiberlogrus.Config{
			Logger: logger,
			Tags: []string{
				// add method field
				fiberlogrus.TagMethod,
				// add status field
				fiberlogrus.TagStatus,
				// add value from locals
				AttachKeyTag(TagLocals, "requestid"),
				// add certain header
				AttachKeyTag(TagReqHeader, "custom-header"),
			},
		},
	),
)

All supported common tags example

package main

import (
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	"github.com/mikhail-bigun/fiberlogrus"
)

func main() {
	app := fiber.New()

	logger := logrus.New()
	logger.SetFormatter(&logrus.JSONFormatter{PrettyPrint: true})

	app.Use(
		fiberlogrus.New(
			fiberlogrus.Config{
				Logger: logger,
				Tags: fiberlogrus.CommonTags,
			}))
	
	app.Get("/", func(c *fiber.Ctx) error { return c.SendStatus(fiber.StatusOK) })
	logger.Fatal(f.Listen(":8080"))
}

Supported tags

Common

// Common Tags
const (
	// request referer
	TagReferer = "referer"
	// request protocol
	TagProtocol = "protocol"
	// request port
	TagPort = "port"
	// request ip
	TagIP = "ip"
	// request ips
	TagIPs = "ips"
	// request host
	TagHost = "host"
	// request path
	TagPath = "path"
	// request url
	TagURL = "url"
	// request user-agent
	TagUA = "ua"
	// request body
	TagBody = "body"
	// request body bytes length
	TagBytesReceived = "bytesReceived"
	// response bytes length
	TagBytesSent = "bytesSent"
	// request route
	TagRoute = "route"
	// response body
	TagResBody = "resBody"
	// request headers
	TagReqHeaders = "reqHeaders"
	// request query parameters
	TagQueryStringParams = "queryParams"
	// response status
	TagStatus = "status"
	// request method
	TagMethod = "method"
	// fiber process id
	TagPid = "pid"
	// request latency
	TagLatency = "latency"
)

Key

// Key Tags
const (
	// request specified header
	TagReqHeader = "reqHeader"
	// response specified header
	TagRespHeader = "respHeader"
	// request specified query
	TagQuery = "query"
	// request specified form value
	TagForm = "form"
	// request specified cookie value
	TagCookie = "cookie"
	// request specified locals value
	TagLocals = "locals"
)

Documentation

Index

• Constants
• Variables
• func AttachKeyTag(keyTag, key string) string
• func New(config ...Config) fiber.Handler
• type Config
• type FuncTag

Constants

const (
	// request referer
	TagReferer = "referer"
	// request protocol
	TagProtocol = "protocol"
	// request port
	TagPort = "port"
	// request ip
	TagIP = "ip"
	// request ips
	TagIPs = "ips"
	// request host
	TagHost = "host"
	// request path
	TagPath = "path"
	// request url
	TagURL = "url"
	// request user-agent
	TagUA = "ua"
	// request body
	TagBody = "body"
	// request body bytes length
	TagBytesReceived = "bytesReceived"
	// response bytes length
	TagBytesSent = "bytesSent"
	// request route
	TagRoute = "route"
	// response body
	TagResBody = "resBody"
	// request headers
	TagReqHeaders = "reqHeaders"
	// request query parameters
	TagQueryStringParams = "queryParams"
	// response status
	TagStatus = "status"
	// request method
	TagMethod = "method"
	// fiber process id
	TagPid = "pid"
	// request latency
	TagLatency = "latency"
)

Common Tags

const (
	// request specified header
	TagReqHeader = "reqHeader"
	// response specified header
	TagRespHeader = "respHeader"
	// request specified query
	TagQuery = "query"
	// request specified form value
	TagForm = "form"
	// request specified cookie value
	TagCookie = "cookie"
	// request specified locals value
	TagLocals = "locals"
)

Key Tags

Variables

var CommonTags []string = []string{
	TagReferer,
	TagProtocol,
	TagPort,
	TagIP,
	TagIPs,
	TagHost,
	TagPath,
	TagURL,
	TagUA,
	TagBody,
	TagBytesReceived,
	TagBytesSent,
	TagRoute,
	TagResBody,
	TagReqHeaders,
	TagQueryStringParams,
	TagStatus,
	TagMethod,
	TagPid,
	TagLatency,
}

var KeyTags []string = []string{
	TagReqHeader,
	TagRespHeader,
	TagQuery,
	TagForm,
	TagCookie,
	TagLocals,
}

Functions

func AttachKeyTag

func AttachKeyTag(keyTag, key string) string

AttachKeyTag forms a string to access values stored as k-v pairs in format

"keytag:key"

Example:

AttachKeyTag(TagLocals, "requestid")

useing in Config.Tags will add a "locals:b367dbaf-7e1d-422c-97f0-ec4348c1bd0b" field in logger output

func New

func New(config ...Config) fiber.Handler

New creates a new middleware handler

Types

type Config

type Config struct {
	Logger *logrus.Logger
	Tags   []string
}

Config defines the config for middleware

var ConfigDefault Config = Config{
	Logger: nil,
	Tags: []string{
		TagStatus,
		TagLatency,
		TagMethod,
		TagPath,
	},
}

ConfigDefault is the default config

type FuncTag

type FuncTag func(c *fiber.Ctx, d *data) interface{}

FuncTag is a function used to populate logrus field

var (
	FuncTagReferer FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Get(fiber.HeaderReferer)
	}
	FuncTagProtocol FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Protocol()
	}
	FuncTagPort FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Port()
	}
	FuncTagIP FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.IP()
	}
	FuncTagIPs FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Get(fiber.HeaderXForwardedFor)
	}
	FuncTagHost FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Hostname()
	}
	FuncTagPath FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Path()
	}
	FuncTagURL FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.OriginalURL()
	}
	FuncTagUA FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Get(fiber.HeaderUserAgent)
	}
	FuncTagBody FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Body()
	}
	FuncTagBytesReceived FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return len(c.Request().Body())
	}
	FuncTagBytesSent FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		if c.Response().Header.ContentLength() < 0 {
			return 0
		}
		return len(c.Response().Body())
	}
	FuncTagRoute FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Route().Path
	}
	FuncTagResBody FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Response().Body()
	}
	FuncTagReqHeaders FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		reqHeaders := make([]string, 0)
		for k, vs := range c.GetReqHeaders() {
			for _, v := range vs {
				reqHeaders = append(reqHeaders, k+"="+v)
			}
		}
		return []byte(strings.Join(reqHeaders, "&"))
	}
	FuncTagQueryStringParams FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Request().URI().QueryArgs().String()
	}
	FuncTagStatus FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Response().StatusCode()
	}
	FuncTagMethod FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return c.Method()
	}
	FuncTagPid FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return d.pid
	}
	FuncTagLatency FuncTag = func(c *fiber.Ctx, d *data) interface{} {
		return d.end.Sub(d.start).String()
	}
	FuncTagReqHeader = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			return c.Get(extra)
		}
	}
	FuncTagRespHeader = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			return c.GetRespHeader(extra)
		}
	}
	FuncTagQuery = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			return c.Query(extra)
		}
	}
	FuncTagForm = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			return c.FormValue(extra)
		}
	}
	FuncTagCookie = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			return c.Cookies(extra)
		}
	}
	FuncTagLocals = func(extra string) FuncTag {
		return func(c *fiber.Ctx, d *data) interface{} {
			switch v := c.Locals(extra).(type) {
			case []byte:
				return string(v)
			case string:
				return v
			case nil:
				return nil
			default:
				return fmt.Sprintf("%v", v)
			}
		}
	}
)

predefined FuncTag functions