logh

Documentation

Index

• Variables
• func BasicHello(w http.ResponseWriter, r *http.Request)
• func Daemon()
• func DoJsonPost(uri string, args, ret interface{}) error
• func Engine() http.Handler
• func InitLog(fn, prefix string) *log.Logger
• func SetLog()
• type AppendStruct
  • func NewAppender(fn string) (*AppendStruct, error)
  • func (as *AppendStruct) Close()
  • func (as *AppendStruct) Restart() error
  • func (as *AppendStruct) Write(bt []byte) (int, error)
• type Cli
  • func New(url string, sec int) *Cli
  • func (c *Cli) Get(u string) ([]byte, error)
  • func (c *Cli) GetBaseURL() string
  • func (c *Cli) SetBaseURL(u string)
• type ErrInfo
• type HandlerInfo
• type LogMux
  • func NewLogMux(fn, prefix string) *LogMux
  • func (l *LogMux) GET(pattern string, handler func(http.ResponseWriter, *http.Request))
  • func (l *LogMux) POST(pattern string, handler func(http.ResponseWriter, *http.Request))
  • func (l *LogMux) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type LogResponseWriter
  • func (lw *LogResponseWriter) Header() http.Header
  • func (lw *LogResponseWriter) Write(bt []byte) (int, error)
  • func (lw *LogResponseWriter) WriteHeader(statusCode int)
• type MgoConfig
• type ReqLogDB
  • func OpenReqLogDB(conf MgoConfig) *ReqLogDB
  • func (db *ReqLogDB) Close()
  • func (db *ReqLogDB) FindDuration(start, end time.Time) ([]RequestInfo, error)
  • func (db *ReqLogDB) InsertOne(ri *RequestInfo) error
• type RequestInfo
  • func RequestToInfo(req *http.Request, t time.Time) RequestInfo
• type RequestLogger
  • func NewRequestLogger(post, get string) *RequestLogger
  • func (hl *RequestLogger) GetStat(start, end time.Time) (*RequestLoggerStat, error)
  • func (hl *RequestLogger) PostOne(req *http.Request) error
• type RequestLoggerStat
• type ServeRequestLogger
  • func NewServeRequestLogger(conf MgoConfig) *ServeRequestLogger
  • func (s *ServeRequestLogger) GetStat(start, end time.Time) (*RequestLoggerStat, error)
  • func (s *ServeRequestLogger) OneRequest(r *RequestInfo) error
• type StatRequestInfo

Variables

var ErrGetStat = errors.New("get stat error")

var ErrPostOne = errors.New("post one error")

ErrPostOne: you could not post one

Functions

func BasicHello

func BasicHello(w http.ResponseWriter, r *http.Request)

BasicHello is test for http

func Daemon

func Daemon()

Daemon close stdin stdout

func DoJsonPost

func DoJsonPost(uri string, args, ret interface{}) error

DoJsonPost is a general api for http post

func Engine

func Engine() http.Handler

Engine is http handler

func InitLog

func InitLog(fn, prefix string) *log.Logger

InitLog create a new log object

func SetLog

func SetLog()

SetLog normal log set

Types

type AppendStruct

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

AppendStruct holds log file needed

func NewAppender

func NewAppender(fn string) (*AppendStruct, error)

NewAppender create an append only log file with debug info

func (*AppendStruct) Close

func (as *AppendStruct) Close()

Close release all resources it holds

func (*AppendStruct) Restart

func (as *AppendStruct) Restart() error

func (*AppendStruct) Write

func (as *AppendStruct) Write(bt []byte) (int, error)

Write api for file write

type Cli

type Cli struct {
	http.Client
	// contains filtered or unexported fields
}

Cli package a http client and baseurl

func New

func New(url string, sec int) *Cli

New create an cli object

func (*Cli) Get

func (c *Cli) Get(u string) ([]byte, error)

Get do a get for client

func (*Cli) GetBaseURL

func (c *Cli) GetBaseURL() string

GetBaseURL returns current baseUrl

func (*Cli) SetBaseURL

func (c *Cli) SetBaseURL(u string)

SetBaseURL change base url for the client

type ErrInfo

type ErrInfo struct {
	Err int    `json:"err"`
	Msg string `json:"msg"`
}

ErrInfo

type HandlerInfo

type HandlerInfo struct {
	Method  string
	Handler http.HandlerFunc
}

HandlerInfo holds method and handle function

type LogMux

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

LogMux is a mux with log

func NewLogMux

func NewLogMux(fn, prefix string) *LogMux

NewLogMux create log mux

func (*LogMux) GET

func (l *LogMux) GET(pattern string, handler func(http.ResponseWriter, *http.Request))

GET is api for logmux get

func (*LogMux) POST

func (l *LogMux) POST(pattern string, handler func(http.ResponseWriter, *http.Request))

POST is api for logmux post

func (*LogMux) ServeHTTP

func (l *LogMux) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP is logmux service

type LogResponseWriter

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

LogResponseWriter implement a interface for http

func (*LogResponseWriter) Header

func (lw *LogResponseWriter) Header() http.Header

Header implement response writer

func (*LogResponseWriter) Write

func (lw *LogResponseWriter) Write(bt []byte) (int, error)

Write impl response writer

func (*LogResponseWriter) WriteHeader

func (lw *LogResponseWriter) WriteHeader(statusCode int)

WriteHeader impl response writer

type MgoConfig

type MgoConfig struct {
	Addrs     []string `json:"addrs"`
	Username  string   `json:"user"`
	Password  string   `json:"pass"`
	DB        string   `json:"db"`
	Coll      string   `json:"coll"`
	TimeoutMs int      `json:"timeoutMs"`
}

MgoConfig is copyed

type ReqLogDB

type ReqLogDB struct {
	Coll    mgo.Collection
	Session *mgo.Session
}

ReqLogDB to mongodb

func OpenReqLogDB

func OpenReqLogDB(conf MgoConfig) *ReqLogDB

OpenReqLogDB opens new db

func (*ReqLogDB) Close

func (db *ReqLogDB) Close()

func (*ReqLogDB) FindDuration

func (db *ReqLogDB) FindDuration(start, end time.Time) ([]RequestInfo, error)

FindDuration find logs from start to end

func (*ReqLogDB) InsertOne

func (db *ReqLogDB) InsertOne(ri *RequestInfo) error

InsertOne insert one log

type RequestInfo

type RequestInfo struct {
	Id       string    `json:"_" bson:"_id"`             // mongodb id
	Name     string    `json:"name" bson:"name"`         // log name
	Method   string    `json:"method" bson:"method"`     // request method, get, post, put, head etc.
	Path     string    `json:"path" bson:"path"`         // url.Path
	ClientIP string    `json:"clientIP" bson:"clientIP"` // client ip
	Time     time.Time `json:"time" bson:"time"`         // when does the request fired
}

RequestInfo retrieves all info in http.Request

func RequestToInfo

func RequestToInfo(req *http.Request, t time.Time) RequestInfo

RequestToInfo makes info from request

type RequestLogger

type RequestLogger struct {
	PostUrl string
	GetUrl  string
}

HTTPLogger holds api server's url

func NewRequestLogger

func NewRequestLogger(post, get string) *RequestLogger

NewRequestLogger gives a new instance

func (*RequestLogger) GetStat

func (hl *RequestLogger) GetStat(start, end time.Time) (*RequestLoggerStat, error)

GetStat get log stat from start to end

func (*RequestLogger) PostOne

func (hl *RequestLogger) PostOne(req *http.Request) error

PostOne post one request log to server

type RequestLoggerStat

type RequestLoggerStat struct {
	ErrInfo
	MethodCount   map[string]int64 `json:"methodCount"`
	PathCount     map[string]int64 `json:"pathCount"`
	ClientIPCount map[string]int64 `json:"clientIPCount"`
}

RequestLoggerStat holds logs from start to end

type ServeRequestLogger

type ServeRequestLogger struct {
	DB   *ReqLogDB
	Conf MgoConfig
}

ServeRequestLogger is server side object of request logger

func NewServeRequestLogger

func NewServeRequestLogger(conf MgoConfig) *ServeRequestLogger

NewServeRequestLogger create instance of server side logger

func (*ServeRequestLogger) GetStat

func (s *ServeRequestLogger) GetStat(start, end time.Time) (*RequestLoggerStat, error)

GetStat get data from mongodb and give back ip info

func (*ServeRequestLogger) OneRequest

func (s *ServeRequestLogger) OneRequest(r *RequestInfo) error

OneRequest handle one request record it into mongodb

type StatRequestInfo

type StatRequestInfo struct {
	Start time.Time `json:"start"`
	End   time.Time `json:"end"`
}

StatRequestInfo just specify start and end time