@localstack/appinspector-ui 1.0.173 → 1.0.175

package/dist/spans-worker.js

@@ -0,0 +1,242 @@
+(() => {
+  // src/types/error-levels.ts
+  var ErrorLevel = {
+    ERROR: 3,
+    // General error
+    IAM_PERMISSION: 5,
+    // IAM permission issues
+    OK: 2,
+    // OK
+    // Standard OTEL status codes
+    UNSET: 1,
+    // Unset
+    // Extended custom levels
+    WARNING: 4
+    // Warning
+  };
+
+  // src/utils/iam-utils.ts
+  function determinePermissionStatus(payload) {
+    if (payload.explicit_deny_count && payload.explicit_deny_count > 0) {
+      return "explicitly_denied";
+    }
+    if (payload.is_allowed && payload.explicit_allow_count && payload.explicit_allow_count > 0) {
+      return "explicitly_allowed";
+    }
+    if (payload.is_allowed) {
+      return "implicitly_allowed";
+    }
+    return "implicitly_denied";
+  }
+  function parseIAMEvent(payloadString) {
+    try {
+      const payload = JSON.parse(payloadString);
+      const permission = determinePermissionStatus(payload);
+      const actions = [];
+      const resources = [];
+      if (payload.explicit_allows) {
+        for (const allow of payload.explicit_allows) {
+          if (!actions.includes(allow.action)) actions.push(allow.action);
+          if (!resources.includes(allow.resource)) resources.push(allow.resource);
+        }
+      }
+      if (payload.explicit_denies) {
+        for (const deny of payload.explicit_denies) {
+          if (!actions.includes(deny.action)) actions.push(deny.action);
+          if (!resources.includes(deny.resource)) resources.push(deny.resource);
+        }
+      }
+      if (payload.implicit_denies) {
+        for (const deny of payload.implicit_denies) {
+          if (!actions.includes(deny.action)) actions.push(deny.action);
+          if (!resources.includes(deny.resource)) resources.push(deny.resource);
+        }
+      }
+      return {
+        details: {
+          actions,
+          explicitAllows: payload.explicit_allow_count,
+          explicitDenies: payload.explicit_deny_count,
+          implicitDenies: payload.implicit_deny_count,
+          resources
+        },
+        operation: payload.operation,
+        permission,
+        principal: payload.principal_arn,
+        service: payload.service
+      };
+    } catch (error) {
+      console.error("Error parsing IAM event payload:", error);
+      return void 0;
+    }
+  }
+
+  // src/utils/error-level.ts
+  var calculateHighestErrorLevel = (span) => {
+    if (span.operation_status) {
+      switch (span.operation_status) {
+        case "error": {
+          return ErrorLevel.ERROR;
+        }
+        case "iam_explicit_deny":
+        case "iam_explicit_warn":
+        case "iam_implicit_deny":
+        case "iam_implicit_warn": {
+          return ErrorLevel.IAM_PERMISSION;
+        }
+        default: {
+          return ErrorLevel.OK;
+        }
+      }
+    }
+    const hasIamDenial = span.events.some((event) => {
+      if (!event.event_type?.toLowerCase().includes("iam")) return false;
+      if (typeof event.attributes?.payload !== "string") return false;
+      const parsed = parseIAMEvent(event.attributes.payload);
+      return parsed?.permission === "explicitly_denied" || parsed?.permission === "implicitly_denied";
+    });
+    if (hasIamDenial) return ErrorLevel.IAM_PERMISSION;
+    if (span.status_code === 2) return ErrorLevel.ERROR;
+    const hasErrorInErrors = span.errors?.some((error) => error.level === "error");
+    if (hasErrorInErrors) return ErrorLevel.ERROR;
+    const hasWarning = span.errors?.some((error) => error.level === "warning");
+    if (hasWarning) return ErrorLevel.WARNING;
+    return span.status_code || ErrorLevel.UNSET;
+  };
+
+  // src/utils/spans-filters.ts
+  var EMPTY_FILTERS = {
+    consumerService: [],
+    producerService: [],
+    status: []
+  };
+  var EXTERNAL_PRODUCER_VALUE = "__external__";
+  function isFiltersEmpty(filters) {
+    return filters.consumerService.length === 0 && filters.producerService.length === 0 && filters.status.length === 0;
+  }
+  var collapseStatusValue = (status) => {
+    if (status === "iam_explicit_deny" || status === "iam_implicit_deny") return "iam_deny";
+    if (status === "iam_explicit_warn" || status === "iam_implicit_warn") return "iam_warn";
+    return status;
+  };
+  function applyFilters(spans, filters) {
+    if (isFiltersEmpty(filters)) return spans;
+    return spans.filter((span) => {
+      if (filters.consumerService.length > 0 && !filters.consumerService.includes(span.service_name)) {
+        return false;
+      }
+      if (filters.producerService.length > 0) {
+        const includesExternal = filters.producerService.includes(EXTERNAL_PRODUCER_VALUE);
+        const namedServices = filters.producerService.filter((value) => value !== EXTERNAL_PRODUCER_VALUE);
+        const matchesExternal = includesExternal && !span.parent_service_name;
+        const matchesNamed = namedServices.length > 0 && !!span.parent_service_name && namedServices.includes(span.parent_service_name);
+        if (!matchesExternal && !matchesNamed) return false;
+      }
+      if (filters.status.length > 0) {
+        if (!span.operation_status) return false;
+        if (!filters.status.includes(collapseStatusValue(span.operation_status))) return false;
+      }
+      return true;
+    });
+  }
+
+  // src/workers/spans-reducer.ts
+  var compareByStartTime = (a, b) => a.start_time_unix_nano < b.start_time_unix_nano ? -1 : 1;
+  var insertSorted = (array, item, compareFunction, hint) => {
+    let left;
+    let right;
+    if (hint === "back") {
+      left = array.length;
+      right = array.length;
+      let step = 1;
+      while (left > 0 && compareFunction(array[left - 1], item) > 0) {
+        right = left;
+        left = Math.max(0, left - step);
+        step *= 2;
+      }
+    } else {
+      left = 0;
+      right = 0;
+      let step = 1;
+      while (right < array.length && compareFunction(array[right], item) <= 0) {
+        left = right + 1;
+        right = Math.min(array.length, right + step);
+        step *= 2;
+      }
+    }
+    while (left < right) {
+      const mid = left + right >>> 1;
+      if (compareFunction(array[mid], item) <= 0) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    array.splice(left, 0, item);
+  };
+  var createSpansReducer = () => {
+    let corpus = [];
+    let filters = EMPTY_FILTERS;
+    const computeResult = () => {
+      const filtered = applyFilters(corpus, filters);
+      let errorCount = 0;
+      let warningCount = 0;
+      const orderedFilteredIds = [];
+      for (const entry of filtered) {
+        orderedFilteredIds.push(entry.span_id);
+        if (entry.errorLevel === ErrorLevel.ERROR || entry.errorLevel === ErrorLevel.IAM_PERMISSION) {
+          errorCount++;
+        } else if (entry.errorLevel === ErrorLevel.WARNING) {
+          warningCount++;
+        }
+      }
+      const producers = /* @__PURE__ */ new Set();
+      const consumers = /* @__PURE__ */ new Set();
+      const statuses = /* @__PURE__ */ new Set();
+      let hasExternalProducer = false;
+      for (const entry of corpus) {
+        if (entry.parent_service_name) producers.add(entry.parent_service_name);
+        else hasExternalProducer = true;
+        consumers.add(entry.service_name);
+        if (entry.operation_status) statuses.add(collapseStatusValue(entry.operation_status));
+      }
+      return {
+        consumerValues: [...consumers].toSorted(),
+        errorCount,
+        hasExternalProducer,
+        orderedFilteredIds,
+        producerValues: [...producers].toSorted(),
+        statusValues: [...statuses].toSorted(),
+        warningCount
+      };
+    };
+    return {
+      addPage: (direction, projections) => {
+        const hint = direction === "forward" ? "back" : "front";
+        const sorted = projections.toSorted(compareByStartTime);
+        for (const projection of sorted) {
+          insertSorted(corpus, { ...projection, errorLevel: calculateHighestErrorLevel(projection) }, compareByStartTime, hint);
+        }
+        return computeResult();
+      },
+      clear: () => {
+        corpus = [];
+        filters = EMPTY_FILTERS;
+        return computeResult();
+      },
+      setFilters: (next) => {
+        filters = next;
+        return computeResult();
+      }
+    };
+  };
+
+  // src/workers/spans-worker.worker.ts
+  var context = globalThis;
+  var reducer = createSpansReducer();
+  context.addEventListener("message", (event) => {
+    const request = event.data;
+    const result = request.op === "addPage" ? reducer.addPage(request.direction, request.projections) : request.op === "setFilters" ? reducer.setFilters(request.filters) : reducer.clear();
+    context.postMessage({ result, seq: request.seq });
+  });
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@localstack/appinspector-ui",
-  "version": "1.0.173",
+  "version": "1.0.175",
   "description": "LocalStack AppInspector UI",
   "license": "UNLICENSED",
   "type": "module",
@@ -14,7 +14,8 @@
       "types": "./dist/routes.d.ts",
       "import": "./dist/routes.js",
       "require": "./dist/routes.cjs"
-    }
+    },
+    "./spans-worker.js": "./dist/spans-worker.js"
   },
   "files": [
     "dist"