@naturalcycles/backend-lib 9.4.0 → 9.5.0

package/dist/sentry/sentry.shared.service.d.ts

@@ -33,7 +33,7 @@ export declare class SentrySharedService {
      * Does console.log(err)
      * Returns "eventId" or undefined (if error was not reported).
      */
-    captureException(err_: any, logError?: boolean): string | undefined;
+    captureException(err_: any): string | undefined;
     /**
      * Returns "eventId"
      */

package/dist/sentry/sentry.shared.service.js

@@ -54,15 +54,13 @@ export class SentrySharedService {
      * Does console.log(err)
      * Returns "eventId" or undefined (if error was not reported).
      */
-    captureException(err_, logError = true) {
+    captureException(err_) {
         // normalize the error
         const err = _anyToError(err_);
         const data = _isErrorObject(err) ? err.data : undefined;
         // Using request-aware logger here
-        if (logError) {
-            // Log both the error and attached ErrorData (if any)
-            getRequestLogger().error('captureException:', ...[err_, data].filter(Boolean));
-        }
+        // Log both the error and attached ErrorData (if any)
+        getRequestLogger().error('captureException:', ...[err_, data].filter(Boolean));
         if (data?.report === false) {
             // Skip reporting the error
             return;

package/dist/server/genericErrorMiddleware.js

@@ -30,16 +30,24 @@ 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);
+    const originalError = _anyToError(err);
+    let errorId;
+    if (errorService) {
+        // captureException logs the error,
+        // so we don't need to log it here
+        errorId = errorService.captureException(originalError);
     }
     else {
-        req.error(err);
+        // because errorService was not provided - we are going to log the error here
+        if (headersSent) {
+            req.error(`error after headersSent:`, err);
+        }
+        else {
+            req.error(err);
+        }
+        // todo: add endpoint to the log
+        // todo: add userId from the "Context" (or, just req.userId?) to the log
     }
-    const originalError = _anyToError(err);
-    const errorId = errorService?.captureException(originalError);
     if (headersSent)
         return;
     const httpError = _errorLikeToErrorObject(originalError);

package/dist/server/logMiddleware.js

@@ -61,7 +61,9 @@ export function logMiddleware() {
             const meta = {
                 // Experimental!
                 // Testing to include userId in metadata (not message payload) to see if it's searchable
-                userId: req.userId,
+                labels: {
+                    userId: req.userId,
+                },
             };
             // CloudRun does NOT have this env variable set,
             // so you have to set it manually on deployment, like this:

package/dist/server/requestLoggerMiddleware.d.ts

@@ -1,7 +1,13 @@
 import type { BackendRequestHandler } from '../index.js';
+export interface RequestLoggerMiddlewareCfg {
+    /**
+     * If set - this prefix will be removed from the request url before logging.
+     */
+    removeUrlPrefix?: string;
+}
 /**
  * Experimental request logger for Cloud Run.
  *
  * @experimental
  */
-export declare function requestLoggerMiddleware(): BackendRequestHandler;
+export declare function requestLoggerMiddleware(cfg?: RequestLoggerMiddlewareCfg): BackendRequestHandler;

package/dist/server/requestLoggerMiddleware.js

@@ -5,14 +5,27 @@ import { onFinished } from '../index.js';
  *
  * @experimental
  */
-export function requestLoggerMiddleware() {
+export function requestLoggerMiddleware(cfg = {}) {
+    const { removeUrlPrefix } = cfg;
+    const removeUrlPrefixLength = removeUrlPrefix?.length;
     return (req, res, next) => {
         const started = Date.now();
-        req.log([req.method, req.originalUrl, req.userId].filter(Boolean).join(' '));
+        let url = req.originalUrl.split('?')[0];
+        if (removeUrlPrefix && url.startsWith(removeUrlPrefix)) {
+            url = url.slice(removeUrlPrefixLength);
+        }
+        // todo: include requestId (3-character hash of it?)
+        req.log(['>>', req.method, url, req.userId].filter(Boolean).join(' '));
         onFinished(res, () => {
-            req.log([res.statusCode || '0', _since(started), req.method, req.originalUrl, req.userId]
+            const str = ['<<', res.statusCode, _since(started), req.method, url, req.userId]
                 .filter(Boolean)
-                .join(' '));
+                .join(' ');
+            if (res.statusCode && res.statusCode >= 400) {
+                req.error(str);
+            }
+            else {
+                req.log(str);
+            }
         });
         next();
     };

package/dist/server/startServer.js

@@ -16,12 +16,20 @@ export class BackendServer {
         // 1. Register error handlers, etc.
         if (registerUncaughtExceptionHandlers) {
             process.on('uncaughtException', err => {
-                console.error('BackendServer uncaughtException:', err);
-                this.cfg.sentryService?.captureException(err, false);
+                if (this.cfg.sentryService) {
+                    this.cfg.sentryService.captureException(err);
+                }
+                else {
+                    console.error('BackendServer uncaughtException:', err);
+                }
             });
             process.on('unhandledRejection', err => {
-                console.error('BackendServer unhandledRejection:', err);
-                this.cfg.sentryService?.captureException(err, false);
+                if (this.cfg.sentryService) {
+                    this.cfg.sentryService.captureException(err);
+                }
+                else {
+                    console.error('BackendServer unhandledRejection:', err);
+                }
             });
         }
         process.once('SIGINT', () => this.stop('SIGINT'));

package/package.json

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

package/src/sentry/sentry.shared.service.ts

@@ -70,16 +70,14 @@ export class SentrySharedService {
    * Does console.log(err)
    * Returns "eventId" or undefined (if error was not reported).
    */
-  captureException(err_: any, logError = true): string | undefined {
+  captureException(err_: any): string | undefined {
     // normalize the error
     const err = _anyToError(err_)
     const data = _isErrorObject(err) ? err.data : undefined
 
     // Using request-aware logger here
-    if (logError) {
-      // Log both the error and attached ErrorData (if any)
-      getRequestLogger().error('captureException:', ...[err_, data].filter(Boolean))
-    }
+    // Log both the error and attached ErrorData (if any)
+    getRequestLogger().error('captureException:', ...[err_, data].filter(Boolean))
 
     if (data?.report === false) {
       // Skip reporting the error

package/src/server/genericErrorMiddleware.ts

@@ -67,17 +67,25 @@ 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)
+  const originalError = _anyToError(err)
+
+  let errorId: string | undefined
+  if (errorService) {
+    // captureException logs the error,
+    // so we don't need to log it here
+    errorId = errorService.captureException(originalError)
   } else {
-    req.error(err)
-  }
+    // because errorService was not provided - we are going to log the error here
 
-  const originalError = _anyToError(err)
+    if (headersSent) {
+      req.error(`error after headersSent:`, err)
+    } else {
+      req.error(err)
+    }
 
-  const errorId = errorService?.captureException(originalError)
+    // todo: add endpoint to the log
+    // todo: add userId from the "Context" (or, just req.userId?) to the log
+  }
 
   if (headersSent) return
 

package/src/server/logMiddleware.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util'
-import type { AnyObject, CommonLogger, StringMap } from '@naturalcycles/js-lib'
+import type { AnyObject, CommonLogger } from '@naturalcycles/js-lib'
 import { _inspect, dimGrey } from '@naturalcycles/nodejs-lib'
 import type { BackendRequestHandler } from './server.model.js'
 
@@ -73,10 +73,12 @@ function logToCI(args: any[]): void {
 export function logMiddleware(): BackendRequestHandler {
   if (isGAE || isCloudRun) {
     return function gcpStructuredLogHandler(req, _res, next) {
-      const meta: StringMap = {
+      const meta: AnyObject = {
         // Experimental!
         // Testing to include userId in metadata (not message payload) to see if it's searchable
-        userId: req.userId,
+        labels: {
+          userId: req.userId,
+        },
       }
 
       // CloudRun does NOT have this env variable set,

package/src/server/requestLoggerMiddleware.ts

@@ -3,23 +3,45 @@ import { _since } from '@naturalcycles/js-lib'
 import type { BackendRequestHandler } from '../index.js'
 import { onFinished } from '../index.js'
 
+export interface RequestLoggerMiddlewareCfg {
+  /**
+   * If set - this prefix will be removed from the request url before logging.
+   */
+  removeUrlPrefix?: string
+}
+
 /**
  * Experimental request logger for Cloud Run.
  *
  * @experimental
  */
-export function requestLoggerMiddleware(): BackendRequestHandler {
+export function requestLoggerMiddleware(
+  cfg: RequestLoggerMiddlewareCfg = {},
+): BackendRequestHandler {
+  const { removeUrlPrefix } = cfg
+  const removeUrlPrefixLength = removeUrlPrefix?.length
+
   return (req, res, next) => {
     const started = Date.now() as UnixTimestampMillis
 
-    req.log([req.method, req.originalUrl, req.userId].filter(Boolean).join(' '))
+    let url = req.originalUrl.split('?')[0]!
+    if (removeUrlPrefix && url.startsWith(removeUrlPrefix)) {
+      url = url.slice(removeUrlPrefixLength)
+    }
+
+    // todo: include requestId (3-character hash of it?)
+    req.log(['>>', req.method, url, req.userId].filter(Boolean).join(' '))
 
     onFinished(res, () => {
-      req.log(
-        [res.statusCode || '0', _since(started), req.method, req.originalUrl, req.userId]
-          .filter(Boolean)
-          .join(' '),
-      )
+      const str = ['<<', res.statusCode, _since(started), req.method, url, req.userId]
+        .filter(Boolean)
+        .join(' ')
+
+      if (res.statusCode && res.statusCode >= 400) {
+        req.error(str)
+      } else {
+        req.log(str)
+      }
     })
 
     next()

package/src/server/startServer.ts

@@ -19,13 +19,19 @@ export class BackendServer {
     // 1. Register error handlers, etc.
     if (registerUncaughtExceptionHandlers) {
       process.on('uncaughtException', err => {
-        console.error('BackendServer uncaughtException:', err)
-        this.cfg.sentryService?.captureException(err, false)
+        if (this.cfg.sentryService) {
+          this.cfg.sentryService.captureException(err)
+        } else {
+          console.error('BackendServer uncaughtException:', err)
+        }
       })
 
       process.on('unhandledRejection', err => {
-        console.error('BackendServer unhandledRejection:', err)
-        this.cfg.sentryService?.captureException(err, false)
+        if (this.cfg.sentryService) {
+          this.cfg.sentryService.captureException(err)
+        } else {
+          console.error('BackendServer unhandledRejection:', err)
+        }
       })
     }