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.

11.0 KB
Raw Blame
import { PrecisionOption } from 'components/Graph/types';
import { getToolTipValue } from 'components/Graph/yAxisConfig';
import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
import { themeColors } from 'constants/theme';
import dayjs from 'dayjs';
import customParseFormat from 'dayjs/plugin/customParseFormat';
import { getLegend } from 'lib/dashboard/getQueryResults';
import getLabelName from 'lib/getLabelName';
import { get } from 'lodash-es';
import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
import { Query } from 'types/api/queryBuilder/queryBuilderData';

import { placement } from '../placement';
import { generateColor } from '../utils/generateColor';

dayjs.extend(customParseFormat);

interface UplotTooltipDataProps {
	show: boolean;
	color: string;
	label: string;
	focus: boolean;
	value: number;
	tooltipValue: string;
	textContent: string;
	queryName: string;
}

function getTooltipBaseValue(
	data: any[],
	index: number,
	idx: number,
	stackBarChart: boolean | undefined,
): any {
	if (stackBarChart && index + 1 < data.length) {
		return data[index][idx] - data[index + 1][idx];
	}

	return data[index][idx];
}

function sortTooltipContentBasedOnValue(
	tooltipDataObj: Record<string, UplotTooltipDataProps>,
): Record<string, UplotTooltipDataProps> {
	const entries = Object.entries(tooltipDataObj);

	// Separate focused and non-focused entries in a single pass
	const focusedEntries: [string, UplotTooltipDataProps][] = [];
	const nonFocusedEntries: [string, UplotTooltipDataProps][] = [];

	for (let i = 0; i < entries.length; i++) {
		const entry = entries[i];
		if (entry[1].focus) {
			focusedEntries.push(entry);
		} else {
			nonFocusedEntries.push(entry);
		}
	}

	// Sort non-focused entries by value (descending)
	nonFocusedEntries.sort((a, b) => b[1].value - a[1].value);

	// Combine with focused entries on top
	return Object.fromEntries(focusedEntries.concat(nonFocusedEntries));
}

const generateTooltipContent = (
	seriesList: any[],
	data: any[],
	idx: number,
	isDarkMode: boolean,
	yAxisUnit?: string,
	decimalPrecision?: PrecisionOption,
	series?: uPlot.Options['series'],
	isBillingUsageGraphs?: boolean,
	isHistogramGraphs?: boolean,
	isMergedSeries?: boolean,
	stackBarChart?: boolean,
	timezone?: string,
	colorMapping?: Record<string, string>,
	query?: Query,
	// eslint-disable-next-line sonarjs/cognitive-complexity
): HTMLElement => {
	const container = document.createElement('div');
	container.classList.add('tooltip-container');
	let tooltipCount = 0;

	let tooltipTitle = '';
	const formattedData: Record<string, UplotTooltipDataProps> = {};
	const duplicatedLegendLabels: Record<string, true> = {};

	// Pre-build a label-to-series map for O(1) lookup instead of O(n) search
	let seriesColorMap: Map<string, string> | null = null;
	if (isBillingUsageGraphs && series) {
		seriesColorMap = new Map();
		for (let i = 0; i < series.length; i++) {
			const item = series[i];
			if (item.label) {
				const fillColor = get(item, '_fill');
				if (fillColor) {
					seriesColorMap.set(item.label, fillColor);
				}
			}
		}
	}

	if (Array.isArray(series) && series.length > 0) {
		for (let index = 0; index < series.length; index++) {
			const item = series[index];

			if (index === 0) {
				if (isBillingUsageGraphs) {
					tooltipTitle = dayjs(data[0][idx] * 1000)
						.tz(timezone)
						.format(DATE_TIME_FORMATS.MONTH_YEAR);
				} else {
					tooltipTitle = dayjs(data[0][idx] * 1000)
						.tz(timezone)
						.format(DATE_TIME_FORMATS.MONTH_DATETIME_SECONDS);
				}
			} else if (item.show) {
				const {
					metric = {},
					queryName = '',
					legend = '',
					quantity = [],
					unit = '',
				} = seriesList[index - 1] || {};

				const value = getTooltipBaseValue(data, index, idx, stackBarChart);

				const dataIngested = quantity[idx];
				const baseLabelName = getLabelName(metric, queryName || '', legend || '');

				let label = '';
				if (isMergedSeries) {
					label = '';
				} else if (query) {
					label = getLegend(seriesList[index - 1], query, baseLabelName);
				} else {
					label = baseLabelName;
				}

				let color =
					colorMapping?.[label] ||
					generateColor(
						label,
						isDarkMode ? themeColors.chartcolors : themeColors.lightModeColor,
					);

				// O(1) lookup instead of O(n) search for billing graph colors
				if (isBillingUsageGraphs && seriesColorMap) {
					const billingColor = seriesColorMap.get(label);
					if (billingColor) {
						color = billingColor;
					}
				}

				let tooltipItemLabel = label;

				if (Number.isFinite(value)) {
					const tooltipValue = getToolTipValue(value, yAxisUnit, decimalPrecision);
					const dataIngestedFormated = getToolTipValue(dataIngested);
					if (duplicatedLegendLabels[label] || label in formattedData) {
						duplicatedLegendLabels[label] = true;
						const tempDataObj = formattedData[label];

						if (tempDataObj) {
							const newLabel = `${tempDataObj.queryName}: ${tempDataObj.label}`;

							tempDataObj.textContent = `${newLabel} : ${tempDataObj.tooltipValue}`;

							formattedData[newLabel] = tempDataObj;

							delete formattedData[label];
						}

						tooltipItemLabel = `${queryName}: ${label}`;
					}

					const dataObj = {
						show: item.show || false,
						color,
						label,
						// @ts-expect-error
						focus: item?._focus || false,
						value,
						tooltipValue,
						queryName,
						textContent: isBillingUsageGraphs
							? `${tooltipItemLabel} : $${tooltipValue} - ${dataIngestedFormated} ${unit}`
							: `${tooltipItemLabel} : ${tooltipValue}`,
					};

					tooltipCount += 1;

					formattedData[tooltipItemLabel] = dataObj;
				}
			}
		}
	}

	// Early return if no valid data points - avoids unnecessary DOM manipulation
	if (tooltipCount <= 0) {
		return container;
	}

	const sortedData: Record<string, UplotTooltipDataProps> =
		sortTooltipContentBasedOnValue(formattedData);

	const headerDiv = document.createElement('div');
	headerDiv.classList.add('tooltip-content-row', 'tooltip-content-header');
	headerDiv.textContent = isHistogramGraphs ? '' : tooltipTitle;
	container.appendChild(headerDiv);

	// Use DocumentFragment for better performance when adding multiple elements
	const fragment = document.createDocumentFragment();

	const sortedValues = Object.values(sortedData);

	for (let i = 0; i < sortedValues.length; i++) {
		const { textContent, color, focus } = sortedValues[i];

		const div = document.createElement('div');
		div.classList.add('tooltip-content-row', 'tooltip-content');

		const squareBox = document.createElement('div');
		squareBox.classList.add('pointSquare');
		squareBox.style.borderColor = color;

		const text = document.createElement('div');
		text.classList.add('tooltip-data-point');
		text.textContent = textContent;
		text.style.color = color;

		if (focus) {
			text.classList.add('focus');
		}

		div.appendChild(squareBox);
		div.appendChild(text);
		fragment.appendChild(div);
	}

	if (fragment.hasChildNodes()) {
		container.appendChild(fragment);
	}

	return container;
};

type ToolTipPluginProps = {
	apiResponse: MetricRangePayloadProps | undefined;
	yAxisUnit?: string;
	isBillingUsageGraphs?: boolean;
	isHistogramGraphs?: boolean;
	isMergedSeries?: boolean;
	decimalPrecision?: PrecisionOption;
	stackBarChart?: boolean;
	isDarkMode: boolean;
	customTooltipElement?: HTMLDivElement;
	timezone?: string;
	colorMapping?: Record<string, string>;
	query?: Query;
};

const tooltipPlugin = ({
	apiResponse,
	yAxisUnit,
	isBillingUsageGraphs,
	isHistogramGraphs,
	isMergedSeries,
	stackBarChart,
	isDarkMode,
	customTooltipElement,
	timezone,
	colorMapping,
	query,
	decimalPrecision,
}: ToolTipPluginProps): any => {
	let over: HTMLElement;
	let bound: HTMLElement;
	// Cache bounding box to avoid recalculating on every cursor move
	let cachedBBox: DOMRect | null = null;
	let isActive = false;
	let overlay: HTMLElement | null = null;

	// Pre-compute apiResult once
	const apiResult = apiResponse?.data?.result || [];

	// Sync bounds and cache the result
	const syncBounds = (): void => {
		if (over) {
			cachedBBox = over.getBoundingClientRect();
		}
	};

	// Create overlay once and reuse it
	const initOverlay = (): void => {
		if (!overlay) {
			overlay = document.getElementById('overlay');
			if (!overlay) {
				overlay = document.createElement('div');
				overlay.id = 'overlay';
				overlay.style.cssText = 'display: none; position: absolute;';
				document.body.appendChild(overlay);
			}
		}
	};

	const showOverlay = (): void => {
		if (overlay && overlay.style.display === 'none') {
			overlay.style.display = 'block';
		}
	};

	const hideOverlay = (): void => {
		if (overlay && overlay.style.display === 'block') {
			overlay.style.display = 'none';
		}
	};

	const plotEnter = (): void => {
		isActive = true;
		showOverlay();
	};

	const plotLeave = (): void => {
		isActive = false;
		hideOverlay();
	};

	// Cleanup function to remove event listeners
	const cleanup = (): void => {
		if (over) {
			over.removeEventListener('mouseenter', plotEnter);
			over.removeEventListener('mouseleave', plotLeave);
		}
	};

	return {
		hooks: {
			init: (u: any): void => {
				over = u?.over;
				bound = over;

				// Initialize overlay once during init
				initOverlay();

				// Initial bounds sync
				syncBounds();

				over.addEventListener('mouseenter', plotEnter);
				over.addEventListener('mouseleave', plotLeave);
			},
			setSize: (): void => {
				// Re-sync bounds when size changes
				syncBounds();
			},
			// Cache bounding box on syncRect for better performance
			syncRect: (u: any, rect: DOMRect): void => {
				cachedBBox = rect;
			},
			setCursor: (u: {
				cursor: { left: any; top: any; idx: any };
				data: any[];
				series: uPlot.Options['series'];
			}): void => {
				if (!overlay) {
					return;
				}

				const { left, top, idx } = u.cursor;

				// Early return if not active or no valid index
				if (!isActive || !Number.isInteger(idx)) {
					if (isActive) {
						// Clear tooltip content efficiently using replaceChildren
						overlay.replaceChildren();
					}
					return;
				}

				// Use cached bounding box if available
				const bbox = cachedBBox || over.getBoundingClientRect();
				const anchor = {
					left: left + bbox.left,
					top: top + bbox.top,
				};

				const content = generateTooltipContent(
					apiResult,
					u.data,
					idx,
					isDarkMode,
					yAxisUnit,
					decimalPrecision,
					u.series,
					isBillingUsageGraphs,
					isHistogramGraphs,
					isMergedSeries,
					stackBarChart,
					timezone,
					colorMapping,
					query,
				);

				// Only show tooltip if there's actual content
				if (content.children.length > 1) {
					if (customTooltipElement) {
						content.appendChild(customTooltipElement);
					}
					// Clear and set new content in one operation
					overlay.replaceChildren(content);
					placement(overlay, anchor, 'right', 'start', {
						bound,
						followCursor: { x: anchor.left, y: anchor.top, offset: 4 },
					});

					showOverlay();
				} else {
					hideOverlay();
				}
			},
			destroy: (): void => {
				// Cleanup on destroy
				cleanup();
				hideOverlay();
			},
		},
	};
};

export default tooltipPlugin;