Version 3.0.0-beta cleaned

middleware/logger/README.md

@@ -0,0 +1,64 @@
+## Middleware information
+
+This folder contains a middleware for the  build'n Iris logger but for the requests.
+
+## How to use
+```go
+
+package main
+
+import (
+	"github.com/kataras/iris"
+	"github.com/kataras/iris/middleware/logger"
+)
+
+func main() {
+
+	iris.UseFunc(logger.Default())
+	// or iris.Use(logger.DefaultHandler())
+	// or iris.UseFunc(iris.HandlerFunc(logger.DefaultHandler())
+	// or iris.Get("/", logger.Default(), func (ctx *iris.Context){})
+	// or iris.Get("/", iris.HandlerFunc(logger.DefaultHandler()), func (ctx *iris.Context){})
+
+	// Custom settings:
+	// ...
+	// iris.UseFunc(logger.Custom(writer io.Writer, prefix string, flag int))
+	// and so on...
+
+	// Custom options:
+	// ...
+	// iris.UseFunc(logger.Default(logger.Options{IP:false}))  // don't log the ip
+	// or iris.UseFunc(logger.Custom(writer io.Writer, prefix string, flag int, logger.Options{IP:false}))
+	// and so on...
+
+	iris.Get("/", func(ctx *iris.Context) {
+		ctx.Write("hello")
+	})
+
+	iris.Get("/1", func(ctx *iris.Context) {
+		ctx.Write("hello")
+	})
+
+	iris.Get("/3", func(ctx *iris.Context) {
+		ctx.Write("hello")
+	})
+
+	// IF YOU WANT LOGGER TO LOGS THE HTTP ERRORS ALSO THEN:
+	// FUTURE: iris.OnError(404, logger.Default(logger.Options{Latency: false}))
+
+	// NOW:
+	errorLogger := logger.Default(logger.Options{Latency: false}) //here we just disable to log the latency, no need for error pages I think
+	// yes we have options look at the logger.Options inside middleware/logger.go
+	iris.OnError(404, func(ctx *iris.Context) {
+		errorLogger.Serve(ctx)
+		ctx.Write("My Custom 404 error page ")
+	})
+	//
+
+	println("Server is running at :80")
+	iris.Listen(":80")
+
+}
+
+
+```

middleware/logger/logger.go

@@ -0,0 +1,122 @@
+package logger
+
+import (
+	"github.com/kataras/iris"
+	"github.com/kataras/iris/config"
+	"github.com/kataras/iris/logger"
+	"strconv"
+	"time"
+)
+
+// Options are the options of the logger middlweare
+// contains 5 bools
+// Latency, Status, IP, Method, Path
+// if set to true then these will print
+type Options struct {
+	Latency bool
+	Status  bool
+	IP      bool
+	Method  bool
+	Path    bool
+}
+
+// DefaultOptions returns an options which all properties are true
+func DefaultOptions() Options {
+	return Options{true, true, true, true, true}
+}
+
+type loggerMiddleware struct {
+	*logger.Logger
+	options Options
+}
+
+// a poor  and ugly implementation of a logger but no need to worry about this at the moment
+func (l *loggerMiddleware) Serve(ctx *iris.Context) {
+	//all except latency to string
+	var date, status, ip, method, path string
+	var latency time.Duration
+	var startTime, endTime time.Time
+	path = ctx.PathString()
+	method = ctx.MethodString()
+
+	if l.options.Latency {
+		startTime = time.Now()
+	}
+
+	ctx.Next()
+	if l.options.Latency {
+		//no time.Since in order to format it well after
+		endTime = time.Now()
+		date = endTime.Format("01/02 - 15:04:05")
+		latency = endTime.Sub(startTime)
+	}
+
+	if l.options.Status {
+		status = strconv.Itoa(ctx.Response.StatusCode())
+	}
+
+	if l.options.IP {
+		ip = ctx.RemoteAddr()
+	}
+
+	if !l.options.Method {
+		method = ""
+	}
+
+	if !l.options.Path {
+		path = ""
+	}
+
+	//finally print the logs
+	if l.options.Latency {
+		l.Printf("%s %v %4v %s %s %s", date, status, latency, ip, method, path)
+	} else {
+		l.Printf("%s %v %s %s %s", date, status, ip, method, path)
+	}
+
+}
+
+func newLoggerMiddleware(loggerCfg config.Logger, options ...Options) *loggerMiddleware {
+	loggerCfg = config.DefaultLogger().MergeSingle(loggerCfg)
+
+	l := &loggerMiddleware{Logger: logger.New(loggerCfg)}
+
+	if len(options) > 0 {
+		l.options = options[0]
+	} else {
+		l.options = DefaultOptions()
+	}
+
+	return l
+}
+
+//all bellow are just for flexibility
+
+// DefaultHandler returns the logger middleware with the default settings
+func DefaultHandler(options ...Options) iris.Handler {
+	loggerCfg := config.DefaultLogger()
+	return newLoggerMiddleware(loggerCfg, options...)
+}
+
+// Default returns the logger middleware as HandlerFunc with the default settings
+func Default(options ...Options) iris.HandlerFunc {
+	return DefaultHandler(options...).Serve
+}
+
+// CustomHandler returns the logger middleware with customized settings
+// accepts 3 parameters
+// first parameter is the writer (io.Writer)
+// second parameter is the prefix of which the message will follow up
+// third parameter is the logger.Options
+func CustomHandler(loggerCfg config.Logger, options ...Options) iris.Handler {
+	return newLoggerMiddleware(loggerCfg, options...)
+}
+
+// Custom returns the logger middleware as HandlerFunc with customized settings
+// accepts 3 parameters
+// first parameter is the writer (io.Writer)
+// second parameter is the prefix of which the message will follow up
+// third parameter is the logger.Options
+func Custom(loggerCfg config.Logger, options ...Options) iris.HandlerFunc {
+	return CustomHandler(loggerCfg, options...).Serve
+}