@naturalcycles/backend-lib 9.3.0 → 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/asyncLocalStorageMiddleware.js

@@ -1,10 +1,10 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { _lazyValue } from '@naturalcycles/js-lib';
-import { ciLogger, devLogger, gaeLogger } from './logMiddleware.js';
-const { GAE_INSTANCE, CI } = process.env;
+import { ciLogger, devLogger, gcpStructuredLogger } from './logMiddleware.js';
+const { GAE_INSTANCE, K_SERVICE, CI } = process.env;
 const isGAE = !!GAE_INSTANCE;
 const isCI = !!CI;
-const isCloudRun = !!CI;
+const isCloudRun = !!K_SERVICE;
 // Singleton, for simplicity
 // Create it lazily (on demand)
 const storage = _lazyValue(() => new AsyncLocalStorage());
@@ -25,7 +25,8 @@ export function getRequest() {
  * @experimental
  */
 export function getRequestLogger() {
-    return (storage().getStore()?.req || (isGAE ? gaeLogger : isCI || isCloudRun ? ciLogger : devLogger));
+    return (storage().getStore()?.req ||
+        (isGAE || isCloudRun ? gcpStructuredLogger : isCI ? ciLogger : devLogger));
 }
 /**
  * CommonLogger implementation that is Request-bound.

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.d.ts

@@ -1,10 +1,10 @@
 import type { CommonLogger } from '@naturalcycles/js-lib';
 import type { BackendRequestHandler } from './server.model.js';
 /**
- * Logger that logs in AppEngine format.
+ * Logger that logs in "GCP structured log" format.
  * To be used in outside-of-request situations (otherwise req.log should be used).
  */
-export declare const gaeLogger: CommonLogger;
+export declare const gcpStructuredLogger: CommonLogger;
 /**
  * Fancy development logger, to be used in outside-of-request situations
  * (otherwise req.log should be used).

package/dist/server/logMiddleware.js

@@ -1,20 +1,20 @@
 import { inspect } from 'node:util';
 import { _inspect, dimGrey } from '@naturalcycles/nodejs-lib';
-const { GOOGLE_CLOUD_PROJECT, GAE_INSTANCE, APP_ENV } = process.env;
+const { GOOGLE_CLOUD_PROJECT, GAE_INSTANCE, K_SERVICE, APP_ENV } = process.env;
 const isGAE = !!GAE_INSTANCE;
-// const isCloudRun = !!K_SERVICE
+const isCloudRun = !!K_SERVICE;
 // const isTest = APP_ENV === 'test'
 const isDev = APP_ENV === 'dev';
 // Simple "request counter" (poor man's "correlation id") counter, to use on dev machine (not in the cloud)
 let reqCounter = 0;
 /**
- * Logger that logs in AppEngine format.
+ * Logger that logs in "GCP structured log" format.
  * To be used in outside-of-request situations (otherwise req.log should be used).
  */
-export const gaeLogger = {
-    log: (...args) => logToAppEngine({}, args),
-    warn: (...args) => logToAppEngine({ severity: 'WARNING' }, args),
-    error: (...args) => logToAppEngine({ severity: 'ERROR' }, args),
+export const gcpStructuredLogger = {
+    log: (...args) => writeGCPStructuredLog({}, args),
+    warn: (...args) => writeGCPStructuredLog({ severity: 'WARNING' }, args),
+    error: (...args) => writeGCPStructuredLog({ severity: 'ERROR' }, args),
 };
 /**
  * Fancy development logger, to be used in outside-of-request situations
@@ -34,7 +34,8 @@ export const ciLogger = {
     error: (...args) => logToCI(args),
 };
 // Documented here: https://cloud.google.com/logging/docs/structured-logging
-function logToAppEngine(meta, args) {
+// Cloud Run logging: https://cloud.google.com/run/docs/logging
+function writeGCPStructuredLog(meta, args) {
     console.log(JSON.stringify({
         message: args.map(a => (typeof a === 'string' ? a : inspect(a))).join(' '),
         ...meta,
@@ -55,31 +56,33 @@ function logToCI(args) {
     console.log(args.map(a => _inspect(a, { includeErrorStack: true, colors: false })).join(' '));
 }
 export function logMiddleware() {
-    if (isGAE) {
-        if (GOOGLE_CLOUD_PROJECT) {
-            return function appEngineLogHandler(req, _res, next) {
+    if (isGAE || isCloudRun) {
+        return function gcpStructuredLogHandler(req, _res, next) {
+            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 \
+            //   --update-env-vars=GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
+            if (GOOGLE_CLOUD_PROJECT) {
                 const traceHeader = req.header('x-cloud-trace-context');
                 if (traceHeader) {
                     const [trace] = traceHeader.split('/');
-                    const meta = {
-                        'logging.googleapis.com/trace': `projects/${GOOGLE_CLOUD_PROJECT}/traces/${trace}`,
-                        'appengine.googleapis.com/request_id': req.header('x-appengine-request-log-id'),
-                    };
-                    Object.assign(req, {
-                        log: (...args) => logToAppEngine({ ...meta, severity: 'INFO' }, args),
-                        warn: (...args) => logToAppEngine({ ...meta, severity: 'WARNING' }, args),
-                        error: (...args) => logToAppEngine({ ...meta, severity: 'ERROR' }, args),
-                    });
+                    meta['logging.googleapis.com/trace'] = `projects/${GOOGLE_CLOUD_PROJECT}/traces/${trace}`;
                     req.requestId = trace;
                 }
-                else {
-                    Object.assign(req, gaeLogger);
-                }
-                next();
-            };
-        }
-        return function appEngineLogHandler(req, _res, next) {
-            Object.assign(req, gaeLogger);
+            }
+            if (isGAE) {
+                meta['appengine.googleapis.com/request_id'] = req.header('x-appengine-request-log-id');
+            }
+            Object.assign(req, {
+                log: (...args) => writeGCPStructuredLog({ ...meta, severity: 'INFO' }, args),
+                warn: (...args) => writeGCPStructuredLog({ ...meta, severity: 'WARNING' }, args),
+                error: (...args) => writeGCPStructuredLog({ ...meta, severity: 'ERROR' }, args),
+            });
             next();
         };
     }
@@ -93,7 +96,7 @@ export function logMiddleware() {
         };
     }
     // Otherwise, return "simple" logger
-    // This includes: unit tests, CloudRun, CI environments
+    // This includes: unit tests, CI environments
     return function simpleLogHandler(req, _res, next) {
         req.log = req.warn = req.error = (...args) => logToCI(args);
         next();

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.d.ts

@@ -9,4 +9,4 @@ export interface SimpleRequestLoggerMiddlewareCfg {
      */
     logFinish: boolean;
 }
-export declare function simpleRequestLoggerMiddleware(_cfg?: Partial<SimpleRequestLoggerMiddlewareCfg>): BackendRequestHandler;
+export declare function simpleRequestLoggerMiddleware(cfg?: Partial<SimpleRequestLoggerMiddlewareCfg>): BackendRequestHandler;

package/dist/server/simpleRequestLoggerMiddleware.js

@@ -1,19 +1,9 @@
 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;
-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 cfg = {
-        logStart: false,
-        logFinish: true,
-        ..._cfg,
-    };
-    const { logStart, logFinish } = cfg;
+import { logRequestWithColors } from './request.log.util.js';
+export function simpleRequestLoggerMiddleware(cfg = {}) {
+    const { logStart = false, logFinish = true } = cfg;
     return (req, res, next) => {
         const started = Date.now();
         if (logStart) {
@@ -21,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.0",
+  "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/asyncLocalStorageMiddleware.ts

@@ -1,13 +1,13 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
 import type { CommonLogger } from '@naturalcycles/js-lib'
 import { _lazyValue } from '@naturalcycles/js-lib'
-import { ciLogger, devLogger, gaeLogger } from './logMiddleware.js'
+import { ciLogger, devLogger, gcpStructuredLogger } from './logMiddleware.js'
 import type { BackendRequest, BackendRequestHandler } from './server.model.js'
 
-const { GAE_INSTANCE, CI } = process.env
+const { GAE_INSTANCE, K_SERVICE, CI } = process.env
 const isGAE = !!GAE_INSTANCE
 const isCI = !!CI
-const isCloudRun = !!CI
+const isCloudRun = !!K_SERVICE
 
 export interface RequestLocalStorage {
   req: BackendRequest
@@ -38,7 +38,8 @@ export function getRequest(): BackendRequest | undefined {
  */
 export function getRequestLogger(): CommonLogger {
   return (
-    storage().getStore()?.req || (isGAE ? gaeLogger : isCI || isCloudRun ? ciLogger : devLogger)
+    storage().getStore()?.req ||
+    (isGAE || isCloudRun ? gcpStructuredLogger : isCI ? ciLogger : devLogger)
   )
 }
 

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

@@ -1,11 +1,11 @@
 import { inspect } from 'node:util'
-import type { AnyObject, CommonLogger } from '@naturalcycles/js-lib'
+import type { AnyObject, CommonLogger, StringMap } from '@naturalcycles/js-lib'
 import { _inspect, dimGrey } from '@naturalcycles/nodejs-lib'
 import type { BackendRequestHandler } from './server.model.js'
 
-const { GOOGLE_CLOUD_PROJECT, GAE_INSTANCE, APP_ENV } = process.env
+const { GOOGLE_CLOUD_PROJECT, GAE_INSTANCE, K_SERVICE, APP_ENV } = process.env
 const isGAE = !!GAE_INSTANCE
-// const isCloudRun = !!K_SERVICE
+const isCloudRun = !!K_SERVICE
 // const isTest = APP_ENV === 'test'
 const isDev = APP_ENV === 'dev'
 
@@ -13,13 +13,13 @@ const isDev = APP_ENV === 'dev'
 let reqCounter = 0
 
 /**
- * Logger that logs in AppEngine format.
+ * Logger that logs in "GCP structured log" format.
  * To be used in outside-of-request situations (otherwise req.log should be used).
  */
-export const gaeLogger: CommonLogger = {
-  log: (...args) => logToAppEngine({}, args),
-  warn: (...args) => logToAppEngine({ severity: 'WARNING' }, args),
-  error: (...args) => logToAppEngine({ severity: 'ERROR' }, args),
+export const gcpStructuredLogger: CommonLogger = {
+  log: (...args) => writeGCPStructuredLog({}, args),
+  warn: (...args) => writeGCPStructuredLog({ severity: 'WARNING' }, args),
+  error: (...args) => writeGCPStructuredLog({ severity: 'ERROR' }, args),
 }
 
 /**
@@ -42,7 +42,8 @@ export const ciLogger: CommonLogger = {
 }
 
 // Documented here: https://cloud.google.com/logging/docs/structured-logging
-function logToAppEngine(meta: AnyObject, args: any[]): void {
+// Cloud Run logging: https://cloud.google.com/run/docs/logging
+function writeGCPStructuredLog(meta: AnyObject, args: any[]): void {
   console.log(
     JSON.stringify({
       message: args.map(a => (typeof a === 'string' ? a : inspect(a))).join(' '),
@@ -70,32 +71,36 @@ function logToCI(args: any[]): void {
 }
 
 export function logMiddleware(): BackendRequestHandler {
-  if (isGAE) {
-    if (GOOGLE_CLOUD_PROJECT) {
-      return function appEngineLogHandler(req, _res, next) {
+  if (isGAE || isCloudRun) {
+    return function gcpStructuredLogHandler(req, _res, next) {
+      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:
+      // gcloud run deploy my-service \
+      //   --update-env-vars=GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
+      if (GOOGLE_CLOUD_PROJECT) {
         const traceHeader = req.header('x-cloud-trace-context')
         if (traceHeader) {
           const [trace] = traceHeader.split('/')
-          const meta = {
-            'logging.googleapis.com/trace': `projects/${GOOGLE_CLOUD_PROJECT}/traces/${trace}`,
-            'appengine.googleapis.com/request_id': req.header('x-appengine-request-log-id'),
-          }
-          Object.assign(req, {
-            log: (...args: any[]) => logToAppEngine({ ...meta, severity: 'INFO' }, args),
-            warn: (...args: any[]) => logToAppEngine({ ...meta, severity: 'WARNING' }, args),
-            error: (...args: any[]) => logToAppEngine({ ...meta, severity: 'ERROR' }, args),
-          })
+          meta['logging.googleapis.com/trace'] = `projects/${GOOGLE_CLOUD_PROJECT}/traces/${trace}`
           req.requestId = trace
-        } else {
-          Object.assign(req, gaeLogger)
         }
-
-        next()
       }
-    }
+      if (isGAE) {
+        meta['appengine.googleapis.com/request_id'] = req.header('x-appengine-request-log-id')
+      }
+
+      Object.assign(req, {
+        log: (...args: any[]) => writeGCPStructuredLog({ ...meta, severity: 'INFO' }, args),
+        warn: (...args: any[]) => writeGCPStructuredLog({ ...meta, severity: 'WARNING' }, args),
+        error: (...args: any[]) => writeGCPStructuredLog({ ...meta, severity: 'ERROR' }, args),
+      })
 
-    return function appEngineLogHandler(req, _res, next) {
-      Object.assign(req, gaeLogger)
       next()
     }
   }
@@ -111,7 +116,7 @@ export function logMiddleware(): BackendRequestHandler {
   }
 
   // Otherwise, return "simple" logger
-  // This includes: unit tests, CloudRun, CI environments
+  // This includes: unit tests, CI environments
   return function simpleLogHandler(req, _res, next) {
     req.log = req.warn = req.error = (...args: any[]) => logToCI(args)
     next()

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 {
   /**
@@ -20,18 +18,9 @@ export interface SimpleRequestLoggerMiddlewareCfg {
 }
 
 export function simpleRequestLoggerMiddleware(
-  _cfg: Partial<SimpleRequestLoggerMiddlewareCfg> = {},
+  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 cfg: SimpleRequestLoggerMiddlewareCfg = {
-    logStart: false,
-    logFinish: true,
-    ..._cfg,
-  }
-  const { logStart, logFinish } = cfg
+  const { logStart = false, logFinish = true } = cfg
 
   return (req, res, next) => {
     const started = Date.now() as UnixTimestampMillis
@@ -42,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)))
       })
     }