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.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
import { CONTEXT_LINK_FIELDS } from 'utils/contextLinks/constants';
import { resolveTexts } from 'hooks/dashboard/useContextVariables';
import { ContextLinkProps } from 'types/api/widgets/widget';
import { v4 as uuid } from 'uuid';
// Configuration for variable source types
export const VARIABLE_SOURCE_CONFIG = {
TIMESTAMP: {
label: 'Global timestamp',
},
QUERY: {
label: 'Query variable',
},
GLOBAL: {
label: 'Global variable',
},
DASHBOARD: {
label: 'Dashboard variable',
},
} as const;
interface ContextVariable {
name: string;
source?: string;
}
interface TransformedVariable {
name: string;
source: string;
}
interface UrlParam {
key: string;
value: string;
}
interface ProcessedContextLink {
id: string;
label: string;
url: string;
}
const getInitialValues = (
contextLink: ContextLinkProps | null,
): Record<string, string> => ({
[CONTEXT_LINK_FIELDS.ID]: contextLink?.id || uuid(),
[CONTEXT_LINK_FIELDS.LABEL]: contextLink?.label || '',
[CONTEXT_LINK_FIELDS.URL]: contextLink?.url || '',
});
const getUrlParams = (url: string): UrlParam[] => {
try {
const [, queryString] = url.split('?');
if (!queryString) {
return [];
}
const paramPairs = queryString.split('&');
const params: UrlParam[] = [];
paramPairs.forEach((pair) => {
try {
const [key, value] = pair.split('=');
if (key) {
const decodedKey = decodeURIComponent(key);
const decodedValue = decodeURIComponent(value || '');
// Double decode the value for display
let displayValue = decodedValue;
try {
// Try to double decode if it looks like it was double encoded
const doubleDecoded = decodeURIComponent(decodedValue);
// Check if double decoding produced a different result
if (doubleDecoded !== decodedValue) {
displayValue = doubleDecoded;
}
} catch {
// If double decoding fails, use single decoded value
displayValue = decodedValue;
}
params.push({
key: decodedKey,
value: displayValue,
});
}
} catch (paramError) {
// Skip malformed parameters and continue processing
console.warn('Failed to parse URL parameter:', pair, paramError);
}
});
return params;
} catch (error) {
console.warn('Failed to parse URL parameters, returning empty array:', error);
return [];
}
};
const updateUrlWithParams = (url: string, params: UrlParam[]): string => {
// Get base URL without query parameters
const [baseUrl] = url.split('?');
// Create query parameter string from current parameters
const validParams = params.filter((param) => param.key.trim() !== '');
const queryString = validParams
.map(
(param) =>
`${encodeURIComponent(param.key.trim())}=${encodeURIComponent(
param.value,
)}`,
)
.join('&');
// Construct final URL
return queryString ? `${baseUrl}?${queryString}` : baseUrl;
};
// Utility function to process context links with variable resolution and URL encoding
const processContextLinks = (
contextLinks: ContextLinkProps[],
processedVariables: Record<string, string>,
maxLength?: number,
): ProcessedContextLink[] => {
// Extract all labels and URLs for batch processing
const labels = contextLinks.map(({ label }) => label);
const urls = contextLinks.map(({ url }) => url);
// Resolve variables in labels
const resolvedLabels = resolveTexts({
texts: labels,
processedVariables,
maxLength,
});
// Process URLs with proper encoding/decoding
const finalUrls = urls.map((url) => {
if (typeof url !== 'string') {
return url;
}
try {
// 1. Get the URL and extract base URL and query string
const [baseUrl, queryString] = url.split('?');
// Resolve variables in base URL.
const resolvedBaseUrlResult = resolveTexts({
texts: [baseUrl],
processedVariables,
});
const resolvedBaseUrl = resolvedBaseUrlResult.fullTexts[0];
if (!queryString) {
return resolvedBaseUrl;
}
// 2. Extract all query params using URLSearchParams
const searchParams = new URLSearchParams(queryString);
const processedParams: Record<string, string> = {};
// 3. Process each parameter
Array.from(searchParams.entries()).forEach(([key, value]) => {
// 4. Decode twice to handle double encoding
let decodedValue = decodeURIComponent(value);
try {
const doubleDecoded = decodeURIComponent(decodedValue);
// Check if double decoding produced a different result
if (doubleDecoded !== decodedValue) {
decodedValue = doubleDecoded;
}
} catch {
// If double decoding fails, use single decoded value
}
// 5. Pass through resolve text for variable resolution
const resolvedTextsResult = resolveTexts({
texts: [decodedValue],
processedVariables,
});
const resolvedValue = resolvedTextsResult.fullTexts[0];
// 6. Encode the resolved value
processedParams[key] = encodeURIComponent(resolvedValue);
});
// 7. Create new URL with processed parameters
const newQueryString = Object.entries(processedParams)
.map(([key, value]) => `${encodeURIComponent(key)}=${value}`)
.join('&');
return `${resolvedBaseUrl}?${newQueryString}`;
} catch (error) {
console.warn('Failed to process URL, using original URL:', error);
return url;
}
});
// Return processed context links
return contextLinks.map((link, index) => ({
id: link.id,
label: resolvedLabels.fullTexts[index],
url: finalUrls[index],
}));
};
/**
* Transforms context variables into the format expected by VariablesPopover
* @param variables - Array of context variables from useContextVariables
* @returns Array of transformed variables with proper source descriptions
*/
export const transformContextVariables = (
variables: ContextVariable[],
): TransformedVariable[] => {
const groupedVars: { [key: string]: TransformedVariable[] } = {};
// Process variables array from useContextVariables
variables.forEach((variable) => {
let source = VARIABLE_SOURCE_CONFIG.DASHBOARD.label as string; // Default to dashboard
// Check if it's a timestamp variable (special case - use name-based detection)
if (variable.name.toLowerCase().includes('timestamp')) {
source = VARIABLE_SOURCE_CONFIG.TIMESTAMP.label;
}
// Use the actual source property from the variable
else if (variable.source === 'global') {
source = VARIABLE_SOURCE_CONFIG.GLOBAL.label;
} else if (variable.source === 'custom') {
source = VARIABLE_SOURCE_CONFIG.QUERY.label;
} else if (variable.source === 'dashboard') {
source = VARIABLE_SOURCE_CONFIG.DASHBOARD.label;
}
// Group variables by source
if (!groupedVars[source]) {
groupedVars[source] = [];
}
groupedVars[source].push({
name: variable.name,
source,
});
});
// Flatten the grouped variables to maintain source grouping order
const allVars: TransformedVariable[] = [];
// Add variables in the order we want them to appear
const sourceOrder = [
VARIABLE_SOURCE_CONFIG.TIMESTAMP.label,
VARIABLE_SOURCE_CONFIG.GLOBAL.label,
VARIABLE_SOURCE_CONFIG.QUERY.label,
VARIABLE_SOURCE_CONFIG.DASHBOARD.label,
];
sourceOrder.forEach((source) => {
if (groupedVars[source]) {
allVars.push(...groupedVars[source]);
}
});
return allVars;
};
export {
getInitialValues,
getUrlParams,
processContextLinks,
updateUrlWithParams,
};