376 lines
41 KiB
Plaintext
376 lines
41 KiB
Plaintext
/* _processed_nuxt_unctx_transform */
|
|
import { executeAsync as __executeAsync } from "/_nuxt/node_modules/unctx/dist/index.mjs?v=e4f18c29";import { collectLongTrace, errorToString, getErrorMessage } from "/_nuxt/@fs/D:/speckle-server/packages/shared/dist/esm/index.js";
|
|
import __vite__cjsImport2_dayjs from "/_nuxt/node_modules/.cache/vite/client/deps/dayjs.js?v=e4f18c29"; const dayjs = __vite__cjsImport2_dayjs.__esModule ? __vite__cjsImport2_dayjs.default : __vite__cjsImport2_dayjs;
|
|
import { omit } from "/_nuxt/node_modules/.cache/vite/client/deps/lodash-es.js?v=e4f18c29";
|
|
import { useReadUserId } from "/_nuxt/lib/auth/composables/activeUser.ts";
|
|
import {
|
|
useCreateLoggingTransport,
|
|
useGetLoggingTransports,
|
|
useLogToLoggingTransports
|
|
} from "/_nuxt/lib/core/composables/error.ts";
|
|
import {
|
|
useRequestId,
|
|
useServerRequestId,
|
|
useUserCountry
|
|
} from "/_nuxt/lib/core/composables/server.ts";
|
|
import { isObjectLike } from "/_nuxt/lib/common/helpers/type.ts";
|
|
import {
|
|
buildFakePinoLogger,
|
|
enableCustomLoggerHandling
|
|
} from "/_nuxt/lib/core/helpers/observability.ts";
|
|
|
|
import { defineNuxtPlugin, useRuntimeConfig } from "/_nuxt/node_modules/nuxt/dist/app/nuxt.js?v=e4f18c29";
|
|
import { useRoute, useRouter } from "/_nuxt/node_modules/nuxt/dist/app/composables/router.js?v=e4f18c29";
|
|
import { createError } from "/_nuxt/node_modules/nuxt/dist/app/composables/error.js?v=e4f18c29";
|
|
const simpleStripHtml = (str) => str.replace(/<[^>]*>?/gm, "");
|
|
export default defineNuxtPlugin(async (nuxtApp) => {let __temp, __restore;
|
|
const runtimeConfig = useRuntimeConfig();
|
|
const {
|
|
public: {
|
|
logLevel: untypedLogLevel,
|
|
logPretty,
|
|
logClientApiToken,
|
|
speckleServerVersion,
|
|
logClientApiEndpoint,
|
|
serverName,
|
|
logCsrEmitProps
|
|
}
|
|
} = runtimeConfig;
|
|
const logLevel = untypedLogLevel;
|
|
const route = useRoute();
|
|
const router = useRouter();
|
|
const reqId = useRequestId();
|
|
const serverReqId = useServerRequestId();
|
|
const getUserId = useReadUserId();
|
|
const country = useUserCountry();
|
|
const registerErrorTransport = useCreateLoggingTransport();
|
|
const { invokeTransportsWithPayload } = useLogToLoggingTransports();
|
|
const profilerLogger = route.query.profilerLogger === "1";
|
|
const collectMainInfo = (params) => {
|
|
const info = {
|
|
browser: params.isBrowser,
|
|
speckleServerVersion,
|
|
serverName,
|
|
frontendType: "frontend-2",
|
|
route: route?.path,
|
|
routeDefinition: route.matched?.[route.matched.length - 1]?.path,
|
|
req: { id: reqId },
|
|
userId: getUserId(),
|
|
country: country.value,
|
|
serverReqId: serverReqId.value
|
|
};
|
|
return info;
|
|
};
|
|
let logger;
|
|
const logHandlers = [];
|
|
const unhandledErrorHandlers = [];
|
|
if (false) {
|
|
const {
|
|
buildLogger,
|
|
enableDynamicBindings,
|
|
serializeRequest,
|
|
prettifiedLoggerFactory,
|
|
initSsrDevLogs
|
|
} = (([__temp,__restore]=__executeAsync(()=>import("/_nuxt/server/lib/core/helpers/observability.ts"))),__temp=await __temp,__restore(),__temp);
|
|
logger = enableDynamicBindings(buildLogger(logLevel, logPretty).child({}), () => ({
|
|
...collectMainInfo({ isBrowser: false }),
|
|
...nuxtApp.ssrContext ? { req: serializeRequest(nuxtApp.ssrContext.event.node.req) } : {}
|
|
}));
|
|
nuxtApp.hook("app:rendered", () => {
|
|
if (!nuxtApp.ssrContext) return;
|
|
const bindings = collectMainInfo({ isBrowser: false });
|
|
nuxtApp.ssrContext.event.node.res.vueLoggerBindings = omit(bindings, [
|
|
"req",
|
|
"res"
|
|
]);
|
|
});
|
|
if (true) {
|
|
const ssrDevLogs = (([__temp,__restore]=__executeAsync(()=>initSsrDevLogs({ logLevel }))),__temp=await __temp,__restore(),__temp);
|
|
const consola = ssrDevLogs.consola;
|
|
if (consola) {
|
|
const unhandledHandler = ({
|
|
error,
|
|
message,
|
|
isUnhandledRejection
|
|
}) => {
|
|
consola.error({ err: error, isUnhandledRejection }, message);
|
|
};
|
|
unhandledErrorHandlers.push(unhandledHandler);
|
|
const errorHandler = ({ args, level }) => {
|
|
prettifiedLoggerFactory(consola[level])(args[0], ...args.slice(1), {
|
|
time: dayjs().format("HH:mm:ss.SSS"),
|
|
separator: "═══════════════════════════════════════════►"
|
|
});
|
|
};
|
|
logHandlers.push(errorHandler);
|
|
}
|
|
}
|
|
} else {
|
|
const localTimeFormat = new Intl.DateTimeFormat("en-GB", {
|
|
dateStyle: "full",
|
|
timeStyle: "long"
|
|
});
|
|
const collectBrowserInfo = () => {
|
|
const {
|
|
userAgent,
|
|
platform: navigatorPlatform,
|
|
vendor: navigatorVendor
|
|
} = navigator;
|
|
const url = window.location.href;
|
|
const localTime = localTimeFormat.format(/* @__PURE__ */ new Date());
|
|
const { innerWidth: browserWidth, innerHeight: browserHeight } = window;
|
|
const { width: screenWidth, height: screenHeight } = window.screen;
|
|
return {
|
|
userAgent,
|
|
navigatorPlatform,
|
|
navigatorVendor,
|
|
url,
|
|
localTime,
|
|
dimensions: {
|
|
browser: { width: browserWidth, height: browserHeight },
|
|
screen: { width: screenWidth, height: screenHeight }
|
|
}
|
|
};
|
|
};
|
|
const collectCoreInfo = () => ({
|
|
...collectBrowserInfo(),
|
|
...collectMainInfo({ isBrowser: true })
|
|
});
|
|
logger = buildFakePinoLogger({
|
|
consoleBindings: logCsrEmitProps ? collectCoreInfo : void 0,
|
|
time: profilerLogger
|
|
});
|
|
if (logClientApiToken?.length && logClientApiEndpoint?.length) {
|
|
const seq = (([__temp,__restore]=__executeAsync(()=>import('/_nuxt/node_modules/.cache/vite/client/deps/seq-logging_browser.js?v=e4f18c29').then(m => ((m$2) => m$2?.__esModule ? m$2 : { ...typeof m$2 === "object" && !Array.isArray(m$2) || typeof m$2 === "function" ? m$2 : {}, default: m$2})(m.default)))),__temp=await __temp,__restore(),__temp);
|
|
const seqLogger = new seq.Logger({
|
|
serverUrl: logClientApiEndpoint,
|
|
apiKey: logClientApiToken,
|
|
// eslint-disable-next-line no-console
|
|
onError: console.error
|
|
});
|
|
const unhandledErrorLogger = ({
|
|
error,
|
|
message,
|
|
isUnhandledRejection
|
|
}) => {
|
|
seqLogger.emit({
|
|
timestamp: /* @__PURE__ */ new Date(),
|
|
level: "error",
|
|
messageTemplate: "Client-side error: {mainSeqErrorMessage}",
|
|
properties: {
|
|
mainSeqErrorMessage: message,
|
|
isUnhandledRejection,
|
|
...collectCoreInfo()
|
|
},
|
|
exception: error instanceof Error ? error.stack : `${error}`
|
|
});
|
|
};
|
|
unhandledErrorHandlers.push(unhandledErrorLogger);
|
|
const mainSeqTransport = ({
|
|
args,
|
|
firstString,
|
|
firstError,
|
|
otherData,
|
|
nonObjectOtherData,
|
|
level
|
|
}) => {
|
|
if (!args.length) return;
|
|
const stack = collectLongTrace();
|
|
const isError = ["error", "fatal"].includes(level);
|
|
const isImportant = !!otherData?.important;
|
|
if (!isError && !isImportant) return;
|
|
if (isError) {
|
|
const errorMessage = firstError?.message ?? firstString ?? `Unknown error`;
|
|
const exception = firstError?.stack ?? new Error(
|
|
"No Error instance was thrown, thus the following stack trace is synthesized manually"
|
|
).stack;
|
|
seqLogger.emit({
|
|
timestamp: /* @__PURE__ */ new Date(),
|
|
level: "error",
|
|
messageTemplate: "Client-side error: {mainSeqErrorMessage}",
|
|
properties: {
|
|
mainSeqErrorMessage: errorMessage,
|
|
// weird name to avoid collision with otherData
|
|
extraData: nonObjectOtherData,
|
|
stack,
|
|
firstError,
|
|
firstString,
|
|
...otherData,
|
|
...collectCoreInfo()
|
|
},
|
|
exception
|
|
});
|
|
} else {
|
|
seqLogger.emit({
|
|
timestamp: /* @__PURE__ */ new Date(),
|
|
level,
|
|
messageTemplate: firstString,
|
|
properties: {
|
|
extraData: nonObjectOtherData,
|
|
firstError,
|
|
stack,
|
|
...otherData,
|
|
...collectCoreInfo()
|
|
}
|
|
});
|
|
}
|
|
};
|
|
logHandlers.push(mainSeqTransport);
|
|
logger.debug("Set up seq ingestion...");
|
|
}
|
|
}
|
|
if (logHandlers.length || unhandledErrorHandlers.length) {
|
|
registerErrorTransport({
|
|
onLog: (...params) => {
|
|
logHandlers.forEach((handler) => handler(...params));
|
|
},
|
|
onUnhandledError: (event) => {
|
|
unhandledErrorHandlers.forEach((handler) => handler(event));
|
|
}
|
|
});
|
|
}
|
|
const transports = useGetLoggingTransports();
|
|
logger = enableCustomLoggerHandling({
|
|
logger,
|
|
handler: (params, helpers) => {
|
|
transports.forEach((handler) => handler.onLog?.(params, helpers));
|
|
}
|
|
});
|
|
if (true && window) {
|
|
const unhandledHandler = (event) => {
|
|
const handlers = transports.filter(
|
|
(t) => !!t.onUnhandledError
|
|
);
|
|
const isUnhandledRejection = isObjectLike(event) && "reason" in event;
|
|
const error = "reason" in event ? event.reason : event.error;
|
|
const message = error instanceof Error ? error.message : `${error}`;
|
|
handlers.forEach(
|
|
(handler) => handler.onUnhandledError({ event, isUnhandledRejection, error, message })
|
|
);
|
|
};
|
|
window.addEventListener("error", unhandledHandler);
|
|
window.addEventListener("unhandledrejection", unhandledHandler);
|
|
}
|
|
const getErrorStatusCode = (err) => {
|
|
if (isObjectLike(err) && "statusCode" in err) {
|
|
const statusCode = err.statusCode;
|
|
if (typeof statusCode === "number" && !Number.isNaN(statusCode)) {
|
|
return statusCode;
|
|
}
|
|
}
|
|
return void 0;
|
|
};
|
|
const isIgnorableError = (err) => {
|
|
const statusCode = getErrorStatusCode(err);
|
|
if (typeof statusCode === "number") {
|
|
if ([404, 403, 401].includes(statusCode)) return true;
|
|
return false;
|
|
}
|
|
};
|
|
router.onError((err, to, from) => {
|
|
if (isIgnorableError(err)) return;
|
|
logger.error(
|
|
{
|
|
err,
|
|
to: to.path,
|
|
from: from?.path,
|
|
isAppError: !!false,
|
|
unhandledRoutingError: true,
|
|
statusCode: getErrorStatusCode(err)
|
|
},
|
|
getErrorMessage(err)
|
|
);
|
|
});
|
|
nuxtApp.vueApp.config.errorHandler = (error, _vm, info) => {
|
|
if (isIgnorableError(error)) return;
|
|
logger.error(
|
|
{
|
|
err: error,
|
|
info,
|
|
vm: _vm?.$options.name,
|
|
errString: errorToString(error),
|
|
vueErrorHandler: true,
|
|
statusCode: getErrorStatusCode(error)
|
|
},
|
|
getErrorMessage(error)
|
|
);
|
|
};
|
|
nuxtApp.hook("app:error", (error) => {
|
|
if (isIgnorableError(error)) return;
|
|
logger.error(
|
|
{
|
|
err: error,
|
|
isAppError: true,
|
|
errString: errorToString(error),
|
|
appErrorHook: true,
|
|
statusCode: getErrorStatusCode(error)
|
|
},
|
|
getErrorMessage(error)
|
|
);
|
|
});
|
|
nuxtApp.hook("vue:error", (error, _vm, info) => {
|
|
if (isIgnorableError(error)) return;
|
|
logger.error(
|
|
{
|
|
err: error,
|
|
info,
|
|
isAppError: true,
|
|
vm: _vm?.$options.name,
|
|
errString: errorToString(error),
|
|
vueErrorHook: true,
|
|
statusCode: getErrorStatusCode(error)
|
|
},
|
|
getErrorMessage(error)
|
|
);
|
|
});
|
|
if (!false) {
|
|
nuxtApp.hook("app:mounted", () => {
|
|
const serverFatalError = nuxtApp.payload.error;
|
|
if (serverFatalError && serverFatalError.statusCode >= 500) {
|
|
const msg = serverFatalError.message || "Fatal server error";
|
|
const stack = serverFatalError.stack ? simpleStripHtml(serverFatalError.stack) : void 0;
|
|
const finalStack = `${msg}${stack ? `
|
|
${stack}` : ""}`;
|
|
const nuxtError = createError({
|
|
...serverFatalError,
|
|
...finalStack ? { stack: finalStack } : {}
|
|
});
|
|
const payload = {
|
|
args: ["Fatal server error", serverFatalError],
|
|
firstError: nuxtError,
|
|
firstString: "Fatal server error",
|
|
otherData: { isAppError: true },
|
|
nonObjectOtherData: [],
|
|
level: "fatal"
|
|
};
|
|
invokeTransportsWithPayload(payload);
|
|
if (true) {
|
|
console.error("Fatal error occurred on server:", payload);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if (!false) {
|
|
nuxtApp.hook("app:mounted", () => {
|
|
logger.info("App mounted in the client", {
|
|
important: true,
|
|
speckleServerVersion,
|
|
runtimeConfig
|
|
});
|
|
});
|
|
} else {
|
|
nuxtApp.hook("app:rendered", () => {
|
|
logger.info("App SSR rendered", {
|
|
important: true,
|
|
speckleServerVersion
|
|
});
|
|
});
|
|
}
|
|
return {
|
|
provide: {
|
|
logger
|
|
}
|
|
};
|
|
},1);
|
|
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["010-logger.ts"],"sourcesContent":["import { collectLongTrace, errorToString, getErrorMessage } from '@speckle/shared'\r\nimport type { LogType } from 'consola'\r\nimport dayjs from 'dayjs'\r\nimport { omit } from 'lodash-es'\r\nimport type { SetRequired } from 'type-fest'\r\nimport { useReadUserId } from '~/lib/auth/composables/activeUser'\r\nimport {\r\n  useCreateLoggingTransport,\r\n  useGetLoggingTransports,\r\n  useLogToLoggingTransports\r\n} from '~/lib/core/composables/error'\r\nimport {\r\n  useRequestId,\r\n  useServerRequestId,\r\n  useUserCountry\r\n} from '~/lib/core/composables/server'\r\nimport { isObjectLike } from '~~/lib/common/helpers/type'\r\nimport {\r\n  buildFakePinoLogger,\r\n  enableCustomLoggerHandling,\r\n  type AbstractLoggerHandler,\r\n  type AbstractLoggerHandlerParams,\r\n  type AbstractUnhandledErrorHandler\r\n} from '~~/lib/core/helpers/observability'\r\n\r\nconst simpleStripHtml = (str: string) => str.replace(/<[^>]*>?/gm, '')\r\n\r\n/**\r\n * - Setting up Pino logger in SSR, basic console.log fallback in CSR\r\n * - Also sets up ability to add extra transport for other observability tools\r\n */\r\n\r\nexport default defineNuxtPlugin(async (nuxtApp) => {\r\n  const runtimeConfig = useRuntimeConfig()\r\n  const {\r\n    public: {\r\n      logLevel: untypedLogLevel,\r\n      logPretty,\r\n      logClientApiToken,\r\n      speckleServerVersion,\r\n      logClientApiEndpoint,\r\n      serverName,\r\n      logCsrEmitProps\r\n    }\r\n  } = runtimeConfig\r\n\r\n  const logLevel = untypedLogLevel as LogType\r\n  const route = useRoute()\r\n  const router = useRouter()\r\n  const reqId = useRequestId()\r\n  const serverReqId = useServerRequestId()\r\n  const getUserId = useReadUserId()\r\n  const country = useUserCountry()\r\n  const registerErrorTransport = useCreateLoggingTransport()\r\n  const { invokeTransportsWithPayload } = useLogToLoggingTransports()\r\n\r\n  const profilerLogger = route.query.profilerLogger === '1'\r\n\r\n  const collectMainInfo = (params: { isBrowser: boolean }) => {\r\n    const info = {\r\n      browser: params.isBrowser,\r\n      speckleServerVersion,\r\n      serverName,\r\n      frontendType: 'frontend-2',\r\n      route: route?.path,\r\n      routeDefinition: route.matched?.[route.matched.length - 1]?.path,\r\n      req: { id: reqId },\r\n      userId: getUserId(),\r\n      country: country.value,\r\n      serverReqId: serverReqId.value\r\n    }\r\n    return info\r\n  }\r\n\r\n  // Set up logger\r\n  let logger: ReturnType<typeof import('@speckle/shared/observability').getLogger>\r\n  const logHandlers: AbstractLoggerHandler[] = []\r\n  const unhandledErrorHandlers: AbstractUnhandledErrorHandler[] = []\r\n\r\n  if (import.meta.server) {\r\n    const {\r\n      buildLogger,\r\n      enableDynamicBindings,\r\n      serializeRequest,\r\n      prettifiedLoggerFactory,\r\n      initSsrDevLogs\r\n    } = await import('~/server/lib/core/helpers/observability')\r\n    logger = enableDynamicBindings(buildLogger(logLevel, logPretty).child({}), () => ({\r\n      ...collectMainInfo({ isBrowser: false }),\r\n      ...(nuxtApp.ssrContext\r\n        ? { req: serializeRequest(nuxtApp.ssrContext.event.node.req) }\r\n        : {})\r\n    }))\r\n\r\n    // Collect bindings for pino-http logger\r\n    nuxtApp.hook('app:rendered', () => {\r\n      if (!nuxtApp.ssrContext) return\r\n      const bindings = collectMainInfo({ isBrowser: false })\r\n      nuxtApp.ssrContext.event.node.res.vueLoggerBindings = omit(bindings, [\r\n        'req',\r\n        'res'\r\n      ])\r\n    })\r\n\r\n    // Send to consola for SSR log streaming in dev mode\r\n    if (import.meta.dev) {\r\n      const ssrDevLogs = await initSsrDevLogs({ logLevel })\r\n      const consola = ssrDevLogs.consola\r\n\r\n      if (consola) {\r\n        const unhandledHandler: AbstractUnhandledErrorHandler = ({\r\n          error,\r\n          message,\r\n          isUnhandledRejection\r\n        }) => {\r\n          consola.error({ err: error, isUnhandledRejection }, message)\r\n        }\r\n        unhandledErrorHandlers.push(unhandledHandler)\r\n\r\n        const errorHandler: AbstractLoggerHandler = ({ args, level }) => {\r\n          // applying pino-like message templating, cause consola doesnt have it\r\n          // the arg slice is TS appeasement\r\n          prettifiedLoggerFactory(consola[level])(args[0], ...args.slice(1), {\r\n            time: dayjs().format('HH:mm:ss.SSS'),\r\n            separator: '═══════════════════════════════════════════►'\r\n          })\r\n        }\r\n        logHandlers.push(errorHandler)\r\n      }\r\n    }\r\n  } else {\r\n    const localTimeFormat = new Intl.DateTimeFormat('en-GB', {\r\n      dateStyle: 'full',\r\n      timeStyle: 'long'\r\n    })\r\n    const collectBrowserInfo = () => {\r\n      const {\r\n        userAgent,\r\n        platform: navigatorPlatform,\r\n        vendor: navigatorVendor\r\n      } = navigator\r\n      const url = window.location.href\r\n      const localTime = localTimeFormat.format(new Date())\r\n\r\n      // Get browser dimensions & screen dimensions\r\n      const { innerWidth: browserWidth, innerHeight: browserHeight } = window\r\n      const { width: screenWidth, height: screenHeight } = window.screen\r\n\r\n      return {\r\n        userAgent,\r\n        navigatorPlatform,\r\n        navigatorVendor,\r\n        url,\r\n        localTime,\r\n        dimensions: {\r\n          browser: { width: browserWidth, height: browserHeight },\r\n          screen: { width: screenWidth, height: screenHeight }\r\n        }\r\n      }\r\n    }\r\n\r\n    const collectCoreInfo = () => ({\r\n      ...collectBrowserInfo(),\r\n      ...collectMainInfo({ isBrowser: true })\r\n    })\r\n\r\n    logger = buildFakePinoLogger({\r\n      consoleBindings: logCsrEmitProps ? collectCoreInfo : undefined,\r\n      time: profilerLogger\r\n    })\r\n\r\n    // SEQ Browser integration\r\n    if (logClientApiToken?.length && logClientApiEndpoint?.length) {\r\n      const seq = await import('seq-logging/browser')\r\n      const seqLogger = new seq.Logger({\r\n        serverUrl: logClientApiEndpoint,\r\n        apiKey: logClientApiToken,\r\n        // eslint-disable-next-line no-console\r\n        onError: console.error\r\n      })\r\n\r\n      const unhandledErrorLogger: AbstractUnhandledErrorHandler = ({\r\n        error,\r\n        message,\r\n        isUnhandledRejection\r\n      }) => {\r\n        seqLogger.emit({\r\n          timestamp: new Date(),\r\n          level: 'error',\r\n          messageTemplate: 'Client-side error: {mainSeqErrorMessage}',\r\n          properties: {\r\n            mainSeqErrorMessage: message,\r\n            isUnhandledRejection,\r\n            ...collectCoreInfo()\r\n          },\r\n          exception: error instanceof Error ? error.stack : `${error}`\r\n        })\r\n      }\r\n      unhandledErrorHandlers.push(unhandledErrorLogger)\r\n\r\n      const mainSeqTransport: AbstractLoggerHandler = ({\r\n        args,\r\n        firstString,\r\n        firstError,\r\n        otherData,\r\n        nonObjectOtherData,\r\n        level\r\n      }) => {\r\n        if (!args.length) return\r\n\r\n        const stack = collectLongTrace()\r\n        const isError = ['error', 'fatal'].includes(level)\r\n        const isImportant = !!otherData?.important\r\n        if (!isError && !isImportant) return\r\n\r\n        if (isError) {\r\n          const errorMessage = firstError?.message ?? firstString ?? `Unknown error`\r\n          const exception =\r\n            firstError?.stack ??\r\n            new Error(\r\n              'No Error instance was thrown, thus the following stack trace is synthesized manually'\r\n            ).stack\r\n\r\n          seqLogger.emit({\r\n            timestamp: new Date(),\r\n            level: 'error',\r\n            messageTemplate: 'Client-side error: {mainSeqErrorMessage}',\r\n            properties: {\r\n              mainSeqErrorMessage: errorMessage, // weird name to avoid collision with otherData\r\n              extraData: nonObjectOtherData,\r\n              stack,\r\n              firstError,\r\n              firstString,\r\n              ...otherData,\r\n              ...collectCoreInfo()\r\n            },\r\n            exception\r\n          })\r\n        } else {\r\n          seqLogger.emit({\r\n            timestamp: new Date(),\r\n            level,\r\n            messageTemplate: firstString,\r\n            properties: {\r\n              extraData: nonObjectOtherData,\r\n              firstError,\r\n              stack,\r\n              ...otherData,\r\n              ...collectCoreInfo()\r\n            }\r\n          })\r\n        }\r\n      }\r\n      logHandlers.push(mainSeqTransport)\r\n\r\n      logger.debug('Set up seq ingestion...')\r\n    }\r\n  }\r\n\r\n  // Register seq transports, if any\r\n  if (logHandlers.length || unhandledErrorHandlers.length) {\r\n    registerErrorTransport({\r\n      onLog: (...params) => {\r\n        logHandlers.forEach((handler) => handler(...params))\r\n      },\r\n      onUnhandledError: (event) => {\r\n        unhandledErrorHandlers.forEach((handler) => handler(event))\r\n      }\r\n    })\r\n  }\r\n\r\n  // Global logger handler - handle all transports besides the core pino/console.log logger\r\n  const transports = useGetLoggingTransports()\r\n  logger = enableCustomLoggerHandling({\r\n    logger,\r\n    handler: (params, helpers) => {\r\n      transports.forEach((handler) => handler.onLog?.(params, helpers))\r\n    }\r\n  })\r\n\r\n  // Unhandled error handler\r\n  if (import.meta.client && window) {\r\n    const unhandledHandler = (event: ErrorEvent | PromiseRejectionEvent) => {\r\n      const handlers = transports.filter(\r\n        (t): t is SetRequired<typeof t, 'onUnhandledError'> => !!t.onUnhandledError\r\n      )\r\n\r\n      const isUnhandledRejection = isObjectLike(event) && 'reason' in event\r\n      const error = ('reason' in event ? event.reason : event.error) as unknown\r\n      const message = error instanceof Error ? error.message : `${error}`\r\n\r\n      handlers.forEach((handler) =>\r\n        handler.onUnhandledError({ event, isUnhandledRejection, error, message })\r\n      )\r\n    }\r\n\r\n    window.addEventListener('error', unhandledHandler)\r\n    window.addEventListener('unhandledrejection', unhandledHandler)\r\n  }\r\n\r\n  const getErrorStatusCode = (err: unknown): number | undefined => {\r\n    if (isObjectLike(err) && 'statusCode' in err) {\r\n      const statusCode = err.statusCode\r\n      if (typeof statusCode === 'number' && !Number.isNaN(statusCode)) {\r\n        return statusCode\r\n      }\r\n    }\r\n    return undefined\r\n  }\r\n\r\n  const isIgnorableError = (err: unknown) => {\r\n    // skip 404, 403, 401\r\n    const statusCode = getErrorStatusCode(err)\r\n    if (typeof statusCode === 'number') {\r\n      if ([404, 403, 401].includes(statusCode)) return true\r\n      return false\r\n    }\r\n  }\r\n\r\n  // Uncaught routing error handler\r\n  router.onError((err, to, from) => {\r\n    if (isIgnorableError(err)) return\r\n\r\n    logger.error(\r\n      {\r\n        err,\r\n        to: to.path,\r\n        from: from?.path,\r\n        isAppError: !!import.meta.server,\r\n        unhandledRoutingError: true,\r\n        statusCode: getErrorStatusCode(err)\r\n      },\r\n      getErrorMessage(err)\r\n    )\r\n  })\r\n\r\n  // More error logging hooks\r\n  nuxtApp.vueApp.config.errorHandler = (error, _vm, info) => {\r\n    if (isIgnorableError(error)) return\r\n\r\n    logger.error(\r\n      {\r\n        err: error,\r\n        info,\r\n        vm: _vm?.$options.name,\r\n        errString: errorToString(error),\r\n        vueErrorHandler: true,\r\n        statusCode: getErrorStatusCode(error)\r\n      },\r\n      getErrorMessage(error)\r\n    )\r\n  }\r\n  nuxtApp.hook('app:error', (error) => {\r\n    if (isIgnorableError(error)) return\r\n\r\n    logger.error(\r\n      {\r\n        err: error,\r\n        isAppError: true,\r\n        errString: errorToString(error),\r\n        appErrorHook: true,\r\n        statusCode: getErrorStatusCode(error)\r\n      },\r\n      getErrorMessage(error)\r\n    )\r\n  })\r\n\r\n  nuxtApp.hook('vue:error', (error, _vm, info) => {\r\n    if (isIgnorableError(error)) return\r\n\r\n    logger.error(\r\n      {\r\n        err: error,\r\n        info,\r\n        isAppError: true,\r\n        vm: _vm?.$options.name,\r\n        errString: errorToString(error),\r\n        vueErrorHook: true,\r\n        statusCode: getErrorStatusCode(error)\r\n      },\r\n      getErrorMessage(error)\r\n    )\r\n  })\r\n\r\n  // Hydrate server fatal error to CSR\r\n  if (!import.meta.server) {\r\n    nuxtApp.hook('app:mounted', () => {\r\n      const serverFatalError = nuxtApp.payload.error\r\n      if (serverFatalError && serverFatalError.statusCode >= 500) {\r\n        const msg = serverFatalError.message || 'Fatal server error'\r\n        const stack = serverFatalError.stack\r\n          ? simpleStripHtml(serverFatalError.stack)\r\n          : undefined\r\n        const finalStack = `${msg}${stack ? `\\n${stack}` : ''}`\r\n\r\n        const nuxtError = createError({\r\n          ...serverFatalError,\r\n          ...(finalStack ? { stack: finalStack } : {})\r\n        })\r\n\r\n        const payload: AbstractLoggerHandlerParams = {\r\n          args: ['Fatal server error', serverFatalError],\r\n          firstError: nuxtError,\r\n          firstString: 'Fatal server error',\r\n          otherData: { isAppError: true },\r\n          nonObjectOtherData: [],\r\n          level: 'fatal'\r\n        }\r\n        invokeTransportsWithPayload(payload)\r\n\r\n        if (import.meta.dev) {\r\n          // intentionally skipping error pipeline:\r\n          // eslint-disable-next-line no-console\r\n          console.error('Fatal error occurred on server:', payload)\r\n        }\r\n      }\r\n    })\r\n  }\r\n\r\n  // Log important tier app mounted msg for seq\r\n  if (!import.meta.server) {\r\n    nuxtApp.hook('app:mounted', () => {\r\n      logger.info('App mounted in the client', {\r\n        important: true,\r\n        speckleServerVersion,\r\n        runtimeConfig\r\n      })\r\n    })\r\n  } else {\r\n    nuxtApp.hook('app:rendered', () => {\r\n      logger.info('App SSR rendered', {\r\n        important: true,\r\n        speckleServerVersion\r\n      })\r\n    })\r\n  }\r\n\r\n  return {\r\n    provide: {\r\n      logger\r\n    }\r\n  }\r\n})\r\n"],"file":"D:/speckle-server/packages/frontend-2/plugins/010-logger.ts"} |