@oneuptime/common 10.5.1 → 10.5.2

package/Models/DatabaseModels/TelemetryException.ts

@@ -65,6 +65,16 @@ import Service from "./Service";
   name: "TelemetryException",
 })
 @Index(["projectId", "isResolved", "isArchived"]) // Exceptions dashboard counts/filters
+/*
+ * Composite uniqueness on the dedup key used by the OTel traces ingest
+ * batched upsert. The ingest path collapses every exception event in a
+ * worker batch into a single INSERT … ON CONFLICT (projectId,
+ * serviceId, fingerprint) DO UPDATE statement; this index is what makes
+ * that conflict target resolvable and stops two concurrent workers from
+ * racing the old findOneBy + update path into duplicate rows or lost
+ * occuranceCount increments.
+ */
+@Index(["projectId", "serviceId", "fingerprint"], { unique: true })
 export default class TelemetryException extends DatabaseBaseModel {
   @ColumnAccessControl({
     create: [

package/Server/API/TelemetryAPI.ts

@@ -32,7 +32,13 @@ import TraceAggregationService, {
 import ExceptionAggregationService, {
   HistogramBucket as ExceptionHistogramBucket,
   HistogramRequest as ExceptionHistogramRequest,
+  FacetValue as ExceptionFacetValue,
+  FacetRequest as ExceptionFacetRequest,
 } from "../Services/ExceptionAggregationService";
+import MetricAggregationService, {
+  FacetValue as MetricFacetValue,
+  FacetRequest as MetricFacetRequest,
+} from "../Services/MetricAggregationService";
 import ProfileAggregationService, {
   FlamegraphRequest,
   FunctionListRequest,
@@ -55,6 +61,10 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import { JSONObject } from "../../Types/JSON";
+import ResourceFacetResolver, {
+  ResolvedFacetValue,
+  ResourceFacetSpec,
+} from "../Utils/Telemetry/ResourceFacetResolver";
 
 const router: ExpressRouter = Express.getRouter();
 
@@ -393,6 +403,18 @@ router.post(
         ? (body["attributes"] as Record<string, string>)
         : undefined;
 
+      /*
+       * Per-facet partial-match filter applied at the Postgres source-of-truth
+       * lookup stage. Only consulted for resource facets (serviceId / hostId /
+       * dockerHostId / kubernetesClusterId) — other facets continue to filter
+       * client-side over the loaded value list.
+       */
+      const facetSearchText: Record<string, string> | undefined = body[
+        "facetSearchText"
+      ]
+        ? (body["facetSearchText"] as Record<string, string>)
+        : undefined;
+
       /*
        * Capture tenantId locally so TypeScript narrowing survives the
        * async closure below (narrowing is lost across closure boundaries).
@@ -437,6 +459,40 @@ router.post(
         facetResults,
       );
 
+      /*
+       * Replace resource-facet results with the Postgres source-of-truth list
+       * (filtered by facetSearchText and enriched with displayName). See the
+       * trace facets handler above for the rationale — same pattern, same
+       * benefit: low-volume resources stay visible and search can reach
+       * resources outside the ClickHouse sample window.
+       */
+      const resourceSpecs: Array<ResourceFacetSpec> = facetKeys
+        .filter((key: string): boolean => {
+          return ResourceFacetResolver.isResourceFacet(key);
+        })
+        .map((key: string): ResourceFacetSpec => {
+          const counts: Map<string, number> = new Map();
+          for (const fv of facets[key] || []) {
+            counts.set(fv.value, fv.count);
+          }
+          return {
+            facetKey: key,
+            counts,
+            searchText: facetSearchText?.[key],
+            limit,
+          };
+        });
+
+      if (resourceSpecs.length > 0) {
+        const resolved: Record<
+          string,
+          Array<ResolvedFacetValue>
+        > = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
+        for (const key of Object.keys(resolved)) {
+          facets[key] = resolved[key] as Array<FacetValue>;
+        }
+      }
+
       return Response.sendJsonObjectResponse(req, res, {
         facets: facets as unknown as JSONObject,
       });
@@ -613,6 +669,18 @@ router.post(
         ? (body["attributes"] as Record<string, string>)
         : undefined;
 
+      /*
+       * Per-facet partial-match filter applied at the Postgres source-of-truth
+       * lookup stage. Only consulted for resource facets (serviceId / hostId /
+       * dockerHostId / kubernetesClusterId) — other facets continue to filter
+       * client-side over the loaded value list.
+       */
+      const facetSearchText: Record<string, string> | undefined = body[
+        "facetSearchText"
+      ]
+        ? (body["facetSearchText"] as Record<string, string>)
+        : undefined;
+
       /*
        * Compute all facets from a single sort-key-aligned sample query
        * (ORDER BY startTime DESC LIMIT N) and count top-K in Node. This
@@ -648,6 +716,44 @@ router.post(
         );
       }
 
+      /*
+       * Replace resource-facet results with the Postgres source-of-truth list
+       * (filtered by facetSearchText and enriched with displayName). Counts
+       * come from the ClickHouse sample above — entities with no recent
+       * telemetry surface with count 0 instead of being hidden entirely. This
+       * means low-volume services / hosts still appear in the sidebar and the
+       * search box can find resources beyond the loaded subset.
+       */
+      const resourceSpecs: Array<ResourceFacetSpec> = facetKeys
+        .filter((key: string): boolean => {
+          return ResourceFacetResolver.isResourceFacet(key);
+        })
+        .map((key: string): ResourceFacetSpec => {
+          const counts: Map<string, number> = new Map();
+          for (const fv of facets[key] || []) {
+            counts.set(fv.value, fv.count);
+          }
+          return {
+            facetKey: key,
+            counts,
+            searchText: facetSearchText?.[key],
+            limit,
+          };
+        });
+
+      if (resourceSpecs.length > 0) {
+        const resolved: Record<
+          string,
+          Array<ResolvedFacetValue>
+        > = await ResourceFacetResolver.resolve(
+          databaseProps.tenantId,
+          resourceSpecs,
+        );
+        for (const key of Object.keys(resolved)) {
+          facets[key] = resolved[key] as Array<TraceFacetValue>;
+        }
+      }
+
       return Response.sendJsonObjectResponse(req, res, {
         facets: facets as unknown as JSONObject,
       });
@@ -748,6 +854,306 @@ router.post(
   },
 );
 
+// --- Exception Facets Endpoint ---
+
+router.post(
+  "/telemetry/exceptions/facets",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const databaseProps: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!databaseProps?.tenantId) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid Project ID"),
+        );
+      }
+
+      const body: JSONObject = req.body as JSONObject;
+
+      const facetKeys: Array<string> = body["facetKeys"]
+        ? (body["facetKeys"] as Array<string>)
+        : [
+            "serviceId",
+            "hostId",
+            "dockerHostId",
+            "kubernetesClusterId",
+            "exceptionType",
+            "environment",
+          ];
+
+      const startTime: Date = body["startTime"]
+        ? OneUptimeDate.fromString(body["startTime"] as string)
+        : OneUptimeDate.addRemoveHours(OneUptimeDate.getCurrentDate(), -24);
+
+      const endTime: Date = body["endTime"]
+        ? OneUptimeDate.fromString(body["endTime"] as string)
+        : OneUptimeDate.getCurrentDate();
+
+      const limit: number = (body["limit"] as number) || 500;
+
+      const serviceIds: Array<ObjectID> | undefined = body["serviceIds"]
+        ? (body["serviceIds"] as Array<string>).map((id: string) => {
+            return new ObjectID(id);
+          })
+        : undefined;
+
+      const exceptionTypes: Array<string> | undefined = body["exceptionTypes"]
+        ? (body["exceptionTypes"] as Array<string>)
+        : undefined;
+
+      const environments: Array<string> | undefined = body["environments"]
+        ? (body["environments"] as Array<string>)
+        : undefined;
+
+      const fingerprints: Array<string> | undefined = body["fingerprints"]
+        ? (body["fingerprints"] as Array<string>)
+        : undefined;
+
+      const traceIds: Array<string> | undefined = body["traceIds"]
+        ? (body["traceIds"] as Array<string>)
+        : undefined;
+
+      const escaped: boolean | undefined =
+        body["escaped"] === undefined ? undefined : Boolean(body["escaped"]);
+
+      const messageSearchText: string | undefined = body["messageSearchText"]
+        ? (body["messageSearchText"] as string)
+        : undefined;
+
+      /*
+       * Per-facet partial-match filter applied at the Postgres source-of-truth
+       * lookup stage. Only consulted for resource facets — other facets
+       * continue to filter client-side over the loaded value list.
+       */
+      const facetSearchText: Record<string, string> | undefined = body[
+        "facetSearchText"
+      ]
+        ? (body["facetSearchText"] as Record<string, string>)
+        : undefined;
+
+      const projectId: ObjectID = databaseProps.tenantId;
+
+      /*
+       * Per-facet ClickHouse query in parallel. Per-facet errors degrade
+       * gracefully to [] so a slow / failing facet can't block the others.
+       */
+      const facetResults: Array<readonly [string, Array<ExceptionFacetValue>]> =
+        await Promise.all(
+          facetKeys.map(
+            async (
+              facetKey: string,
+            ): Promise<readonly [string, Array<ExceptionFacetValue>]> => {
+              try {
+                const request: ExceptionFacetRequest = {
+                  projectId,
+                  startTime,
+                  endTime,
+                  facetKey,
+                  limit,
+                  serviceIds,
+                  exceptionTypes,
+                  environments,
+                  fingerprints,
+                  traceIds,
+                  escaped,
+                  messageSearchText,
+                };
+                const values: Array<ExceptionFacetValue> =
+                  await ExceptionAggregationService.getFacetValues(request);
+                return [facetKey, values] as const;
+              } catch {
+                return [facetKey, [] as Array<ExceptionFacetValue>] as const;
+              }
+            },
+          ),
+        );
+
+      const facets: Record<
+        string,
+        Array<ExceptionFacetValue>
+      > = Object.fromEntries(facetResults);
+
+      /*
+       * Replace resource-facet results with the Postgres source-of-truth list
+       * (filtered by facetSearchText and enriched with displayName). Same
+       * pattern as the trace/log facets endpoints.
+       */
+      const resourceSpecs: Array<ResourceFacetSpec> = facetKeys
+        .filter((key: string): boolean => {
+          return ResourceFacetResolver.isResourceFacet(key);
+        })
+        .map((key: string): ResourceFacetSpec => {
+          const counts: Map<string, number> = new Map();
+          for (const fv of facets[key] || []) {
+            counts.set(fv.value, fv.count);
+          }
+          return {
+            facetKey: key,
+            counts,
+            searchText: facetSearchText?.[key],
+            limit,
+          };
+        });
+
+      if (resourceSpecs.length > 0) {
+        const resolved: Record<
+          string,
+          Array<ResolvedFacetValue>
+        > = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
+        for (const key of Object.keys(resolved)) {
+          facets[key] = resolved[key] as Array<ExceptionFacetValue>;
+        }
+      }
+
+      return Response.sendJsonObjectResponse(req, res, {
+        facets: facets as unknown as JSONObject,
+      });
+    } catch (err: unknown) {
+      next(err);
+    }
+  },
+);
+
+// --- Metric Facets Endpoint ---
+
+router.post(
+  "/telemetry/metrics/facets",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const databaseProps: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!databaseProps?.tenantId) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid Project ID"),
+        );
+      }
+
+      const body: JSONObject = req.body as JSONObject;
+
+      const facetKeys: Array<string> = body["facetKeys"]
+        ? (body["facetKeys"] as Array<string>)
+        : ["serviceId", "hostId", "dockerHostId", "kubernetesClusterId"];
+
+      const startTime: Date = body["startTime"]
+        ? OneUptimeDate.fromString(body["startTime"] as string)
+        : OneUptimeDate.addRemoveHours(OneUptimeDate.getCurrentDate(), -1);
+
+      const endTime: Date = body["endTime"]
+        ? OneUptimeDate.fromString(body["endTime"] as string)
+        : OneUptimeDate.getCurrentDate();
+
+      const limit: number = (body["limit"] as number) || 500;
+
+      const serviceIds: Array<ObjectID> | undefined = body["serviceIds"]
+        ? (body["serviceIds"] as Array<string>).map((id: string) => {
+            return new ObjectID(id);
+          })
+        : undefined;
+
+      const metricNames: Array<string> | undefined = body["metricNames"]
+        ? (body["metricNames"] as Array<string>)
+        : undefined;
+
+      const facetSearchText: Record<string, string> | undefined = body[
+        "facetSearchText"
+      ]
+        ? (body["facetSearchText"] as Record<string, string>)
+        : undefined;
+
+      const projectId: ObjectID = databaseProps.tenantId;
+
+      /*
+       * Per-facet ClickHouse GROUP BY in parallel. Per-facet errors degrade
+       * to [] so a slow facet doesn't block the rest.
+       */
+      const facetResults: Array<readonly [string, Array<MetricFacetValue>]> =
+        await Promise.all(
+          facetKeys.map(
+            async (
+              facetKey: string,
+            ): Promise<readonly [string, Array<MetricFacetValue>]> => {
+              try {
+                const request: MetricFacetRequest = {
+                  projectId,
+                  startTime,
+                  endTime,
+                  facetKey,
+                  limit,
+                  serviceIds,
+                  metricNames,
+                };
+                const values: Array<MetricFacetValue> =
+                  await MetricAggregationService.getFacetValues(request);
+                return [facetKey, values] as const;
+              } catch {
+                return [facetKey, [] as Array<MetricFacetValue>] as const;
+              }
+            },
+          ),
+        );
+
+      const facets: Record<
+        string,
+        Array<MetricFacetValue>
+      > = Object.fromEntries(facetResults);
+
+      /*
+       * Replace resource-facet results with the Postgres source-of-truth list
+       * (filtered by facetSearchText and enriched with displayName). Same
+       * pattern as the trace / log / exception facets endpoints.
+       */
+      const resourceSpecs: Array<ResourceFacetSpec> = facetKeys
+        .filter((key: string): boolean => {
+          return ResourceFacetResolver.isResourceFacet(key);
+        })
+        .map((key: string): ResourceFacetSpec => {
+          const counts: Map<string, number> = new Map();
+          for (const fv of facets[key] || []) {
+            counts.set(fv.value, fv.count);
+          }
+          return {
+            facetKey: key,
+            counts,
+            searchText: facetSearchText?.[key],
+            limit,
+          };
+        });
+
+      if (resourceSpecs.length > 0) {
+        const resolved: Record<
+          string,
+          Array<ResolvedFacetValue>
+        > = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
+        for (const key of Object.keys(resolved)) {
+          facets[key] = resolved[key] as Array<MetricFacetValue>;
+        }
+      }
+
+      return Response.sendJsonObjectResponse(req, res, {
+        facets: facets as unknown as JSONObject,
+      });
+    } catch (err: unknown) {
+      next(err);
+    }
+  },
+);
+
 // --- Log Analytics Endpoint ---
 
 router.post(

package/Server/Infrastructure/Postgres/SchemaMigrations/1779879993421-MigrationName.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1779879993421 implements MigrationInterface {
+    public name = 'MigrationName1779879993421'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP INDEX "public"."IDX_telemetry_exception_project_service_fingerprint"`);
+        await queryRunner.query(`ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`);
+        await queryRunner.query(`ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`);
+        await queryRunner.query(`CREATE UNIQUE INDEX "IDX_1f55d43a0b73e883bb226158c7" ON "TelemetryException" ("projectId", "serviceId", "fingerprint") `);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP INDEX "public"."IDX_1f55d43a0b73e883bb226158c7"`);
+        await queryRunner.query(`ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`);
+        await queryRunner.query(`ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`);
+        await queryRunner.query(`CREATE UNIQUE INDEX "IDX_telemetry_exception_project_service_fingerprint" ON "TelemetryException" ("projectId", "serviceId", "fingerprint") `);
+    }
+
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1779900000000-DedupeTelemetryExceptionsAndAddUniqueIndex.ts

@@ -0,0 +1,115 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * The OTel traces ingest path used to call
+ * ExceptionUtil.saveOrUpdateTelemetryException once per exception
+ * event with a findOneBy + updateOneBy/create pair, fire-and-forget,
+ * from inside the span loop. That has three problems we are fixing
+ * in tandem with this schema change:
+ *
+ *   1. Cost: each event is a Postgres round-trip. A worker batch
+ *      with thousands of exception events drives thousands of
+ *      parallel SELECT/UPDATE statements and starves the pool.
+ *   2. Lost increments: `occuranceCount = existing.occuranceCount + 1`
+ *      is read-modify-write at the JS layer, so two workers
+ *      seeing the same row at the same instant collapse to a
+ *      single +1 instead of +2.
+ *   3. Duplicate rows: two workers both missing the row at the
+ *      same time both INSERT, with no DB-level guard, producing
+ *      two TelemetryException rows for the same fingerprint.
+ *
+ * The ingest path is moving to a single batched
+ *   INSERT … ON CONFLICT ("projectId", "serviceId", "fingerprint")
+ *   DO UPDATE SET "occuranceCount" =
+ *       "TelemetryException"."occuranceCount" + EXCLUDED."occuranceCount",
+ *       ...
+ * statement per worker batch, which needs the composite unique
+ * index this migration creates. Before we can create the index we
+ * have to clear out the duplicate rows produced by the legacy race
+ * (problem 3 above) — otherwise the CREATE UNIQUE INDEX would fail
+ * on production data.
+ *
+ * Strategy: pick one survivor per (projectId, serviceId, fingerprint)
+ * group and hard-delete the rest. We do NOT try to merge
+ * occuranceCount / firstSeenAt / lastSeenAt from the losers into the
+ * survivor — the simpler delete-only approach trades a small,
+ * one-time count discrepancy on duplicated fingerprints for a much
+ * simpler migration that is easy to reason about and roll back. The
+ * next exception occurrence for that fingerprint will re-increment
+ * the survivor via the new ON CONFLICT upsert, and the dashboard
+ * recovers within seconds.
+ *
+ * Survivor selection prefers the row that was carrying the most
+ * traffic before the unique index landed, because in the legacy
+ * code path `findOneBy` returned an implementation-defined row and
+ * all subsequent UPDATEs piled into that one — discarding it would
+ * be the most lossy choice. Order is:
+ *   1. Highest occuranceCount (the "real" row absorbing updates).
+ *   2. Most recent lastSeenAt (in case counts are tied).
+ *   3. Non-deleted before deleted (live data beats soft-deleted).
+ *   4. Smallest _id as a deterministic tiebreaker so re-runs pick
+ *      the same survivor.
+ *
+ * TelemetryException is a leaf table — no other table holds an FK
+ * referencing it — so we do not need to reparent anything before
+ * deleting loser rows. NULL-fingerprint rows are left alone; the
+ * composite unique index treats NULLs as distinct, and the new
+ * ingest path never produces a NULL fingerprint anyway.
+ */
+export class DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000
+  implements MigrationInterface
+{
+  public name: string =
+    "DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // 1. Delete every row that is not the chosen survivor for its group.
+    await queryRunner.query(`
+      WITH survivors AS (
+        SELECT DISTINCT ON ("projectId", "serviceId", "fingerprint")
+          _id AS survivor_id
+        FROM "TelemetryException"
+        WHERE "fingerprint" IS NOT NULL
+        ORDER BY
+          "projectId",
+          "serviceId",
+          "fingerprint",
+          COALESCE("occuranceCount", 0) DESC,
+          "lastSeenAt" DESC NULLS LAST,
+          CASE WHEN "deletedAt" IS NULL THEN 0 ELSE 1 END,
+          _id ASC
+      )
+      DELETE FROM "TelemetryException" te
+      WHERE te."fingerprint" IS NOT NULL
+        AND te._id NOT IN (SELECT survivor_id FROM survivors)
+        AND EXISTS (
+          SELECT 1
+          FROM "TelemetryException" t2
+          WHERE t2."projectId" = te."projectId"
+            AND t2."serviceId" = te."serviceId"
+            AND t2."fingerprint" = te."fingerprint"
+            AND t2._id <> te._id
+        );
+    `);
+
+    /*
+     * 2. Create the DB-level composite unique index. Matches the
+     *    @Index decorator on TelemetryException and is the conflict
+     *    target for the batched upsert in ExceptionUtil.
+     */
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_telemetry_exception_project_service_fingerprint" ON "TelemetryException" ("projectId", "serviceId", "fingerprint") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_telemetry_exception_project_service_fingerprint"`,
+    );
+    /*
+     * The duplicate rows deleted in up() are not resurrectable from
+     * a down-migration, and recreating them is not desirable — they
+     * only existed because of a race the unique index now prevents.
+     */
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -354,6 +354,8 @@ import { AttachServiceToScheduledMaintenanceTemplatesAndLabelRules1779742211961
 import { MigrationName1779790539196 } from "./1779790539196-MigrationName";
 import { ExpandOwnerRuleInheritFlags1779823516881 } from "./1779823516881-ExpandOwnerRuleInheritFlags";
 import { RenameStatusPageZhToZhCN1779827700000 } from "./1779827700000-RenameStatusPageZhToZhCN";
+import { MigrationName1779879993421 } from "./1779879993421-MigrationName";
+import { DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000 } from "./1779900000000-DedupeTelemetryExceptionsAndAddUniqueIndex";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -711,4 +713,6 @@ export default [
   MigrationName1779790539196,
   ExpandOwnerRuleInheritFlags1779823516881,
   RenameStatusPageZhToZhCN1779827700000,
+  DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000,
+  MigrationName1779879993421
 ];