Add vercel log drain

src/errors.ts

@@ -4,3 +4,5 @@ import ModernErrorsSerialize from "modern-errors-serialize";
 export const BaseError = ModernError.subclass("BaseError", {
   plugins: [ModernErrorsSerialize],
 });
+
+export const UnknownError = BaseError.subclass("UnknownError");

src/lib/logger/create-logger.ts

@@ -1,8 +1,8 @@
 import packageJson from "../../../package.json";
 import { attachLoggerConsoleTransport } from "./logger-console-transport";
 import { createLogger, logger } from "./logger";
-import { attachLoggerOtelTransport } from "./logger-otel-transport";
 import { attachLoggerSentryTransport } from "./logger-sentry-transport";
+import {attachLoggerVercelRuntimeTransport} from "@/lib/logger/logger-vercel-transport";
 import { loggerContext } from "@/logger-context";
 
 logger.settings.maskValuesOfKeys = ["metadata", "username", "password", "apiKey"];
@@ -14,7 +14,13 @@ if (process.env.NODE_ENV !== "production") {
 if (typeof window === "undefined") {
   attachLoggerSentryTransport(logger);
 
-  attachLoggerOtelTransport(logger, packageJson.version, loggerContext);
+  if (process.env.NODE_ENV === "production") {
+    attachLoggerVercelRuntimeTransport(
+      logger,
+      packageJson.version,
+      loggerContext
+    );
+  }
 }
 
 export { createLogger, logger };

src/lib/logger/logger-vercel-transport.ts

@@ -0,0 +1,82 @@
+import { trace } from "@opentelemetry/api";
+import * as Sentry from "@sentry/nextjs";
+import { ILogObj, Logger } from "tslog";
+
+import { BaseError, UnknownError } from "@/errors";
+import { LoggerContext } from "./logger-context";
+
+const VercelMaximumLogSizeExceededError = BaseError.subclass("VercelMaximumLogSizeExceededError");
+
+function isLogExceedingVercelLimit(inputString: string): boolean {
+  const byteLength = new TextEncoder().encode(inputString).length;
+
+  return byteLength > 4096; // Vercel serverless function log limit - 4KB
+}
+
+export const attachLoggerVercelRuntimeTransport = (
+  logger: Logger<ILogObj>,
+  appVersion: string,
+  loggerContext?: LoggerContext,
+) => {
+  logger.attachTransport((log) => {
+    try {
+      const { message, attributes, _meta } = log;
+
+      const bodyMessage = log._meta.name ? `[${log._meta.name}] ${message}` : message;
+
+      const stringifiedMessage = JSON.stringify({
+        message: bodyMessage,
+        ...(loggerContext?.getRawContext() ?? {}),
+        ...attributes,
+        deployment: {
+          environment: process.env.ENV,
+        },
+        otel: {
+          span_id: trace.getActiveSpan()?.spanContext().spanId,
+          trace_id: trace.getActiveSpan()?.spanContext().traceId,
+          timestamp: _meta.date.getTime(),
+        },
+        "commit-sha": process.env.VERCEL_GIT_COMMIT_SHA,
+        service: {
+          name: process.env.OTEL_SERVICE_NAME,
+          version: appVersion,
+        },
+        _meta: {
+          ..._meta,
+          // used to filter out log in log drain
+          source: "saleor-app",
+        },
+      });
+
+      if (isLogExceedingVercelLimit(stringifiedMessage)) {
+        Sentry.captureException(
+          new VercelMaximumLogSizeExceededError("Log message is exceeding Vercel limit", {
+            props: {
+              logName: log._meta.name,
+              logMessage: bodyMessage,
+            },
+          }),
+        );
+      }
+
+      // Prints Vercel log in proper level https://vercel.com/docs/observability/runtime-logs#level
+      if (_meta.logLevelName === "ERROR") {
+        console.error(stringifiedMessage);
+        return;
+      }
+
+      if (_meta.logLevelName === "WARN") {
+        console.warn(stringifiedMessage);
+        return;
+      }
+
+      console.log(stringifiedMessage);
+    } catch (error) {
+      Sentry.captureException(
+        new UnknownError("Error during attaching Vercel transport", {
+          cause: error,
+        }),
+      );
+    }
+  });
+};