middleware

Documentation

Index

• Constants
• Variables
• func Authorization(next http.Handler) http.Handler
• func GetAuthorization(w http.ResponseWriter, r *http.Request) (string, error)
• func GetReqID(ctx context.Context) string
• func Logger(next http.Handler) http.Handler
• func NextRequestID() uint64
• func PrintPrettyStack(rvr interface{})
• func Recoverer(next http.Handler) http.Handler
• func RequestID(next http.Handler) http.Handler
• func RequestLogger(f LogFormatter) func(next http.Handler) http.Handler
• func Test(next http.Handler) http.Handler
• func WithLogEntry(r *http.Request, entry LogEntry) *http.Request
• type ContentLength
• type DefaultLogFormatter
  • func (l *DefaultLogFormatter) NewLogEntry(r *http.Request) LogEntry
• type LogEntry
  • func GetLogEntry(r *http.Request) LogEntry
• type LogFormatter
• type LoggerInterface
• type Metrics
  • func NewMetric(r *http.Request) *Metrics
  • func (m *Metrics) CallCPUUsage()
  • func (m *Metrics) CallMemoryUsage()
  • func (m *Metrics) CallSearchTime()
  • func (m *Metrics) DoneFn(rw *ResponseWriterWrapper) et.Json
  • func (m *Metrics) HTTPError(w http.ResponseWriter, r *http.Request, statusCode int, message string) error
  • func (m *Metrics) HandlerFunc(handler http.HandlerFunc, w http.ResponseWriter, r *http.Request)
  • func (m *Metrics) ITEM(w http.ResponseWriter, r *http.Request, statusCode int, dt et.Item) error
  • func (m *Metrics) ITEMS(w http.ResponseWriter, r *http.Request, statusCode int, dt et.Items) error
  • func (m *Metrics) JSON(w http.ResponseWriter, r *http.Request, statusCode int, dt interface{}) error
  • func (m *Metrics) Unauthorized(w http.ResponseWriter, r *http.Request)
  • func (m *Metrics) WriteResponse(w http.ResponseWriter, r *http.Request, statusCode int, e []byte) error
• type Request
• type ResponseWriterWrapper
  • func (rw *ResponseWriterWrapper) ContentLength() ContentLength
  • func (rw *ResponseWriterWrapper) Write(b []byte) (int, error)
  • func (rw *ResponseWriterWrapper) WriteHeader(statusCode int)
• type Result
• type WrapResponseWriter
  • func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter

Constants

const (
	ServiceIDKey contextKey = "serviceId"
	ClientIDKey  contextKey = "clientId"
	AppKey       contextKey = "app"
	NameKey      contextKey = "name"
	KindKey      contextKey = "kind"
	UsernameKey  contextKey = "username"
	TokenKey     contextKey = "token"
)

const RequestIDKey ctxKeyRequestID = 0

RequestIDKey is the key that holds the unique request ID in a request context.

Variables

var (
	// LogEntryCtxKey is the context.Context key to store the request log entry.
	LogEntryCtxKey = contextKey("LogEntry")

	// DefaultLogger is called by the Logger middleware handler to log each request.
	// Its made a package-level variable so that it can be reconfigured for custom
	// logging configurations.
	DefaultLogger func(next http.Handler) http.Handler
)

var RequestIDHeader = "X-Request-Id"

RequestIDHeader is the name of the HTTP Header which contains the request id. Exported so that it can be changed by developers

Functions

func Authorization

func Authorization(next http.Handler) http.Handler

* * Authorization * @param next http.Handler *

func GetAuthorization

func GetAuthorization(w http.ResponseWriter, r *http.Request) (string, error)

* * GetAuthorization * @param w http.ResponseWriter * @param r *http.Request * @return string * @return error *

func GetReqID

func GetReqID(ctx context.Context) string

GetReqID returns a request ID from the given context if one is present. Returns the empty string if a request ID cannot be found.

func Logger

func Logger(next http.Handler) http.Handler

Logger is a middleware that logs the start and end of each request, along with some useful data about what was requested, what the response status was, and how long it took to return. When standard output is a TTY, Logger will print in color, otherwise it will print in black and white. Logger prints a request ID if one is provided.

Alternatively, look at https://github.com/goware/httplog for a more in-depth http logger with structured logging support.

IMPORTANT NOTE: Logger should go before any other middleware that may change the response, such as `middleware.Recoverer`. Example:

```go r := chi.NewRouter() r.Use(middleware.Logger) // <--<< Logger should come before Recoverer r.Use(middleware.Recoverer) r.Get("/", handler) ```

func NextRequestID

func NextRequestID() uint64

NextRequestID generates the next request ID in the sequence.

func PrintPrettyStack

func PrintPrettyStack(rvr interface{})

func Recoverer

func Recoverer(next http.Handler) http.Handler

Recoverer is a middleware that recovers from panics, logs the panic (and a backtrace), and returns a HTTP 500 (Internal Server Error) status if possible. Recoverer prints a request ID if one is provided.

Alternatively, look at https://github.com/pressly/lg middleware pkgs.

func RequestID

func RequestID(next http.Handler) http.Handler

RequestID is a middleware that injects a request ID into the context of each request. A request ID is a string of the form "host.example.com/random-0001", where "random" is a base62 random string that uniquely identifies this go process, and where the last number is an atomically incremented request counter.

func RequestLogger

func RequestLogger(f LogFormatter) func(next http.Handler) http.Handler

RequestLogger returns a logger handler using a custom LogFormatter.

func Test

func Test(next http.Handler) http.Handler

func WithLogEntry

func WithLogEntry(r *http.Request, entry LogEntry) *http.Request

WithLogEntry sets the in-context LogEntry for a request.

Types

type ContentLength

type ContentLength struct {
	Header int
	Body   int
	Total  int
}

type DefaultLogFormatter

type DefaultLogFormatter struct {
	Logger  LoggerInterface
	NoColor bool
}

DefaultLogFormatter is a simple logger that implements a LogFormatter.

func (*DefaultLogFormatter) NewLogEntry

func (l *DefaultLogFormatter) NewLogEntry(r *http.Request) LogEntry

NewLogEntry creates a new LogEntry for the request.

type LogEntry

type LogEntry interface {
	Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{})
	Panic(v interface{}, stack []byte)
}

LogEntry records the final log when a request completes. See defaultLogEntry for an example implementation.

func GetLogEntry

func GetLogEntry(r *http.Request) LogEntry

GetLogEntry returns the in-context LogEntry for a request.

type LogFormatter

type LogFormatter interface {
	NewLogEntry(r *http.Request) LogEntry
}

LogFormatter initiates the beginning of a new LogEntry per request. See DefaultLogFormatter for an example implementation.

type LoggerInterface

type LoggerInterface interface {
	Print(v ...interface{})
}

LoggerInterface accepts printing to stdlib logger or compatible logger.

type Metrics

type Metrics struct {
	ReqID            string
	TimeBegin        time.Time
	TimeEnd          time.Time
	TimeExec         time.Time
	SearchTime       time.Duration
	ResponseTime     time.Duration
	Downtime         time.Duration
	Latency          time.Duration
	StatusCode       int
	Status           string
	ContentLength    ContentLength
	Header           http.Header
	Host             string
	EndPoint         string
	Method           string
	Proto            string
	RemoteAddr       string
	HostName         string
	RequestsHost     Request
	RequestsEndpoint Request
	Scheme           string
	CPUUsage         float64
	MemoryTotal      uint64
	MemoeryUsage     uint64
	MmemoryFree      uint64
}

func NewMetric

func NewMetric(r *http.Request) *Metrics

* * NewMetric * @params r *http.Request *

func (*Metrics) CallCPUUsage

func (m *Metrics) CallCPUUsage()

* * CallCPUUsage *

func (*Metrics) CallMemoryUsage

func (m *Metrics) CallMemoryUsage()

* * CallMemoryUsage *

func (*Metrics) CallSearchTime

func (m *Metrics) CallSearchTime()

* * CallSearchTime *

func (*Metrics) DoneFn

func (m *Metrics) DoneFn(rw *ResponseWriterWrapper) et.Json

* * DoneFn * @params rw *ResponseWriterWrapper * @params r *http.Request * @return et.Json *

func (*Metrics) HTTPError

func (m *Metrics) HTTPError(w http.ResponseWriter, r *http.Request, statusCode int, message string) error

func (*Metrics) HandlerFunc

func (m *Metrics) HandlerFunc(handler http.HandlerFunc, w http.ResponseWriter, r *http.Request)

* * HandlerFunc * @params handler http.HandlerFunc * @params w http.ResponseWriter * @params r *http.Request *

func (*Metrics) ITEM

func (m *Metrics) ITEM(w http.ResponseWriter, r *http.Request, statusCode int, dt et.Item) error

func (*Metrics) ITEMS

func (m *Metrics) ITEMS(w http.ResponseWriter, r *http.Request, statusCode int, dt et.Items) error

func (*Metrics) JSON

func (m *Metrics) JSON(w http.ResponseWriter, r *http.Request, statusCode int, dt interface{}) error

func (*Metrics) Unauthorized

func (m *Metrics) Unauthorized(w http.ResponseWriter, r *http.Request)

* * Unauthorized * @params w http.ResponseWriter * @params r *http.Request *

func (*Metrics) WriteResponse

func (m *Metrics) WriteResponse(w http.ResponseWriter, r *http.Request, statusCode int, e []byte) error

type Request

type Request struct {
	Tag     string
	Day     int
	Hour    int
	Minute  int
	Seccond int
	Limit   int
}

type ResponseWriterWrapper

type ResponseWriterWrapper struct {
	http.ResponseWriter
	StatusCode int
	SizeHeader int
	SizeBody   int
	SizeTotal  int
	Host       string
}

func (*ResponseWriterWrapper) ContentLength

func (rw *ResponseWriterWrapper) ContentLength() ContentLength

* * ContentLength * @return ContentLength *

func (*ResponseWriterWrapper) Write

func (rw *ResponseWriterWrapper) Write(b []byte) (int, error)

* * Write * @params b []byte *

func (*ResponseWriterWrapper) WriteHeader

func (rw *ResponseWriterWrapper) WriteHeader(statusCode int)

* * WriteHeader * @params statusCode int *

type Result

type Result struct {
	Ok     bool        `json:"ok"`
	Result interface{} `json:"result"`
}

type WrapResponseWriter

type WrapResponseWriter interface {
	http.ResponseWriter
	// Status returns the HTTP status of the request, or 0 if one has not
	// yet been sent.
	Status() int
	// BytesWritten returns the total number of bytes sent to the client.
	BytesWritten() int
	// Tee causes the response body to be written to the given io.Writer in
	// addition to proxying the writes through. Only one io.Writer can be
	// tee'd to at once: setting a second one will overwrite the first.
	// Writes will be sent to the proxy before being written to this
	// io.Writer. It is illegal for the tee'd writer to be modified
	// concurrently with writes.
	Tee(io.Writer)
	// Unwrap returns the original proxied target.
	Unwrap() http.ResponseWriter
}

WrapResponseWriter is a proxy around an http.ResponseWriter that allows you to hook into various parts of the response process.

func NewWrapResponseWriter

func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter

NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to hook into various parts of the response process.