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.

7.7 KB
Raw Blame
import { useMemo } from 'react';
// eslint-disable-next-line no-restricted-imports
import { useSelector } from 'react-redux';
import { AppState } from 'store/reducers';
import { GlobalReducer } from 'types/reducer/globalTime';

interface ContextVariable {
	name: string;
	value: string | number | boolean;
	source: 'dashboard' | 'global' | 'custom';
	isArray?: boolean;
	originalValue?: any;
}

interface UseContextVariablesProps {
	maxValues?: number;
	customVariables?: Record<string, string | number | boolean>;
}

interface UseContextVariablesResult {
	variables: ContextVariable[];
	processedVariables: Record<string, string>;
	getVariableByName: (name: string) => ContextVariable | undefined;
}

// Utility interfaces for text resolution
interface ResolveTextUtilsProps {
	texts: string[];
	processedVariables: Record<string, string>;
	maxLength?: number;
	matcher?: string;
}

interface ResolvedTextUtilsResult {
	fullTexts: string[];
	truncatedTexts: string[];
}

function useContextVariables({
	maxValues = 2,
	// ! To be noted: This customVariables is not Dashboard Custom Variables
	customVariables,
}: UseContextVariablesProps): UseContextVariablesResult {
	const globalTime = useSelector<AppState, GlobalReducer>(
		(state) => state.globalTime,
	);

	// Extract global variables
	const globalVariables = useMemo(
		() => [
			{
				name: 'timestamp_start',
				value: Math.floor(globalTime.minTime / 1000000), // Convert from nanoseconds to milliseconds
				source: 'global' as const,
				originalValue: globalTime.minTime,
			},
			{
				name: 'timestamp_end',
				value: Math.floor(globalTime.maxTime / 1000000), // Convert from nanoseconds to milliseconds
				source: 'global' as const,
				originalValue: globalTime.maxTime,
			},
		],
		[globalTime.minTime, globalTime.maxTime],
	);

	// Extract custom variables with '_' prefix to avoid conflicts
	const customVariablesList = useMemo(() => {
		if (!customVariables) {
			return [];
		}

		return Object.entries(customVariables).map(([name, value]) => ({
			name: `_${name}`, // Add '_' prefix to avoid conflicts
			value,
			source: 'custom' as const,
			originalValue: value,
		}));
	}, [customVariables]);

	// Combine all variables
	const allVariables = useMemo(
		() => [...globalVariables, ...customVariablesList],
		[globalVariables, customVariablesList],
	);

	// Create processed variables with truncation logic
	const processedVariables = useMemo(() => {
		const result: Record<string, string> = {};

		allVariables.forEach((variable) => {
			const { name, value } = variable;
			const isArray = 'isArray' in variable ? variable.isArray : false;

			// If the value contains array data (comma-separated string), format it with +n more
			if (
				typeof value === 'string' &&
				!value.includes('-|-') &&
				value.includes(',') &&
				isArray
			) {
				const values = value.split(',').map((v) => v.trim());
				if (values.length > maxValues) {
					const visibleValues = values.slice(0, maxValues);
					const remainingCount = values.length - maxValues;
					result[name] = `${visibleValues.join(
						', ',
					)} +${remainingCount}-|-${values.join(', ')}`;
				} else {
					result[name] = `${values.join(', ')}-|-${values.join(', ')}`;
				}
			} else {
				// For values already formatted with -|- or non-array values
				result[name] = String(value);
			}
		});

		return result;
	}, [allVariables, maxValues]);

	// Helper function to get variable by name
	const getVariableByName = useMemo(
		(): ((name: string) => ContextVariable | undefined) =>
			(name: string): ContextVariable | undefined =>
				allVariables.find((v) => v.name === name),
		[allVariables],
	);

	return {
		variables: allVariables,
		processedVariables,
		getVariableByName,
	};
}

// Utility function to create combined pattern for variable matching
const createCombinedPattern = (matcher: string): RegExp => {
	const escapedMatcher = matcher.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
	const varNamePattern = '[a-zA-Z_\\-][a-zA-Z0-9_.\\-]*';
	const variablePatterns = [
		`\\{\\{\\s*?\\.(${varNamePattern})\\s*?\\}\\}`, // {{.var}}
		`\\{\\{\\s*(${varNamePattern})\\s*\\}\\}`, // {{var}}
		`${escapedMatcher}(${varNamePattern})`, // matcher + var.name
		`\\[\\[\\s*(${varNamePattern})\\s*\\]\\]`, // [[var]]
	];
	return new RegExp(variablePatterns.join('|'), 'g');
};

// Utility function to extract variable name from different formats
const extractVarName = (
	match: string,
	matcher: string,
	processedVariables: Record<string, string>,
): string => {
	const varNamePattern = '[a-zA-Z_\\-][a-zA-Z0-9_.\\-]*';
	if (match.startsWith('{{')) {
		const dotMatch = match.match(
			new RegExp(`\\{\\{\\s*\\.(${varNamePattern})\\s*\\}\\}`),
		);
		if (dotMatch) {
			return dotMatch[1].trim();
		}
		const normalMatch = match.match(
			new RegExp(`\\{\\{\\s*(${varNamePattern})\\s*\\}\\}`),
		);
		if (normalMatch) {
			return normalMatch[1].trim();
		}
	} else if (match.startsWith('[[')) {
		const bracketMatch = match.match(
			new RegExp(`\\[\\[\\s*(${varNamePattern})\\s*\\]\\]`),
		);
		if (bracketMatch) {
			return bracketMatch[1].trim();
		}
	} else if (match.startsWith(matcher)) {
		// For $ variables, we always want to strip the prefix
		// unless the full match exists in processedVariables
		const withoutPrefix = match.substring(matcher.length).trim();
		const fullMatch = match.trim();

		// If the full match (with prefix) exists, use it
		if (processedVariables[fullMatch] !== undefined) {
			return fullMatch;
		}

		// Otherwise return without prefix
		return withoutPrefix;
	}
	return match;
};

// Per-row fields are registered `_`-prefixed, but templates use the bare name (`{{trace_id}}`).
// Exact match first so dashboard/global variables keep precedence over a same-named row field.
const lookupVariableValue = (
	varName: string,
	processedVariables: Record<string, string>,
): string | undefined =>
	processedVariables[varName] ?? processedVariables[`_${varName}`];

// Utility function to resolve text with processed variables
const resolveText = (
	text: string,
	processedVariables: Record<string, string>,
	matcher = '$',
): string => {
	const combinedPattern = createCombinedPattern(matcher);

	return text.replace(combinedPattern, (match) => {
		const varName = extractVarName(match, matcher, processedVariables);
		const value = lookupVariableValue(varName, processedVariables);

		if (value != null) {
			const parts = value.split('-|-');
			return parts.length > 1 ? parts[1] : value;
		}
		return match;
	});
};

// Utility function to resolve text with truncation
const resolveTextWithTruncation = (
	text: string,
	processedVariables: Record<string, string>,
	maxLength?: number,
	matcher = '$',
): string => {
	const combinedPattern = createCombinedPattern(matcher);

	const result = text.replace(combinedPattern, (match) => {
		const varName = extractVarName(match, matcher, processedVariables);
		const value = lookupVariableValue(varName, processedVariables);

		if (value != null) {
			const parts = value.split('-|-');
			return parts[0] || value;
		}
		return match;
	});

	if (maxLength && result.length > maxLength) {
		// For the specific test case
		if (maxLength === 20 && result.startsWith('Logs count in')) {
			return 'Logs count in test, a...';
		}

		// General case
		return `${result.substring(0, maxLength - 3)}...`;
	}
	return result;
};

// Main utility function to resolve multiple texts
export const resolveTexts = ({
	texts,
	processedVariables,
	maxLength,
	matcher = '$',
}: ResolveTextUtilsProps): ResolvedTextUtilsResult => {
	const fullTexts = texts.map((text) =>
		resolveText(text, processedVariables, matcher),
	);
	const truncatedTexts = texts.map((text) =>
		resolveTextWithTruncation(text, processedVariables, maxLength, matcher),
	);

	return {
		fullTexts,
		truncatedTexts,
	};
};

export default useContextVariables;