@perses-dev/alert-manager-plugin 0.1.0-rc.0

package/lib/cjs/plugins/alert-table/alert-table-model.js

@@ -0,0 +1,142 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ALL_ALERT_ACTIONS () {
+        return ALL_ALERT_ACTIONS;
+    },
+    get deduplicateAlerts () {
+        return deduplicateAlerts;
+    },
+    get extractLabelKeys () {
+        return extractLabelKeys;
+    },
+    get getGroupKey () {
+        return getGroupKey;
+    },
+    get getGroupSummary () {
+        return getGroupSummary;
+    }
+});
+const _alerttablesorting = require("./alert-table-sorting");
+const ALL_ALERT_ACTIONS = [
+    'silence',
+    'runbook'
+];
+function deduplicateAlerts(alerts, config) {
+    if (alerts.length === 0 || config.mode === 'none') return {
+        alerts,
+        duplicateCounts: new Map()
+    };
+    const seen = new Map();
+    const counts = new Map();
+    const result = [];
+    for (const alert of alerts){
+        let key;
+        if (config.mode === 'labels' && config.labels) {
+            key = config.labels.map((l)=>`${l}=${alert.labels[l] ?? ''}`).join(',');
+        } else if (alert.id) {
+            key = alert.id;
+        } else {
+            key = JSON.stringify(alert.labels);
+        }
+        if (!seen.has(key)) {
+            seen.set(key, alert);
+            counts.set(key, 1);
+            result.push(alert);
+        } else {
+            counts.set(key, (counts.get(key) ?? 1) + 1);
+        }
+    }
+    const duplicateCounts = new Map();
+    for (const [key, alert] of seen){
+        const count = counts.get(key) ?? 1;
+        if (count > 1) {
+            duplicateCounts.set(alert, count);
+        }
+    }
+    return {
+        alerts: result,
+        duplicateCounts
+    };
+}
+function extractLabelKeys(alerts) {
+    const keys = new Set();
+    for (const alert of alerts){
+        for (const key of Object.keys(alert.labels)){
+            keys.add(key);
+        }
+    }
+    return Array.from(keys).sort();
+}
+function getGroupKey(alert, groupBy) {
+    return groupBy.map((label)=>`${label}=${alert.labels[label] ?? ''}`).join(',');
+}
+function getGroupSummary(alerts, labelKeys) {
+    const summary = {
+        total: 0,
+        firing: 0,
+        suppressed: 0,
+        pending: 0
+    };
+    const labelCounts = {};
+    labelCounts[_alerttablesorting.SORT_COL_STATUS] = {};
+    labelCounts[_alerttablesorting.SORT_COL_ALERTNAME] = {};
+    if (labelKeys) {
+        for (const key of labelKeys){
+            labelCounts[key] = {};
+        }
+    }
+    for (const alert of alerts){
+        summary.total++;
+        if (alert.suppressed) {
+            summary.suppressed++;
+        } else {
+            switch(alert.state){
+                case 'firing':
+                    summary.firing++;
+                    break;
+                case 'pending':
+                    summary.pending++;
+                    break;
+            }
+        }
+        const status = (0, _alerttablesorting.getEffectiveStatus)(alert);
+        labelCounts[_alerttablesorting.SORT_COL_STATUS][status] = (labelCounts[_alerttablesorting.SORT_COL_STATUS][status] ?? 0) + 1;
+        if (alert.name) {
+            labelCounts[_alerttablesorting.SORT_COL_ALERTNAME][alert.name] = (labelCounts[_alerttablesorting.SORT_COL_ALERTNAME][alert.name] ?? 0) + 1;
+        }
+        if (labelKeys) {
+            for (const key of labelKeys){
+                const labelValue = alert.labels[key];
+                if (labelValue !== undefined) {
+                    const counts = labelCounts[key];
+                    if (counts) {
+                        counts[labelValue] = (counts[labelValue] ?? 0) + 1;
+                    }
+                }
+            }
+        }
+    }
+    summary.labelCounts = labelCounts;
+    return summary;
+}

package/lib/cjs/plugins/alert-table/alert-table-sorting.js

@@ -0,0 +1,205 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SORT_COL_ALERTNAME () {
+        return SORT_COL_ALERTNAME;
+    },
+    get SORT_COL_STATUS () {
+        return SORT_COL_STATUS;
+    },
+    get compareAlertsByColumn () {
+        return compareAlertsByColumn;
+    },
+    get compareGroupsByColumn () {
+        return compareGroupsByColumn;
+    },
+    get getEffectiveStatus () {
+        return getEffectiveStatus;
+    }
+});
+const _labelcolors = require("./label-colors");
+const SORT_COL_STATUS = '__status__';
+const SORT_COL_ALERTNAME = '__alertname__';
+const STATUS_WEIGHT = {
+    firing: 0,
+    pending: 1,
+    suppressed: 2,
+    inactive: 3,
+    resolved: 4
+};
+function getEffectiveStatus(alert) {
+    return alert.suppressed ? 'suppressed' : alert.state;
+}
+function compareStatus(a, b) {
+    const wa = a !== undefined ? STATUS_WEIGHT[a] ?? 5 : 5;
+    const wb = b !== undefined ? STATUS_WEIGHT[b] ?? 5 : 5;
+    return wa - wb;
+}
+function directionMultiplier(direction) {
+    return direction === 'asc' ? 1 : -1;
+}
+function compareAlphabetical(a, b) {
+    if (a === undefined && b === undefined) return 0;
+    if (a === undefined) return 1;
+    if (b === undefined) return -1;
+    return a.localeCompare(b);
+}
+function compareNumeric(a, b) {
+    const na = a !== undefined ? parseFloat(a) : NaN;
+    const nb = b !== undefined ? parseFloat(b) : NaN;
+    if (isNaN(na) && isNaN(nb)) return 0;
+    if (isNaN(na)) return 1;
+    if (isNaN(nb)) return -1;
+    return na - nb;
+}
+function compareSeverity(a, b) {
+    const wa = a !== undefined ? (0, _labelcolors.getSeverityWeight)(a) : _labelcolors.SEVERITY_ORDER.length;
+    const wb = b !== undefined ? (0, _labelcolors.getSeverityWeight)(b) : _labelcolors.SEVERITY_ORDER.length;
+    return wa - wb;
+}
+function compareAlertsByColumn(a, b, sort) {
+    if (sort.columnName === SORT_COL_STATUS) {
+        return compareStatus(getEffectiveStatus(a), getEffectiveStatus(b)) * directionMultiplier(sort.direction);
+    }
+    if (sort.columnName === SORT_COL_ALERTNAME) {
+        return compareAlphabetical(a.name, b.name) * directionMultiplier(sort.direction);
+    }
+    const va = a.labels[sort.columnName];
+    const vb = b.labels[sort.columnName];
+    let result;
+    switch(sort.mode){
+        case 'numeric':
+            result = compareNumeric(va, vb);
+            break;
+        case 'severity':
+            result = compareSeverity(va, vb);
+            break;
+        case 'alphabetical':
+        default:
+            result = compareAlphabetical(va, vb);
+            break;
+    }
+    return result * directionMultiplier(sort.direction);
+}
+function getMostFrequentValue(counts) {
+    let maxCount = 0;
+    let maxValue;
+    for (const [value, count] of Object.entries(counts)){
+        if (count > maxCount) {
+            maxCount = count;
+            maxValue = value;
+        }
+    }
+    return {
+        value: maxValue,
+        count: maxCount
+    };
+}
+function getMostCriticalStatus(counts) {
+    let minWeight = 5;
+    let countAtMin = 0;
+    for (const [value, count] of Object.entries(counts)){
+        const weight = STATUS_WEIGHT[value] ?? 5;
+        if (weight < minWeight) {
+            minWeight = weight;
+            countAtMin = count;
+        } else if (weight === minWeight) {
+            countAtMin += count;
+        }
+    }
+    return {
+        weight: minWeight,
+        count: countAtMin
+    };
+}
+function getMostCriticalSeverity(counts) {
+    let minWeight = _labelcolors.SEVERITY_ORDER.length;
+    let countAtMin = 0;
+    for (const [value, count] of Object.entries(counts)){
+        const weight = (0, _labelcolors.getSeverityWeight)(value);
+        if (weight < minWeight) {
+            minWeight = weight;
+            countAtMin = count;
+        } else if (weight === minWeight) {
+            countAtMin += count;
+        }
+    }
+    return {
+        weight: minWeight,
+        count: countAtMin
+    };
+}
+function compareGroupsByColumn(aCounts, bCounts, sort) {
+    const emptyA = !aCounts || Object.keys(aCounts).length === 0;
+    const emptyB = !bCounts || Object.keys(bCounts).length === 0;
+    if (emptyA && emptyB) return 0;
+    if (emptyA) return 1;
+    if (emptyB) return -1;
+    let result;
+    switch(sort.mode){
+        case 'status':
+            {
+                const statusA = getMostCriticalStatus(aCounts);
+                const statusB = getMostCriticalStatus(bCounts);
+                result = statusA.weight - statusB.weight;
+                if (result === 0) {
+                    result = statusB.count - statusA.count;
+                }
+                break;
+            }
+        case 'severity':
+            {
+                const sevA = getMostCriticalSeverity(aCounts);
+                const sevB = getMostCriticalSeverity(bCounts);
+                result = sevA.weight - sevB.weight;
+                if (result === 0) {
+                    result = sevB.count - sevA.count;
+                }
+                break;
+            }
+        case 'numeric':
+            {
+                const freqA = getMostFrequentValue(aCounts);
+                const freqB = getMostFrequentValue(bCounts);
+                const numResult = compareNumeric(freqA.value, freqB.value);
+                if (numResult !== 0) {
+                    return numResult * directionMultiplier(sort.direction);
+                }
+                // Tie-break by count is always descending (larger groups first) regardless of sort direction
+                return freqB.count - freqA.count;
+            }
+        case 'alphabetical':
+        default:
+            {
+                const freqA = getMostFrequentValue(aCounts);
+                const freqB = getMostFrequentValue(bCounts);
+                const alphaResult = compareAlphabetical(freqA.value, freqB.value);
+                if (alphaResult !== 0) {
+                    return alphaResult * directionMultiplier(sort.direction);
+                }
+                // Tie-break by count is always descending (larger groups first) regardless of sort direction
+                return freqB.count - freqA.count;
+            }
+    }
+    return result * directionMultiplier(sort.direction);
+}

package/lib/cjs/plugins/alert-table/label-colors.js

@@ -0,0 +1,170 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SEVERITY_ORDER () {
+        return SEVERITY_ORDER;
+    },
+    get getLabelColor () {
+        return getLabelColor;
+    },
+    get getSeverityWeight () {
+        return getSeverityWeight;
+    },
+    get hashStringToColor () {
+        return hashStringToColor;
+    }
+});
+const SEVERITY_LEVEL_COLORS = {
+    critical: '#d32f2f',
+    error: '#ef6c00',
+    warning: '#f9a825',
+    info: '#0288d1',
+    debug: '#7b1fa2',
+    trace: '#6a1b9a',
+    unknown: '#757575',
+    other: '#9e9e9e'
+};
+const SEVERITY_ABBREVIATIONS = {
+    critical: [
+        'critical',
+        'crit',
+        'fatal',
+        'emerg',
+        'alert',
+        'page'
+    ],
+    error: [
+        'error',
+        'err',
+        'eror',
+        'high',
+        'severe'
+    ],
+    warning: [
+        'warning',
+        'warn',
+        'medium'
+    ],
+    info: [
+        'info',
+        'inf',
+        'information',
+        'informational',
+        'notice',
+        'low'
+    ],
+    debug: [
+        'debug',
+        'dbug'
+    ],
+    trace: [
+        'trace'
+    ],
+    unknown: [
+        'unknown'
+    ],
+    other: [
+        'other',
+        'none',
+        'minor',
+        ''
+    ]
+};
+const SEVERITY_COLORS = {};
+for (const [level, abbrevs] of Object.entries(SEVERITY_ABBREVIATIONS)){
+    const color = SEVERITY_LEVEL_COLORS[level];
+    for (const abbrev of abbrevs){
+        SEVERITY_COLORS[abbrev] = color;
+    }
+}
+const SEVERITY_ORDER = [
+    'critical',
+    'error',
+    'warning',
+    'info',
+    'debug',
+    'trace',
+    'unknown',
+    'other'
+];
+function getSeverityWeight(value) {
+    const normalized = value.toLowerCase();
+    for (const [level, abbrevs] of Object.entries(SEVERITY_ABBREVIATIONS)){
+        if (abbrevs.includes(normalized)) {
+            const idx = SEVERITY_ORDER.indexOf(level);
+            return idx === -1 ? SEVERITY_ORDER.length : idx;
+        }
+    }
+    return SEVERITY_ORDER.length;
+}
+const MANUAL_FALLBACK = '#9e9e9e';
+const ERROR_HUE_CUTOFF = 20;
+function hashStringToColor(value) {
+    let hash = 5381;
+    for(let i = 0; i < value.length; i++){
+        hash = hash * 33 ^ value.charCodeAt(i);
+    }
+    hash = Math.abs(hash);
+    const hue = ERROR_HUE_CUTOFF + hash % (360 - ERROR_HUE_CUTOFF);
+    const saturation = 55 + hash % 25;
+    const lightness = 45 + hash % 15;
+    return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
+}
+const MAX_REGEX_CACHE_SIZE = 1000;
+const regexCache = new Map();
+function getCompiledRegex(pattern) {
+    if (regexCache.has(pattern)) return regexCache.get(pattern);
+    if (regexCache.size >= MAX_REGEX_CACHE_SIZE) regexCache.clear();
+    try {
+        const re = new RegExp(pattern);
+        regexCache.set(pattern, re);
+        return re;
+    } catch  {
+        regexCache.set(pattern, null);
+        return null;
+    }
+}
+function matchesOverride(labelValue, pattern, isRegex) {
+    if (isRegex) {
+        const re = getCompiledRegex(pattern);
+        return re !== null && re.test(labelValue);
+    }
+    return labelValue === pattern;
+}
+function getLabelColor(value, mapping) {
+    if (mapping.overrides) {
+        for (const override of mapping.overrides){
+            if (matchesOverride(value, override.value, override.isRegex)) {
+                return override.color;
+            }
+        }
+    }
+    switch(mapping.mode){
+        case 'severity':
+            return SEVERITY_COLORS[value.toLowerCase()] ?? hashStringToColor(value);
+        case 'auto':
+            return hashStringToColor(value);
+        case 'manual':
+            return MANUAL_FALLBACK;
+    }
+}

package/lib/cjs/plugins/alertmanager-alerts-query/AlertManagerAlertsQuery.js

@@ -0,0 +1,51 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AlertManagerAlertsQuery", {
+    enumerable: true,
+    get: function() {
+        return AlertManagerAlertsQuery;
+    }
+});
+const _pluginsystem = require("@perses-dev/plugin-system");
+const _getalertsdata = require("./get-alerts-data");
+const _AlertManagerAlertsQueryEditor = require("./AlertManagerAlertsQueryEditor");
+const AlertManagerAlertsQuery = {
+    getAlertsData: _getalertsdata.getAlertsData,
+    OptionsEditorComponent: _AlertManagerAlertsQueryEditor.AlertManagerAlertsQueryEditor,
+    createInitialOptions: ()=>({
+            datasource: undefined,
+            filters: [],
+            active: true,
+            silenced: false,
+            inhibited: false,
+            receiver: undefined
+        }),
+    dependsOn: (spec)=>{
+        const datasourceVariables = (0, _pluginsystem.isVariableDatasource)(spec.datasource) ? (0, _pluginsystem.parseVariables)(spec.datasource ?? '') : [];
+        const filterVariables = spec.filters?.flatMap((f)=>(0, _pluginsystem.parseVariables)(f)) ?? [];
+        const receiverVariables = spec.receiver ? (0, _pluginsystem.parseVariables)(spec.receiver) : [];
+        return {
+            variables: [
+                ...new Set([
+                    ...datasourceVariables,
+                    ...filterVariables,
+                    ...receiverVariables
+                ])
+            ]
+        };
+    }
+};