httplog

README

httplog

Small but powerful structured logging package for HTTP request logging in Go.

Example

(see _example/)

package main

import (
  "net/http"
  "github.com/go-chi/chi/v5"
  "github.com/go-chi/chi/v5/middleware"
  "github.com/go-chi/httplog"
)

func main() {
  // Logger
  logger := httplog.NewLogger("httplog-example", httplog.Options{
    JSON: true,
  })

  // Service
  r := chi.NewRouter()
  r.Use(httplog.RequestLogger(logger))
  r.Use(middleware.Heartbeat("/ping"))

  r.Get("/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello world"))
  })

  r.Get("/panic", func(w http.ResponseWriter, r *http.Request) {
    panic("oh no")
  })

  r.Get("/info", func(w http.ResponseWriter, r *http.Request) {
    oplog := httplog.LogEntry(r.Context())
    w.Header().Add("Content-Type", "text/plain")
    oplog.Info().Msg("info here")
    w.Write([]byte("info here"))
  })

  r.Get("/warn", func(w http.ResponseWriter, r *http.Request) {
    oplog := httplog.LogEntry(r.Context())
    oplog.Warn().Msg("warn here")
    w.WriteHeader(400)
    w.Write([]byte("warn here"))
  })

  r.Get("/err", func(w http.ResponseWriter, r *http.Request) {
    oplog := httplog.LogEntry(r.Context())
    oplog.Error().Msg("err here")
    w.WriteHeader(500)
    w.Write([]byte("err here"))
  })

  http.ListenAndServe(":5555", r)
}

License

MIT

Documentation

Index

• Variables
• func Configure(opts Options)
• func Handler(logger *slog.Logger) func(next http.Handler) http.Handler
• func LogEntry(ctx context.Context) slog.Logger
• func LogEntrySetField(ctx context.Context, key, value string)
• func LogEntrySetFields(ctx context.Context, fields map[string]interface{})
• func NewLogger(serviceName string, opts ...Options) *slog.Logger
• func RequestLogger(logger *slog.Logger) func(next http.Handler) http.Handler
• type Options
• type PrettyHandler
  • func NewPrettyHandler(w io.Writer, op ...*slog.HandlerOptions) *PrettyHandler
  • func (h *PrettyHandler) Enabled(level slog.Level) bool
  • func (h *PrettyHandler) Handle(r slog.Record) error
  • func (h *PrettyHandler) WithAttrs(attrs []slog.Attr) slog.Handler
  • func (h *PrettyHandler) WithGroup(name string) slog.Handler
• type RequestLoggerEntry
  • func (l *RequestLoggerEntry) Panic(v interface{}, stack []byte)
  • func (l *RequestLoggerEntry) Write(status, bytes int, header http.Header, elapsed time.Duration, ...)

Variables

var DefaultHandlerConfig = &slog.HandlerOptions{
	AddSource: true,
	Level:     slog.LevelInfo,
}

var DefaultOptions = Options{
	LogLevel:        "info",
	LevelFieldName:  "level",
	JSON:            false,
	Concise:         false,
	Tags:            nil,
	SkipHeaders:     nil,
	QuietDownRoutes: nil,
	QuietDownPeriod: 0,
	TimeFieldFormat: time.RFC3339Nano,
	TimeFieldName:   "timestamp",
}

var IsTTY bool

Functions

func Configure

func Configure(opts Options)

Configure will set new global/default options for the httplog and behaviour of underlying zerolog pkg and its global logger.

func Handler

func Handler(logger *slog.Logger) func(next http.Handler) http.Handler

func LogEntry

func LogEntry(ctx context.Context) slog.Logger

func LogEntrySetField

func LogEntrySetField(ctx context.Context, key, value string)

func LogEntrySetFields

func LogEntrySetFields(ctx context.Context, fields map[string]interface{})

func NewLogger

func NewLogger(serviceName string, opts ...Options) *slog.Logger

func RequestLogger

func RequestLogger(logger *slog.Logger) func(next http.Handler) http.Handler

RequestLogger is an http middleware to log http requests and responses.

NOTE: for simplicity, RequestLogger automatically makes use of the chi RequestID and Recoverer middleware.

Types

type Options

type Options struct {
	// LogLevel defines the minimum level of severity that app should log.
	// Must be one of:
	// "debug", "info", "warn", "error"
	LogLevel string

	// LevelFieldName sets the field name for the log level or severity.
	// Some providers parse and search for different field names.
	LevelFieldName string

	// JSON enables structured logging output in json. Make sure to enable this
	// in production mode so log aggregators can receive data in parsable format.
	//
	// In local development mode, its appropriate to set this value to false to
	// receive pretty output and stacktraces to stdout.
	JSON bool

	// Concise mode includes fewer log details during the request flow. For example
	// excluding details like request content length, user-agent and other details.
	// This is useful if during development your console is too noisy.
	Concise bool

	// Tags are additional fields included at the root level of all logs.
	// These can be useful for example the commit hash of a build, or an environment
	// name like prod/stg/dev
	Tags map[string]string

	// SkipHeaders are additional headers which are redacted from the logs
	SkipHeaders []string

	// QuietDownRoutes are routes which are temporarily excluded from logging for a QuietDownPeriod after it occurs
	// for the first time
	// to cancel noise from logging for routes that are known to be noisy.
	QuietDownRoutes []string

	// QuietDownPeriod is the duration for which a route is excluded from logging after it occurs for the first time
	// if the route is in QuietDownRoutes
	QuietDownPeriod time.Duration

	// TimeFieldFormat defines the time format of the Time field, defaulting to "time.RFC3339Nano" see options at:
	// https://pkg.go.dev/time#pkg-constants
	TimeFieldFormat string

	// TimeFieldName sets the field name for the time field.
	// Some providers parse and search for different field names.
	TimeFieldName string

	// SourceFieldName sets the field name for the source field which logs
	// the location where the logger was called
	// its "" if not enabled
	SourceFieldName string
}

type PrettyHandler

type PrettyHandler struct {
	// contains filtered or unexported fields
}

func NewPrettyHandler

func NewPrettyHandler(w io.Writer, op ...*slog.HandlerOptions) *PrettyHandler

func (*PrettyHandler) Enabled

func (h *PrettyHandler) Enabled(level slog.Level) bool

func (*PrettyHandler) Handle

func (h *PrettyHandler) Handle(r slog.Record) error

func (*PrettyHandler) WithAttrs

func (h *PrettyHandler) WithAttrs(attrs []slog.Attr) slog.Handler

func (*PrettyHandler) WithGroup

func (h *PrettyHandler) WithGroup(name string) slog.Handler

type RequestLoggerEntry

type RequestLoggerEntry struct {
	Logger slog.Logger
	// contains filtered or unexported fields
}

func (*RequestLoggerEntry) Panic

func (l *RequestLoggerEntry) Panic(v interface{}, stack []byte)

func (*RequestLoggerEntry) Write

func (l *RequestLoggerEntry) Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{})