Pass Logger into handler

client.go

@@ -36,6 +36,7 @@ import (
 // Client.DebugRequest is true.
 type Logger interface {
 	Println(...interface{})
+	Printf(string, ...interface{})
 }
 
 // Client embeds http.Client and provides a convenient way to make JSON-RPC 2.0

doc.go

@@ -78,6 +78,7 @@
 //
 //      func StartServer() {
 //      	methods := jsonrpc2.MethodMap{"version": versionMethod}
-//      	http.ListenAndServe(":8080", jsonrpc2.HTTPRequestHandler(methods))
+//      	http.ListenAndServe(":8080", jsonrpc2.HTTPRequestHandler(methods,
+//                      log.New(os.Stderr, "", 0)))
 //      }
 package jsonrpc2

example_test.go

@@ -26,7 +26,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/http"
+	"os"
 
 	// Specify the package name to avoid goimports from reverting this
 	// import to an older version.
@@ -124,7 +126,7 @@ func Example() {
 			"get_data":     getData,
 		}
 		jsonrpc2.DebugMethodFunc = true
-		handler := jsonrpc2.HTTPRequestHandler(methods)
+		handler := jsonrpc2.HTTPRequestHandler(methods, log.New(os.Stdout, "", 0))
 		http.ListenAndServe(":18888", handler)
 	}()
 

handler.go

@@ -25,7 +25,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/http"
+	"os"
 	"strings"
 )
 
@@ -44,33 +46,40 @@ import (
 //
 // This will panic if a method name beginning with "rpc." is used. See
 // MethodMap for more details.
-func HTTPRequestHandler(methods MethodMap) http.HandlerFunc {
+//
+// The handler will use lgr to log any errors and debug information, if
+// DebugMethodFunc is true. If lgr is nil, the default Logger from the log
+// package is used.
+func HTTPRequestHandler(methods MethodMap, lgr Logger) http.HandlerFunc {
 	for name := range methods {
 		if strings.HasPrefix(name, "rpc.") {
 			panic(fmt.Errorf("invalid method name: %v", name))
 		}
 	}
+	if lgr == nil {
+		lgr = log.New(os.Stderr, "", log.LstdFlags)
+	}
 
 	return func(w http.ResponseWriter, req *http.Request) {
-		res := handle(methods, req)
+		res := handle(methods, req, lgr)
 		if res == nil {
 			return
 		}
-		enc := json.NewEncoder(w)
 		// We should never have a JSON encoding related error because
 		// MethodFunc.call() already Marshaled any user provided Data
 		// or Result, and everything else is marshalable.
 		//
 		// However an error can be returned related to w.Write, which
 		// there is nothing we can do about, so we just log it here.
+		enc := json.NewEncoder(w)
 		if err := enc.Encode(res); err != nil {
-			logger.Printf("error writing response: %v", err)
+			lgr.Printf("req.Body.Write(): %v", err)
 		}
 	}
 }
 
 // handle an http.Request for the given methods.
-func handle(methods MethodMap, req *http.Request) interface{} {
+func handle(methods MethodMap, req *http.Request, lgr Logger) interface{} {
 	// Read all bytes of HTTP request body.
 	reqBytes, err := ioutil.ReadAll(req.Body)
 	if err != nil {
@@ -102,7 +111,7 @@ func handle(methods MethodMap, req *http.Request) interface{} {
 	// Process each Request, omitting any returned Response that is empty.
 	responses := make(BatchResponse, 0, len(rawReqs))
 	for _, rawReq := range rawReqs {
-		res := processRequest(req.Context(), methods, rawReq)
+		res := processRequest(req.Context(), methods, rawReq, lgr)
 		if res == (Response{}) {
 			// Don't respond to Notifications.
 			continue
@@ -128,7 +137,7 @@ func handle(methods MethodMap, req *http.Request) interface{} {
 // using the methods defined in methods. If res is zero valued, then the
 // Request was a Notification and should not be responded to.
 func processRequest(ctx context.Context,
-	methods MethodMap, rawReq json.RawMessage) (res Response) {
+	methods MethodMap, rawReq json.RawMessage, lgr Logger) (res Response) {
 
 	// Unmarshal into req with an error on any unknown fields.
 	var req Request
@@ -162,12 +171,12 @@ func processRequest(ctx context.Context,
 	if !ok {
 		return Response{Error: errorMethodNotFound(req.Method)}
 	}
-	res = method.call(ctx, req.Method, params)
+	res = method.call(ctx, req.Method, params, lgr)
 
 	// Log the method name if debugging is enabled and the method had an
 	// internal error.
 	if DebugMethodFunc && res.HasError() && res.Error.Code == ErrorCodeInternal {
-		logger.Printf("Method: %#v\n\n", req.Method)
+		lgr.Printf("Method: %#v\n\n", req.Method)
 	}
 
 	return res

methods.go

@@ -24,8 +24,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
-	"os"
 	"runtime"
 )
 
@@ -36,8 +34,6 @@ import (
 // MethodFunc.
 var DebugMethodFunc = false
 
-var logger = log.New(os.Stdout, "", 0)
-
 // MethodMap associates method names with MethodFuncs and is passed to
 // HTTPRequestHandler to generate a corresponding http.HandlerFunc.
 //
@@ -88,7 +84,7 @@ type MethodFunc func(ctx context.Context, params json.RawMessage) interface{}
 // and validate and sanitize the returned Response. If the method panics or
 // returns an invalid Response, an Internal Error is returned.
 func (method MethodFunc) call(ctx context.Context,
-	name string, params json.RawMessage) (res Response) {
+	name string, params json.RawMessage, lgr Logger) (res Response) {
 
 	var result interface{}
 	defer func() {
@@ -99,10 +95,10 @@ func (method MethodFunc) call(ctx context.Context,
 				const size = 64 << 10
 				buf := make([]byte, size)
 				buf = buf[:runtime.Stack(buf, false)]
-				logger.Printf("jsonrpc2: panic running method %#v: %v\n%s",
+				lgr.Printf("jsonrpc2: panic running method %#v: %v\n%s",
 					method, err, buf)
-				logger.Printf("jsonrpc2: Params: %v", string(params))
-				logger.Printf("jsonrpc2: Return: %#v", result)
+				lgr.Printf("jsonrpc2: Params: %v", string(params))
+				lgr.Printf("jsonrpc2: Return: %#v", result)
 			}
 		}
 	}()

methods_test.go

@@ -26,7 +26,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -80,14 +79,11 @@ func TestMethodFuncCall(t *testing.T) {
 	assert := assert.New(t)
 
 	var buf bytes.Buffer
-	logger.SetOutput(&buf) // hide output
+	log := log.New(&buf, "", 0) // record output
 	DebugMethodFunc = true
-	defer func() {
-		logger = log.New(os.Stdout, "", 0)
-	}()
 
 	for _, test := range testMethods {
-		res := test.Func.call(context.Background(), "", nil)
+		res := test.Func.call(context.Background(), "", nil, log)
 		if test.Error == nil {
 			assert.Equal(errorInternal(nil), res.Error, test.Name)
 		} else {
@@ -101,7 +97,7 @@ func TestMethodFuncCall(t *testing.T) {
 	var f MethodFunc = func(_ context.Context, _ json.RawMessage) interface{} {
 		return Error{100, "custom", "data"}
 	}
-	res := f.call(context.Background(), "", nil)
+	res := f.call(context.Background(), "", nil, log)
 	if assert.NotNil(res.Error) {
 		assert.Equal(Error{
 			Code:    100,
@@ -114,7 +110,7 @@ func TestMethodFuncCall(t *testing.T) {
 	f = func(_ context.Context, _ json.RawMessage) interface{} {
 		return ErrorInvalidParams("data")
 	}
-	res = f.call(context.Background(), "", nil)
+	res = f.call(context.Background(), "", nil, log)
 	if assert.NotNil(res.Error) {
 		e := ErrorInvalidParams(json.RawMessage(`"data"`))
 		assert.Equal(e, res.Error)