@solidxai/core 0.1.10-beta.8 → 0.1.10

package/src/services/dashboard-providers/mq-dashboard-inflight-messages-kpi-provider.service.ts

@@ -0,0 +1,45 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { applyMqDashboardFilters, MQ_INFLIGHT_STAGES } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardInflightMessagesKpiProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardInflightMessagesKpiProvider";
+    }
+
+    help(): string {
+        return "Returns in-flight mq message count after applying dashboard variables.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<{ value: number; label: string }>> {
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {}, { ignoreStage: true });
+        qb.andWhere("mqMessage.stage IN (:...stages)", { stages: MQ_INFLIGHT_STAGES });
+
+        const value = await qb.getCount();
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                value,
+                label: widgetDefinition?.name ?? "In Flight",
+            },
+        };
+    }
+}
+

package/src/services/dashboard-providers/mq-dashboard-latency-trend-provider.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardLatencyTrendProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardLatencyTrendProvider";
+    }
+
+    help(): string {
+        return "Returns average elapsed millis trend over time buckets after applying dashboard variables.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<any>> {
+        const bucket = normalizeBucket(ctxt?.providerContext?.bucket);
+
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {});
+        qb.andWhere("mqMessage.elapsedMillis IS NOT NULL");
+
+        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const rows = await qb
+            .select(bucketExpr, "bucket")
+            .addSelect("AVG(mqMessage.elapsedMillis)", "value")
+            .groupBy(bucketExpr)
+            .orderBy("bucket", "ASC")
+            .getRawMany<{ bucket: string; value: string | number }>();
+
+        const categories = rows.map((r) => new Date(r.bucket).toISOString());
+        const values = rows.map((r) => Number(toNumber(r.value).toFixed(2)));
+
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                categories,
+                series: [{ name: "avg_elapsed_millis", data: values }],
+                bucket,
+            },
+        };
+    }
+}
+

package/src/services/dashboard-providers/mq-dashboard-messages-over-time-provider.service.ts

@@ -0,0 +1,79 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardMessagesOverTimeProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardMessagesOverTimeProvider";
+    }
+
+    help(): string {
+        return "Returns time-series message counts by stage (and total) after applying dashboard variables.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<any>> {
+        const bucket = normalizeBucket(ctxt?.providerContext?.bucket);
+        const requestedSeries: string[] = Array.isArray(ctxt?.providerContext?.series) && ctxt.providerContext.series.length > 0
+            ? ctxt.providerContext.series
+            : ["total", "succeeded", "failed", "retrying"];
+
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {});
+
+        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const rows = await qb
+            .select(bucketExpr, "bucket")
+            .addSelect("mqMessage.stage", "stage")
+            .addSelect("COUNT(mqMessage.id)", "count")
+            .groupBy(bucketExpr)
+            .addGroupBy("mqMessage.stage")
+            .orderBy("bucket", "ASC")
+            .getRawMany<{ bucket: string; stage: string; count: string | number }>();
+
+        const bucketToStageMap = new Map<string, Record<string, number>>();
+        for (const row of rows) {
+            const key = new Date(row.bucket).toISOString();
+            const entry = bucketToStageMap.get(key) ?? {};
+            entry[row.stage] = (entry[row.stage] ?? 0) + toNumber(row.count, 0);
+            bucketToStageMap.set(key, entry);
+        }
+
+        const categories = Array.from(bucketToStageMap.keys()).sort();
+        const series = requestedSeries.map((seriesName) => {
+            const data = categories.map((category) => {
+                const stageMap = bucketToStageMap.get(category) ?? {};
+                if (seriesName === "total") {
+                    return Object.values(stageMap).reduce((sum, value) => sum + value, 0);
+                }
+                return stageMap[seriesName] ?? 0;
+            });
+            return { name: seriesName, data };
+        });
+
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                categories,
+                series,
+                bucket,
+            },
+        };
+    }
+}
+

package/src/services/dashboard-providers/mq-dashboard-provider-utils.ts

@@ -0,0 +1,165 @@
+import { MqMessage } from "src/entities/mq-message.entity";
+import { SelectQueryBuilder } from "typeorm";
+
+export const MQ_INFLIGHT_STAGES = ['pending', 'scheduled', 'started', 'retry', 'retrying'];
+
+export interface MqDashboardVariables {
+    date?: any;
+    queueName?: string | string[];
+    stage?: string | string[];
+    messageBroker?: string | string[];
+}
+
+export interface ApplyMqDashboardFiltersOptions {
+    ignoreStage?: boolean;
+    ensureQueueJoin?: boolean;
+}
+
+export function applyMqDashboardFilters(
+    qb: SelectQueryBuilder<MqMessage>,
+    variables: MqDashboardVariables = {},
+    options: ApplyMqDashboardFiltersOptions = {},
+): SelectQueryBuilder<MqMessage> {
+    applyDateFilter(qb, variables.date);
+    applyStringOrArrayFilter(qb, 'mqMessage.messageBroker', variables.messageBroker, 'messageBroker');
+
+    if (!options.ignoreStage) {
+        applyStringOrArrayFilter(qb, 'mqMessage.stage', variables.stage, 'stage');
+    }
+
+    if (
+        options.ensureQueueJoin ||
+        (variables.queueName !== undefined && variables.queueName !== null && variables.queueName !== '')
+    ) {
+        qb.leftJoin('mqMessage.mqMessageQueue', 'mqMessageQueue');
+    }
+
+    if (variables.queueName !== undefined && variables.queueName !== null && variables.queueName !== '') {
+        applyStringOrArrayFilter(qb, 'mqMessageQueue.name', variables.queueName, 'queueName');
+    }
+
+    return qb;
+}
+
+export function normalizeBucket(value: string | undefined): 'hour' | 'day' | 'week' | 'month' {
+    const v = `${value ?? ''}`.toLowerCase();
+    if (v === 'hour' || v === 'day' || v === 'week' || v === 'month') {
+        return v;
+    }
+    return 'hour';
+}
+
+export function toNumber(value: any, fallback = 0): number {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+
+
+function applyDateFilter(qb: SelectQueryBuilder<MqMessage>, dateVariable: any): void {
+    const range = resolveDateRange(dateVariable);
+    if (range.from) {
+        qb.andWhere('mqMessage.createdAt >= :dashboardDateFrom', { dashboardDateFrom: range.from.toISOString() });
+    }
+    if (range.to) {
+        qb.andWhere('mqMessage.createdAt <= :dashboardDateTo', { dashboardDateTo: range.to.toISOString() });
+    }
+}
+
+function applyStringOrArrayFilter(
+    qb: SelectQueryBuilder<MqMessage>,
+    qualifiedColumn: string,
+    value: string | string[] | undefined,
+    paramKey: string,
+) {
+    if (value === undefined || value === null || value === '') {
+        return;
+    }
+
+    const values = Array.isArray(value) ? value.filter((v) => !!v) : [value];
+    if (values.length === 0) {
+        return;
+    }
+
+    if (values.length === 1) {
+        qb.andWhere(`${qualifiedColumn} = :${paramKey}`, { [paramKey]: values[0] });
+        return;
+    }
+
+    qb.andWhere(`${qualifiedColumn} IN (:...${paramKey})`, { [paramKey]: values });
+}
+
+function resolveDateRange(dateVariable: any): { from?: Date; to?: Date } {
+    if (!dateVariable) return {};
+
+    if (Array.isArray(dateVariable) && dateVariable.length >= 2) {
+        return {
+            from: parseDate(dateVariable[0]),
+            to: parseDate(dateVariable[1]),
+        };
+    }
+
+    if (typeof dateVariable === 'object') {
+        const presetRange = resolvePresetRange(dateVariable.preset);
+        const from = parseDate(dateVariable.from ?? dateVariable.start ?? dateVariable.startDate) ?? presetRange.from;
+        const to = parseDate(dateVariable.to ?? dateVariable.end ?? dateVariable.endDate) ?? presetRange.to;
+        return { from, to };
+    }
+
+    if (typeof dateVariable === 'string') {
+        const presetRange = resolvePresetRange(dateVariable);
+        if (presetRange.from || presetRange.to) {
+            return presetRange;
+        }
+        const parsed = parseDate(dateVariable);
+        if (!parsed) return {};
+        return { from: parsed, to: parsed };
+    }
+
+    return {};
+}
+
+function parseDate(value: any): Date | undefined {
+    if (!value) return undefined;
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) return undefined;
+    return d;
+}
+
+function resolvePresetRange(preset: string | undefined): { from?: Date; to?: Date } {
+    if (!preset) return {};
+
+    const now = new Date();
+    const to = new Date(now);
+    switch (preset) {
+        case 'today': {
+            const from = new Date(now);
+            from.setHours(0, 0, 0, 0);
+            return { from, to };
+        }
+        case 'yesterday': {
+            const from = new Date(now);
+            from.setDate(from.getDate() - 1);
+            from.setHours(0, 0, 0, 0);
+            const end = new Date(from);
+            end.setHours(23, 59, 59, 999);
+            return { from, to: end };
+        }
+        case 'last_24_hours': {
+            const from = new Date(now);
+            from.setHours(from.getHours() - 24);
+            return { from, to };
+        }
+        case 'last_7_days': {
+            const from = new Date(now);
+            from.setDate(from.getDate() - 7);
+            return { from, to };
+        }
+        case 'last_30_days': {
+            const from = new Date(now);
+            from.setDate(from.getDate() - 30);
+            return { from, to };
+        }
+        default:
+            return {};
+    }
+}

package/src/services/dashboard-providers/mq-dashboard-queue-sla-heatmap-provider.service.ts

@@ -0,0 +1,155 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+type HeatmapLegendThreshold = {
+    label: string;
+    color: string;
+    lte?: number;
+    gte?: number;
+    gt?: number;
+};
+
+type HeatmapPointDetail = {
+    xIndex: number;
+    yIndex: number;
+    bucket: string;
+    queueName: string;
+    avgElapsedMillis: number;
+    messageCount: number;
+    peakElapsedMillis: number;
+};
+
+type QueueSlaHeatmapResponse = {
+    xCategories: string[];
+    yCategories: string[];
+    points: [number, number, number][];
+    metric: string;
+    bucket: string;
+    tooltipFields?: string[];
+    pointDetails?: HeatmapPointDetail[];
+    legendThresholds?: HeatmapLegendThreshold[];
+};
+
+const DEFAULT_LEGEND_THRESHOLDS: HeatmapLegendThreshold[] = [
+    { label: "0-5s", color: "#22c55e", lte: 5000 },
+    { label: "5-15s", color: "#f59e0b", gt: 5000, lte: 15000 },
+    { label: "15-30s", color: "#f97316", gt: 15000, lte: 30000 },
+    { label: "30s+", color: "#ef4444", gt: 30000 },
+];
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardQueueSlaHeatmapProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardQueueSlaHeatmapProvider";
+    }
+
+    help(): string {
+        return "Returns queue-wise SLA heatmap data using average elapsed millis across time buckets.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<QueueSlaHeatmapResponse>> {
+        const bucket = normalizeBucket(ctxt?.providerContext?.bucket);
+        const legendThresholds = Array.isArray(ctxt?.providerContext?.legendThresholds) && ctxt.providerContext.legendThresholds.length > 0
+            ? ctxt.providerContext.legendThresholds
+            : DEFAULT_LEGEND_THRESHOLDS;
+        const tooltipFields = Array.isArray(ctxt?.providerContext?.tooltipFields) && ctxt.providerContext.tooltipFields.length > 0
+            ? ctxt.providerContext.tooltipFields
+            : ["avgElapsedMillis", "messageCount", "peakElapsedMillis"];
+
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {}, { ensureQueueJoin: true });
+        qb.andWhere("mqMessage.elapsedMillis IS NOT NULL");
+
+        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const rows = await qb
+            .select(bucketExpr, "bucket")
+            .addSelect("mqMessageQueue.name", "queueName")
+            .addSelect("AVG(mqMessage.elapsedMillis)", "avgElapsedMillis")
+            .addSelect("COUNT(mqMessage.id)", "messageCount")
+            .addSelect("MAX(mqMessage.elapsedMillis)", "peakElapsedMillis")
+            .groupBy(bucketExpr)
+            .addGroupBy("mqMessageQueue.name")
+            .orderBy("bucket", "ASC")
+            .addOrderBy("mqMessageQueue.name", "ASC")
+            .getRawMany<{
+                bucket: string;
+                queueName: string;
+                avgElapsedMillis: string | number;
+                messageCount: string | number;
+                peakElapsedMillis: string | number;
+            }>();
+
+        const xCategories = Array.from(
+            new Set(
+                rows
+                    .map((row) => row?.bucket ? new Date(row.bucket).toISOString() : "")
+                    .filter((bucketValue) => !!bucketValue)
+            )
+        ).sort();
+        const yCategories = Array.from(
+            new Set(rows.map((row) => `${row?.queueName ?? ""}`.trim()).filter((queueName) => !!queueName))
+        ).sort((left, right) => left.localeCompare(right));
+
+        const xIndexMap = new Map(xCategories.map((value, index) => [value, index]));
+        const yIndexMap = new Map(yCategories.map((value, index) => [value, index]));
+
+        const points: [number, number, number][] = [];
+        const pointDetails: HeatmapPointDetail[] = [];
+
+        for (const row of rows) {
+            const bucketValue = row?.bucket ? new Date(row.bucket).toISOString() : "";
+            const queueName = `${row?.queueName ?? ""}`.trim();
+            const xIndex = xIndexMap.get(bucketValue);
+            const yIndex = yIndexMap.get(queueName);
+
+            if (xIndex === undefined || yIndex === undefined) {
+                continue;
+            }
+
+            const avgElapsedMillis = Number(toNumber(row.avgElapsedMillis).toFixed(2));
+            const messageCount = toNumber(row.messageCount);
+            const peakElapsedMillis = Number(toNumber(row.peakElapsedMillis).toFixed(2));
+
+            points.push([xIndex, yIndex, avgElapsedMillis]);
+            pointDetails.push({
+                xIndex,
+                yIndex,
+                bucket: bucketValue,
+                queueName,
+                avgElapsedMillis,
+                messageCount,
+                peakElapsedMillis,
+            });
+        }
+
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                xCategories,
+                yCategories,
+                points,
+                metric: "avg_elapsed_millis",
+                bucket,
+                tooltipFields,
+                pointDetails,
+                legendThresholds,
+            },
+        };
+    }
+}

package/src/services/dashboard-providers/mq-dashboard-queue-wise-avg-elapsed-provider.service.ts

@@ -0,0 +1,51 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { applyMqDashboardFilters, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardQueueWiseAvgElapsedProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardQueueWiseAvgElapsedProvider";
+    }
+
+    help(): string {
+        return "Returns queue-wise average elapsed millis after applying dashboard variables.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<any>> {
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {}, { ensureQueueJoin: true });
+        qb.andWhere("mqMessage.elapsedMillis IS NOT NULL");
+
+        const rows = await qb
+            .select("mqMessageQueue.name", "category")
+            .addSelect("AVG(mqMessage.elapsedMillis)", "value")
+            .groupBy("mqMessageQueue.name")
+            .orderBy("value", "DESC")
+            .getRawMany<{ category: string; value: string | number }>();
+
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                categories: rows.map((r) => r.category),
+                series: [{ name: "avg_elapsed_millis", data: rows.map((r) => Number(toNumber(r.value).toFixed(2))) }],
+            },
+        };
+    }
+}
+

package/src/services/dashboard-providers/mq-dashboard-queue-wise-failures-provider.service.ts

@@ -0,0 +1,51 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
+import { applyMqDashboardFilters, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+
+@DashboardWidgetDataProvider()
+@Injectable()
+export class MqDashboardQueueWiseFailuresProvider implements IDashboardWidgetDataProvider {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardQueueWiseFailuresProvider";
+    }
+
+    help(): string {
+        return "Returns queue-wise failed message count after applying dashboard variables.";
+    }
+
+    async getData(
+        widgetDefinition: Record<string, any>,
+        ctxt: IDashboardWidgetDataProviderContext,
+    ): Promise<IDashboardWidgetDataResponseEnvelope<any>> {
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        applyMqDashboardFilters(qb, ctxt.variables ?? {}, { ignoreStage: true, ensureQueueJoin: true });
+        qb.andWhere("mqMessage.stage = :failedStage", { failedStage: "failed" });
+
+        const rows = await qb
+            .select("mqMessageQueue.name", "category")
+            .addSelect("COUNT(mqMessage.id)", "value")
+            .groupBy("mqMessageQueue.name")
+            .orderBy("value", "DESC")
+            .getRawMany<{ category: string; value: string | number }>();
+
+        return {
+            meta: {
+                providerName: this.name(),
+                generatedAt: new Date().toISOString(),
+                widgetName: ctxt.widgetName,
+                durationMs: 0,
+            },
+            data: {
+                categories: rows.map((r) => r.category),
+                series: [{ name: "failed_count", data: rows.map((r) => toNumber(r.value)) }],
+            },
+        };
+    }
+}
+