lib/http: use package mlog for logging

In case the consumer of lib/http package use mlog for logging, the
log will be written to their predefined writers.

In case they did not use mlog, the log will written to stdout and stderr.

4 files changed, 68 insertions, 44 deletions

diff --git a/lib/http/callback_error_handler.go b/lib/http/callback_error_handler.go
index 6cd44c3e..b6e927a2 100644
--- a/lib/http/callback_error_handler.go
+++ b/lib/http/callback_error_handler.go
@@ -7,10 +7,10 @@ package http
 import (
 	"encoding/json"
 	"errors"
-	"log"
 	"net/http"
 
 	liberrors "github.com/shuLhan/share/lib/errors"
+	"github.com/shuLhan/share/lib/mlog"
 )
 
 //
@@ -35,15 +35,21 @@ type CallbackErrorHandler func(epr *EndpointRequest)
 //	{"code":<HTTP_STATUS_CODE>, "message":<err.Error()>}
 //
 func DefaultErrorHandler(epr *EndpointRequest) {
-	errInternal := &liberrors.E{}
+	var (
+		logp        = "DefaultErrorHandler"
+		errInternal = &liberrors.E{}
+
+		jsonb []byte
+		err   error
+	)
+
 	if errors.As(epr.Error, &errInternal) {
 		if errInternal.Code <= 0 || errInternal.Code >= 512 {
 			errInternal.Code = http.StatusInternalServerError
 		}
 	} else {
-		log.Printf("DefaultErrorHandler: %d %s %s %s\n",
-			http.StatusInternalServerError,
-			epr.HttpRequest.Method, epr.HttpRequest.URL.Path, epr.Error)
+		mlog.Errf("%s: %s %s: %s", logp, epr.HttpRequest.Method,
+			epr.HttpRequest.URL.Path, epr.Error)
 
 		errInternal = liberrors.Internal(epr.Error)
 	}
@@ -51,14 +57,14 @@ func DefaultErrorHandler(epr *EndpointRequest) {
 	epr.HttpWriter.Header().Set(HeaderContentType, ContentTypeJSON)
 	epr.HttpWriter.WriteHeader(errInternal.Code)
 
-	rsp, err := json.Marshal(errInternal)
+	jsonb, err = json.Marshal(errInternal)
 	if err != nil {
-		log.Println("DefaultErrorHandler: " + err.Error())
+		mlog.Errf("%s: json.Marshal: %s", logp, err)
 		return
 	}
 
-	_, err = epr.HttpWriter.Write(rsp)
+	_, err = epr.HttpWriter.Write(jsonb)
 	if err != nil {
-		log.Println("DefaultErrorHandler: " + err.Error())
+		mlog.Errf("%s: Write: %s", logp, err)
 	}
 }
diff --git a/lib/http/endpoint.go b/lib/http/endpoint.go
index 6e23352d..bce29eba 100644
--- a/lib/http/endpoint.go
+++ b/lib/http/endpoint.go
@@ -7,11 +7,11 @@ package http
 import (
 	"bytes"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"net/url"
 
 	"github.com/shuLhan/share/lib/debug"
+	"github.com/shuLhan/share/lib/mlog"
 )
 
 //
@@ -79,7 +79,8 @@ func (ep *Endpoint) call(
 	vals map[string]string,
 ) {
 	var (
-		epr = &EndpointRequest{
+		logp = "Endpoint.call"
+		epr  = &EndpointRequest{
 			Endpoint:    ep,
 			HttpWriter:  res,
 			HttpRequest: req,
@@ -90,7 +91,7 @@ func (ep *Endpoint) call(
 
 	epr.RequestBody, e = ioutil.ReadAll(req.Body)
 	if e != nil {
-		log.Printf("endpoint.call: " + e.Error())
+		mlog.Errf("%s: ReadAll: %s", logp, e)
 		res.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -105,16 +106,14 @@ func (ep *Endpoint) call(
 	case RequestTypeMultipartForm:
 		e = req.ParseMultipartForm(0)
 	}
-
 	if e != nil {
-		log.Printf("endpoint.call: %d %s %s %s\n",
-			http.StatusBadRequest, req.Method, req.URL.Path, e)
+		mlog.Errf("%s: %s %s: request parse: %s", logp, req.Method, req.URL.Path, e)
 		res.WriteHeader(http.StatusBadRequest)
 		return
 	}
 
 	if debug.Value >= 3 {
-		log.Printf("> request body: %s\n", epr.RequestBody)
+		mlog.Outf("%s: %s %s: request body: %s", logp, req.Method, req.URL.Path, epr.RequestBody)
 	}
 	if len(vals) > 0 && req.Form == nil {
 		req.Form = make(url.Values, len(vals))
@@ -165,8 +164,7 @@ func (ep *Endpoint) call(
 	for nwrite < len(responseBody) {
 		n, err := res.Write(responseBody[nwrite:])
 		if err != nil {
-			log.Printf("endpoint.call: %s %s %s\n", req.Method,
-				req.URL.Path, e)
+			mlog.Errf("%s: %s %s: response write: %s", logp, req.Method, req.URL.Path, e)
 			break
 		}
 		nwrite += n
diff --git a/lib/http/server.go b/lib/http/server.go
index e51fc9bb..4a9f4aa7 100644
--- a/lib/http/server.go
+++ b/lib/http/server.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"os"
 	"path"
@@ -20,6 +19,7 @@ import (
 
 	"github.com/shuLhan/share/lib/debug"
 	"github.com/shuLhan/share/lib/memfs"
+	"github.com/shuLhan/share/lib/mlog"
 )
 
 const (
@@ -260,8 +260,12 @@ func (srv *Server) registerPut(ep *Endpoint) (err error) {
 // ServeHTTP handle mapping of client request to registered endpoints.
 //
 func (srv *Server) ServeHTTP(res http.ResponseWriter, req *http.Request) {
+	var (
+		logp = "ServeHTTP"
+	)
+
 	if debug.Value >= 3 {
-		log.Printf("> ServeHTTP: %s %+v\n", req.Method, req.URL)
+		mlog.Outf("%s: %s %+v", logp, req.Method, req.URL)
 	}
 
 	switch req.Method {
@@ -325,17 +329,20 @@ func (srv *Server) Stop(wait time.Duration) (err error) {
 }
 
 func (srv *Server) getFSNode(reqPath string) (node *memfs.Node) {
+	var (
+		logp = "getFSNode"
+		err  error
+	)
+
 	if srv.Options.Memfs == nil {
 		return nil
 	}
 
-	var err error
-
 	node, err = srv.Options.Memfs.Get(reqPath)
 	if err != nil {
 		if !errors.Is(err, os.ErrNotExist) {
 			if debug.Value >= 3 {
-				log.Printf("http: getFSNode %q: %s", reqPath, err.Error())
+				mlog.Outf("%s: %q: %s", logp, reqPath, err)
 			}
 			return nil
 		}
@@ -348,7 +355,7 @@ func (srv *Server) getFSNode(reqPath string) (node *memfs.Node) {
 			node, err = srv.Options.Memfs.Get(asHtml)
 			if err != nil {
 				if debug.Value >= 3 {
-					log.Printf("http: getFSNode %q: %s", reqPath, err.Error())
+					mlog.Outf("%s: %q: %s", logp, reqPath, err)
 				}
 				return nil
 			}
@@ -485,7 +492,18 @@ func (srv *Server) handleDelete(res http.ResponseWriter, req *http.Request) {
 // If the request Path is not exist it will return 404 Not Found.
 //
 func (srv *Server) HandleFS(res http.ResponseWriter, req *http.Request) {
-	node := srv.getFSNode(req.URL.Path)
+	var (
+		logp = "HandleFS"
+
+		node         *memfs.Node
+		responseETag string
+		requestETag  string
+		body         []byte
+		size         int64
+		err          error
+	)
+
+	node = srv.getFSNode(req.URL.Path)
 	if node == nil {
 		res.WriteHeader(http.StatusNotFound)
 		return
@@ -493,19 +511,13 @@ func (srv *Server) HandleFS(res http.ResponseWriter, req *http.Request) {
 
 	res.Header().Set(HeaderContentType, node.ContentType)
 
-	responseETag := strconv.FormatInt(node.ModTime().Unix(), 10)
-	requestETag := req.Header.Get(HeaderIfNoneMatch)
+	responseETag = strconv.FormatInt(node.ModTime().Unix(), 10)
+	requestETag = req.Header.Get(HeaderIfNoneMatch)
 	if requestETag == responseETag {
 		res.WriteHeader(http.StatusNotModified)
 		return
 	}
 
-	var (
-		body []byte
-		size int64
-		err  error
-	)
-
 	if len(node.Content) > 0 {
 		body = node.Content
 		size = node.Size()
@@ -529,7 +541,7 @@ func (srv *Server) HandleFS(res http.ResponseWriter, req *http.Request) {
 	res.WriteHeader(http.StatusOK)
 	_, err = res.Write(body)
 	if err != nil {
-		log.Println("HandleFS: ", err.Error())
+		mlog.Errf("%s: %s %s: %s", logp, req.Method, req.URL.Path, err)
 	}
 }
 
diff --git a/lib/mlog/multi_logger_example_test.go b/lib/mlog/multi_logger_example_test.go
index 874b29bd..b3e24164 100644
--- a/lib/mlog/multi_logger_example_test.go
+++ b/lib/mlog/multi_logger_example_test.go
@@ -7,13 +7,17 @@ package mlog
 import (
 	"bytes"
 	"fmt"
-	"log"
 	"os"
-
-	"github.com/shuLhan/share/api/slack"
+	// The following import and code below, is intentionally commented to
+	// prevent import cycle.
+	// "github.com/shuLhan/share/api/slack"
 )
 
 func ExampleMultiLogger() {
+	// The following example import package
+	// "github.com/shuLhan/share/api/slack".
+	// The code is intentionally commented to prevent import cycle.
+
 	buf := bytes.Buffer{}
 
 	wouts := []NamedWriter{
@@ -29,14 +33,18 @@ func ExampleMultiLogger() {
 	// Create an error writer to slack.
 	slackWebhookURL := os.Getenv("SLACK_WEBHOOK_URL")
 	if len(slackWebhookURL) > 0 {
-		slackChannel := os.Getenv("SLACK_WEBHOOK_CHANNEL")
-		slackUsername := os.Getenv("SLACK_WEBHOOK_USERNAME")
+		// Get the Slack configuration from environment.
+		//slackChannel := os.Getenv("SLACK_WEBHOOK_CHANNEL")
+		//slackUsername := os.Getenv("SLACK_WEBHOOK_USERNAME")
+
+		// Create Slack's client.
+		//slackc, err := slack.NewWebhookClient(slackWebhookURL, slackUsername, slackChannel)
+		//if err != nil {
+		//log.Fatal(err)
+		//}
 
-		slackc, err := slack.NewWebhookClient(slackWebhookURL, slackUsername, slackChannel)
-		if err != nil {
-			log.Fatal(err)
-		}
-		mlog.RegisterErrorWriter(NewNamedWriter("slack", slackc))
+		// Forward all errors to Slack client.
+		//mlog.RegisterErrorWriter(NewNamedWriter("slack", slackc))
 	}
 
 	mlog.Outf("writing to standard output and buffer\n")