Refactor access and error logging

Closes: #165
PR-URL: #172

Author: tshemsedinov

lib/client.js

@@ -34,15 +34,19 @@ class Client {
   }
 
   static() {
-    const { req: { url }, res } = this;
+    const { req: { url, method }, res, ip } = this;
     const filePath = url === '/' ? '/index.html' : url;
     const fileExt = path.extname(filePath).substring(1);
     const mimeType = MIME_TYPES[fileExt] || MIME_TYPES.html;
     res.writeHead(200, { ...HEADERS, 'Content-Type': mimeType });
     if (res.writableEnded) return;
     const data = application.static.get(filePath);
-    if (data) res.end(data);
-    else this.error(404);
+    if (data) {
+      res.end(data);
+      application.logger.log(`${ip}\t${method}\t${url}`);
+      return;
+    }
+    this.error(404);
   }
 
   redirect(location) {
@@ -52,38 +56,43 @@ class Client {
     res.end();
   }
 
-  error(status, err, callId = err) {
-    const { req: { url }, res, connection, ip } = this;
-    const reason = http.STATUS_CODES[status];
+  error(code, err, callId = err) {
+    const { req: { url, method }, res, connection, ip } = this;
+    const status = http.STATUS_CODES[code];
     if (typeof err === 'number') err = undefined;
-    const error = err ? err.stack : reason;
-    const msg = status === 403 ? err.message : `${url}\t${error}\t${status}`;
-    application.logger.error(`${ip}\t${msg}`);
-    const packet = { callback: callId, error: { message: reason } };
-    const result = JSON.stringify(packet);
+    const reason = err ? err.stack : status;
+    application.logger.error(`${ip}\t${method}\t${url}\t${code}\t${reason}`);
     if (connection) {
-      connection.send(result);
+      const packet = { callback: callId, error: { code, message: status } };
+      connection.send(JSON.stringify(packet));
       return;
     }
     if (res.writableEnded) return;
-    res.writeHead(status, { 'Content-Type': MIME_TYPES.json });
-    res.end(result);
+    res.writeHead(code, { 'Content-Type': MIME_TYPES.json });
+    const packet = { code, error: status };
+    res.end(JSON.stringify(packet));
   }
 
   message(data) {
+    let packet;
     try {
-      const packet = JSON.parse(data);
-      const [callType, methodName] = Object.keys(packet);
-      const callId = packet[callType];
-      const args = packet[methodName];
-      this.rpc(callId, methodName, args);
+      packet = JSON.parse(data);
     } catch (err) {
-      application.logger.error(err.message);
+      this.error(500, new Error('JSON parsing error'));
+      return;
+    }
+    const [callType, methodName] = Object.keys(packet);
+    const callId = packet[callType];
+    const args = packet[methodName];
+    if (callId && args) {
+      this.rpc(callId, methodName, args);
+      return;
     }
+    this.error(500, new Error('Packet structure error'));
   }
 
   async rpc(callId, method, args) {
-    const { res, connection } = this;
+    const { res, connection, ip } = this;
     const { semaphore } = application.server;
     try {
       await semaphore.enter();
@@ -92,25 +101,27 @@ class Client {
       return;
     }
     try {
-      const session = await application.auth.restore(this);
+      let session = await application.auth.restore(this);
       const proc = application.runMethod(method, session);
       if (!proc) {
         this.error(404, callId);
         return;
       }
       if (!session && proc.access !== 'public') {
-        this.error(403, new Error(`Forbidden: /api/${method}`), callId);
+        this.error(403, callId);
         return;
       }
       const result = await proc.method(args);
       if (!session && proc.access === 'public') {
-        const session = application.auth.start(this, result.userId);
+        session = application.auth.start(this, result.userId);
         result.token = session.token;
       }
       const packet = { callback: callId, result };
       const data = JSON.stringify(packet);
       if (connection) connection.send(data);
       else res.end(data);
+      const token = session ? session.token : 'anonymous';
+      application.logger.log(`${ip}\t${token}\t${method}`);
     } catch (err) {
       this.error(500, err, callId);
     } finally {

lib/server.js

@@ -49,10 +49,9 @@ const listener = (req, res) => {
     clients.delete(connection);
   });
 
-  application.logger.log(`${client.ip}\t${method}\t${url}`);
   if (url === '/api') {
     if (method !== 'POST') {
-      client.error(403, new Error(`Forbidden: ${url}`));
+      client.error(403);
       return;
     }
     receiveBody(req).then(data => {