Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
import type { WorkloadGuest } from '@/types/workloads';
import { getWorkloadCPUPercent } from '@/utils/workloads';
import { getCurrentWorkloadDiskUsage } from '@/utils/workloadDiskUsage';
import { getCurrentWorkloadMemoryUsage } from '@/utils/memoryObservation';
// Exclusion-aware split of a free-text search. Terms prefixed with `-` hide
// matching rows ("-watchtower" hides anything whose haystack contains
// "watchtower"); everything else is kept intact, joined back together, and
// matched as a single case-insensitive substring so existing multi-word
// searches keep their meaning. Shared by every platform table search
// predicate so `-term` behaves identically on Docker, Kubernetes, workloads,
// and the generic platform tables.
export interface SearchTermSplit {
needle: string;
excludes: string[];
alternatives?: string[];
}
export function splitSearchExclusions(search: string): SearchTermSplit {
const excludes: string[] = [];
const kept: string[] = [];
for (const token of search.trim().split(/\s+/)) {
if (!token) continue;
if (token.length > 1 && token.startsWith('-')) {
excludes.push(token.slice(1).toLowerCase());
} else {
kept.push(token);
}
}
const needle = kept.join(' ').toLowerCase();
const alternatives = needle
.split(',')
.map((term) => term.trim())
.filter(Boolean);
return alternatives.length > 1 ? { needle, excludes, alternatives } : { needle, excludes };
}
export function matchesSearchTermSplit(haystack: string, split: SearchTermSplit): boolean {
for (const exclude of split.excludes) {
if (haystack.includes(exclude)) return false;
}
if (!split.needle) return true;
if (split.alternatives) {
return split.alternatives.some((alternative) => haystack.includes(alternative));
}
return haystack.includes(split.needle);
}
export type ComparisonOperator = '>' | '<' | '>=' | '<=' | '=' | '==';
export type LogicalOperator = 'AND' | 'OR';
export interface MetricCondition {
field:
'cpu' | 'memory' | 'disk' | 'diskRead' | 'diskWrite' | 'networkIn' | 'networkOut' | 'uptime';
operator: ComparisonOperator;
value: number;
}
export interface TextCondition {
field: 'name' | 'node' | 'vmid' | 'tags';
value: string;
}
// New interfaces for stackable filters
export interface ParsedFilter {
type: 'metric' | 'text' | 'raw';
rawText?: string;
field?: string;
operator?: ComparisonOperator;
value?: string | number;
}
export interface FilterStack {
filters: ParsedFilter[];
operators: LogicalOperator[]; // Operators between filters (length = filters.length - 1)
}
// Parse a single filter from a search term
export function parseFilter(term: string): ParsedFilter {
term = term.trim();
// Try to parse metric condition (e.g., "cpu>80", "size>1000000000")
const metricMatch = term.match(/^(\w+)\s*(>|<|>=|<=|=|==)\s*(\d+(?:\.\d+)?)$/i);
if (metricMatch) {
const [, field, operator, value] = metricMatch;
const parsedValue = parseFloat(value);
if (isNaN(parsedValue)) {
return {
type: 'raw',
rawText: term,
};
}
return {
type: 'metric',
field: field.toLowerCase(),
operator: operator as ComparisonOperator,
value: parsedValue,
};
}
// Try to parse text condition (e.g., "name:prod", "tags:production", "storage:local", "type:VM")
const textMatch = term.match(/^(\w+)\s*:\s*(.+)$/i);
if (textMatch) {
const [, field, value] = textMatch;
return {
type: 'text',
field: field.toLowerCase(),
value: value.trim(),
};
}
// Otherwise treat as raw text search
return {
type: 'raw',
rawText: term,
};
}
// Parse multiple filters from a search string
export function parseFilterStack(searchString: string): FilterStack {
const trimmed = searchString.trim();
if (!trimmed) {
return { filters: [], operators: [] };
}
// Split by AND/OR operators while preserving them
const regex = /\s+(AND|OR)\s+/gi;
const parts = trimmed.split(regex);
const filters: ParsedFilter[] = [];
const operators: LogicalOperator[] = [];
// Process the parts
for (let i = 0; i < parts.length; i++) {
const part = parts[i].trim();
if (!part) continue;
if (i % 2 === 0) {
// Even indices are filter expressions
const filter = parseFilter(part);
filters.push(filter);
} else {
// Odd indices are operators
operators.push(part.toUpperCase() as LogicalOperator);
}
}
return { filters, operators };
}
type FilterableItem = WorkloadGuest;
function evaluateMetricCondition(guest: FilterableItem, condition: MetricCondition): boolean {
let value: number;
switch (condition.field) {
case 'cpu':
value = getWorkloadCPUPercent('cpu' in guest ? guest.cpu : undefined) ?? 0;
break;
case 'memory': {
const usage = getCurrentWorkloadMemoryUsage(guest);
if (usage === null) return false;
value = usage;
break;
}
case 'disk': {
// Missing and retained reads are not zero (or current capacity).
// Preserve the same provider/linked-agent freshness rule as the row.
const usage = getCurrentWorkloadDiskUsage(guest);
if (usage === null) return false;
value = usage;
break;
}
case 'uptime':
// Uptime in seconds (only for running VMs/containers)
value =
'status' in guest && guest.status === 'running' && 'uptime' in guest
? guest.uptime || 0
: 0;
break;
default:
// For backup-specific numeric fields like 'size'
if (typeof guest === 'object' && guest !== null && condition.field in guest) {
const fieldValue = (guest as unknown as Record<string, unknown>)[condition.field];
if (fieldValue !== undefined) {
value = Number(fieldValue) || 0;
} else {
return false;
}
} else {
return false;
}
}
switch (condition.operator) {
case '>':
return value > condition.value;
case '<':
return value < condition.value;
case '>=':
return value >= condition.value;
case '<=':
return value <= condition.value;
case '=':
case '==':
return Math.abs(value - condition.value) < 0.01;
default:
return false;
}
}
function evaluateTextCondition(guest: FilterableItem, condition: TextCondition): boolean {
const searchValue = condition.value.toLowerCase();
switch (condition.field) {
case 'name':
return 'name' in guest && guest.name ? guest.name.toLowerCase().includes(searchValue) : false;
case 'node':
return 'node' in guest && guest.node ? guest.node.toLowerCase().includes(searchValue) : false;
case 'vmid':
return 'vmid' in guest && guest.vmid ? guest.vmid.toString().includes(searchValue) : false;
case 'tags':
// Check if guest has any tags that match the search value
if (!('tags' in guest) || !guest.tags) return false;
const tagsArray = Array.isArray(guest.tags)
? guest.tags.filter((tag): tag is string => typeof tag === 'string')
: typeof guest.tags === 'string'
? guest.tags
.split(',')
.map((tag) => tag.trim())
.filter((tag) => tag.length > 0)
: [];
if (tagsArray.length === 0) return false;
// Support comma-separated tag searches (OR logic)
const searchTags = searchValue
.split(',')
.map((t) => t.trim())
.filter((t) => t.length > 0);
return searchTags.some((searchTag) =>
tagsArray.some((tag) => tag.toLowerCase().includes(searchTag.toLowerCase())),
);
default:
// For backup-specific fields
if (typeof guest === 'object' && guest !== null && condition.field in guest) {
const fieldValue = (guest as unknown as Record<string, unknown>)[condition.field];
if (fieldValue) {
if (typeof fieldValue === 'string') {
return fieldValue.toLowerCase().includes(searchValue);
} else if (typeof fieldValue === 'number') {
return fieldValue.toString().includes(searchValue);
} else if (typeof fieldValue === 'boolean') {
return fieldValue.toString() === searchValue;
}
}
}
return false;
}
}
// Evaluate a filter stack against a guest or backup item
export function evaluateFilterStack(guest: FilterableItem, stack: FilterStack): boolean {
if (stack.filters.length === 0) {
return true;
}
const results = stack.filters.map((filter) => {
if (filter.type === 'metric' && filter.field && filter.operator && filter.value !== undefined) {
const condition: MetricCondition = {
field: filter.field as MetricCondition['field'],
operator: filter.operator,
value: filter.value as number,
};
return evaluateMetricCondition(guest, condition);
} else if (filter.type === 'text' && filter.field && filter.value) {
// Handle tags field specifically since it might not be in the type union
if (filter.field === 'tags') {
const condition: TextCondition = {
field: 'tags',
value: filter.value as string,
};
return evaluateTextCondition(guest, condition);
}
const condition: TextCondition = {
field: filter.field as TextCondition['field'],
value: filter.value as string,
};
return evaluateTextCondition(guest, condition);
} else if (filter.type === 'raw' && filter.rawText) {
const term = filter.rawText.toLowerCase();
// Check name, vmid, node, status, and tags for raw text matches
const nameMatch =
'name' in guest &&
typeof guest.name === 'string' &&
guest.name.toLowerCase().includes(term);
const vmidMatch = 'vmid' in guest && !!guest.vmid && guest.vmid.toString().includes(term);
const nodeMatch =
'node' in guest &&
typeof guest.node === 'string' &&
guest.node.toLowerCase().includes(term);
const statusMatch =
'status' in guest &&
typeof guest.status === 'string' &&
guest.status.toLowerCase().includes(term);
// Also check if any tags contain the search term
const tagMatch =
'tags' in guest && Array.isArray(guest.tags)
? guest.tags
.filter((tag): tag is string => typeof tag === 'string')
.some((tag) => tag.toLowerCase().includes(term))
: false;
return nameMatch || vmidMatch || nodeMatch || statusMatch || tagMatch;
}
return true;
});
// If only one filter, return its result
if (results.length === 1) {
return results[0];
}
// Apply operators between filters
let result = results[0];
for (let i = 0; i < stack.operators.length && i < results.length - 1; i++) {
const operator = stack.operators[i];
const nextResult = results[i + 1];
if (operator === 'AND') {
result = result && nextResult;
} else {
result = result || nextResult;
}
}
return result;
}