@oneuptime/common 14.0.10 → 14.0.12

package/build/dist/Types/Monitor/MessageQueueAlertTemplates.js

@@ -0,0 +1,1207 @@
+import Includes from "../BaseDatabase/Includes";
+import MonitorStep from "./MonitorStep";
+import MonitorCriteria from "./MonitorCriteria";
+import { EvaluateOverTimeType, FilterType } from "./CriteriaFilter";
+import MonitorType from "./MonitorType";
+import RollingTime from "../RollingTime/RollingTime";
+import RollingTimeUtil from "../RollingTime/RollingTimeUtil";
+import MetricsAggregationType from "../Metrics/MetricsAggregationType";
+import MetricUnitUtil from "../../Utils/MetricUnitUtil";
+import { MESSAGE_QUEUE_METRICS, getMessageQueueMetricId, } from "../MessageQueue/MessageQueueMetricCatalog";
+import { resolveMessagingMetricDatapoint, } from "../MessageQueue/MessagingTelemetryResolver";
+import { buildMessageQueueIdentifier, toMessageQueueIdentity, } from "../MessageQueue/MessageQueueIdentity";
+import { buildHealthyCriteriaInstance, buildUnhealthyCriteriaInstance, getRecoveryFilterType, } from "./Recommendation/RecommendationCriteriaBuilder";
+/*
+ * The signals a static "at or above" threshold means something for (see
+ * WHICH METRICS GET A TEMPLATE in the header). published, consumed and
+ * consumers are the rest of MessageQueueSignal.
+ */
+export const MESSAGE_QUEUE_THRESHOLDABLE_SIGNALS = [
+    "backlog",
+    "consumerLag",
+    "oldestMessageAge",
+    "deadLetter",
+    "errors",
+    "throttled",
+];
+export function getMessageQueueAlertMeasure(descriptor) {
+    return descriptor.aggregation === MetricsAggregationType.Sum
+        ? "count"
+        : "level";
+}
+export const MESSAGE_QUEUE_ALERT_POLICIES = [
+    /*
+     * A thousand messages held for ten minutes. A work queue that keeps up
+     * drains to near empty between bursts, so a thousand waiting messages
+     * that do not go away within ten minutes means the queue fills faster
+     * than it drains, or nothing drains it; a burst that drains inside the
+     * window never fires. For the brokers that track each message
+     * (RabbitMQ, ActiveMQ, SQS, Service Bus, Pub/Sub subscriptions) and the
+     * ready count of RocketMQ and Pulsar's topic backlog.
+     */
+    {
+        signal: "backlog",
+        measure: "level",
+        threshold: 1000,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AllValues,
+        rollingTime: RollingTime.Past10Minutes,
+        severity: "Warning",
+        category: "Backlog",
+        nameSuffix: "High",
+        metricAlias: "queue_backlog",
+        meaning: "Messages are arriving faster than consumers take them, or nothing is consuming them. A healthy queue drains to near empty between bursts, so retune to a few times this queue's normal peak.",
+        incidentDescription: "Messages are piling up in the queue. Check that its consumers are running and connected, whether they are failing and returning messages to the queue, and whether they need more instances to keep up with the publish rate.",
+    },
+    /*
+     * Ten thousand messages held for ten minutes — ten times the backlog
+     * default, because a consumer group's lag is measured against the offset
+     * it last COMMITTED: a healthy Kafka consumer commits every few seconds
+     * (five by default), so on a topic taking a few thousand messages a
+     * second it trails by thousands between commits, all the time. The same
+     * default serves Pulsar's subscription backlog and RocketMQ's lag, the
+     * other log-based brokers.
+     */
+    {
+        signal: "consumerLag",
+        measure: "level",
+        threshold: 10000,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AllValues,
+        rollingTime: RollingTime.Past10Minutes,
+        severity: "Warning",
+        category: "Consumer Lag",
+        nameSuffix: "High",
+        metricAlias: "consumer_lag",
+        meaning: "Consumers are falling behind what is produced. A healthy consumer group that commits its offsets every few seconds already trails a busy topic by thousands of messages, so retune to a few times this topic's normal lag.",
+        incidentDescription: "The consumer group is falling behind its producers. Check that every consumer is running and not stuck rebalancing, whether one partition is stuck on a message its consumer cannot process, and whether the group needs more consumers (up to one per partition).",
+    },
+    /*
+     * Ten minutes of waiting, held for five. A consumer that keeps up takes a
+     * message within seconds, so a message ten minutes old means consumers
+     * are stopped or far behind, or keep failing on one message that is
+     * received and returned until its dead-letter policy moves it aside. An
+     * age already is a duration, so a shorter sustain (five minutes) is
+     * enough to ignore one late sample.
+     */
+    {
+        signal: "oldestMessageAge",
+        measure: "level",
+        threshold: 600,
+        thresholdUnit: "s",
+        evaluation: EvaluateOverTimeType.AllValues,
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Warning",
+        category: "Message Age",
+        nameSuffix: "High",
+        metricAlias: "oldest_message_age",
+        meaning: "Messages are waiting far longer than a working consumer takes: consumers are stopped or far behind, or keep failing on a message that is received and returned again and again. Retune to how long a message may wait before it is late.",
+        incidentDescription: "The oldest message has waited longer than a working consumer takes. Check that consumers are running; a message that fails every time it is processed is received and returned until the dead-letter policy moves it aside, so look at its receive count.",
+    },
+    /*
+     * Any dead-lettered message, held for five minutes: each one failed
+     * every delivery attempt and waits for a person. It stays open until
+     * the dead-letter queue is drained, which is the point.
+     */
+    {
+        signal: "deadLetter",
+        measure: "level",
+        threshold: 1,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AllValues,
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Warning",
+        category: "Dead Letters",
+        nameSuffix: "",
+        metricAlias: "dead_letters",
+        meaning: "Messages that failed every delivery attempt are waiting in the dead-letter queue for someone to inspect them. Raise the threshold if the dead-letter queue is drained on a schedule.",
+        incidentDescription: "Messages failed every delivery attempt and were moved to the dead-letter queue. Inspect them to find the failing handler or the malformed payload, fix the cause, then resubmit or discard them.",
+    },
+    // Any message dead-lettered in any one minute.
+    {
+        signal: "deadLetter",
+        measure: "count",
+        threshold: 1,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AnyValue,
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Warning",
+        category: "Dead Letters",
+        nameSuffix: "",
+        metricAlias: "dead_letters",
+        meaning: "Messages are being moved to a dead-letter queue after failing every delivery attempt.",
+        incidentDescription: "Messages failed every delivery attempt and were moved to a dead-letter queue. Inspect them to find the failing handler or the malformed payload, fix the cause, then resubmit or discard them.",
+    },
+    /*
+     * Ten in any one minute. Clients retry a failed request and brokers
+     * redeliver a failed message, so one failure goes unnoticed; ten in a
+     * minute is a pattern, not a blip.
+     */
+    {
+        signal: "errors",
+        measure: "count",
+        threshold: 10,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AnyValue,
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Warning",
+        category: "Errors",
+        nameSuffix: "",
+        metricAlias: "failures",
+        meaning: "Failures are recurring rather than occasional: clients retry a failed request and brokers redeliver a failed message, so a single failure goes unnoticed, while a burst like this is a pattern, not a blip. Retune to this queue's volume.",
+        incidentDescription: "Operations on the queue are failing. The broker's own diagnostics name the operation and the error: failures the broker causes point at the service itself (check its health status), while failures its clients cause usually follow a deployment, a credential or permission change, a consumer that crashes on a message, or an entity that was deleted or disabled.",
+    },
+    /*
+     * Ten in any one minute: a throttled client backs off before it retries,
+     * so a few throttled requests at a peak are absorbed, while ten a minute
+     * means the namespace is out of capacity.
+     */
+    {
+        signal: "throttled",
+        measure: "count",
+        threshold: 10,
+        thresholdUnit: null,
+        evaluation: EvaluateOverTimeType.AnyValue,
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Warning",
+        category: "Throttling",
+        nameSuffix: "",
+        metricAlias: "throttled_requests",
+        meaning: "The broker is refusing requests because the namespace is out of capacity, and every throttled client backs off before it retries, which slows everything on the namespace. If it persists, add capacity (Service Bus Premium messaging units, Event Hubs throughput or processing units).",
+        incidentDescription: "The broker is throttling requests because the namespace is out of capacity. Look for a traffic spike or a new heavy client; if throttling persists, scale the namespace up.",
+    },
+];
+export const MESSAGE_QUEUE_ALERT_POLICY_OVERRIDES = [
+    {
+        system: "aws_sqs",
+        metricNames: [
+            "amazonaws.com/aws/sqs/approximatenumberofmessagesnotvisible",
+            "approximatenumberofmessagesnotvisible",
+        ],
+        /*
+         * 90% of the in-flight quota of a standard queue (about 120,000
+         * messages received but not yet deleted): early enough to act before
+         * receives start failing, and far above what a busy queue that is
+         * draining keeps in flight.
+         */
+        threshold: 108000,
+        /*
+         * Critical, and held for five minutes rather than a backlog's ten: the
+         * last 10% of the quota is what stands between the queue and receives
+         * that fail.
+         */
+        rollingTime: RollingTime.Past5Minutes,
+        severity: "Critical",
+        name: "Messages In Flight Near Quota",
+        meaning: "A standard queue keeps about 120,000 messages in flight (received but not yet deleted) at most; past that, short-polling receives fail with OverLimit and long polls return nothing, so every consumer stalls. This fires at 90% of that quota; for a FIFO queue, retune to 90% of its own quota.",
+        incidentDescription: "Close to 120,000 messages are received but not yet deleted, so receives are about to fail. Check that consumers delete messages once they have processed them, and whether a long visibility timeout keeps failed messages in flight.",
+        reason: "Messages in flight are not a backlog: a busy queue keeps thousands in flight while it drains, and the one level that matters is the queue's in-flight quota.",
+    },
+    {
+        system: "aws_sqs",
+        metricNames: [
+            "amazonaws.com/aws/sqs/approximateageofoldestmessage",
+            "approximateageofoldestmessage",
+        ],
+        recoverOnNoData: true,
+        reason: "CloudWatch reports this metric only while the queue holds a message, so a silent window is an empty queue: recovery reads it as an age of zero.",
+    },
+];
+/*
+ * Catalog gauges with a thresholdable signal that deliberately get no
+ * template. The queue page still charts them, and its "Create monitor" link
+ * still builds a monitor on them for a team that wants one.
+ */
+export const UNTEMPLATED_MESSAGE_QUEUE_GAUGES = [
+    {
+        system: "kafka",
+        metricName: "kafka.consumer_group.lag",
+        reason: "Every partition's lag is part of its consumer group's lag, so at Consumer lag's threshold it could only fire after that template has, and no fixed lower threshold tells one stuck partition from a busy one: a healthy group that commits every few seconds trails each busy partition by thousands of messages.",
+    },
+    {
+        system: "activemq",
+        metricName: "activemq.message.enqueue.average_duration",
+        reason: "It is a running average the broker keeps from its start (AverageEnqueueTime), so after one stall it stays high long after the destination has drained, and on a destination with a long history a new stall barely moves it: a threshold on it fires late and does not clear. Queue size catches a stall directly.",
+    },
+    {
+        system: "activemq",
+        metricName: "activemq.message.wait_time.avg",
+        reason: "It is the same running average the broker keeps from its start (AverageEnqueueTime), under the JMX Scraper's legacy name, so a threshold on it fires late and does not clear. Queue size (legacy names) catches a stall directly.",
+    },
+    {
+        system: "pulsar",
+        metricName: "pulsar_storage_backlog_age_seconds",
+        reason: "It read -1 (unknown) on topics that held a backlog in a live capture from Pulsar 4.2.4 on its default configuration, so a threshold on it would watch nothing there. Subscription backlog catches a subscription that stopped acknowledging.",
+    },
+];
+/*
+ * What each counter would be tempting to alert on, by signal: the catalog
+ * marks every cumulative total `kind: "counter"`, and the monitor path has
+ * no rate to threshold it with.
+ */
+const COUNTER_TEMPTATION_BY_SIGNAL = {
+    published: "publishing stopping or spiking",
+    consumed: "consumers stopping",
+    errors: "a rise in failed or expired messages",
+    deadLetter: "messages being dead-lettered",
+    backlog: "a growing backlog",
+    consumerLag: "a growing lag",
+    oldestMessageAge: "messages getting old",
+    throttled: "throttling",
+    consumers: "consumers leaving",
+};
+/*
+ * Every catalog counter, which no template reads, and what a team would
+ * reach for it for. The honest workaround for a team that needs one alerted
+ * today is a `cumulative_to_delta` processor in its collector pipeline
+ * (`cumulativetodelta`, its old name, is a deprecated alias in
+ * collector-contrib 0.161.0) converting a COPY of the counter, made under a
+ * name of its own, into per-scrape deltas that a Sum over the window
+ * thresholds correctly; `initial_value: drop` keeps back the copy's first
+ * point after a collector start, the counter's whole running total. The
+ * config is at /docs/telemetry/queues#alerting. Never convert the counter
+ * itself: the queue page reads each counter as a running total and charts
+ * how fast it grows, so a counter converted in place charts about 0/s for
+ * steady traffic. The processor only converts sums, so it leaves Kafka's
+ * offsets and Pulsar's totals, which reach the collector as gauges, as they
+ * are.
+ */
+export const UNALERTABLE_MESSAGE_QUEUE_COUNTERS = MESSAGE_QUEUE_METRICS.filter((descriptor) => {
+    return descriptor.kind === "counter";
+}).map((descriptor) => {
+    return {
+        system: descriptor.system,
+        metricName: descriptor.metricName,
+        wouldAlertOn: COUNTER_TEMPTATION_BY_SIGNAL[descriptor.signal],
+    };
+});
+export const MESSAGE_QUEUE_SOURCE_WINDOW_FLOORS = [
+    {
+        receiver: "aws_cloudwatch",
+        /*
+         * The newest point is up to delay + 2 × period + collection_interval
+         * old: 17 minutes under the documented configuration, 25 under the
+         * receiver's defaults. Thirty is the shortest RollingTime above both.
+         */
+        minimumRollingTime: RollingTime.Past30Minutes,
+        reason: "The collector's `aws_cloudwatch` receiver fetches CloudWatch's periods `delay` (ten minutes) after they end, `collection_interval` (five minutes) at a time, so its points arrive 11 to 17 minutes late, and up to 25 minutes late with the receiver's default five-minute `period`: the window is thirty minutes so that it always holds some.",
+    },
+    {
+        receiver: "googlecloudmonitoring",
+        /*
+         * A sample arrives up to ingestDelay + collection_interval late: nine
+         * minutes for dead_letter_message_count (240 seconds) with the
+         * receiver's default five-minute interval, and the next one-minute
+         * evaluation reads it up to ten minutes after it was taken — the very
+         * edge of a Past10Minutes window, which any export delay tips over.
+         * Fifteen leaves a margin.
+         */
+        minimumRollingTime: RollingTime.Past15Minutes,
+        reason: "Cloud Monitoring makes a Pub/Sub sample visible two to four minutes after it is taken, and the collector's `googlecloudmonitoring` receiver fetches what has become visible once per `collection_interval`, so a point arrives up to nine minutes late with the receiver's default five-minute interval: the window is fifteen minutes so that it always holds some and reads every point.",
+    },
+];
+/**
+ * The window floor of a catalog entry's source, or null when its points
+ * arrive live.
+ */
+export function getMessageQueueSourceWindowFloor(descriptor) {
+    if (!descriptor) {
+        return null;
+    }
+    for (const floor of MESSAGE_QUEUE_SOURCE_WINDOW_FLOORS) {
+        if (floor.receiver === descriptor.receiver) {
+            return floor;
+        }
+    }
+    return null;
+}
+function getRollingTimeSeconds(rollingTime) {
+    const window = RollingTimeUtil.convertToStartAndEndDate(rollingTime);
+    return (window.endValue.getTime() - window.startValue.getTime()) / 1000;
+}
+/**
+ * The window a monitor on this catalog entry reads: `preferred`, widened to
+ * the entry's source floor when that is longer. The templates read their
+ * signal's window through it, and the "Create monitor" link its default.
+ */
+export function getMessageQueueMetricMonitorRollingTime(descriptor, preferred) {
+    const floor = getMessageQueueSourceWindowFloor(descriptor);
+    if (floor &&
+        getRollingTimeSeconds(floor.minimumRollingTime) >
+            getRollingTimeSeconds(preferred)) {
+        return floor.minimumRollingTime;
+    }
+    return preferred;
+}
+export const MESSAGE_QUEUE_SERIES_TOTALS = [
+    {
+        system: "rabbitmq",
+        metricName: "rabbitmq.message.current",
+        seriesKey: "state",
+        values: ["ready", "unacknowledged"],
+        reason: "The rabbitmq receiver records both states of every queue on every scrape, under the scrape's one timestamp (collectQueue in receiver/rabbitmqreceiver scraper.go@v0.161.0), so the average of each state over a bucket, added together, is the queue's average depth.",
+    },
+];
+function getSeriesTotalDefinition(descriptor) {
+    const seriesKeys = descriptor.seriesKeys || [];
+    for (const definition of MESSAGE_QUEUE_SERIES_TOTALS) {
+        if (definition.system === descriptor.system &&
+            definition.metricName === descriptor.metricName &&
+            seriesKeys.length === 1 &&
+            seriesKeys[0] === definition.seriesKey) {
+            return definition;
+        }
+    }
+    return null;
+}
+// --- the shared query builder (templates and the "Create monitor" link) ---
+/*
+ * Whether a monitor can evaluate this catalog entry at all: a gauge, whose
+ * series are all part of the queue. A counter only grows (see the header),
+ * and an entry with `excludeSeriesWithAttributes` needs "this attribute is
+ * absent" to leave out its finer-grained repeats, which an equality filter
+ * cannot say — both are refused rather than built into a monitor that
+ * compares the wrong number.
+ */
+export function isMessageQueueMetricMonitorable(descriptor) {
+    if (!descriptor || descriptor.kind !== "gauge") {
+        return false;
+    }
+    return !(descriptor.excludeSeriesWithAttributes &&
+        descriptor.excludeSeriesWithAttributes.length > 0);
+}
+function aggregationLabel(aggregationType) {
+    return aggregationType === MetricsAggregationType.Avg
+        ? "Average"
+        : String(aggregationType);
+}
+/**
+ * The query shape that evaluates what the queue page shows for this entry
+ * (see AGGREGATION CONTRACT in the header), or null for an entry no monitor
+ * can evaluate (isMessageQueueMetricMonitorable).
+ */
+export function getMessageQueueMetricMonitorSeed(descriptor) {
+    if (!isMessageQueueMetricMonitorable(descriptor)) {
+        return null;
+    }
+    const aggregation = descriptor.aggregation;
+    const seriesKeys = [...(descriptor.seriesKeys || [])];
+    const floor = getMessageQueueSourceWindowFloor(descriptor);
+    const shape = getMonitorShape({
+        descriptor: descriptor,
+        aggregation: aggregation,
+        seriesKeys: seriesKeys,
+    });
+    return Object.assign(Object.assign({}, shape), { minimumRollingTime: floor ? floor.minimumRollingTime : null });
+}
+function getMonitorShape(data) {
+    const aggregation = data.aggregation;
+    const seriesKeys = data.seriesKeys;
+    switch (data.descriptor.seriesCombine) {
+        case "max":
+            if (aggregation === MetricsAggregationType.Sum) {
+                /*
+                 * A per-period count: the Sum of a bucket is one series' count for
+                 * its period, never Max, which on a CloudWatch Summary reads the
+                 * period's Average (see AGGREGATION CONTRACT). With series keys, the
+                 * worst series crossing is the highest one crossing.
+                 */
+                return {
+                    aggregationType: MetricsAggregationType.Sum,
+                    groupByAttributeKeys: seriesKeys,
+                    seriesTotal: null,
+                    note: seriesKeys.length > 0
+                        ? `The chart shows the highest of this metric's series (one per ${seriesKeys.join(" / ")}). A monitor would add them up, so this one alerts on each series separately, which fires exactly when the highest one crosses the threshold.`
+                        : null,
+                };
+            }
+            return {
+                aggregationType: MetricsAggregationType.Max,
+                groupByAttributeKeys: [],
+                seriesTotal: null,
+                note: aggregation === MetricsAggregationType.Max
+                    ? null
+                    : `The chart shows the highest of this metric's series. A monitor folds every series and sample into one number, so this one takes their Max instead of each series' ${aggregationLabel(aggregation)}.`,
+            };
+        case "avg":
+            return {
+                aggregationType: aggregation,
+                groupByAttributeKeys: [],
+                seriesTotal: null,
+                note: null,
+            };
+        default: {
+            // "sum".
+            if (aggregation === MetricsAggregationType.Sum) {
+                return {
+                    aggregationType: MetricsAggregationType.Sum,
+                    groupByAttributeKeys: [],
+                    seriesTotal: null,
+                    note: null,
+                };
+            }
+            const total = getSeriesTotalDefinition(data.descriptor);
+            if (total) {
+                // The page's own total: one query per part, added up by a formula.
+                return {
+                    aggregationType: aggregation,
+                    groupByAttributeKeys: [],
+                    seriesTotal: { key: total.seriesKey, values: [...total.values] },
+                    note: null,
+                };
+            }
+            return {
+                aggregationType: aggregation,
+                groupByAttributeKeys: seriesKeys,
+                seriesTotal: null,
+                note: seriesKeys.length > 0
+                    ? `The chart adds this metric's series up (one per ${seriesKeys.join(" / ")}). They are not a fixed set, so a monitor cannot add them together the way the chart does: this one alerts on each series separately. Set a threshold for one series, not for the total.`
+                    : null,
+            };
+        }
+    }
+}
+/**
+ * Every stored key a monitor filter on this entry can pin: its destination,
+ * broker-scope and required attributes. The attributes a series of the
+ * metric has to be read with to build its filter.
+ */
+export function getMessageQueueMetricFilterAttributeKeys(descriptor) {
+    const keys = [];
+    for (const key of [
+        ...descriptor.destinationAttributes,
+        ...(descriptor.scopeAttributes || []),
+        ...Object.keys(descriptor.requiredAttributes || {}),
+    ]) {
+        if (!keys.includes(key)) {
+            keys.push(key);
+        }
+    }
+    return keys;
+}
+function readObserved(series, key) {
+    return Object.prototype.hasOwnProperty.call(series, key)
+        ? series[key]
+        : undefined;
+}
+/*
+ * The text a value is stored as, which is what an equality filter has to
+ * match: a string exactly as it is — surrounding whitespace included — and a
+ * number or boolean as its String() form. Null for a value that is absent,
+ * blank or not a scalar, which the resolver does not read a destination,
+ * scope or required value from either.
+ */
+function observedText(value) {
+    let text = null;
+    if (typeof value === "string") {
+        text = value;
+    }
+    else if (typeof value === "number") {
+        text = Number.isFinite(value) ? String(value) : null;
+    }
+    else if (typeof value === "boolean" || typeof value === "bigint") {
+        text = String(value);
+    }
+    return text !== null && text.trim().length > 0 ? text : null;
+}
+/*
+ * The (key, stored value) pairs that pin one series to its queue: the first
+ * destination key with a value (the resolver's own "first non-empty wins"),
+ * the first broker-scope key with one, and every required key. Null when the
+ * series lacks a destination or a required attribute.
+ */
+function getSeriesFilter(descriptor, series) {
+    const firstWithValue = (keys) => {
+        for (const key of keys) {
+            const text = observedText(readObserved(series, key));
+            if (text !== null) {
+                return [key, text];
+            }
+        }
+        return null;
+    };
+    const destination = firstWithValue(descriptor.destinationAttributes);
+    if (!destination) {
+        return null;
+    }
+    const entries = [destination];
+    const scope = descriptor.scopeAttributes
+        ? firstWithValue(descriptor.scopeAttributes)
+        : null;
+    if (scope) {
+        entries.push(scope);
+    }
+    for (const key of Object.keys(descriptor.requiredAttributes || {})) {
+        const text = observedText(readObserved(series, key));
+        if (text === null) {
+            return null;
+        }
+        entries.push([key, text]);
+    }
+    return entries;
+}
+/*
+ * The identifier of the queue a series of this entry belongs to, through the
+ * same resolver ingest stamps entity keys with — or null when the series
+ * resolves to nothing, or to another system's entry (a Service Bus name
+ * observed on an Event Hubs series).
+ */
+function getSeriesQueueIdentifier(descriptor, series) {
+    const resolved = resolveMessagingMetricDatapoint({
+        metricName: descriptor.metricName,
+        getAttribute: (key) => {
+            return readObserved(series, key);
+        },
+    });
+    if (!resolved || resolved.system !== descriptor.system) {
+        return null;
+    }
+    const identity = toMessageQueueIdentity({
+        system: resolved.system,
+        brokerScope: resolved.brokerScope,
+        destination: resolved.destination,
+    });
+    return identity ? buildMessageQueueIdentifier(identity) : null;
+}
+/**
+ * The metric monitor query that watches one queue through one catalog
+ * entry, built from the stored attributes of the series observed for it —
+ * the code path the queue page's "Create monitor" link and getMonitorStep
+ * share. Null when the entry cannot be monitored
+ * (isMessageQueueMetricMonitorable) or no observed series resolves to the
+ * queue.
+ *
+ * A series is used only when the resolver maps it to the queue under this
+ * entry — `identity`'s queue when given, else the first series that
+ * resolves — and when it pins the same keys as the first series used (one
+ * spelling of Azure's entity key, not two: an AND of equalities cannot say
+ * "this key or that one"). Values are kept exactly as stored, and a key the
+ * used series disagree on (a Pulsar topic's partitions) becomes an Includes
+ * of every value, sorted. A queue whose destination is templated from many
+ * raw names (a UUID) is watched under the names observed.
+ */
+export function buildMessageQueueMetricMonitorQuery(data) {
+    if (!data || !data.descriptor) {
+        return null;
+    }
+    const descriptor = data.descriptor;
+    const seed = getMessageQueueMetricMonitorSeed(descriptor);
+    if (!seed) {
+        return null;
+    }
+    let queueIdentifier = null;
+    if (data.identity) {
+        queueIdentifier = buildMessageQueueIdentifier(data.identity);
+        if (!queueIdentifier) {
+            return null;
+        }
+    }
+    let keys = null;
+    const valuesByKey = new Map();
+    const observedSeries = Array.isArray(data.observedSeries)
+        ? data.observedSeries
+        : [];
+    for (const candidate of observedSeries) {
+        if (!candidate ||
+            typeof candidate !== "object" ||
+            Array.isArray(candidate)) {
+            continue;
+        }
+        const series = candidate;
+        const entries = getSeriesFilter(descriptor, series);
+        if (!entries) {
+            continue;
+        }
+        const identifier = getSeriesQueueIdentifier(descriptor, series);
+        if (!identifier) {
+            continue;
+        }
+        if (queueIdentifier === null) {
+            queueIdentifier = identifier;
+        }
+        else if (identifier !== queueIdentifier) {
+            continue;
+        }
+        const seriesKeys = entries.map((entry) => {
+            return entry[0];
+        });
+        if (keys === null) {
+            keys = seriesKeys;
+        }
+        else if (keys.join("\n") !== seriesKeys.join("\n")) {
+            continue;
+        }
+        for (const [key, value] of entries) {
+            const values = valuesByKey.get(key) || [];
+            if (!values.includes(value)) {
+                values.push(value);
+            }
+            valuesByKey.set(key, values);
+        }
+    }
+    if (keys === null) {
+        return null;
+    }
+    const attributes = {};
+    for (const key of keys) {
+        const values = [...(valuesByKey.get(key) || [])].sort();
+        attributes[key] = values.length === 1 ? values[0] : new Includes(values);
+    }
+    return {
+        metricId: getMessageQueueMetricId(descriptor),
+        metricName: descriptor.metricName,
+        attributes: attributes,
+        aggregationType: seed.aggregationType,
+        groupByAttributeKeys: [...seed.groupByAttributeKeys],
+        seriesTotal: seed.seriesTotal
+            ? { key: seed.seriesTotal.key, values: [...seed.seriesTotal.values] }
+            : null,
+        unit: descriptor.unit,
+    };
+}
+// "unacknowledged" → "unacknowledged"; any other character → "_".
+function toAliasPart(value) {
+    return (value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "") || "part");
+}
+// A copy, so a config edited in the explorer never edits the query.
+function copyAttributes(attributes) {
+    const copy = {};
+    for (const key of Object.keys(attributes)) {
+        const value = attributes[key];
+        if (value instanceof Includes) {
+            copy[key] = new Includes([...value.values]);
+        }
+        else if (value !== undefined) {
+            copy[key] = value;
+        }
+    }
+    return copy;
+}
+function buildQueryConfig(data) {
+    const query = data.query;
+    return {
+        metricAliasData: {
+            metricVariable: data.metricVariable,
+            title: data.title,
+            description: data.description,
+            legend: data.title,
+            legendUnit: query.unit || undefined,
+        },
+        metricQueryData: Object.assign({ filterData: {
+                metricName: query.metricName,
+                attributes: data.attributes,
+                aggegationType: query.aggregationType,
+                aggregateBy: {},
+            } }, (query.groupByAttributeKeys.length > 0
+            ? { groupByAttributeKeys: [...query.groupByAttributeKeys] }
+            : {})),
+    };
+}
+/**
+ * The metric monitor view for a queue query — what the "Create monitor"
+ * link pre-seeds Monitor Create with, and what getMonitorStep builds: the
+ * exact filters, the fold, the grouping, and the catalog's unit as the legend
+ * unit. A plain query is one query config, aliased `metricVariable`. A
+ * series total is one query per part, each also filtered on its value and
+ * aliased `<metricVariable>_<value>`, plus the formula adding them up,
+ * aliased `metricVariable` — the alias a criteria compares either way.
+ * `metricVariable` must be a formula identifier (letters, digits, "_").
+ */
+export function buildMessageQueueMetricMonitorViewConfig(data) {
+    const query = data.query;
+    const description = data.description || data.title;
+    const total = query.seriesTotal;
+    if (!total || total.values.length === 0) {
+        return {
+            metricViewConfig: {
+                queryConfigs: [
+                    buildQueryConfig({
+                        query: query,
+                        attributes: copyAttributes(query.attributes),
+                        metricVariable: data.metricVariable,
+                        title: data.title,
+                        description: description,
+                    }),
+                ],
+                formulaConfigs: [],
+            },
+            criteriaAlias: data.metricVariable,
+        };
+    }
+    const partAliases = total.values.map((value) => {
+        return `${data.metricVariable}_${toAliasPart(value)}`;
+    });
+    const queryConfigs = total.values.map((value, index) => {
+        return buildQueryConfig({
+            query: query,
+            attributes: Object.assign(Object.assign({}, copyAttributes(query.attributes)), { [total.key]: value }),
+            metricVariable: partAliases[index],
+            title: `${data.title} (${value})`,
+            description: description,
+        });
+    });
+    const formulaConfig = {
+        metricAliasData: {
+            metricVariable: data.metricVariable,
+            title: data.title,
+            description: description,
+            legend: data.title,
+            legendUnit: query.unit || undefined,
+        },
+        metricFormulaData: {
+            metricFormula: partAliases.join(" + "),
+        },
+    };
+    return {
+        metricViewConfig: {
+            queryConfigs: queryConfigs,
+            formulaConfigs: [formulaConfig],
+        },
+        criteriaAlias: data.metricVariable,
+    };
+}
+function getUntemplatedReason(descriptor) {
+    for (const entry of UNTEMPLATED_MESSAGE_QUEUE_GAUGES) {
+        if (entry.system === descriptor.system &&
+            entry.metricName === descriptor.metricName) {
+            return entry.reason;
+        }
+    }
+    return null;
+}
+function getPolicyDefault(signal, measure) {
+    for (const policy of MESSAGE_QUEUE_ALERT_POLICIES) {
+        if (policy.signal === signal && policy.measure === measure) {
+            return policy;
+        }
+    }
+    return null;
+}
+function getPolicyOverride(descriptor) {
+    for (const override of MESSAGE_QUEUE_ALERT_POLICY_OVERRIDES) {
+        if (override.system === descriptor.system &&
+            override.metricNames.includes(descriptor.metricName)) {
+            return override;
+        }
+    }
+    return null;
+}
+// "1000" → "1,000"; a fraction to at most two decimals.
+function formatNumber(value) {
+    if (!Number.isInteger(value)) {
+        return String(Number(value.toFixed(2)));
+    }
+    return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function formatDuration(seconds) {
+    if (seconds > 0 && seconds % 3600 === 0) {
+        const hours = seconds / 3600;
+        return `${formatNumber(hours)} ${hours === 1 ? "hour" : "hours"}`;
+    }
+    if (seconds > 0 && seconds % 60 === 0) {
+        const minutes = seconds / 60;
+        return `${formatNumber(minutes)} ${minutes === 1 ? "minute" : "minutes"}`;
+    }
+    return `${formatNumber(seconds)} ${seconds === 1 ? "second" : "seconds"}`;
+}
+/*
+ * A threshold in words, in the metric's own unit: "1,000 messages",
+ * "1 message", "10 minutes".
+ */
+export function formatMessageQueueThreshold(value, unit) {
+    const trimmedUnit = (unit || "").trim();
+    if (trimmedUnit === "s") {
+        return formatDuration(value);
+    }
+    if (trimmedUnit === "ms") {
+        return value % 1000 === 0
+            ? formatDuration(value / 1000)
+            : `${formatNumber(value)} milliseconds`;
+    }
+    if (!trimmedUnit) {
+        return formatNumber(value);
+    }
+    const singular = value === 1 && trimmedUnit.length > 1 && trimmedUnit.endsWith("s")
+        ? trimmedUnit.substring(0, trimmedUnit.length - 1)
+        : trimmedUnit;
+    return `${formatNumber(value)} ${singular}`;
+}
+// "Dead-lettered messages" → "Dead-Lettered Messages"; small words stay small.
+const TITLE_CASE_SMALL_WORDS = [
+    "a",
+    "an",
+    "and",
+    "at",
+    "by",
+    "for",
+    "in",
+    "of",
+    "on",
+    "or",
+    "the",
+    "to",
+];
+function toTitleCase(value) {
+    return value
+        .split(" ")
+        .map((word, index) => {
+        if (index > 0 && TITLE_CASE_SMALL_WORDS.includes(word.toLowerCase())) {
+            return word.toLowerCase();
+        }
+        return word
+            .split("-")
+            .map((part) => {
+            return part.length > 0
+                ? `${part.charAt(0).toUpperCase()}${part.substring(1)}`
+                : part;
+        })
+            .join("-");
+    })
+        .join(" ");
+}
+/*
+ * A catalog title split into its name and a trailing qualifier:
+ * "Messages visible (JSON stream)" → "Messages visible", "(JSON stream)".
+ */
+function splitTitle(title) {
+    const match = title.match(/^(.*?)\s*(\([^()]*\))$/);
+    if (!match) {
+        return { base: title, qualifier: "" };
+    }
+    return { base: match[1] || title, qualifier: match[2] || "" };
+}
+/**
+ * The alert a catalog entry gets, or null when it gets none: not a
+ * monitorable gauge, a signal no static threshold means anything for, no
+ * default for its (signal, measure), or a deliberately untemplated gauge.
+ * The threshold is in the metric's own unit (an age of 600 s reads 600000 on
+ * a metric reported in milliseconds).
+ */
+export function getMessageQueueAlertPolicy(descriptor) {
+    var _a, _b;
+    if (!isMessageQueueMetricMonitorable(descriptor) ||
+        !MESSAGE_QUEUE_THRESHOLDABLE_SIGNALS.includes(descriptor.signal) ||
+        getUntemplatedReason(descriptor) !== null) {
+        return null;
+    }
+    const measure = getMessageQueueAlertMeasure(descriptor);
+    const defaults = getPolicyDefault(descriptor.signal, measure);
+    if (!defaults) {
+        return null;
+    }
+    const override = getPolicyOverride(descriptor);
+    const defaultThreshold = defaults.thresholdUnit
+        ? MetricUnitUtil.convertToMetricUnit({
+            value: defaults.threshold,
+            fromUnit: defaults.thresholdUnit,
+            metricUnit: descriptor.unit,
+        })
+        : defaults.threshold;
+    // Clears the binary noise a unit conversion leaves (600 / 0.001).
+    const threshold = Number(((_a = override === null || override === void 0 ? void 0 : override.threshold) !== null && _a !== void 0 ? _a : defaultThreshold).toPrecision(12));
+    const title = splitTitle(descriptor.title);
+    const generatedName = defaults.nameSuffix
+        ? `${toTitleCase(title.base)} ${defaults.nameSuffix}`
+        : toTitleCase(title.base);
+    // A late source's points never land in a window shorter than their lag.
+    const signalWindow = (override === null || override === void 0 ? void 0 : override.rollingTime) || defaults.rollingTime;
+    const rollingTime = getMessageQueueMetricMonitorRollingTime(descriptor, signalWindow);
+    return {
+        threshold: threshold,
+        thresholdLabel: `at or above ${formatMessageQueueThreshold(threshold, descriptor.unit)}`,
+        filterType: FilterType.GreaterThanOrEqualTo,
+        evaluation: defaults.evaluation,
+        rollingTime: rollingTime,
+        windowFloor: rollingTime === signalWindow
+            ? null
+            : getMessageQueueSourceWindowFloor(descriptor),
+        severity: (override === null || override === void 0 ? void 0 : override.severity) || defaults.severity,
+        category: defaults.category,
+        // A count's silent window is a window without events (see THRESHOLDS).
+        recoverOnNoData: (_b = override === null || override === void 0 ? void 0 : override.recoverOnNoData) !== null && _b !== void 0 ? _b : measure === "count",
+        metricAlias: defaults.metricAlias,
+        meaning: (override === null || override === void 0 ? void 0 : override.meaning) || defaults.meaning,
+        incidentDescription: (override === null || override === void 0 ? void 0 : override.incidentDescription) || defaults.incidentDescription,
+        baseName: (override === null || override === void 0 ? void 0 : override.name) || generatedName,
+    };
+}
+// --- template builders ---
+const ROLLING_TIME_WORDS = {
+    [RollingTime.Past5Minutes]: {
+        noun: "five minutes",
+        adjective: "five-minute",
+    },
+    [RollingTime.Past10Minutes]: {
+        noun: "ten minutes",
+        adjective: "ten-minute",
+    },
+    [RollingTime.Past15Minutes]: {
+        noun: "fifteen minutes",
+        adjective: "fifteen-minute",
+    },
+    [RollingTime.Past30Minutes]: {
+        noun: "thirty minutes",
+        adjective: "thirty-minute",
+    },
+};
+// ["ready", "unacknowledged"] → "ready and unacknowledged".
+function joinWords(values) {
+    if (values.length <= 1) {
+        return values.join("");
+    }
+    return `${values.slice(0, -1).join(", ")} and ${values[values.length - 1]}`;
+}
+function getWindowWords(rollingTime) {
+    return (ROLLING_TIME_WORDS[rollingTime] || {
+        noun: rollingTime.toLowerCase(),
+        adjective: rollingTime.toLowerCase(),
+    });
+}
+// A collector component type: "googlecloudmonitoring", "kafka_metrics".
+const COLLECTOR_COMPONENT_PATTERN = /^[a-z0-9_]+$/;
+/*
+ * "the collector's `googlecloudmonitoring` receiver" — how a sentence names
+ * the component, which the catalog spells as a receiver type,
+ * "prometheus" or a product name.
+ */
+function describeReceiver(receiver) {
+    return COLLECTOR_COMPONENT_PATTERN.test(receiver)
+        ? `the collector's \`${receiver}\` receiver`
+        : receiver;
+}
+function buildTemplateDescription(data) {
+    const descriptor = data.descriptor;
+    const policy = data.policy;
+    const window = getWindowWords(policy.rollingTime);
+    const subject = `"${splitTitle(descriptor.title).base}"`;
+    const perSeries = data.seed.groupByAttributeKeys.length > 0
+        ? `any one ${data.seed.groupByAttributeKeys.join(" / ")} series of `
+        : "";
+    /*
+     * A late source's window holds less than its length of data (see WINDOWS
+     * AND LATE SOURCES), so its breach is worded by points, not by minutes.
+     */
+    let breach;
+    if (policy.evaluation === EvaluateOverTimeType.AnyValue) {
+        breach = policy.windowFloor
+            ? `Alert when ${perSeries}${subject} reads ${policy.thresholdLabel} at any point of a ${window.adjective} window.`
+            : `Alert when ${perSeries}${subject} reads ${policy.thresholdLabel} in any single minute of a ${window.adjective} window.`;
+    }
+    else {
+        breach = policy.windowFloor
+            ? `Alert when ${perSeries}${subject} reads ${policy.thresholdLabel} at every point of a ${window.adjective} window.`
+            : `Alert when ${perSeries}${subject} stays ${policy.thresholdLabel} for ${window.noun}.`;
+    }
+    const sentences = [breach, policy.meaning];
+    if (policy.windowFloor) {
+        sentences.push(policy.windowFloor.reason);
+    }
+    sentences.push(`Reads ${descriptor.metricName}. ${descriptor.description}`);
+    if (data.seed.seriesTotal) {
+        sentences.push(`The monitor reads the ${joinWords(data.seed.seriesTotal.values)} series with one query each and adds them up with a formula, the total the queue page shows.`);
+    }
+    if (data.seed.groupByAttributeKeys.length > 0) {
+        sentences.push("Its series are not a fixed set, so the monitor cannot add them up the way the queue page does: it watches each series on its own, and the threshold is for one series, not for the total.");
+    }
+    if (!descriptor.enabledByDefault) {
+        sentences.push(`${capitalizeFirst(describeReceiver(descriptor.receiver))} only reports ${descriptor.metricName} once it is enabled in the collector's configuration${descriptor.receiver === "googlecloudmonitoring"
+            ? " (listed under the receiver's `metrics_list`)"
+            : ""}.`);
+    }
+    return sentences.join(" ");
+}
+function capitalizeFirst(value) {
+    return value.length > 0
+        ? `${value.charAt(0).toUpperCase()}${value.substring(1)}`
+        : value;
+}
+/*
+ * "rabbitmq.message.current (resource.rabbitmq.queue.name = orders), state
+ * ready + unacknowledged" or "…, per broker" — the query as the criteria
+ * description names it.
+ */
+function describeQuery(query) {
+    const filters = Object.keys(query.attributes).map((key) => {
+        const value = query.attributes[key];
+        if (value instanceof Includes) {
+            const values = value.values;
+            return `${key} in [${values
+                .map((item) => {
+                return String(item);
+            })
+                .join(", ")}]`;
+        }
+        return `${key} = ${String(value)}`;
+    });
+    let series = "";
+    if (query.seriesTotal) {
+        series = `, ${query.seriesTotal.key} ${query.seriesTotal.values.join(" + ")}`;
+    }
+    else if (query.groupByAttributeKeys.length > 0) {
+        series = `, per ${query.groupByAttributeKeys.join(" / ")}`;
+    }
+    return `${query.metricName} (${filters.join(", ")})${series}`;
+}
+function describeCriteria(data) {
+    if (data.policy.evaluation === EvaluateOverTimeType.AnyValue) {
+        return `Triggers when ${data.subject} reads ${data.policy.thresholdLabel} at any point in the evaluation window.`;
+    }
+    return `Triggers when ${data.subject} stays ${data.policy.thresholdLabel} for the whole evaluation window.`;
+}
+function buildCriteria(data) {
+    const policy = data.policy;
+    const unhealthy = buildUnhealthyCriteriaInstance({
+        offlineMonitorStatusId: data.args.offlineMonitorStatusId,
+        incidentSeverityId: data.args.defaultIncidentSeverityId,
+        alertSeverityId: data.args.defaultAlertSeverityId,
+        monitorName: data.args.monitorName,
+        metricAlias: data.criteriaAlias,
+        filterType: policy.filterType,
+        value: policy.threshold,
+        incidentTitle: `[Queue] ${data.templateName} - ${data.args.monitorName}`,
+        incidentDescription: policy.incidentDescription,
+        criteriaName: `${data.templateName} - ${policy.thresholdLabel}`,
+        criteriaDescription: describeCriteria({
+            subject: describeQuery(data.query),
+            policy: policy,
+        }),
+        resourceNoun: "queue",
+        metricAggregationType: policy.evaluation,
+    });
+    /*
+     * Recovery mirrors the breach: the complementary comparison below a dead
+     * band, held for the whole window — also for a count, which breaches on
+     * any one minute — and, where a silent window means zero, met by one.
+     */
+    const healthy = buildHealthyCriteriaInstance({
+        onlineMonitorStatusId: data.args.onlineMonitorStatusId,
+        metricAlias: data.criteriaAlias,
+        filterType: getRecoveryFilterType(policy.filterType),
+        value: policy.threshold,
+        metricAggregationType: policy.evaluation === EvaluateOverTimeType.AnyValue
+            ? EvaluateOverTimeType.AllValues
+            : policy.evaluation,
+        treatNoDataAsZero: policy.recoverOnNoData,
+    });
+    const monitorCriteria = new MonitorCriteria();
+    monitorCriteria.data = {
+        monitorCriteriaInstanceArray: [unhealthy, healthy],
+    };
+    return monitorCriteria;
+}
+// "aws_sqs" + "amazonaws.com/aws/sqs/x" → "aws-sqs-amazonaws-com-aws-sqs-x".
+function toIdSlug(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function buildTemplate(descriptor) {
+    const policy = getMessageQueueAlertPolicy(descriptor);
+    const seed = getMessageQueueMetricMonitorSeed(descriptor);
+    if (!policy || !seed) {
+        return null;
+    }
+    const qualifier = splitTitle(descriptor.title).qualifier;
+    const name = qualifier
+        ? `${policy.baseName} ${qualifier}`
+        : policy.baseName;
+    return {
+        id: `message-queue-${toIdSlug(descriptor.system)}-${toIdSlug(descriptor.metricName)}`,
+        name: name,
+        description: buildTemplateDescription({
+            descriptor: descriptor,
+            policy: policy,
+            seed: seed,
+        }),
+        category: policy.category,
+        severity: policy.severity,
+        monitorType: MonitorType.Metrics,
+        system: descriptor.system,
+        receiver: descriptor.receiver,
+        signal: descriptor.signal,
+        metricId: getMessageQueueMetricId(descriptor),
+        metricName: descriptor.metricName,
+        metricNames: [descriptor.metricName],
+        unit: descriptor.unit,
+        aggregationType: seed.aggregationType,
+        groupByAttributeKeys: [...seed.groupByAttributeKeys],
+        seriesTotal: seed.seriesTotal
+            ? { key: seed.seriesTotal.key, values: [...seed.seriesTotal.values] }
+            : null,
+        filterType: policy.filterType,
+        threshold: policy.threshold,
+        thresholdLabel: policy.thresholdLabel,
+        evaluation: policy.evaluation,
+        rollingTime: policy.rollingTime,
+        recoverOnNoData: policy.recoverOnNoData,
+        getMonitorStep: (args) => {
+            if (!args) {
+                return null;
+            }
+            const query = buildMessageQueueMetricMonitorQuery({
+                descriptor: descriptor,
+                observedSeries: args.observedSeries,
+                identity: args.identity,
+            });
+            if (!query) {
+                return null;
+            }
+            const step = MonitorStep.getDefaultMonitorStep({
+                monitorName: args.monitorName,
+                monitorType: MonitorType.Metrics,
+                onlineMonitorStatusId: args.onlineMonitorStatusId,
+                offlineMonitorStatusId: args.offlineMonitorStatusId,
+                defaultIncidentSeverityId: args.defaultIncidentSeverityId,
+                defaultAlertSeverityId: args.defaultAlertSeverityId,
+            });
+            const view = buildMessageQueueMetricMonitorViewConfig({
+                query: query,
+                metricVariable: policy.metricAlias,
+                title: name,
+                description: descriptor.description,
+            });
+            step.setMetricMonitor({
+                rollingTime: policy.rollingTime,
+                metricViewConfig: view.metricViewConfig,
+            });
+            step.setMonitorCriteria(buildCriteria({
+                args: args,
+                templateName: name,
+                query: query,
+                policy: policy,
+                criteriaAlias: view.criteriaAlias,
+            }));
+            return step;
+        },
+    };
+}
+/*
+ * Every catalog entry's template, in catalog order, built once. The product
+ * reads them one at a time, by catalog entry, and never as a list (see WHO
+ * READS THEM).
+ */
+const ALL_MESSAGE_QUEUE_ALERT_TEMPLATES = MESSAGE_QUEUE_METRICS.map((descriptor) => {
+    return buildTemplate(descriptor);
+}).filter((template) => {
+    return template !== null;
+});
+/**
+ * The template of one catalog entry, or undefined when the entry has none:
+ * where the "Create monitor" link reads its starting threshold, comparison,
+ * severity and window. Keyed by the entry (getMessageQueueMetricId), not the
+ * metric name, which Service Bus and Event Hubs share.
+ */
+export function getMessageQueueAlertTemplateForMetric(descriptor) {
+    if (!descriptor) {
+        return undefined;
+    }
+    const metricId = getMessageQueueMetricId(descriptor);
+    return ALL_MESSAGE_QUEUE_ALERT_TEMPLATES.find((template) => {
+        return template.metricId === metricId;
+    });
+}
+//# sourceMappingURL=MessageQueueAlertTemplates.js.map