@awsless/cli 0.1.29 → 0.1.30

package/dist/handlers/on-error-log.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/feature/on-error-log/server/handle.ts
 import { createHash } from "crypto";
 import * as zlib from "zlib";
@@ -16,6 +19,640 @@ import {
   transform,
   uuid
 } from "@awsless/validate";
+
+// src/feature/on-error-log/keys.ts
+var SOURCEMAP_ROOT = "sourcemaps/";
+var formatSourcemapVersionKey = (name, version) => {
+  return `${SOURCEMAP_ROOT}${name}/versions/${version}`;
+};
+
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = 44;
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0;i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max)
+    return false;
+  return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol)
+        sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+var schemeRegex = /^[\w+.-]+:\/\//;
+var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path) {
+  if (path.endsWith("/.."))
+    return path;
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1;i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path = "";
+  for (let i = 1;i < pointer; i++) {
+    path += "/" + pieces[i];
+  }
+  if (!path || addTrailingSlash && !path.endsWith("/..")) {
+    path += "/";
+  }
+  url.path = path;
+}
+function resolve(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      case 2:
+        url.query = baseUrl.query;
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path = url.path.slice(1);
+      if (!path)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path)) {
+        return "./" + path + queryHash;
+      }
+      return path + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+
+// ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+  if (!path)
+    return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length)
+    return mappings;
+  if (!owned)
+    mappings = mappings.slice();
+  for (let i = unsortedIndex;i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start;i < mappings.length; i++) {
+    if (!isSorted(mappings[i]))
+      return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1;j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned)
+    line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1;i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1;i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo)
+      return map;
+    const parsed = parse(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+    const resolve2 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve2);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = undefined;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = undefined;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = undefined;
+    this._bySourceMemos = undefined;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function sourceIndex(map, source) {
+  const { sources, resolvedSources } = map;
+  let index = sources.indexOf(source);
+  if (index === -1)
+    index = resolvedSources.indexOf(source);
+  return index;
+}
+function sourceContentFor(map, source) {
+  const { sourcesContent } = map;
+  if (sourcesContent == null)
+    return null;
+  const index = sourceIndex(map, source);
+  return index === -1 ? null : sourcesContent[index];
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+
+// src/feature/on-error-log/server/sourcemap.ts
+var FRAME = /^(\s*at\s+(?:async\s+)?)(?:(.*?)\s+\()?(?:file:\/\/)?\/var\/task\/([^\s:)]+):(\d+):(\d+)(\)?)\s*$/;
+var MESSAGE_TEMPLATES = /^([A-Za-z_$][\w$]{0,2}) (is not a (?:function|constructor)|is not defined|is not iterable)/;
+var createSymbolicator = (loaders) => {
+  const prefixes = new Map;
+  const maps = new Map;
+  const bound = (cache, limit) => {
+    while (cache.size > limit) {
+      cache.delete(cache.keys().next().value);
+    }
+  };
+  const prefixFor = (functionName, version) => {
+    const key = `${functionName}:${version}`;
+    if (!prefixes.has(key)) {
+      const promise = loaders.loadPrefix(functionName, version);
+      promise.then((prefix) => prefix === undefined && prefixes.delete(key), () => prefixes.delete(key));
+      prefixes.set(key, promise);
+      bound(prefixes, 100);
+    }
+    return prefixes.get(key);
+  };
+  const mapFor = (key) => {
+    if (!maps.has(key)) {
+      const promise = loaders.loadMap(key).then((json) => json ? new TraceMap(JSON.parse(json)) : undefined);
+      promise.catch(() => maps.delete(key));
+      maps.set(key, promise);
+      bound(maps, 6);
+    }
+    return maps.get(key);
+  };
+  const KEYWORDS = new Set([
+    "new",
+    "return",
+    "throw",
+    "await",
+    "async",
+    "typeof",
+    "void",
+    "delete",
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "this",
+    "super",
+    "yield",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "try",
+    "catch",
+    "finally",
+    "in",
+    "of",
+    "import",
+    "export",
+    "default",
+    "extends",
+    "static",
+    "break",
+    "continue",
+    "debugger",
+    "instanceof",
+    "null",
+    "true",
+    "false",
+    "undefined",
+    "get",
+    "set"
+  ]);
+  const identifierAt = (map, position) => {
+    if (position.name) {
+      return position.name;
+    }
+    const content = sourceContentFor(map, position.source);
+    const line = content?.split(`
+`)[position.line - 1];
+    const token = line?.slice(position.column ?? 0).match(/^[A-Za-z_$][\w$]*/)?.[0];
+    return token && !KEYWORDS.has(token) ? token : undefined;
+  };
+  const cleanSource = (source) => {
+    const path = source.split("?")[0];
+    const nested = path.lastIndexOf("node_modules/");
+    if (nested >= 0) {
+      return path.slice(nested + "node_modules/".length);
+    }
+    return path.replace(/^(\.\.\/)+/, "");
+  };
+  return async (error) => {
+    const passthrough = { message: error.message, stackTrace: error.stackTrace };
+    try {
+      if (!error.stackTrace?.length) {
+        return passthrough;
+      }
+      const prefix = await prefixFor(error.functionName, error.version);
+      if (!prefix) {
+        return passthrough;
+      }
+      const resolved = await Promise.all(error.stackTrace.map(async (line) => {
+        const match = FRAME.exec(line);
+        if (!match) {
+          return;
+        }
+        const [, at, caller, file, lineNo, columnNo] = match;
+        const map = await mapFor(`${prefix}${file}.map`).catch(() => {
+          return;
+        });
+        if (!map) {
+          return;
+        }
+        const position = originalPositionFor(map, {
+          line: Number(lineNo),
+          column: Number(columnNo) - 1
+        });
+        if (position.source === null || position.line === null) {
+          return;
+        }
+        const source = cleanSource(position.source);
+        return {
+          at,
+          caller,
+          location: `${source}:${position.line}:${(position.column ?? 0) + 1}`,
+          callee: identifierAt(map, { ...position, source: position.source, line: position.line })
+        };
+      }));
+      const stackTrace = error.stackTrace.map((line, index) => {
+        const frame = resolved[index];
+        if (!frame) {
+          return line;
+        }
+        const name = resolved[index + 1]?.callee ?? frame.caller;
+        return name ? `${frame.at}${name} (${frame.location})` : `${frame.at}${frame.location}`;
+      });
+      const headerType = error.stackTrace[0]?.match(/^([A-Z][\w$]*Error): /)?.[1];
+      const type = error.type === undefined || /Error$/.test(error.type) ? error.type : headerType;
+      const engineError = type === undefined || type === "TypeError" || type === "ReferenceError";
+      let message = error.message;
+      const template = engineError ? MESSAGE_TEMPLATES.exec(message) : null;
+      const firstFrame = error.stackTrace.findIndex((line) => FRAME.test(line));
+      const top = firstFrame >= 0 ? resolved[firstFrame] : undefined;
+      if (template && top?.callee) {
+        message = `${top.callee} ${template[2]}${message.slice(template[0].length)}`;
+        if (stackTrace[0] && !resolved[0] && stackTrace[0].endsWith(error.message)) {
+          stackTrace[0] = stackTrace[0].slice(0, -error.message.length) + message;
+        }
+      }
+      return { message, stackTrace };
+    } catch {
+      return passthrough;
+    }
+  };
+};
+
+// src/feature/on-error-log/server/handle.ts
 var RuntimeErrorSchema = object({
   timestamp: string(),
   level: pipe(string(), toLowerCase(), picklist(["error", "warn", "fatal"])),
@@ -43,13 +680,45 @@ var SystemErrorSchema = object({
 });
 var EventSchema = object({
   logGroup: string(),
+  logStream: optional(string()),
   logEvents: array(object({
     id: string(),
     message: string(),
     timestamp: pipe(number(), transform((v) => new Date(v)))
   }))
 });
-var createHandler = (consumer) => {
+var createAwsLoaders = async () => {
+  const { GetObjectCommand, S3Client } = await import("@aws-sdk/client-s3");
+  const s3 = new S3Client({});
+  const bucket = process.env.SOURCEMAP_BUCKET;
+  const read = async (key) => {
+    try {
+      const result = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+      return result.Body?.transformToString();
+    } catch (error) {
+      if (error.name === "NoSuchKey" || error.name === "NotFound") {
+        return;
+      }
+      throw error;
+    }
+  };
+  return {
+    loadPrefix(functionName, version) {
+      return read(formatSourcemapVersionKey(functionName, version));
+    },
+    loadMap(key) {
+      return read(key);
+    }
+  };
+};
+var createHandler = (consumer, loaders) => {
+  let symbolicator;
+  const getSymbolicator = async () => {
+    if (!symbolicator && (loaders || process.env.SOURCEMAP_BUCKET)) {
+      symbolicator = createSymbolicator(loaders ?? await createAwsLoaders());
+    }
+    return symbolicator;
+  };
   return async (event, context) => {
     try {
       const payload = Buffer.from(event.awslogs.data, "base64");
@@ -60,11 +729,38 @@ var createHandler = (consumer) => {
         return;
       }
       const origin = result.output.logGroup.split("/").pop();
+      const version = result.output.logStream?.match(/\[([^\]]+)\]/)?.[1];
       for (const logEvent of result.output.logEvents) {
         const error = parseError(logEvent.message, origin);
         if (!error) {
           continue;
         }
+        if (error.stackTrace?.length && version) {
+          try {
+            const mapper = await getSymbolicator();
+            if (mapper) {
+              const mapped = await Promise.race([
+                mapper({
+                  functionName: origin,
+                  version,
+                  type: error.type,
+                  message: error.message,
+                  stackTrace: error.stackTrace
+                }),
+                new Promise((resolve2) => setTimeout(() => resolve2(undefined), 3000))
+              ]);
+              if (mapped) {
+                const didMap = mapped.stackTrace !== error.stackTrace;
+                error.message = mapped.message;
+                error.stackTrace = mapped.stackTrace;
+                const header = mapped.stackTrace?.[0]?.match(/^([A-Z][\w$]*Error): /);
+                if (didMap && header && !/Error$/.test(error.type)) {
+                  error.type = header[1];
+                }
+              }
+            }
+          } catch {}
+        }
         const invoke = Promise.resolve().then(() => {
           return consumer({
             ...error,
@@ -72,7 +768,7 @@ var createHandler = (consumer) => {
           });
         }).catch((error2) => console.error("The on-error-log consumer failed", error2));
         const deadline = Math.max(0, context.getRemainingTimeInMillis() - 3000);
-        await Promise.race([invoke, new Promise((resolve) => setTimeout(resolve, deadline))]);
+        await Promise.race([invoke, new Promise((resolve2) => setTimeout(resolve2, deadline))]);
       }
     } catch (error) {
       console.warn("Failed to consume the error logs", error);
@@ -94,6 +790,7 @@ var parseError = (message, origin) => {
       origin = extra.route;
       delete extra.route;
     }
+    delete extra.name;
     const hash = createHash("sha256").update([origin, errorType, errorMessage, stackTrace].join("-")).digest("hex");
     return {
       hash,