Fix: default value of rate-limit and unnecessary content of access logs.

package.json

@@ -8,6 +8,7 @@
   "private": true,
   "dependencies": {
     "@koa/cors": "^3.3.0",
+    "bytes": "^3.1.2",
     "class-validator": "^0.13.2",
     "commander": "^9.4.0",
     "dayjs": "^1.11.2",
@@ -42,6 +43,7 @@
     "@nrwl/linter": "14.0.3",
     "@nrwl/workspace": "14.0.3",
     "@types/bcryptjs": "^2.4.2",
+    "@types/bytes": "^3.1.1",
     "@types/from2": "^2.3.1",
     "@types/glob": "^7.2.0",
     "@types/inquirer": "^8.0.0",

packages/core/src/lib/utils/logger.ts

@@ -6,7 +6,7 @@ export enum LoggingScope {
   CORE = 'CORE',
   BUILD = 'BUILD',
   SERVE = 'SERVE',
-  AUDIT = 'AUDIT',
+  ACCESS_LOG = 'ACCESS_LOG',
 }
 
 type LoggingScopeTypes = keyof typeof LoggingScope;
@@ -21,32 +21,21 @@ export enum LoggingLevel {
   FATAL = 'fatal',
 }
 
+type DisplayFilePathTypes = 'hidden' | 'displayAll' | 'hideNodeModulesOnly';
+
 export interface LoggerOptions {
   level?: LoggingLevel;
   displayRequestId?: boolean;
+  displayFunctionName?: boolean;
+  displayFilePath?: DisplayFilePathTypes;
 }
 
-type LoggerMapConfig = {
-  [scope in LoggingScope]: LoggerOptions;
-};
-
-const defaultMapConfig: LoggerMapConfig = {
-  [LoggingScope.CORE]: {
-    level: LoggingLevel.DEBUG,
-    displayRequestId: false,
-  },
-  [LoggingScope.BUILD]: {
-    level: LoggingLevel.DEBUG,
-    displayRequestId: false,
-  },
-  [LoggingScope.SERVE]: {
-    level: LoggingLevel.DEBUG,
-    displayRequestId: false,
-  },
-  [LoggingScope.AUDIT]: {
-    level: LoggingLevel.DEBUG,
-    displayRequestId: false,
-  },
+// The default logger options
+const defaultLoggerOptions: LoggerOptions = {
+  level: LoggingLevel.DEBUG,
+  displayRequestId: false,
+  displayFilePath: 'hidden',
+  displayFunctionName: false,
 };
 
 export type AsyncRequestIdStorage = AsyncLocalStorage<{ requestId: string }>;
@@ -58,9 +47,11 @@ class LoggerFactory {
     this.asyncReqIdStorage = new AsyncLocalStorage();
 
     this.loggerMap = {
+      // Here, create default scope logger, we could add other package or extension logger name in here
       [LoggingScope.CORE]: this.createLogger(LoggingScope.CORE),
       [LoggingScope.BUILD]: this.createLogger(LoggingScope.BUILD),
       [LoggingScope.SERVE]: this.createLogger(LoggingScope.SERVE),
+      [LoggingScope.ACCESS_LOG]: this.createLogger(LoggingScope.ACCESS_LOG),
     };
   }
 
@@ -84,7 +75,7 @@ class LoggerFactory {
       return logger;
     }
     // if scope name does not exist in map or exist but would like to update config
-    const newLogger = this.createLogger(scopeName as LoggingScope, options);
+    const newLogger = this.createLogger(scopeName, options);
     this.loggerMap[scopeName] = newLogger;
     return newLogger;
   }
@@ -95,17 +86,25 @@ class LoggerFactory {
       minLevel: options.level || prevSettings.minLevel,
       displayRequestId:
         options.displayRequestId || prevSettings.displayRequestId,
+      displayFunctionName:
+        options.displayFunctionName || prevSettings.displayFunctionName,
+      displayFilePath: options.displayFilePath || prevSettings.displayFilePath,
     });
   }
 
-  private createLogger(name: LoggingScope, options?: LoggerOptions) {
+  private createLogger(name: string, options?: LoggerOptions) {
     return new Logger({
       name,
-      minLevel: options?.level || defaultMapConfig[name].level,
+      minLevel: options?.level || defaultLoggerOptions.level,
       // use function call for requestId, then when logger get requestId, it will get newest store again
       requestId: () => this.asyncReqIdStorage.getStore()?.requestId as string,
       displayRequestId:
-        options?.displayRequestId || defaultMapConfig[name].displayRequestId,
+        options?.displayRequestId || defaultLoggerOptions.displayRequestId,
+      displayFunctionName:
+        options?.displayFunctionName ||
+        defaultLoggerOptions.displayFunctionName,
+      displayFilePath:
+        options?.displayFilePath || defaultLoggerOptions.displayFilePath,
     });
   }
 }

packages/serve/src/lib/middleware/accessLogMiddleware.ts

@@ -0,0 +1,33 @@
+import {
+  getLogger,
+  LoggerOptions,
+  VulcanInternalExtension,
+} from '@vulcan-sql/core';
+import * as bytes from 'bytes';
+import { BuiltInMiddleware, KoaContext, Next } from '@vulcan-sql/serve/models';
+
+@VulcanInternalExtension('access-log')
+export class AccessLogMiddleware extends BuiltInMiddleware<LoggerOptions> {
+  private logger = getLogger({
+    scopeName: 'ACCESS_LOG',
+    options: this.getOptions(),
+  });
+
+  public async handle(context: KoaContext, next: Next) {
+    if (!this.enabled) return next();
+
+    const { request: req, response: resp, params } = context;
+
+    const reqSize = req.length ? bytes(req.length).toLowerCase() : 'none';
+    const respSize = resp.length ? bytes(resp.length).toLowerCase() : 'none';
+    this.logger.info(
+      `--> ${req.ip} -- "${req.method} ${req.path}" -- size: ${reqSize}`
+    );
+    this.logger.info(` -> header: ${JSON.stringify(req.header)}`);
+    this.logger.info(` -> query: ${JSON.stringify(req.query)}`);
+    this.logger.info(` -> params: ${JSON.stringify(params)}`);
+    await next();
+    this.logger.info(`<-- status: ${resp.status} -- size: ${respSize}`);
+    this.logger.info(` <- header: ${JSON.stringify(resp.header)}`);
+  }
+}

packages/serve/src/lib/middleware/index.ts

@@ -1,6 +1,6 @@
 export * from './corsMiddleware';
 export * from './requestIdMiddleware';
-export * from './auditLogMiddleware';
+export * from './accessLogMiddleware';
 export * from './rateLimitMiddleware';
 export * from './authMiddleware';
 export * from './response-format';
@@ -11,18 +11,18 @@ import { CorsMiddleware } from './corsMiddleware';
 import { AuthMiddleware } from './authMiddleware';
 import { RateLimitMiddleware } from './rateLimitMiddleware';
 import { RequestIdMiddleware } from './requestIdMiddleware';
-import { AuditLoggingMiddleware } from './auditLogMiddleware';
+import { AccessLogMiddleware } from './accessLogMiddleware';
 import { ResponseFormatMiddleware } from './response-format';
 import { EnforceHttpsMiddleware } from './enforceHttpsMiddleware';
 import { ClassType, ExtensionBase } from '@vulcan-sql/core';
 import { DocRouterMiddleware } from './docRouterMiddleware';
 
 // The order is the middleware running order
 export const BuiltInRouteMiddlewares: ClassType<ExtensionBase>[] = [
+  AccessLogMiddleware,
   CorsMiddleware,
   EnforceHttpsMiddleware,
   RequestIdMiddleware,
-  AuditLoggingMiddleware,
   RateLimitMiddleware,
   AuthMiddleware,
   ResponseFormatMiddleware,

packages/serve/src/lib/middleware/rateLimitMiddleware.ts

@@ -1,15 +1,26 @@
 import { RateLimit, RateLimitOptions } from 'koa2-ratelimit';
 import { BuiltInMiddleware, KoaContext, Next } from '@vulcan-sql/serve/models';
-import { VulcanInternalExtension } from '@vulcan-sql/core';
+import { VulcanInternalExtension, TYPES as CORE_TYPES } from '@vulcan-sql/core';
+import { inject } from 'inversify';
 
 export { RateLimitOptions };
 
 @VulcanInternalExtension('rate-limit')
 export class RateLimitMiddleware extends BuiltInMiddleware<RateLimitOptions> {
-  private koaRateLimit = RateLimit.middleware(this.getOptions());
+  private options: RateLimitOptions;
+  private koaRateLimitFunc;
+  constructor(
+    @inject(CORE_TYPES.ExtensionConfig) config: any,
+    @inject(CORE_TYPES.ExtensionName) name: string
+  ) {
+    super(config, name);
+    this.options = (this.getOptions() as RateLimitOptions) || { max: 60 };
+    if (!this.options['max']) this.options['max'] = 60;
+    this.koaRateLimitFunc = RateLimit.middleware(this.options);
+  }
 
   public async handle(context: KoaContext, next: Next) {
     if (!this.enabled) return next();
-    return this.koaRateLimit(context, next);
+    return this.koaRateLimitFunc(context, next);
   }
 }

packages/serve/test/app.spec.ts

@@ -369,6 +369,7 @@ describe('Test vulcan server for calling restful APIs', () => {
 
       // Assert
       expect(response.body.data).toEqual(expected);
-    }
+    },
+    10000
   );
 });