How to use logging middleware

Here below is the entry point of my web application written in Go using Labstack's Echo:

package main

import (
    "github.com/labstack/echo"
    mw "github.com/labstack/echo/middleware"
)

func main() {
    controller := controllers.NewUserController(getSession())

    app := echo.New()

    app.Use(mw.Logger())
    app.Use(mw.Recover())
    app.SetDebug(true)

    app.Post("/users", controller.CreateUser)
    app.Get("/users", controller.ListUsers)
    app.Get("/users/:id", controller.GetUser)
    app.Patch("/users/:id", controller.UpdateUser)
    app.Delete("/users/:id", controller.DeleteUser)

    app.Run(":8000")
}

How do I reuse the logging middleware instantiated in the Echo application? I've tried this:

package controllers

import (
    "net/http"

    "github.com/labstack/echo"
    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

type (
    UserController struct {
        session *mgo.Session
    }
)

func NewUserController(s *mgo.Session) *UserController {
    return &UserController{s}
}

func (userController UserController) CreateUser(context *echo.Context) error {
    user := &models.User{}

    if err := context.Bind(user); err != nil {
        context.Echo().Logger().Error("Error creating user")
        return err
    }

    user.Id = bson.NewObjectId()

    userController.session.DB("test").C("users").Insert(user)
    context.Echo().Logger().Debug("Created user", id)

    return context.JSON(http.StatusCreated, user)
}

Even if the code above compiles, the statement

context.Echo().Logger().Debug("Created user", id)

doesn't produce any output... while the following statement does:

context.Echo().Logger().Info("Created user", id)

Am I missing something?

I just started using Echo and don't know if anything has changed since this was posted, but I've found you can just import labstack's logger:

import "github.com/labstack/gommon/log"

Then use it:

log.Debug("Created user", id)

By Default echo uses "INFO" Log Level. So anything below "INFO" Level gets displayed.

If you want to see "DEBUG" Logs as well, You need to set the level to "DEBUG":

import "github.com/labstack/gommon/log"
e.Logger.SetLevel(log.DEBUG)

Hierarchy:

DEBUG
INFO
WARN
ERROR
OFF

you can use 3rd party logging middleware such as https://github.com/sirupsen/logrus

import log "github.com/sirupsen/logrus"

example

create log entry function:

func makeLogEntry(c echo.Context) *log.Entry {
    if c == nil {
        return log.WithFields(log.Fields{
            "at": time.Now().Format("2006-01-02 15:04:05"),
        })
    }

    return log.WithFields(log.Fields{
        "at":     time.Now().Format("2006-01-02 15:04:05"),
        "method": c.Request().Method,
        "uri":    c.Request().URL.String(),
        "ip":     c.Request().RemoteAddr,
    })
}

then:

func middlewareLogging(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        makeLogEntry(c).Info("incoming request")
        return next(c)
    }
}

func errorHandler(err error, c echo.Context) {
    report, ok := err.(*echo.HTTPError)
    if ok {
        report.Message = fmt.Sprintf("http error %d - %v", report.Code, report.Message)
    } else {
        report = echo.NewHTTPError(http.StatusInternalServerError, err.Error())
    }

    makeLogEntry(c).Error(report.Message)
    c.HTML(report.Code, report.Message.(string))
}

and then in main() function:

func main() {
	e := echo.New()

	e.Use(middlewareLogging)
	e.HTTPErrorHandler = errorHandler

	e.GET("/index", func(c echo.Context) error {
		return c.JSON(http.StatusOK, true)
	})

	lock := make(chan error)
	go func(lock chan error) {
		lock <- e.Start(":9000")
	}(lock)

	time.Sleep(1 * time.Millisecond)
	makeLogEntry(nil).Warning("application started without ssl/tls enabled")

	err := <-lock
	if err != nil {
		makeLogEntry(nil).Panic("failed to start application")
	}
}