Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

5.7 KB
Raw Blame
import { themeColors } from 'constants/theme';
import getLabelName from 'lib/getLabelName';
import { isUndefined } from 'lodash-es';
import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
import { QueryData } from 'types/api/widgets/getQuery';

import { normalizePlotValue } from './dataUtils';
import { generateColor } from './generateColor';

function getXAxisTimestamps(seriesList: QueryData[]): number[] {
	const timestamps = new Set<number>();

	seriesList.forEach((series: { values?: [number, string][] }) => {
		if (series?.values) {
			series.values.forEach((value) => {
				timestamps.add(value[0]);
			});
		}
	});

	const timestampsArr = Array.from(timestamps);
	timestampsArr.sort((a, b) => a - b);

	return timestampsArr;
}

// eslint-disable-next-line sonarjs/cognitive-complexity
function fillMissingXAxisTimestamps(
	timestampArr: number[],
	data: Array<{ values?: [number, string][] }>,
): (number | null)[][] {
	// Generate a set of all timestamps in the range
	const allTimestampsSet = new Set(timestampArr);
	const result: (number | null)[][] = [];

	// Process each series entry
	for (let i = 0; i < data.length; i++) {
		const entry = data[i];
		if (!entry?.values) {
			result.push([]);
		} else {
			// Build Set of existing timestamps directly (avoid intermediate array)
			const existingTimestamps = new Set<number>();
			const valuesMap = new Map<number, number | null>();

			for (let j = 0; j < entry.values.length; j++) {
				const [timestamp, value] = entry.values[j];
				existingTimestamps.add(timestamp);
				valuesMap.set(timestamp, normalizePlotValue(value));
			}

			// Find missing timestamps by iterating Set directly (avoid Array.from + filter)
			const missingTimestamps: number[] = [];
			const allTimestampsArray = Array.from(allTimestampsSet);
			for (let k = 0; k < allTimestampsArray.length; k++) {
				const timestamp = allTimestampsArray[k];
				if (!existingTimestamps.has(timestamp)) {
					missingTimestamps.push(timestamp);
				}
			}

			// Add missing timestamps to map
			for (let j = 0; j < missingTimestamps.length; j++) {
				valuesMap.set(missingTimestamps[j], null);
			}

			// Build sorted array of values
			const sortedTimestamps = Array.from(valuesMap.keys()).sort((a, b) => a - b);
			const yValues = sortedTimestamps.map((timestamp) => {
				const value = valuesMap.get(timestamp);
				return value !== undefined ? value : null;
			});
			result.push(yValues);
		}
	}

	return result;
}

function getStackedSeries(val: (number | null)[][]): (number | null)[][] {
	const series = val ? val.map((row: (number | null)[]) => [...row]) : [];

	for (let i = series.length - 2; i >= 0; i--) {
		for (let j = 0; j < series[i].length; j++) {
			series[i][j] = (series[i][j] || 0) + (series[i + 1][j] || 0);
		}
	}

	return series;
}

export const getUPlotChartData = (
	apiResponse?: MetricRangePayloadProps,
	fillSpans?: boolean,
	stackedBarChart?: boolean,
	hiddenGraph?: {
		[key: string]: boolean;
	},
): any[] => {
	const seriesList = apiResponse?.data?.result || [];
	const timestampArr = getXAxisTimestamps(seriesList);
	const yAxisValuesArr = fillMissingXAxisTimestamps(timestampArr, seriesList);

	return [
		timestampArr,
		...(stackedBarChart && isUndefined(hiddenGraph)
			? getStackedSeries(yAxisValuesArr)
			: yAxisValuesArr),
	];
};

const processAnomalyDetectionData = (
	anomalyDetectionData: any,
	isDarkMode: boolean,
	// eslint-disable-next-line sonarjs/cognitive-complexity
): Record<string, { data: number[][]; color: string }> => {
	if (!anomalyDetectionData) {
		return {};
	}

	const processedData: Record<
		string,
		{ data: number[][]; color: string; legendLabel: string }
	> = {};

	for (
		let queryIndex = 0;
		queryIndex < anomalyDetectionData.length;
		queryIndex++
	) {
		const queryData = anomalyDetectionData[queryIndex];
		const {
			series,
			predictedSeries,
			upperBoundSeries,
			lowerBoundSeries,
			queryName,
			legend,
		} = queryData;

		for (let index = 0; index < series?.length; index++) {
			const label = getLabelName(
				series[index].labels,
				queryName || '', // query
				legend || '',
			);

			const objKey =
				anomalyDetectionData.length > 1 ? `${queryName}-${label}` : label;

			// Single iteration instead of 5 separate map operations
			const { values: seriesValues } = series[index] || { values: [] };
			const { values: predictedValues } = predictedSeries[index] || { values: [] };
			const { values: upperBoundValues } = upperBoundSeries[index] || {
				values: [],
			};
			const { values: lowerBoundValues } = lowerBoundSeries[index] || {
				values: [],
			};
			const length = seriesValues.length;

			const timestamps: number[] = new Array(length);
			const values: number[] = new Array(length);
			const predicted: number[] = new Array(length);
			const upperBound: number[] = new Array(length);
			const lowerBound: number[] = new Array(length);

			for (let i = 0; i < length; i++) {
				timestamps[i] = seriesValues[i].timestamp / 1000;
				values[i] = seriesValues[i]?.value ?? null;
				predicted[i] = predictedValues[i]?.value ?? null;
				upperBound[i] = upperBoundValues[i]?.value ?? null;
				lowerBound[i] = lowerBoundValues[i]?.value ?? null;
			}

			processedData[objKey] = {
				data: [timestamps, values, predicted, upperBound, lowerBound],
				color: generateColor(
					objKey,
					isDarkMode ? themeColors.chartcolors : themeColors.lightModeColor,
				),
				legendLabel: label,
			};
		}
	}

	return processedData;
};

export const getUplotChartDataForAnomalyDetection = (
	apiResponse: MetricRangePayloadProps,
	isDarkMode: boolean,
): Record<string, { [x: string]: any; data: number[][]; color: string }> => {
	const anomalyDetectionData = apiResponse?.data?.newResult?.data?.result;
	return processAnomalyDetectionData(anomalyDetectionData, isDarkMode);
};