@naturalcycles/backend-lib 9.3.1 → 9.4.0

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from './server/notFoundMiddleware.js';
 export * from './server/okMiddleware.js';
 export * from './server/request.log.util.js';
 export * from './server/request.util.js';
+export * from './server/requestLoggerMiddleware.js';
 export * from './server/requestTimeoutMiddleware.js';
 export * from './server/safeJsonMiddleware.js';
 export * from './server/server.model.js';

package/dist/index.js

@@ -19,6 +19,7 @@ export * from './server/notFoundMiddleware.js';
 export * from './server/okMiddleware.js';
 export * from './server/request.log.util.js';
 export * from './server/request.util.js';
+export * from './server/requestLoggerMiddleware.js';
 export * from './server/requestTimeoutMiddleware.js';
 export * from './server/safeJsonMiddleware.js';
 export * from './server/server.model.js';

package/dist/server/createDefaultApp.js

@@ -1,7 +1,6 @@
 import cookieParser from 'cookie-parser';
 import cors from 'cors';
 import express from 'express';
-import { isCloudRun, isGAE } from '../util.js';
 import { asyncLocalStorageMiddleware } from './asyncLocalStorageMiddleware.js';
 import { genericErrorMiddleware } from './genericErrorMiddleware.js';
 import { logMiddleware } from './logMiddleware.js';
@@ -10,6 +9,7 @@ import { notFoundMiddleware } from './notFoundMiddleware.js';
 import { requestTimeoutMiddleware } from './requestTimeoutMiddleware.js';
 import { simpleRequestLoggerMiddleware } from './simpleRequestLoggerMiddleware.js';
 const isTest = process.env['APP_ENV'] === 'test';
+const isDev = process.env['APP_ENV'] === 'dev';
 export async function createDefaultApp(cfg) {
     const { sentryService } = cfg;
     const app = express();
@@ -26,7 +26,7 @@ export async function createDefaultApp(cfg) {
     app.use(requestTimeoutMiddleware());
     // app.use(serverStatsMiddleware()) // disabled by default
     // app.use(bodyParserTimeout()) // removed by default
-    if (!isGAE() && !isCloudRun() && !isTest) {
+    if (isDev) {
         app.use(simpleRequestLoggerMiddleware());
     }
     // app.use(safeJsonMiddleware()) // optional

package/dist/server/genericErrorMiddleware.d.ts

@@ -1,12 +1,7 @@
-import type { ErrorObject } from '@naturalcycles/js-lib';
+import { type ErrorObject } from '@naturalcycles/js-lib';
 import type { BackendErrorRequestHandler, BackendRequest, BackendResponse } from './server.model.js';
 export interface GenericErrorMiddlewareCfg {
     errorReportingService?: ErrorReportingService;
-    /**
-     * Defaults to false.
-     * So, by default, it will report ALL errors, not only 5xx.
-     */
-    reportOnly5xx?: boolean;
     /**
      * Generic hook that can be used to **mutate** errors before they are returned to client.
      * This function does not affect data sent to sentry.

package/dist/server/genericErrorMiddleware.js

@@ -1,9 +1,9 @@
-import { _anyToError, _errorLikeToErrorObject, _filterUndefinedValues } from '@naturalcycles/js-lib';
+import { _objectAssign, } from '@naturalcycles/js-lib';
+import { _anyToError, _errorLikeToErrorObject } from '@naturalcycles/js-lib';
 const { APP_ENV } = process.env;
 const includeErrorStack = APP_ENV === 'dev';
-// Hacky way to store the sentryService, so it's available to `respondWithError` function
+// Hacky way to store the errorService, so it's available to `respondWithError` function
 let errorService;
-let reportOnly5xx = false;
 let formatError;
 /**
  * Generic error handler.
@@ -12,7 +12,6 @@ let formatError;
  */
 export function genericErrorMiddleware(cfg = {}) {
     errorService ||= cfg.errorReportingService;
-    reportOnly5xx = cfg.reportOnly5xx || false;
     formatError = cfg.formatError;
     return (err, req, res, _next) => {
         // if (res.headersSent) {
@@ -31,6 +30,8 @@ export function genericErrorMiddleware(cfg = {}) {
 }
 export function respondWithError(req, res, err) {
     const { headersSent } = res;
+    // todo: add endpoint to the log
+    // todo: add userId from the "Context" (or, just req.userId?) to the log
     if (headersSent) {
         req.error(`error after headersSent:`, err);
     }
@@ -38,38 +39,19 @@ export function respondWithError(req, res, err) {
         req.error(err);
     }
     const originalError = _anyToError(err);
-    let errorId;
-    const shouldReport = errorService && shouldReportToSentry(originalError);
-    if (shouldReport) {
-        errorId = errorService?.captureException(originalError);
-    }
+    const errorId = errorService?.captureException(originalError);
     if (headersSent)
         return;
     const httpError = _errorLikeToErrorObject(originalError);
     if (!includeErrorStack)
         delete httpError.stack;
-    httpError.data.errorId = errorId;
     httpError.data.backendResponseStatusCode ||= 500; // default to 500
-    httpError.data.headersSent = headersSent || undefined;
-    _filterUndefinedValues(httpError.data, true);
+    _objectAssign(httpError.data, {
+        errorId,
+        headersSent: headersSent || undefined,
+    });
     formatError?.(httpError); // Mutates
     res.status(httpError.data.backendResponseStatusCode).json({
         error: httpError,
     });
 }
-function shouldReportToSentry(err) {
-    const e = err;
-    // By default - report
-    if (!e?.data)
-        return true;
-    // If `report` is set - do as it says
-    if (e.data.report === true)
-        return true;
-    if (e.data.report === false)
-        return false;
-    // Report if http 5xx, otherwise not
-    // If no httpCode - report
-    // if httpCode >= 500 - report
-    // Otherwise - report, unless !reportOnly5xx is set
-    return (!reportOnly5xx || !e.data.backendResponseStatusCode || e.data.backendResponseStatusCode >= 500);
-}

package/dist/server/logMiddleware.js

@@ -58,7 +58,11 @@ function logToCI(args) {
 export function logMiddleware() {
     if (isGAE || isCloudRun) {
         return function gcpStructuredLogHandler(req, _res, next) {
-            const meta = {};
+            const meta = {
+                // Experimental!
+                // Testing to include userId in metadata (not message payload) to see if it's searchable
+                userId: req.userId,
+            };
             // CloudRun does NOT have this env variable set,
             // so you have to set it manually on deployment, like this:
             // gcloud run deploy my-service \

package/dist/server/request.log.util.d.ts

@@ -1,3 +1,3 @@
 import type { BackendRequest } from './server.model.js';
-export declare function logRequest(req: BackendRequest, statusCode: number, ...tokens: any[]): void;
+export declare function logRequestWithColors(req: BackendRequest, statusCode: number, ...tokens: any[]): void;
 export declare function coloredHttpCode(statusCode: number): string;

package/dist/server/request.log.util.js

@@ -1,5 +1,5 @@
 import { boldGrey, green, red, yellow } from '@naturalcycles/nodejs-lib';
-export function logRequest(req, statusCode, ...tokens) {
+export function logRequestWithColors(req, statusCode, ...tokens) {
     req[logLevel(statusCode)]([coloredHttpCode(statusCode), req.method, boldGrey(req.url), ...tokens].join(' '));
 }
 export function coloredHttpCode(statusCode) {

package/dist/server/requestLoggerMiddleware.d.ts

@@ -0,0 +1,7 @@
+import type { BackendRequestHandler } from '../index.js';
+/**
+ * Experimental request logger for Cloud Run.
+ *
+ * @experimental
+ */
+export declare function requestLoggerMiddleware(): BackendRequestHandler;

package/dist/server/requestLoggerMiddleware.js

@@ -0,0 +1,19 @@
+import { _since } from '@naturalcycles/js-lib';
+import { onFinished } from '../index.js';
+/**
+ * Experimental request logger for Cloud Run.
+ *
+ * @experimental
+ */
+export function requestLoggerMiddleware() {
+    return (req, res, next) => {
+        const started = Date.now();
+        req.log([req.method, req.originalUrl, req.userId].filter(Boolean).join(' '));
+        onFinished(res, () => {
+            req.log([res.statusCode || '0', _since(started), req.method, req.originalUrl, req.userId]
+                .filter(Boolean)
+                .join(' '));
+        });
+        next();
+    };
+}

package/dist/server/server.model.d.ts

@@ -12,6 +12,10 @@ export interface BackendRequest extends Request {
     warn: CommonLogFunction;
     error: CommonLogFunction;
     requestId?: string;
+    /**
+     * Only used for request logging purposes.
+     */
+    userId?: string;
     /**
      * Set by requestTimeoutMiddleware.
      * Can be used to cancel/override the timeout.

package/dist/server/simpleRequestLoggerMiddleware.js

@@ -1,13 +1,8 @@
 import { _since } from '@naturalcycles/js-lib';
 import { boldGrey, dimGrey } from '@naturalcycles/nodejs-lib';
 import { onFinished } from '../index.js';
-import { logRequest } from './request.log.util.js';
-const { APP_ENV } = process.env;
+import { logRequestWithColors } from './request.log.util.js';
 export function simpleRequestLoggerMiddleware(cfg = {}) {
-    // Disable logger in AppEngine, as it doesn't make sense there
-    // UPD: Only log in dev environment
-    if (APP_ENV !== 'dev')
-        return (_req, _res, next) => next();
     const { logStart = false, logFinish = true } = cfg;
     return (req, res, next) => {
         const started = Date.now();
@@ -16,13 +11,7 @@ export function simpleRequestLoggerMiddleware(cfg = {}) {
         }
         if (logFinish) {
             onFinished(res, () => {
-                logRequest(req, res.statusCode, dimGrey(_since(started)));
-                // Avoid logging twice. It was previously logged by genericErrorHandler
-                // if (res.__err) {
-                //   logRequest(req, res.statusCode, dimGrey(_since(started)), _inspect(res.__err))
-                // } else {
-                //   logRequest(req, res.statusCode, dimGrey(_since(started)))
-                // }
+                logRequestWithColors(req, res.statusCode, dimGrey(_since(started)));
             });
         }
         next();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/backend-lib",
   "type": "module",
-  "version": "9.3.1",
+  "version": "9.4.0",
   "peerDependencies": {
     "@sentry/node": "^9"
   },

package/src/index.ts

@@ -19,6 +19,7 @@ export * from './server/notFoundMiddleware.js'
 export * from './server/okMiddleware.js'
 export * from './server/request.log.util.js'
 export * from './server/request.util.js'
+export * from './server/requestLoggerMiddleware.js'
 export * from './server/requestTimeoutMiddleware.js'
 export * from './server/safeJsonMiddleware.js'
 export * from './server/server.model.js'

package/src/server/createDefaultApp.ts

@@ -1,7 +1,6 @@
 import cookieParser from 'cookie-parser'
 import cors from 'cors'
 import express from 'express'
-import { isCloudRun, isGAE } from '../util.js'
 import { asyncLocalStorageMiddleware } from './asyncLocalStorageMiddleware.js'
 import type {
   BackendRequestHandlerCfg,
@@ -17,6 +16,7 @@ import type { BackendApplication } from './server.model.js'
 import { simpleRequestLoggerMiddleware } from './simpleRequestLoggerMiddleware.js'
 
 const isTest = process.env['APP_ENV'] === 'test'
+const isDev = process.env['APP_ENV'] === 'dev'
 
 export async function createDefaultApp(cfg: DefaultAppCfg): Promise<BackendApplication> {
   const { sentryService } = cfg
@@ -41,7 +41,7 @@ export async function createDefaultApp(cfg: DefaultAppCfg): Promise<BackendAppli
   // app.use(serverStatsMiddleware()) // disabled by default
   // app.use(bodyParserTimeout()) // removed by default
 
-  if (!isGAE() && !isCloudRun() && !isTest) {
+  if (isDev) {
     app.use(simpleRequestLoggerMiddleware())
   }
 

package/src/server/genericErrorMiddleware.ts

@@ -1,16 +1,14 @@
-import type { AppError, BackendErrorResponseObject, ErrorObject } from '@naturalcycles/js-lib'
-import { _anyToError, _errorLikeToErrorObject, _filterUndefinedValues } from '@naturalcycles/js-lib'
+import {
+  _objectAssign,
+  type BackendErrorResponseObject,
+  type ErrorObject,
+} from '@naturalcycles/js-lib'
+import { _anyToError, _errorLikeToErrorObject } from '@naturalcycles/js-lib'
 import type { BackendErrorRequestHandler, BackendRequest, BackendResponse } from './server.model.js'
 
 export interface GenericErrorMiddlewareCfg {
   errorReportingService?: ErrorReportingService
 
-  /**
-   * Defaults to false.
-   * So, by default, it will report ALL errors, not only 5xx.
-   */
-  reportOnly5xx?: boolean
-
   /**
    * Generic hook that can be used to **mutate** errors before they are returned to client.
    * This function does not affect data sent to sentry.
@@ -34,9 +32,8 @@ export interface ErrorReportingService {
 const { APP_ENV } = process.env
 const includeErrorStack = APP_ENV === 'dev'
 
-// Hacky way to store the sentryService, so it's available to `respondWithError` function
+// Hacky way to store the errorService, so it's available to `respondWithError` function
 let errorService: ErrorReportingService | undefined
-let reportOnly5xx = false
 let formatError: GenericErrorMiddlewareCfg['formatError']
 
 /**
@@ -48,7 +45,6 @@ export function genericErrorMiddleware(
   cfg: GenericErrorMiddlewareCfg = {},
 ): BackendErrorRequestHandler {
   errorService ||= cfg.errorReportingService
-  reportOnly5xx = cfg.reportOnly5xx || false
   formatError = cfg.formatError
 
   return (err, req, res, _next) => {
@@ -71,6 +67,8 @@ export function genericErrorMiddleware(
 export function respondWithError(req: BackendRequest, res: BackendResponse, err: any): void {
   const { headersSent } = res
 
+  // todo: add endpoint to the log
+  // todo: add userId from the "Context" (or, just req.userId?) to the log
   if (headersSent) {
     req.error(`error after headersSent:`, err)
   } else {
@@ -79,22 +77,18 @@ export function respondWithError(req: BackendRequest, res: BackendResponse, err:
 
   const originalError = _anyToError(err)
 
-  let errorId: string | undefined
-
-  const shouldReport = errorService && shouldReportToSentry(originalError)
-  if (shouldReport) {
-    errorId = errorService?.captureException(originalError)
-  }
+  const errorId = errorService?.captureException(originalError)
 
   if (headersSent) return
 
   const httpError = _errorLikeToErrorObject(originalError)
   if (!includeErrorStack) delete httpError.stack
 
-  httpError.data.errorId = errorId
   httpError.data.backendResponseStatusCode ||= 500 // default to 500
-  httpError.data.headersSent = headersSent || undefined
-  _filterUndefinedValues(httpError.data, true)
+  _objectAssign(httpError.data, {
+    errorId,
+    headersSent: headersSent || undefined,
+  })
 
   formatError?.(httpError) // Mutates
 
@@ -102,22 +96,3 @@ export function respondWithError(req: BackendRequest, res: BackendResponse, err:
     error: httpError,
   } satisfies BackendErrorResponseObject)
 }
-
-function shouldReportToSentry(err: Error): boolean {
-  const e = err as AppError
-
-  // By default - report
-  if (!e?.data) return true
-
-  // If `report` is set - do as it says
-  if (e.data.report === true) return true
-  if (e.data.report === false) return false
-
-  // Report if http 5xx, otherwise not
-  // If no httpCode - report
-  // if httpCode >= 500 - report
-  // Otherwise - report, unless !reportOnly5xx is set
-  return (
-    !reportOnly5xx || !e.data.backendResponseStatusCode || e.data.backendResponseStatusCode >= 500
-  )
-}

package/src/server/logMiddleware.ts

@@ -73,7 +73,11 @@ function logToCI(args: any[]): void {
 export function logMiddleware(): BackendRequestHandler {
   if (isGAE || isCloudRun) {
     return function gcpStructuredLogHandler(req, _res, next) {
-      const meta: StringMap = {}
+      const meta: StringMap = {
+        // Experimental!
+        // Testing to include userId in metadata (not message payload) to see if it's searchable
+        userId: req.userId,
+      }
 
       // CloudRun does NOT have this env variable set,
       // so you have to set it manually on deployment, like this:

package/src/server/request.log.util.ts

@@ -2,7 +2,11 @@ import type { CommonLogLevel } from '@naturalcycles/js-lib'
 import { boldGrey, green, red, yellow } from '@naturalcycles/nodejs-lib'
 import type { BackendRequest } from './server.model.js'
 
-export function logRequest(req: BackendRequest, statusCode: number, ...tokens: any[]): void {
+export function logRequestWithColors(
+  req: BackendRequest,
+  statusCode: number,
+  ...tokens: any[]
+): void {
   req[logLevel(statusCode)](
     [coloredHttpCode(statusCode), req.method, boldGrey(req.url), ...tokens].join(' '),
   )

package/src/server/requestLoggerMiddleware.ts

@@ -0,0 +1,27 @@
+import type { UnixTimestampMillis } from '@naturalcycles/js-lib'
+import { _since } from '@naturalcycles/js-lib'
+import type { BackendRequestHandler } from '../index.js'
+import { onFinished } from '../index.js'
+
+/**
+ * Experimental request logger for Cloud Run.
+ *
+ * @experimental
+ */
+export function requestLoggerMiddleware(): BackendRequestHandler {
+  return (req, res, next) => {
+    const started = Date.now() as UnixTimestampMillis
+
+    req.log([req.method, req.originalUrl, req.userId].filter(Boolean).join(' '))
+
+    onFinished(res, () => {
+      req.log(
+        [res.statusCode || '0', _since(started), req.method, req.originalUrl, req.userId]
+          .filter(Boolean)
+          .join(' '),
+      )
+    })
+
+    next()
+  }
+}

package/src/server/server.model.ts

@@ -14,6 +14,10 @@ export interface BackendRequest extends Request {
   error: CommonLogFunction
 
   requestId?: string
+  /**
+   * Only used for request logging purposes.
+   */
+  userId?: string
 
   /**
    * Set by requestTimeoutMiddleware.

package/src/server/simpleRequestLoggerMiddleware.ts

@@ -3,9 +3,7 @@ import { _since } from '@naturalcycles/js-lib'
 import { boldGrey, dimGrey } from '@naturalcycles/nodejs-lib'
 import type { BackendRequestHandler } from '../index.js'
 import { onFinished } from '../index.js'
-import { logRequest } from './request.log.util.js'
-
-const { APP_ENV } = process.env
+import { logRequestWithColors } from './request.log.util.js'
 
 export interface SimpleRequestLoggerMiddlewareCfg {
   /**
@@ -22,10 +20,6 @@ export interface SimpleRequestLoggerMiddlewareCfg {
 export function simpleRequestLoggerMiddleware(
   cfg: Partial<SimpleRequestLoggerMiddlewareCfg> = {},
 ): BackendRequestHandler {
-  // Disable logger in AppEngine, as it doesn't make sense there
-  // UPD: Only log in dev environment
-  if (APP_ENV !== 'dev') return (_req, _res, next) => next()
-
   const { logStart = false, logFinish = true } = cfg
 
   return (req, res, next) => {
@@ -37,14 +31,7 @@ export function simpleRequestLoggerMiddleware(
 
     if (logFinish) {
       onFinished(res, () => {
-        logRequest(req, res.statusCode, dimGrey(_since(started)))
-
-        // Avoid logging twice. It was previously logged by genericErrorHandler
-        // if (res.__err) {
-        //   logRequest(req, res.statusCode, dimGrey(_since(started)), _inspect(res.__err))
-        // } else {
-        //   logRequest(req, res.statusCode, dimGrey(_since(started)))
-        // }
+        logRequestWithColors(req, res.statusCode, dimGrey(_since(started)))
       })
     }