@oneuptime/common 12.0.15 → 12.0.16

package/build/dist/Server/Services/IncidentMeasurementService.js

@@ -0,0 +1,252 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentMeasurement";
+import IncidentStateService from "./IncidentStateService";
+import IncidentMeasurementAnchorType from "../../Types/Incident/IncidentMeasurementAnchorType";
+import MeasurementDefinitionValidator from "../Utils/Measurement/MeasurementDefinitionValidator";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+/*
+ * Which column each timestamp anchor actually reads. Several anchors are
+ * aliases for the same instant, so the validator compares these rather than
+ * the enum values -- otherwise a definition like "Created At -> Timeline
+ * Start" would be accepted and report a constant zero on every entity.
+ */
+const TIMESTAMP_ANCHOR_SOURCES = {
+    [IncidentMeasurementAnchorType.ImpactStartedAt]: "impactStartedAt",
+    [IncidentMeasurementAnchorType.DeclaredAt]: "declaredAt",
+    [IncidentMeasurementAnchorType.TimelineStart]: "declaredAt",
+    [IncidentMeasurementAnchorType.CreatedAt]: "createdAt",
+    [IncidentMeasurementAnchorType.PostmortemPostedAt]: "postmortemPostedAt",
+};
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    async onBeforeCreate(createBy) {
+        MeasurementDefinitionValidator.validateKey(createBy.data.key);
+        /*
+         * Derived here rather than from the slug: DatabaseService generates the
+         * slug AFTER onBeforeCreate runs, and Slug.getSlug appends ten random
+         * digits, so a slug-derived metric name would be both unavailable at
+         * this point and unreadable if it were.
+         */
+        createBy.data.metricName = Service.METRIC_NAME_PREFIX + createBy.data.key;
+        await this.validateAnchors({
+            projectId: createBy.data.projectId,
+            startAnchorType: createBy.data.startAnchorType,
+            endAnchorType: createBy.data.endAnchorType,
+            startStateId: createBy.data.startIncidentStateId,
+            endStateId: createBy.data.endIncidentStateId,
+            startStateRole: createBy.data.startIncidentStateRole,
+            endStateRole: createBy.data.endIncidentStateRole,
+            startOccurrence: createBy.data.startStateOccurrence,
+            endOccurrence: createBy.data.endStateOccurrence,
+        });
+        if (!createBy.data.order) {
+            const highest = await this.findOneBy({
+                query: { projectId: createBy.data.projectId },
+                select: { order: true },
+                sort: { order: SortOrder.Descending },
+                props: { isRoot: true },
+            });
+            createBy.data.order = ((highest === null || highest === void 0 ? void 0 : highest.order) || 0) + 1;
+        }
+        /*
+         * A definition created today must apply to incidents that already
+         * happened, or the page it appears on is empty for every closed incident
+         * forever. The backfill worker picks this stamp up.
+         */
+        createBy.data.backfillRequestedAt = OneUptimeDate.getCurrentDate();
+        return { createBy, carryForward: null };
+    }
+    async onBeforeUpdate(updateBy) {
+        /*
+         * Read as a plain record rather than Partial<Model>: the model graph is
+         * deep enough that instantiating the partial here trips the compiler's
+         * recursion limit, and every use below is a key lookup anyway.
+         */
+        const data = updateBy.data;
+        const definitionKeys = [
+            "startAnchorType",
+            "endAnchorType",
+            "startIncidentStateId",
+            "endIncidentStateId",
+            "startIncidentStateRole",
+            "endIncidentStateRole",
+            "startStateOccurrence",
+            "endStateOccurrence",
+            "isEnabled",
+        ];
+        const touchesDefinition = definitionKeys.some((key) => {
+            return Object.prototype.hasOwnProperty.call(data, key);
+        });
+        if (!touchesDefinition) {
+            return { updateBy, carryForward: null };
+        }
+        const existingItems = await this.findBy({
+            query: updateBy.query,
+            select: {
+                projectId: true,
+                startAnchorType: true,
+                endAnchorType: true,
+                startIncidentStateId: true,
+                endIncidentStateId: true,
+                startIncidentStateRole: true,
+                endIncidentStateRole: true,
+                startStateOccurrence: true,
+                endStateOccurrence: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        for (const existing of existingItems) {
+            const merged = Object.assign(Object.assign({}, existing), data);
+            await this.validateAnchors({
+                projectId: existing.projectId,
+                startAnchorType: merged["startAnchorType"],
+                endAnchorType: merged["endAnchorType"],
+                startStateId: merged["startIncidentStateId"],
+                endStateId: merged["endIncidentStateId"],
+                startStateRole: merged["startIncidentStateRole"],
+                endStateRole: merged["endIncidentStateRole"],
+                startOccurrence: merged["startStateOccurrence"],
+                endOccurrence: merged["endStateOccurrence"],
+            });
+        }
+        /*
+         * Changing what a measurement means rewrites its history in place, under
+         * the same metric point identity -- one series, one current definition.
+         * Keeping the old numbers means creating a new definition instead, which
+         * the settings page says.
+         */
+        const backfillFields = updateBy.data;
+        backfillFields.backfillRequestedAt = OneUptimeDate.getCurrentDate();
+        // Cleared, not left stale: the backfill must restart from the beginning.
+        backfillFields.backfillCursorCreatedAt = null;
+        backfillFields.backfillCompletedAt = null;
+        return { updateBy, carryForward: null };
+    }
+    async onBeforeDelete(deleteBy) {
+        const items = await this.findBy({
+            query: deleteBy.query,
+            select: { isSystemDefined: true, name: true },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        for (const item of items) {
+            if (item.isSystemDefined) {
+                throw new BadDataException(`"${item.name}" is a built-in measurement and cannot be deleted. Disable it instead.`);
+            }
+        }
+        return { deleteBy, carryForward: null };
+    }
+    /*
+     * Every measurement metric name in the project, enabled or not.
+     *
+     * Disabled definitions must stay in this list: the tombstone pass diffs
+     * live metric points against the desired set scoped to these names, so a
+     * name that is omitted keeps its points live in every chart until the
+     * retention date rather than disappearing when the user disables it.
+     */
+    async getMetricNamesForProject(projectId) {
+        const measurements = await this.findBy({
+            query: { projectId: projectId },
+            select: { metricName: true },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        return measurements
+            .map((measurement) => {
+            return measurement.metricName;
+        })
+            .filter((name) => {
+            return Boolean(name);
+        });
+    }
+    async validateAnchors(data) {
+        var _a, _b;
+        MeasurementDefinitionValidator.validateAnchorPair({
+            timestampAnchorSources: TIMESTAMP_ANCHOR_SOURCES,
+            startAnchorType: data.startAnchorType,
+            endAnchorType: data.endAnchorType,
+            stateEnteredAnchor: IncidentMeasurementAnchorType.StateEntered,
+            stateRoleEnteredAnchor: IncidentMeasurementAnchorType.StateRoleEntered,
+            startStateId: (_a = data.startStateId) === null || _a === void 0 ? void 0 : _a.toString(),
+            endStateId: (_b = data.endStateId) === null || _b === void 0 ? void 0 : _b.toString(),
+            startStateRole: data.startStateRole,
+            endStateRole: data.endStateRole,
+            startOccurrence: data.startOccurrence,
+            endOccurrence: data.endOccurrence,
+        });
+        if (data.startAnchorType !== IncidentMeasurementAnchorType.StateEntered ||
+            data.endAnchorType !== IncidentMeasurementAnchorType.StateEntered ||
+            !data.startStateId ||
+            !data.endStateId) {
+            return;
+        }
+        const states = await IncidentStateService.findBy({
+            query: { projectId: data.projectId },
+            select: { _id: true, name: true, order: true },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        const startState = states.find((state) => {
+            var _a;
+            return ((_a = state._id) === null || _a === void 0 ? void 0 : _a.toString()) === data.startStateId.toString();
+        });
+        const endState = states.find((state) => {
+            var _a;
+            return ((_a = state._id) === null || _a === void 0 ? void 0 : _a.toString()) === data.endStateId.toString();
+        });
+        MeasurementDefinitionValidator.validateStateOrder({
+            startStateName: startState === null || startState === void 0 ? void 0 : startState.name,
+            startStateOrder: startState === null || startState === void 0 ? void 0 : startState.order,
+            endStateName: endState === null || endState === void 0 ? void 0 : endState.name,
+            endStateOrder: endState === null || endState === void 0 ? void 0 : endState.order,
+        });
+    }
+}
+Service.METRIC_NAME_PREFIX = "oneuptime.incident.measurement.";
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeCreate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeUpdate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeDelete", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getMetricNamesForProject", null);
+export default new Service();
+//# sourceMappingURL=IncidentMeasurementService.js.map

package/build/dist/Server/Services/IncidentMeasurementService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncidentMeasurementService.js","sourceRoot":"","sources":["../../../../Server/Services/IncidentMeasurementService.ts"],"names":[],"mappings":"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"}

package/build/dist/Server/Services/IncidentMeasurementValueService.js

@@ -0,0 +1,413 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentMeasurementValue";
+import IncidentMeasurementService from "./IncidentMeasurementService";
+import IncidentService from "./IncidentService";
+import IncidentStateTimelineService from "./IncidentStateTimelineService";
+import IncidentMeasurementAnchorType from "../../Types/Incident/IncidentMeasurementAnchorType";
+import IncidentStateRole from "../../Types/Incident/IncidentStateRole";
+import MeasurementEvaluator from "../../Utils/Measurement/MeasurementEvaluator";
+import MeasurementMetricWriter from "../Utils/Measurement/MeasurementMetricWriter";
+import MeasurementAnchorKind from "../../Types/Measurement/MeasurementAnchorKind";
+import MeasurementOccurrence from "../../Types/Measurement/MeasurementOccurrence";
+import MeasurementStatus from "../../Types/Measurement/MeasurementStatus";
+import MetricResourceAttributeUtil from "../../Utils/Metrics/MetricResourceAttributeUtil";
+import ServiceType from "../../Types/Telemetry/ServiceType";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    /*
+     * Recomputes every measurement for one incident from scratch.
+     *
+     * This is deliberately a total function of the incident's current data: it
+     * reads the timeline and the definitions, and never reads its own previous
+     * output. That is what makes a corrected timestamp, a deleted timeline row
+     * or an edited definition converge without a repair path -- there is no
+     * accumulated state to be wrong.
+     */
+    async recomputeForIncident(data) {
+        const incident = await IncidentService.findOneById({
+            id: data.incidentId,
+            select: {
+                _id: true,
+                projectId: true,
+                createdAt: true,
+                declaredAt: true,
+                impactStartedAt: true,
+                postmortemPostedAt: true,
+                labels: { _id: true, name: true, color: true },
+                customFields: true,
+                monitors: { _id: true, name: true },
+                incidentSeverity: { _id: true, name: true },
+            },
+            props: { isRoot: true },
+        });
+        if (!incident || !incident.projectId) {
+            return;
+        }
+        const measurements = await IncidentMeasurementService.findBy({
+            query: { projectId: incident.projectId },
+            select: {
+                _id: true,
+                name: true,
+                key: true,
+                description: true,
+                metricName: true,
+                unit: true,
+                isEnabled: true,
+                startAnchorType: true,
+                endAnchorType: true,
+                startIncidentStateId: true,
+                endIncidentStateId: true,
+                startIncidentStateRole: true,
+                endIncidentStateRole: true,
+                startStateOccurrence: true,
+                endStateOccurrence: true,
+                startIncidentState: { _id: true, name: true, order: true },
+                endIncidentState: { _id: true, name: true, order: true },
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        if (measurements.length === 0) {
+            return;
+        }
+        const timeline = await this.loadTimeline(data.incidentId);
+        const specs = measurements.map((measurement) => {
+            return this.toSpec({ measurement: measurement, incident: incident });
+        });
+        const evaluations = MeasurementEvaluator.evaluate({ definitions: specs, timeline: timeline });
+        await this.persist({
+            projectId: incident.projectId,
+            incidentId: data.incidentId,
+            evaluations: evaluations,
+        });
+        await this.emitMetrics({
+            incident: incident,
+            measurements: measurements,
+            evaluations: evaluations,
+        });
+    }
+    async loadTimeline(incidentId) {
+        const timelines = await IncidentStateTimelineService.findBy({
+            query: { incidentId: incidentId },
+            select: {
+                _id: true,
+                incidentStateId: true,
+                startsAt: true,
+                incidentState: {
+                    _id: true,
+                    name: true,
+                    order: true,
+                    isCreatedState: true,
+                    isAcknowledgedState: true,
+                    isResolvedState: true,
+                },
+            },
+            sort: { startsAt: SortOrder.Ascending },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        return timelines
+            .filter((timeline) => {
+            return Boolean(timeline.startsAt);
+        })
+            .map((timeline) => {
+            var _a, _b, _c, _d, _e;
+            const roles = [];
+            if ((_a = timeline.incidentState) === null || _a === void 0 ? void 0 : _a.isCreatedState) {
+                roles.push(IncidentStateRole.Created);
+            }
+            if ((_b = timeline.incidentState) === null || _b === void 0 ? void 0 : _b.isAcknowledgedState) {
+                roles.push(IncidentStateRole.Acknowledged);
+            }
+            if ((_c = timeline.incidentState) === null || _c === void 0 ? void 0 : _c.isResolvedState) {
+                roles.push(IncidentStateRole.Resolved);
+            }
+            return {
+                id: timeline._id.toString(),
+                stateId: timeline.incidentStateId.toString(),
+                stateName: (_d = timeline.incidentState) === null || _d === void 0 ? void 0 : _d.name,
+                stateOrder: (_e = timeline.incidentState) === null || _e === void 0 ? void 0 : _e.order,
+                stateRoles: roles,
+                startsAt: timeline.startsAt,
+            };
+        });
+    }
+    toSpec(data) {
+        var _a, _b, _c, _d;
+        const { measurement, incident } = data;
+        return {
+            id: measurement._id.toString(),
+            name: measurement.name || "",
+            start: this.toAnchor({
+                anchorType: measurement.startAnchorType,
+                stateId: measurement.startIncidentStateId,
+                stateName: (_a = measurement.startIncidentState) === null || _a === void 0 ? void 0 : _a.name,
+                stateOrder: (_b = measurement.startIncidentState) === null || _b === void 0 ? void 0 : _b.order,
+                stateRole: measurement.startIncidentStateRole,
+                occurrence: measurement.startStateOccurrence,
+                incident: incident,
+            }),
+            end: this.toAnchor({
+                anchorType: measurement.endAnchorType,
+                stateId: measurement.endIncidentStateId,
+                stateName: (_c = measurement.endIncidentState) === null || _c === void 0 ? void 0 : _c.name,
+                stateOrder: (_d = measurement.endIncidentState) === null || _d === void 0 ? void 0 : _d.order,
+                stateRole: measurement.endIncidentStateRole,
+                occurrence: measurement.endStateOccurrence,
+                incident: incident,
+            }),
+        };
+    }
+    toAnchor(data) {
+        var _a;
+        const occurrence = data.occurrence || MeasurementOccurrence.First;
+        const { incident } = data;
+        switch (data.anchorType) {
+            case IncidentMeasurementAnchorType.StateEntered:
+                return {
+                    kind: MeasurementAnchorKind.StateEntered,
+                    label: data.stateName || "The chosen state",
+                    stateId: (_a = data.stateId) === null || _a === void 0 ? void 0 : _a.toString(),
+                    stateOrder: data.stateOrder,
+                    occurrence: occurrence,
+                    /*
+                     * The FK is SET NULL rather than RESTRICT, so that deleting a
+                     * state never blocks a project from reordering its states. The
+                     * measurement degrades and says why instead of throwing.
+                     */
+                    isDanglingStateReference: !data.stateId,
+                };
+            case IncidentMeasurementAnchorType.StateRoleEntered:
+                return {
+                    kind: MeasurementAnchorKind.StateRoleEntered,
+                    label: `The ${(data.stateRole || "").toLowerCase()} state`,
+                    stateRole: data.stateRole,
+                    occurrence: occurrence,
+                };
+            case IncidentMeasurementAnchorType.ImpactStartedAt:
+                return {
+                    kind: MeasurementAnchorKind.Timestamp,
+                    label: "Impact Started At",
+                    timestamp: incident.impactStartedAt,
+                    /*
+                     * Recorded by a person after the fact, so a blank value on an open
+                     * incident is still coming rather than never arriving.
+                     */
+                    canResolveAfterTerminalState: true,
+                };
+            case IncidentMeasurementAnchorType.DeclaredAt:
+                return {
+                    kind: MeasurementAnchorKind.Timestamp,
+                    label: "Declared At",
+                    timestamp: incident.declaredAt,
+                };
+            case IncidentMeasurementAnchorType.PostmortemPostedAt:
+                return {
+                    kind: MeasurementAnchorKind.Timestamp,
+                    label: "Postmortem Posted At",
+                    timestamp: incident.postmortemPostedAt,
+                    // Postmortems are posted after resolution; resolution is not the end.
+                    canResolveAfterTerminalState: true,
+                };
+            case IncidentMeasurementAnchorType.TimelineStart:
+                return {
+                    kind: MeasurementAnchorKind.Timestamp,
+                    label: "Timeline Start",
+                    /*
+                     * The origin the built-in incident metrics use, reproduced exactly
+                     * so a definition can match today's numbers rather than silently
+                     * disagreeing with them.
+                     */
+                    timestamp: incident.declaredAt || incident.createdAt,
+                };
+            case IncidentMeasurementAnchorType.CreatedAt:
+            default:
+                return {
+                    kind: MeasurementAnchorKind.Timestamp,
+                    label: "Created At",
+                    timestamp: incident.createdAt,
+                };
+        }
+    }
+    async persist(data) {
+        var _a, _b, _c, _d;
+        const existingValues = await this.findBy({
+            query: { incidentId: data.incidentId },
+            select: { _id: true, incidentMeasurementId: true },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: { isRoot: true },
+        });
+        const existingByMeasurementId = new Map();
+        for (const existingValue of existingValues) {
+            if (existingValue.incidentMeasurementId) {
+                existingByMeasurementId.set(existingValue.incidentMeasurementId.toString(), existingValue);
+            }
+        }
+        const computedAt = OneUptimeDate.getCurrentDate();
+        for (const evaluation of data.evaluations) {
+            /*
+             * Absent parts are written as NULL rather than skipped. A measurement
+             * that was Recorded and becomes Invalid after a timestamp correction
+             * must lose its old value -- leaving the previous number in place is
+             * exactly the "field that looks fine and is wrong" this feature exists
+             * to remove.
+             */
+            const fields = {
+                startedAt: ((_a = evaluation.startedAt) !== null && _a !== void 0 ? _a : null),
+                endedAt: ((_b = evaluation.endedAt) !== null && _b !== void 0 ? _b : null),
+                valueInSeconds: ((_c = evaluation.valueInSeconds) !== null && _c !== void 0 ? _c : null),
+                status: evaluation.status,
+                statusMessage: ((_d = evaluation.statusMessage) !== null && _d !== void 0 ? _d : null),
+                startIncidentStateTimelineId: (evaluation.startTimelineEntryId
+                    ? new ObjectID(evaluation.startTimelineEntryId)
+                    : null),
+                endIncidentStateTimelineId: (evaluation.endTimelineEntryId
+                    ? new ObjectID(evaluation.endTimelineEntryId)
+                    : null),
+                computedAt: computedAt,
+            };
+            const existing = existingByMeasurementId.get(evaluation.measurementId);
+            if (existing) {
+                await this.updateOneById({
+                    id: existing.id,
+                    data: fields,
+                    props: { isRoot: true },
+                });
+                continue;
+            }
+            const value = new Model();
+            value.projectId = data.projectId;
+            value.incidentId = data.incidentId;
+            value.incidentMeasurementId = new ObjectID(evaluation.measurementId);
+            value.startedAt = fields.startedAt;
+            value.endedAt = fields.endedAt;
+            value.valueInSeconds = fields.valueInSeconds;
+            value.status = fields.status;
+            value.statusMessage = fields.statusMessage;
+            value.startIncidentStateTimelineId = fields.startIncidentStateTimelineId;
+            value.endIncidentStateTimelineId = fields.endIncidentStateTimelineId;
+            value.computedAt = fields.computedAt;
+            try {
+                await this.create({ data: value, props: { isRoot: true } });
+            }
+            catch (err) {
+                /*
+                 * Two pods can recompute the same incident concurrently -- the metric
+                 * refresh's semaphore only logs on failure and proceeds unlocked --
+                 * so both can miss the row and both try to insert it. The unique key
+                 * on (incidentId, incidentMeasurementId) turns the loser into an
+                 * error; treating it as an update is the correct resolution, since
+                 * both are computing the same total function of the same data.
+                 */
+                const raced = await this.findOneBy({
+                    query: {
+                        incidentId: data.incidentId,
+                        incidentMeasurementId: new ObjectID(evaluation.measurementId),
+                    },
+                    select: { _id: true },
+                    props: { isRoot: true },
+                });
+                if (!raced) {
+                    throw err;
+                }
+                await this.updateOneById({
+                    id: raced.id,
+                    data: fields,
+                    props: { isRoot: true },
+                });
+            }
+        }
+    }
+    async emitMetrics(data) {
+        var _a, _b, _c, _d;
+        const { incident, measurements, evaluations } = data;
+        const measurementsById = new Map();
+        for (const measurement of measurements) {
+            measurementsById.set(measurement._id.toString(), measurement);
+        }
+        const points = [];
+        for (const evaluation of evaluations) {
+            const measurement = measurementsById.get(evaluation.measurementId);
+            if (!measurement || !measurement.isEnabled || !measurement.metricName) {
+                continue;
+            }
+            /*
+             * Only a Recorded value becomes a metric point. A skipped state or an
+             * unrecorded timestamp writes nothing at all rather than a zero, so a
+             * milestone nobody reached cannot drag an average towards it.
+             */
+            if (evaluation.status !== MeasurementStatus.Recorded ||
+                evaluation.valueInSeconds === undefined ||
+                !evaluation.endedAt) {
+                continue;
+            }
+            points.push({
+                metricName: measurement.metricName,
+                measurementId: evaluation.measurementId,
+                measurementKey: measurement.key || "",
+                measurementName: measurement.name || "",
+                description: measurement.description,
+                unit: measurement.unit,
+                valueInSeconds: evaluation.valueInSeconds,
+                time: evaluation.endedAt,
+            });
+        }
+        const allMetricNames = measurements
+            .map((measurement) => {
+            return measurement.metricName;
+        })
+            .filter((name) => {
+            return Boolean(name);
+        });
+        const baseAttributes = Object.assign({ incidentId: incident._id.toString(), projectId: incident.projectId.toString(), incidentSeverityId: (_b = (_a = incident.incidentSeverity) === null || _a === void 0 ? void 0 : _a._id) === null || _b === void 0 ? void 0 : _b.toString(), incidentSeverityName: (_d = (_c = incident.incidentSeverity) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.toString() }, MetricResourceAttributeUtil.getResourceAttributes({
+            labels: incident.labels,
+            customFields: incident.customFields,
+        }));
+        try {
+            await MeasurementMetricWriter.write({
+                projectId: incident.projectId,
+                primaryEntityId: incident.id,
+                primaryEntityType: ServiceType.Incident,
+                allMeasurementMetricNames: allMetricNames,
+                points: points,
+                baseAttributes: baseAttributes,
+            });
+        }
+        catch (err) {
+            /*
+             * The stored value rows are the first-class artefact and are already
+             * committed by this point. A ClickHouse outage should cost the charts,
+             * not the field on the incident.
+             */
+            logger.error(err);
+        }
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "recomputeForIncident", null);
+export default new Service();
+//# sourceMappingURL=IncidentMeasurementValueService.js.map