state/api: optionally log messages

state/api/server.go

 package api
 
 import (
         "code.google.com/p/go.net/websocket"
         "crypto/tls"
         "encoding/json"
         "io"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/rpc"
         "launchpad.net/juju-core/state"
@@ skipping 89 matching lines @@
                 for _ = range msgs {
                 }
         }()
         return srv.rpcSrv.ServeCodec(&serverCodec{
                 srv:  srv,
                 conn: conn,
                 msgs: msgs,
         }, newStateServer(srv, conn))
 }
 
+var logRequests = true
+
 func readRequests(conn *websocket.Conn, c chan<- serverReq) {
         defer close(c)
         var req serverReq
         for {
+                var err error
                 req = serverReq{} // avoid any potential cross-message contamination.
-                err := websocket.JSON.Receive(conn, &req)
+                if logRequests {
+                        var m json.RawMessage
+                        err = websocket.JSON.Receive(conn, &m)
+                        if err == nil {
+                                log.Debugf("api: <- %s", m)
+                                err = json.Unmarshal(m, &req)
+                        } else {
+                                log.Debugf("api: <- error: %v", err)
+                        }
+                } else {
+                        err = websocket.JSON.Receive(conn, &req)
+                }
                 if err == io.EOF {
                         break
                 }
                 if err != nil {
                         log.Printf("api: error receiving request: %v", err)
                         break
                 }
                 c <- req
         }
 }
@@ skipping 37 matching lines @@
 }
 
 func (c *serverCodec) ReadRequestBody(body interface{}) error {
         if body == nil {
                 return nil
         }
         return json.Unmarshal(c.req.Params, body)
 }
 
 func (c *serverCodec) WriteResponse(resp *rpc.Response, body interface{}) error {
-        return websocket.JSON.Send(c.conn, &serverResp{
+        r := &serverResp{
                 RequestId: resp.RequestId,
                 Error:     resp.Error,
                 Response:  body,
-        })
+        }
+        if logRequests {
+                data, err := json.Marshal(r)
+                if err != nil {
+                        log.Debugf("api: -> marshal error: %v", err)
+                        return err
+                }
+                log.Debugf("api: -> %s", data)
+        }
+        return websocket.JSON.Send(c.conn, r)
 }