@oneuptime/common 12.0.2 → 12.0.4

package/Server/Services/MetricTypeService.ts

@@ -1,10 +1,94 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/MetricType";
+import ObjectID from "../../Types/ObjectID";
+import BadDataException from "../../Types/Exception/BadDataException";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { RelationMetadata } from "typeorm/metadata/RelationMetadata";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * Additively associate services with a metric type, in ONE statement.
+   *
+   * This replaces routing the association through `updateOneById` with the
+   * whole `services` array in the payload. That looked innocuous and was not:
+   * `services` is a `TableColumnType.EntityArray`, and its mere PRESENCE as a
+   * key flips `hasRelationUpdates` in DatabaseService, which routes the write
+   * to `getRepository().save()` — a real BEGIN/COMMIT that reloads the entity,
+   * loads the relation ids, bumps `version`, and DELETEs then re-INSERTs
+   * junction rows, holding the MetricType row's write lock across every one of
+   * those round trips. On the ingest path, where this runs per metric name per
+   * batch with no backpressure, it was the only multi-round-trip lock hold in
+   * the pipeline.
+   *
+   * The whole-array write was also silently LOSING data. `save()` diffs the
+   * array it is given against what is currently in the database and deletes
+   * anything missing — but each ingest worker only knows the services in ITS
+   * batch. Two workers with different batches therefore deleted each other's
+   * associations and re-inserted them on the next batch: permanent junction
+   * churn, and real service-to-metric links disappearing from the UI in
+   * between. Additive insert makes that impossible to express.
+   *
+   * ON CONFLICT DO NOTHING is well-defined here: the junction's primary key is
+   * exactly (metricTypeId, serviceId), so a concurrent writer adding the same
+   * association is a no-op rather than a unique violation.
+   */
+  @CaptureSpan()
+  public async attachServices(data: {
+    metricTypeId: ObjectID;
+    serviceIds: Array<ObjectID>;
+  }): Promise<void> {
+    if (!data.metricTypeId) {
+      throw new BadDataException("metricTypeId is required");
+    }
+
+    if (!data.serviceIds || data.serviceIds.length === 0) {
+      return;
+    }
+
+    /*
+     * Identifiers come from entity metadata, never from the caller, and every
+     * value is bound as a parameter — the same rule the other raw-SQL paths in
+     * DatabaseService follow.
+     */
+    const relation: RelationMetadata | undefined =
+      this.getRepository().metadata.findRelationWithPropertyPath("services");
+
+    const junction: string | undefined =
+      relation?.junctionEntityMetadata?.tableName;
+    const metricTypeColumn: string | undefined =
+      relation?.junctionEntityMetadata?.columns[0]?.databaseName;
+    const serviceColumn: string | undefined =
+      relation?.junctionEntityMetadata?.columns[1]?.databaseName;
+
+    if (!junction || !metricTypeColumn || !serviceColumn) {
+      throw new BadDataException(
+        "MetricTypeService.attachServices: the services relation has no junction metadata",
+      );
+    }
+
+    /*
+     * Deduplicate and SORT. Concurrent statements that insert overlapping sets
+     * acquire their row locks in the same order this way, which is what keeps
+     * two workers associating the same services from deadlocking each other.
+     */
+    const serviceIds: Array<string> = Array.from(
+      new Set(
+        data.serviceIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ),
+    ).sort();
+
+    await this.getRepository().manager.query(
+      `INSERT INTO "${junction}" ("${metricTypeColumn}", "${serviceColumn}") ` +
+        `SELECT $1, unnest($2::uuid[]) ON CONFLICT DO NOTHING`,
+      [data.metricTypeId.toString(), serviceIds],
+    );
+  }
 }
 
 export default new Service();

package/Server/Services/MonitorService.ts

@@ -15,6 +15,7 @@ import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorProbeService from "./MonitorProbeService";
 import MonitorStatusService from "./MonitorStatusService";
 import ServiceLevelObjectiveMonitorRuleEngineService from "./ServiceLevelObjectiveMonitorRuleEngineService";
+import StatusPageMonitorRuleEngineService from "./StatusPageMonitorRuleEngineService";
 import NetworkSiteService from "./NetworkSiteService";
 import MonitorStatusTimelineService, {
   MONITOR_STATUS_SAME_AS_PREVIOUS_ERROR_MESSAGE,
@@ -404,27 +405,47 @@ export class Service extends DatabaseService<Model> {
       resolveReferenceId(updateBy.data.currentMonitorStatusId) ||
       resolveReferenceId(updateBy.data.currentMonitorStatus);
 
-    if (updateBy.data.monitorSteps || currentMonitorStatusId) {
+    if (updateBy.data.monitorSteps) {
       /*
-       * Root/API updates do not always carry a tenantId, so fall back to the
-       * project of each monitor the query actually matches.
+       * Validated per matched monitor rather than per distinct project, because
+       * the check needs that monitor's CURRENT monitorSteps: a reference id it
+       * already holds is exempt from the existence check, so an update never
+       * refuses a monitor that was stored broken before the guard existed. See
+       * MonitorStepsProjectValidator.
        */
+      const monitors: Array<Model> = await this.findBy({
+        query: updateBy.query,
+        select: {
+          projectId: true,
+          monitorSteps: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+
+      for (const monitor of monitors) {
+        await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
+          monitorSteps: updateBy.data.monitorSteps as MonitorSteps | JSONObject,
+          /*
+           * Root/API updates do not always carry a tenantId, so fall back to
+           * the project of the monitor being updated.
+           */
+          projectId: updateBy.props.tenantId || monitor.projectId,
+          alreadyStoredMonitorSteps: monitor.monitorSteps,
+        });
+      }
+    }
+
+    if (currentMonitorStatusId) {
       const projectIds: Array<ObjectID> = updateBy.props.tenantId
         ? [updateBy.props.tenantId]
         : await this.getProjectIdsForUpdateQuery(updateBy);
 
       for (const projectId of projectIds) {
-        if (updateBy.data.monitorSteps) {
-          await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject(
-            {
-              monitorSteps: updateBy.data.monitorSteps as
-                | MonitorSteps
-                | JSONObject,
-              projectId: projectId,
-            },
-          );
-        }
-
         await ProjectScopedReferenceValidator.validateReferencesBelongToProject(
           {
             projectId: projectId,
@@ -644,6 +665,37 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    /*
+     * Status page monitor rules match on labels, name and description, so an
+     * edit to any of the three can pull this monitor onto a status page or
+     * push it off one. Keyed on `!== undefined` for the same reason as the SLO
+     * block above: clearing every label arrives as `[]`, and that is exactly
+     * the edit that should detach the monitor from every label-driven rule.
+     */
+    if (
+      (onUpdate.updateBy.data.labels !== undefined ||
+        onUpdate.updateBy.data.name !== undefined ||
+        onUpdate.updateBy.data.description !== undefined) &&
+      updatedItemIds.length > 0
+    ) {
+      for (const monitorId of updatedItemIds) {
+        try {
+          await StatusPageMonitorRuleEngineService.syncRulesForMonitor({
+            monitorId: monitorId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+          });
+        } catch (error) {
+          logger.error(
+            "Syncing status page monitor rules failed in MonitorService.onUpdateSuccess",
+            {
+              monitorId: monitorId?.toString(),
+            } as LogAttributes,
+          );
+          logger.error(error as Error);
+        }
+      }
+    }
+
     return onUpdate;
   }
 
@@ -1040,6 +1092,29 @@ ${createdItem.description?.trim() || "No description provided."}
         }
         return Promise.resolve();
       })
+      .then(async () => {
+        /*
+         * Also runs after the label rules above, so a monitor that only earns
+         * its labels from a MonitorLabelRule still lands on the status pages
+         * those labels imply.
+         */
+        try {
+          await StatusPageMonitorRuleEngineService.syncRulesForMonitor({
+            monitorId: createdItem.id!,
+            projectId: createdItem.projectId!,
+          });
+        } catch (error) {
+          logger.error(
+            "Syncing status page monitor rules failed in MonitorService.onCreateSuccess",
+            {
+              projectId: createdItem.projectId?.toString(),
+              monitorId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+          logger.error(error as Error);
+        }
+        return Promise.resolve();
+      })
       .then(async () => {
         try {
           return await this.refreshMonitorProbeStatus(createdItem.id!);

package/Server/Services/MonitorStatusTimelineService.ts

@@ -4,6 +4,7 @@ import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import logger, { LogAttributes } from "../Utils/Logger";
+import ProjectScopedReferenceValidator from "../Utils/Database/ProjectScopedReferenceValidator";
 import DatabaseService from "./DatabaseService";
 import MonitorService from "./MonitorService";
 import UserService from "./UserService";
@@ -191,6 +192,34 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       throw new BadDataException("monitorStatusId is null");
     }
 
+    /*
+     * Every writer of this table funnels through here, so this is the one place
+     * that can turn issue #3039's failure mode into an answer. A monitorStatusId
+     * that does not exist (or belongs to another project) used to travel all the
+     * way to Postgres and come back as
+     *   insert or update on table "MonitorStatusTimeline" violates foreign key
+     *   constraint "FK_574feb4161c5216c2c7ee0faaf8"
+     * — an opaque 500 over the API, and a job that fails and retries forever in
+     * the probe worker. Reject it here instead, naming the id.
+     *
+     * The probe/telemetry ingest callers screen the id themselves before they
+     * get here (Utils/Monitor/MonitorStatusTimeline and Utils/Monitor/MonitorResource)
+     * so a monitor whose stored criteria already point at a deleted status skip
+     * the status change rather than failing their whole run. This check is the
+     * backstop for everything else, chiefly direct API writes.
+     */
+    await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+      projectId: createBy.props.tenantId || createBy.data.projectId,
+      subject: "monitor status timeline",
+      references: [
+        {
+          modelName: "Monitor Status",
+          id: monitorStatusId,
+          service: MonitorStatusService,
+        },
+      ],
+    });
+
     const stateBeforeThis: MonitorStatusTimeline | null = await this.findOneBy({
       query: {
         monitorId: monitorId,

package/Server/Services/MonitorTemplateService.ts

@@ -1,8 +1,14 @@
 import DatabaseService from "./DatabaseService";
 import MonitorService from "./MonitorService";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import MonitorStepsProjectValidator from "../Utils/Monitor/MonitorStepsProjectValidator";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import BadDataException from "../../Types/Exception/BadDataException";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
+import { JSONObject } from "../../Types/JSON";
+import MonitorSteps from "../../Types/Monitor/MonitorSteps";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/MonitorTemplate";
@@ -37,6 +43,65 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  /*
+   * A template's monitorSteps embeds the same reference ids a monitor's does,
+   * and every one of them reaches a real monitor eventually — through "create
+   * monitor from template" and through syncLinkedMonitors, which pushes the
+   * blob onto every linked monitor. Validating it here is what makes the error
+   * land on the template the bad id was typed into, rather than on a monitor
+   * sync days later. Without this the template is the one place a dangling id
+   * can still enter the system.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
+      monitorSteps: createBy.data.monitorSteps,
+      projectId: createBy.props.tenantId || createBy.data.projectId,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    if (!updateBy.data.monitorSteps) {
+      return { updateBy, carryForward: null };
+    }
+
+    /*
+     * Per matched template, so each is checked against its own project and its
+     * own currently-stored ids — see MonitorService.onBeforeUpdate for why the
+     * stored ids matter.
+     */
+    const templates: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        projectId: true,
+        monitorSteps: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+        ignoreHooks: true,
+      },
+    });
+
+    for (const template of templates) {
+      await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
+        monitorSteps: updateBy.data.monitorSteps as MonitorSteps | JSONObject,
+        projectId: updateBy.props.tenantId || template.projectId,
+        alreadyStoredMonitorSteps: template.monitorSteps,
+      });
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
   /**
    * Count monitors created from this template.
    * Caller must already have read access on the template via the API layer.

package/Server/Services/OpenTelemetryIngestService.ts

@@ -168,6 +168,66 @@ const PROJECT_RETENTION_CACHE_TTL_SECONDS: number = 5 * 60;
 const projectRetentionInProcessCache: Map<string, CachedRetentionContext> =
   new Map();
 
+/*
+ * Everything `findOrCreateTelemetryService` needs from the Service row. Cached
+ * instead of the model itself so the payload is a flat, JSON-round-trippable
+ * shape with no TypeORM entity semantics riding along.
+ */
+interface ServiceResolution {
+  serviceId: string;
+  retainTelemetryDataForDays: number | null;
+  telemetryRetentionConfig: TelemetryRetentionConfig | null;
+}
+
+interface CachedServiceResolution {
+  resolution: ServiceResolution;
+  expiresAtMs: number;
+}
+
+/*
+ * Per-process memo for `service.name` -> Service resolution, backed by the same
+ * L1-Map + L2-Redis pair as the project retention context above.
+ *
+ * This is the hot read on the whole ingest path and it was the one ungated
+ * operation in the function. `resolveTelemetryResource` calls it once per OTLP
+ * *resource*, not per request — the shipped host-metrics collector config
+ * produces hundreds per batch — and again for every signal type a collector
+ * exports, from every ingest pod. The per-batch `serviceDictionary` in the four
+ * Otel*IngestService files cannot help: it is written AFTER this resolves and
+ * never read before it.
+ *
+ * The uncached read was also the most expensive shape it could have been.
+ * `QueryHelper.findWithSameText` emits `LOWER("Service"."name") = $2`, and the
+ * live indexes on Service are all over the RAW name column
+ * (IDX_80cd6d06b0ab8fbce9fea6d3bc on ("projectId","name")), so Postgres can use
+ * only the `projectId` prefix as an index qual and must then heap-fetch and
+ * filter every service in the project. Cost per call is O(services in project),
+ * not O(log n). The matching expression index existed once —
+ * `("projectId", LOWER("name")) WHERE "deletedAt" IS NULL` in migration
+ * 1774559064921 — and was dropped as collateral damage by autogenerated
+ * migration 1775735059360. Restoring it is a separate change; this cache is
+ * what removes the calls in the first place.
+ */
+const SERVICE_RESOLUTION_CACHE_NAMESPACE: string = "service-resolution";
+
+/*
+ * Matches the project-retention TTL deliberately: the two are read together on
+ * every resolution and there is no value in them expiring at different times.
+ *
+ * Staleness is bounded rather than invalidated, exactly as it is for project
+ * retention. A retention change made in the UI takes up to this long to affect
+ * newly ingested rows, and a service deleted in the UI keeps resolving for up
+ * to this long — which stamps `primaryEntityId` values into ClickHouse that no
+ * longer have a Postgres parent. Those rows are orphaned, not corrupt (the
+ * analytics side has no FK to Service) and they age out via retention; this is
+ * the same trade-off the dedupe migration already documents for its own
+ * ClickHouse rows. Cross-process invalidation would need pub/sub, which
+ * GlobalCache has no primitive for.
+ */
+const SERVICE_RESOLUTION_CACHE_TTL_SECONDS: number = 5 * 60;
+const serviceResolutionInProcessCache: Map<string, CachedServiceResolution> =
+  new Map();
+
 export default class OTelIngestService {
   /*
    * Read a single string-valued OTel resource attribute out of the raw
@@ -459,6 +519,114 @@ export default class OTelIngestService {
     return result;
   }
 
+  /*
+   * Normalises exactly as `QueryHelper.findWithSameText` does
+   * (`toLowerCase().trim()`). This has to stay in lockstep with that helper:
+   * if the key kept casing or surrounding whitespace that the SQL predicate
+   * folds away, two spellings of one `service.name` would occupy two cache
+   * entries pointing at the same row, and a batch could miss the entry the
+   * previous batch just wrote.
+   */
+  private static getServiceResolutionCacheKey(
+    projectId: ObjectID,
+    serviceName: string,
+  ): string {
+    return `${projectId.toString()}:${serviceName.toLowerCase().trim()}`;
+  }
+
+  private static async getCachedServiceResolution(
+    cacheKey: string,
+  ): Promise<ServiceResolution | null> {
+    const now: number = Date.now();
+
+    // L1: in-process memo. Zero network cost.
+    const memoed: CachedServiceResolution | undefined =
+      serviceResolutionInProcessCache.get(cacheKey);
+    if (memoed && memoed.expiresAtMs > now) {
+      return memoed.resolution;
+    }
+
+    // L2: Redis. Single round-trip; shared across workers.
+    try {
+      const cached: JSONObject | null = await GlobalCache.getJSONObject(
+        SERVICE_RESOLUTION_CACHE_NAMESPACE,
+        cacheKey,
+      );
+
+      /*
+       * `serviceId` is the load-bearing field — a cached entry without one
+       * cannot produce a `primaryEntityId`, so treat it as a miss and let the
+       * caller re-resolve rather than stamping rows with a broken id.
+       */
+      if (cached && cached["serviceId"]) {
+        const resolution: ServiceResolution = {
+          serviceId: String(cached["serviceId"]),
+          retainTelemetryDataForDays:
+            (cached["retainTelemetryDataForDays"] as number | null) ?? null,
+          telemetryRetentionConfig:
+            (cached[
+              "telemetryRetentionConfig"
+            ] as TelemetryRetentionConfig | null) ?? null,
+        };
+
+        serviceResolutionInProcessCache.set(cacheKey, {
+          resolution,
+          expiresAtMs: now + SERVICE_RESOLUTION_CACHE_TTL_SECONDS * 1000,
+        });
+
+        return resolution;
+      }
+    } catch (err) {
+      // Cache outage must never fail ingest. Fall through to Postgres.
+      logger.warn(
+        `Service resolution cache read failed for "${cacheKey}"; falling back to Postgres: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+
+    return null;
+  }
+
+  private static async cacheServiceResolution(
+    cacheKey: string,
+    resolution: ServiceResolution,
+  ): Promise<void> {
+    serviceResolutionInProcessCache.set(cacheKey, {
+      resolution,
+      expiresAtMs: Date.now() + SERVICE_RESOLUTION_CACHE_TTL_SECONDS * 1000,
+    });
+
+    try {
+      await GlobalCache.setJSON(
+        SERVICE_RESOLUTION_CACHE_NAMESPACE,
+        cacheKey,
+        {
+          serviceId: resolution.serviceId,
+          retainTelemetryDataForDays: resolution.retainTelemetryDataForDays,
+          telemetryRetentionConfig: (resolution.telemetryRetentionConfig ??
+            null) as unknown as JSONObject,
+        },
+        { expiresInSeconds: SERVICE_RESOLUTION_CACHE_TTL_SECONDS },
+      );
+    } catch (err) {
+      // Best-effort warm. Don't fail the request.
+      logger.warn(
+        `Service resolution cache write failed for "${cacheKey}": ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
+  private static toServiceResolution(service: Service): ServiceResolution {
+    return {
+      serviceId: service.id!.toString(),
+      retainTelemetryDataForDays: service.retainTelemetryDataForDays ?? null,
+      telemetryRetentionConfig: service.telemetryRetentionConfig ?? null,
+    };
+  }
+
   @CaptureSpan()
   private static async findOrCreateTelemetryService(data: {
     serviceName: string;
@@ -481,23 +649,38 @@ export default class OTelIngestService {
      * Stored casing is preserved: service-detail pages key telemetry by the
      * stable primaryEntityId, and the name is user-facing.
      */
-    const service: Service | null = await ServiceService.findOneBy({
-      query: {
-        projectId: data.projectId,
-        name: QueryHelper.findWithSameText(data.serviceName),
-      },
-      select: {
-        _id: true,
-        retainTelemetryDataForDays: true,
-        telemetryRetentionConfig: true,
-      },
-      sort: {
-        createdAt: SortOrder.Ascending,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
+    const resolutionCacheKey: string = this.getServiceResolutionCacheKey(
+      data.projectId,
+      data.serviceName,
+    );
+
+    let resolution: ServiceResolution | null =
+      await this.getCachedServiceResolution(resolutionCacheKey);
+
+    if (!resolution) {
+      const service: Service | null = await ServiceService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          name: QueryHelper.findWithSameText(data.serviceName),
+        },
+        select: {
+          _id: true,
+          retainTelemetryDataForDays: true,
+          telemetryRetentionConfig: true,
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (service) {
+        resolution = this.toServiceResolution(service);
+        await this.cacheServiceResolution(resolutionCacheKey, resolution);
+      }
+    }
 
     const projectContext: ProjectRetentionContext =
       await this.getProjectRetentionContext(data.projectId);
@@ -513,14 +696,16 @@ export default class OTelIngestService {
       data.serviceName,
     );
 
-    const buildMetadata: (svc: Service) => TelemetryServiceMetadata = (
-      svc: Service,
+    const buildMetadata: (
+      resolved: ServiceResolution,
+    ) => TelemetryServiceMetadata = (
+      resolved: ServiceResolution,
     ): TelemetryServiceMetadata => {
       const serviceLevelRetention: number | null =
-        svc.retainTelemetryDataForDays ?? null;
+        resolved.retainTelemetryDataForDays ?? null;
       return {
         serviceName: data.serviceName,
-        primaryEntityId: svc.id!,
+        primaryEntityId: new ObjectID(resolved.serviceId),
         primaryEntityType: ServiceType.OpenTelemetry,
         entityKeys: [serviceEntityKey],
         /*
@@ -534,14 +719,14 @@ export default class OTelIngestService {
         },
         dataRententionInDays:
           serviceLevelRetention || projectContext.projectRetentionInDays,
-        serviceRetentionConfig: svc.telemetryRetentionConfig ?? null,
+        serviceRetentionConfig: resolved.telemetryRetentionConfig ?? null,
         serviceRetentionInDays: serviceLevelRetention,
         projectRetentionConfig: projectContext.projectRetentionConfig,
         projectRetentionInDays: projectContext.projectRetentionInDays,
       };
     };
 
-    if (!service) {
+    if (!resolution) {
       try {
         const newService: Service = new Service();
         newService.projectId = data.projectId;
@@ -555,11 +740,23 @@ export default class OTelIngestService {
           },
         });
 
-        return buildMetadata(createdService);
+        const createdResolution: ServiceResolution =
+          this.toServiceResolution(createdService);
+        await this.cacheServiceResolution(
+          resolutionCacheKey,
+          createdResolution,
+        );
+
+        return buildMetadata(createdResolution);
       } catch {
         /*
          * Race condition: another request created the service concurrently.
          * Re-fetch the existing service (oldest wins, see sort above).
+         *
+         * This refetch emits SQL byte-identical to the lookup above, so it is
+         * indistinguishable from it in pg_stat_activity — caching the result
+         * here matters as much as caching it there. A first-contact stampede
+         * on a brand-new service.name is exactly when this branch runs hot.
          */
         const existingService: Service | null = await ServiceService.findOneBy({
           query: {
@@ -580,7 +777,14 @@ export default class OTelIngestService {
         });
 
         if (existingService) {
-          return buildMetadata(existingService);
+          const existingResolution: ServiceResolution =
+            this.toServiceResolution(existingService);
+          await this.cacheServiceResolution(
+            resolutionCacheKey,
+            existingResolution,
+          );
+
+          return buildMetadata(existingResolution);
         }
 
         throw new Error(
@@ -589,7 +793,7 @@ export default class OTelIngestService {
       }
     }
 
-    return buildMetadata(service);
+    return buildMetadata(resolution);
   }
 
   /*