@modern-js/server-core 2.54.6 → 2.56.0

package/dist/esm/plugins/monitors.js

@@ -0,0 +1,261 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { SERVER_TIMING, ServerTimings } from "../constants";
+function createMonitors() {
+  var coreMonitors = [];
+  var log = function(level, message, args) {
+    var event = {
+      type: "log",
+      payload: {
+        level,
+        message,
+        args
+      }
+    };
+    coreMonitors.forEach(function(monitor) {
+      return monitor(event);
+    });
+  };
+  var mointors = {
+    push: function push(monitor) {
+      coreMonitors.push(monitor);
+    },
+    error: function error(message) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      log("error", message, args);
+    },
+    warn: function warn(message) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      log("warn", message, args);
+    },
+    debug: function debug(message) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      log("debug", message, args);
+    },
+    info: function info(message) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      log("info", message, args);
+    },
+    timing: function timing(name, dur, desc) {
+      var event = {
+        type: "timing",
+        payload: {
+          name,
+          dur,
+          desc
+        }
+      };
+      coreMonitors.forEach(function(monitor) {
+        return monitor(event);
+      });
+    }
+  };
+  return mointors;
+}
+var initMonitorsPlugin = function() {
+  return {
+    name: "@modern-js/init-mointor",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "init-monitor",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var monitors;
+                return _ts_generator(this, function(_state) {
+                  if (!c.get("monitors")) {
+                    monitors = createMonitors();
+                    c.set("monitors", monitors);
+                  }
+                  return [
+                    2,
+                    next()
+                  ];
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }(),
+            order: "pre"
+          });
+        }
+      };
+    }
+  };
+};
+var injectloggerPluigin = function(logger) {
+  return {
+    name: "@modern-js/inject-logger",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "inject-logger",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var pathname, loggerMonitor, monitors;
+                return _ts_generator(this, function(_state) {
+                  if (!c.get("logger")) {
+                    c.set("logger", logger);
+                  }
+                  pathname = c.req.path;
+                  loggerMonitor = function(event) {
+                    if (event.type === "log") {
+                      var _logger;
+                      var _event_payload = event.payload, level = _event_payload.level, message = _event_payload.message, args = _event_payload.args;
+                      (_logger = logger)[level].apply(_logger, [
+                        message
+                      ].concat(_to_consumable_array(args || [])));
+                    }
+                    if (event.type === "timing") {
+                      var _event_payload1 = event.payload, name = _event_payload1.name, dur = _event_payload1.dur, desc = _event_payload1.desc;
+                      if (desc) {
+                        logger.debug("%s Debug - ".concat(name, ", cost: %s, req.url = %s "), desc, dur, pathname);
+                      } else {
+                        logger.debug("Debug - ".concat(name, ", cost: %s, req.url = %s"), dur, pathname);
+                      }
+                    }
+                  };
+                  monitors = c.get("monitors");
+                  monitors === null || monitors === void 0 ? void 0 : monitors.push(loggerMonitor);
+                  return [
+                    2,
+                    next()
+                  ];
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }()
+          });
+        }
+      };
+    }
+  };
+};
+var injectServerTiming = function() {
+  var metaName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "modern-js";
+  return {
+    name: "@modern-js/inject-server-timing",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "inject-server-timing",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var serverTimings, timingMonitor, monitors;
+                return _ts_generator(this, function(_state) {
+                  switch (_state.label) {
+                    case 0:
+                      serverTimings = [];
+                      timingMonitor = function(event) {
+                        if (event.type === "timing") {
+                          serverTimings.push(event.payload);
+                        }
+                      };
+                      monitors = c.get("monitors");
+                      monitors === null || monitors === void 0 ? void 0 : monitors.push(timingMonitor);
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 1:
+                      _state.sent();
+                      serverTimings.forEach(function(serverTiming) {
+                        var name = serverTiming.name, desc = serverTiming.desc, dur = serverTiming.dur;
+                        var _name = "bd-".concat(metaName, "-").concat(name);
+                        var value = "".concat(_name, ";").concat(desc ? 'decs="'.concat(desc, '";') : "", " dur=").concat(dur);
+                        c.header(SERVER_TIMING, value, {
+                          append: true
+                        });
+                      });
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }()
+          });
+        }
+      };
+    }
+  };
+};
+function initReporter(entryName) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var reporter, getCost, cost;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            reporter = c.get("reporter");
+            if (!!reporter)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+          case 2:
+            return [
+              4,
+              reporter.init({
+                entryName
+              })
+            ];
+          case 3:
+            _state.sent();
+            getCost = time();
+            return [
+              4,
+              next()
+            ];
+          case 4:
+            _state.sent();
+            cost = getCost();
+            reporter.reportTiming(ServerTimings.SERVER_HANDLE_REQUEST, cost);
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  initMonitorsPlugin,
+  initReporter,
+  injectServerTiming,
+  injectloggerPluigin
+};

package/dist/esm/plugins/render/dataHandler.js

@@ -3,11 +3,11 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 var dataHandler = function() {
   var _ref = _async_to_generator(function(request, param) {
-    var routeInfo, serverRoutes, reporter, logger, serverManifest, _serverManifest_loaderBundles, serverLoaderModule, routes, handleRequest, response;
+    var routeInfo, serverRoutes, reporter, onError, onTiming, serverManifest, _serverManifest_loaderBundles, serverLoaderModule, routes, handleRequest, response;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, serverRoutes = param.serverRoutes, reporter = param.reporter, logger = param.logger, serverManifest = param.serverManifest;
+          routeInfo = param.routeInfo, serverRoutes = param.serverRoutes, reporter = param.reporter, onError = param.onError, onTiming = param.onTiming, serverManifest = param.serverManifest;
           serverLoaderModule = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_loaderBundles = serverManifest.loaderBundles) === null || _serverManifest_loaderBundles === void 0 ? void 0 : _serverManifest_loaderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
           if (!serverLoaderModule) {
             return [
@@ -21,9 +21,10 @@ var dataHandler = function() {
               request,
               serverRoutes,
               context: {
-                logger,
                 reporter
               },
+              onTiming,
+              onError,
               routes
             })
           ];

package/dist/esm/plugins/render/index.js

@@ -1,7 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { initReporter } from "../monitor";
+import { initReporter } from "../monitors";
 import { sortRoutes } from "../../utils";
 import { getLoaderCtx, CustomServer, getServerMidFromUnstableMid } from "../customServer";
 import { createRender } from "./render";
@@ -150,12 +150,13 @@ function getPageRoutes(routes) {
 function createRenderHandler(render) {
   return function() {
     var _ref = _async_to_generator(function(c, _) {
-      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, loaderContext, request, nodeReq, res, body, status, headers, headersData;
+      var _c_env_node, logger, reporter, monitors, templates, serverManifest, locals, metrics, loaderContext, request, nodeReq, res, body, status, headers, headersData;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
             logger = c.get("logger");
             reporter = c.get("reporter");
+            monitors = c.get("monitors");
             templates = c.get("templates") || {};
             serverManifest = c.get("serverManifest") || {};
             locals = c.get("locals");
@@ -166,8 +167,9 @@ function createRenderHandler(render) {
             return [
               4,
               render(request, {
-                logger,
                 nodeReq,
+                monitors,
+                logger,
                 reporter,
                 templates,
                 metrics,
@@ -208,7 +210,7 @@ function _getRenderHandler() {
       render = createRender({
         routes,
         pwd,
-        // TODO: need static Genrate
+        config,
         staticGenerate,
         cacheConfig,
         forceCSR,

package/dist/esm/plugins/render/render.js

@@ -1,11 +1,14 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
-import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest, parseHeaders } from "../../utils";
 import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
@@ -52,24 +55,31 @@ function matchRoute(router, request) {
   var result = matched[0][0];
   return result || [];
 }
+function getHeadersWithoutCookie(headers) {
+  var _headers = _object_spread_props(_object_spread({}, headers), {
+    cookie: void 0
+  });
+  delete _headers.cookie;
+  return _headers;
+}
 function createRender(_) {
   return _createRender.apply(this, arguments);
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallbackFn, router;
+    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallbackFn, router;
     return _ts_generator(this, function(_state) {
-      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, config = param.config, onFallbackFn = param.onFallback;
       router = getRouter(routes);
       return [
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
+            var logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, locals, loaderContext, _matchRoute, routeInfo, params, onFallback, html, renderMode, pathname, headerData, onError, onTiming, onBoundError, renderOptions, response, _tmp;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
-                  logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics, loaderContext = param2.loaderContext;
+                  logger = param2.logger, reporter = param2.reporter, metrics = param2.metrics, monitors = param2.monitors, nodeReq = param2.nodeReq, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, loaderContext = param2.loaderContext;
                   _matchRoute = _sliced_to_array(matchRoute(router, req), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
                   onFallback = function() {
                     var _ref2 = _async_to_generator(function(reason, error) {
@@ -117,12 +127,20 @@ function _createRender() {
                   ];
                 case 1:
                   renderMode = _state2.sent();
-                  onError = function() {
+                  pathname = getPathname(req);
+                  headerData = parseHeaders(req);
+                  onError = function(e) {
+                    monitors === null || monitors === void 0 ? void 0 : monitors.error("SSR Error - ".concat(_instanceof(e, Error) ? e.name : e, ", error = %s, req.url = %s, req.headers = %o"), _instanceof(e, Error) ? e.stack || e.message : e, pathname, getHeadersWithoutCookie(headerData));
+                  };
+                  onTiming = function(name, dur) {
+                    monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
+                  };
+                  onBoundError = function() {
                     var _ref2 = _async_to_generator(function(e) {
                       return _ts_generator(this, function(_state3) {
                         switch (_state3.label) {
                           case 0:
-                            onErrorFn(ErrorDigest.ERENDER, e, logger, req);
+                            onErrorFn(ErrorDigest.ERENDER, e, monitors, req);
                             return [
                               4,
                               onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e)
@@ -135,7 +153,7 @@ function _createRender() {
                         }
                       });
                     });
-                    return function onError2(e) {
+                    return function onBoundError2(e) {
                       return _ref2.apply(this, arguments);
                     };
                   }();
@@ -144,18 +162,19 @@ function _createRender() {
                     html,
                     routeInfo,
                     staticGenerate: staticGenerate || false,
-                    metaName: metaName || "modern-js",
-                    nonce,
-                    logger,
+                    config,
                     nodeReq,
                     cacheConfig,
                     reporter,
                     serverRoutes: routes,
                     params,
+                    logger,
+                    metrics,
                     locals,
                     serverManifest,
-                    metrics,
-                    loaderContext: loaderContext || /* @__PURE__ */ new Map()
+                    loaderContext: loaderContext || /* @__PURE__ */ new Map(),
+                    onError,
+                    onTiming
                   };
                   switch (renderMode) {
                     case "data":
@@ -176,7 +195,7 @@ function _createRender() {
                   }
                   return [
                     3,
-                    7
+                    8
                   ];
                 case 2:
                   return [
@@ -184,34 +203,42 @@ function _createRender() {
                     dataHandler(req, renderOptions)
                   ];
                 case 3:
-                  response = _state2.sent();
-                  if (!!response)
+                  _tmp = _state2.sent();
+                  if (_tmp)
                     return [
                       3,
                       5
                     ];
                   return [
                     4,
-                    renderHandler(req, renderOptions, "ssr", onError)
+                    renderHandler(req, renderOptions, "ssr", onBoundError)
                   ];
                 case 4:
-                  response = _state2.sent();
+                  _tmp = _state2.sent();
                   _state2.label = 5;
                 case 5:
+                  response = _tmp;
                   return [
-                    2,
-                    response
+                    3,
+                    9
                   ];
                 case 6:
                   return [
-                    2,
-                    renderHandler(req, renderOptions, renderMode, onError)
+                    4,
+                    renderHandler(req, renderOptions, renderMode, onBoundError)
                   ];
                 case 7:
-                  throw new Error("Unknown render mode: ".concat(renderMode));
+                  response = _state2.sent();
+                  return [
+                    3,
+                    9
+                  ];
                 case 8:
+                  throw new Error("Unknown render mode: ".concat(renderMode));
+                case 9:
                   return [
-                    2
+                    2,
+                    response
                   ];
               }
             });