Add Winston for log handling

- write log data to 'homepage.log'

src/pages/api/services/proxy.js

@@ -1,3 +1,4 @@
+import logger from "utils/logger";
 import genericProxyHandler from "utils/proxies/generic";
 import credentialedProxyHandler from "utils/proxies/credentialed";
 import rutorrentProxyHandler from "utils/proxies/rutorrent";
@@ -98,20 +99,27 @@ const serviceProxyHandlers = {
 };
 
 export default async function handler(req, res) {
-  const { type } = req.query;
+  try {
+    const { type } = req.query;
 
-  const serviceProxyHandler = serviceProxyHandlers[type];
+    const serviceProxyHandler = serviceProxyHandlers[type];
 
-  if (serviceProxyHandler) {
-    if (serviceProxyHandler instanceof Function) {
-      return serviceProxyHandler(req, res);
+    if (serviceProxyHandler) {
+      if (serviceProxyHandler instanceof Function) {
+        return serviceProxyHandler(req, res);
+      }
+  
+      const { proxy, maps } = serviceProxyHandler;
+      if (proxy) {
+        return proxy(req, res, maps);
+      }
     }
 
-    const { proxy, maps } = serviceProxyHandler;
-    if (proxy) {
-      return proxy(req, res, maps);
-    }
+    logger.debug("Unknown proxy service type: %s", type);
+    return res.status(403).json({ error: "Unkown proxy service type" });
+  }
+  catch (ex) {
+    logger.error(ex);
+    return res.status(500).send({ error: "Unexpected error" });
   }
-
-  return res.status(403).json({ error: "Unkown proxy service type" });
 }

src/utils/logger.js

@@ -0,0 +1,76 @@
+import winston from "winston";
+
+function messageFormatter(logInfo) {
+  if (logInfo.stack) {
+    return `[${logInfo.timestamp}] ${logInfo.level}: ${logInfo.stack}`;
+  }
+  return `[${logInfo.timestamp}] ${logInfo.level}: ${logInfo.message}`;
+};
+
+const consoleFormat = winston.format.combine(
+  winston.format.errors({ stack: true }),
+  winston.format.splat(),
+  winston.format.timestamp(),
+  winston.format.colorize(),
+  winston.format.printf(messageFormatter)
+);
+
+const fileFormat = winston.format.combine(
+  winston.format.errors({ stack: true }),
+  winston.format.splat(),
+  winston.format.timestamp(),
+  winston.format.printf(messageFormatter)
+);
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  transports: [
+    new winston.transports.Console({
+      format: consoleFormat,
+      handleExceptions: true,
+      handleRejections: true
+    }),
+
+    new winston.transports.File({
+      format: fileFormat,
+      filename: 'homepage.log',
+      handleExceptions: true,
+      handleRejections: true
+    }),
+  ]
+});
+
+function debug(message, ...args) {
+  logger.debug(message, ...args);
+}
+
+function verbose(message, ...args) {
+  logger.verbose(message, ...args);
+}
+
+function info(message, ...args) {
+  logger.info(message, ...args);
+}
+
+function warn(message, ...args) {
+  logger.warn(message, ...args);
+}
+
+function error(message, ...args) {
+  logger.error(message, ...args);
+}
+
+function crit(message, ...args) {
+  logger.crit(message, ...args);
+}
+
+const thisModule = {
+  debug,
+  verbose,
+  info,
+  warn,
+  error,
+  crit
+};
+
+export default thisModule;

src/utils/proxies/generic.js

@@ -1,6 +1,7 @@
 import getServiceWidget from "utils/service-helpers";
 import { formatApiCall } from "utils/api-helpers";
 import { httpProxy } from "utils/http";
+import logger from "utils/logger";
 
 export default async function genericProxyHandler(req, res, maps) {
   const { group, service, endpoint } = req.query;
@@ -24,7 +25,7 @@ export default async function genericProxyHandler(req, res, maps) {
       });
 
       let resultData = data;
-      if (maps?.[endpoint]) {
+      if ((status === 200) && (maps?.[endpoint])) {
         resultData = maps[endpoint](data);
       }
 
@@ -34,9 +35,14 @@ export default async function genericProxyHandler(req, res, maps) {
         return res.status(status).end();
       }
 
+      if (status >= 400) {
+        logger.debug("HTTP Error %d calling %s//%s%s...", status, url.protocol, url.hostname, url.pathname);
+      }
+
       return res.status(status).send(resultData);
     }
   }
 
+  logger.debug("Invalid or missing proxy service type '%s' in group '%s'", service, group);
   return res.status(400).json({ error: "Invalid proxy service type" });
 }