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 { useMemo, useRef, useState } from 'react';
import { Color } from '@signozhq/design-tokens';
import { Group } from '@visx/group';
import { Pie } from '@visx/shape';
import { useTooltip, useTooltipInPortal } from '@visx/tooltip';
import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
import { themeColors } from 'constants/theme';
import { getPieChartClickData } from 'container/QueryTable/Drilldown/drilldownUtils';
import useGraphContextMenu from 'container/QueryTable/Drilldown/useGraphContextMenu';
import { useIsDarkMode } from 'hooks/useDarkMode';
import ContextMenu, { useCoordinates } from 'periscope/components/ContextMenu';
import {
PanelWrapperProps,
TooltipData,
} from 'container/WidgetCard/Panels/panelWrapper.types';
import { preparePieChartData } from 'container/WidgetCard/Panels/preparePieChartData';
import { lightenColor, tooltipStyles } from 'container/WidgetCard/Panels/utils';
import 'container/WidgetCard/Panels/PiePanelWrapper.styles.scss';
// reference: https://www.youtube.com/watch?v=bL3P9CqQkKw
function PiePanelWrapper({
queryResponse,
widget,
enableDrillDown = false,
}: PanelWrapperProps): JSX.Element {
const [active, setActive] = useState<{
label: string;
value: string;
color: string;
} | null>(null);
const {
tooltipOpen,
tooltipLeft,
tooltipTop,
tooltipData,
hideTooltip,
showTooltip,
} = useTooltip<TooltipData>();
const { containerRef, TooltipInPortal } = useTooltipInPortal({
scroll: true,
detectBounds: true,
});
const isDarkMode = useIsDarkMode();
const pieChartData = useMemo(
() =>
preparePieChartData(queryResponse.data?.payload, {
customLegendColors: widget?.customLegendColors,
colorMap: isDarkMode ? themeColors.chartcolors : themeColors.lightModeColor,
}),
[queryResponse.data?.payload, widget?.customLegendColors, isDarkMode],
);
let size = 0;
let width = 0;
let height = 0;
const chartRef = useRef<HTMLDivElement>(null);
if (chartRef.current) {
const { offsetWidth, offsetHeight } = chartRef.current;
size = Math.min(offsetWidth, offsetHeight);
width = offsetWidth;
height = offsetHeight;
}
// Adjust the size to leave room for external labels
const radius = size * 0.35;
// Add inner radius for donut chart
const innerRadius = radius * 0.6;
// Calculate total value for center display
const totalValue = pieChartData.reduce(
(sum, data) => sum + parseFloat(data.value || '0'),
0,
);
// Format total for display with the same unit as segments
const formattedTotal = getYAxisFormattedValue(
totalValue.toString(),
widget?.yAxisUnit || 'none',
widget?.decimalPrecision,
);
// Extract numeric part and unit separately for styling
const matches = formattedTotal.match(/([\d.]+[KMB]?)(.*)$/);
const numericTotal = matches?.[1] || formattedTotal;
const unitTotal = matches?.[2]?.trim() || '';
// Dynamically calculate font size based on text length to prevent overflow
const getScaledFontSize = ({
text,
baseSize,
innerRadius,
}: {
text: string;
baseSize: number;
innerRadius: number;
}): number => {
if (!text) {
return baseSize;
}
const { length } = text;
// More aggressive scaling for very long numbers
const scaleFactor = Math.max(0.3, 1 - (length - 3) * 0.09);
// Ensure text fits in the inner circle (roughly)
const maxSize = innerRadius * 0.9; // Don't use more than 90% of inner radius
return Math.min(baseSize * scaleFactor, maxSize);
};
const numericFontSize = getScaledFontSize({
text: numericTotal,
baseSize: radius * 0.3,
innerRadius,
});
const unitFontSize = numericFontSize * 0.5; // Unit size is half of numeric size
const getFillColor = (color: string): string => {
if (active === null) {
return color;
}
const lightenedColor = lightenColor(color, 0.4); // Adjust the opacity value (0.4 in this case)
return active.color === color ? color : lightenedColor;
};
const {
coordinates,
popoverPosition,
clickedData,
onClose,
onClick,
subMenu,
setSubMenu,
} = useCoordinates();
const { menuItemsConfig } = useGraphContextMenu({
widgetId: widget.id || '',
query: widget.query,
graphData: clickedData,
onClose,
coordinates,
subMenu,
setSubMenu,
contextLinks: widget.contextLinks,
panelType: widget.panelTypes,
queryRange: queryResponse,
});
return (
<div className="piechart-wrapper">
{!pieChartData.length && <div className="piechart-no-data">No data</div>}
{pieChartData.length > 0 && (
<>
<div className="piechart-container" ref={chartRef}>
<svg width={width} height={height} ref={containerRef}>
<Group top={height / 2} left={width / 2}>
<Pie
data={pieChartData}
pieValue={(data: {
label: string;
value: string;
color: string;
}): number => parseFloat(data.value)}
outerRadius={radius}
innerRadius={innerRadius}
padAngle={0.01}
cornerRadius={3}
width={size}
height={size}
>
{
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type, sonarjs/cognitive-complexity
(pie) =>
pie.arcs.map((arc) => {
const { label } = arc.data;
const [centroidX, centroidY] = pie.path.centroid(arc);
const arcPath = pie.path(arc);
const arcFill = arc.data.color;
// Calculate angle bisector for the arc (midpoint of the arc)
const angle = (arc.startAngle + arc.endAngle) / 2;
// Calculate outer point for the label
const labelRadius = radius * 1.3; // Label position
const labelX = Math.sin(angle) * labelRadius;
const labelY = -Math.cos(angle) * labelRadius;
// Calculate endpoint for the connecting line
const lineEndRadius = radius * 1.1;
const lineEndX = Math.sin(angle) * lineEndRadius;
const lineEndY = -Math.cos(angle) * lineEndRadius;
// Format the value for display
const displayValue = getYAxisFormattedValue(
arc.data.value,
widget?.yAxisUnit || 'none',
widget?.decimalPrecision,
);
// Determine text anchor based on position in the circle
const textAnchor = Math.sin(angle) > 0 ? 'start' : 'end';
// Shorten label if too long
const shortenedLabel =
label.length > 15 ? `${label.substring(0, 12)}...` : label;
const shouldShowLabel =
parseFloat(arc.data.value) /
pieChartData.reduce((sum, d) => sum + parseFloat(d.value), 0) >
0.03;
return (
<g
key={`arc-${label}-${arc.data.value}-${arc.startAngle.toFixed(
6,
)}`}
onMouseEnter={(): void => {
showTooltip({
tooltipData: {
label,
value: displayValue,
color: arc.data.color,
key: label,
},
tooltipTop: centroidY + height / 2,
tooltipLeft: centroidX + width / 2,
});
setActive(arc.data);
}}
onMouseLeave={(): void => {
hideTooltip();
setActive(null);
}}
onClick={(e): void => {
if (enableDrillDown) {
const data = getPieChartClickData(arc);
if (data && data?.queryName) {
onClick(
{ x: e.clientX, y: e.clientY },
{ ...data, label: data.label },
);
}
}
}}
>
<path d={arcPath || ''} fill={getFillColor(arcFill)} />
{shouldShowLabel && (
<>
{/* Connecting line */}
<line
x1={centroidX}
y1={centroidY}
x2={lineEndX}
y2={lineEndY}
stroke={isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400}
strokeWidth={1}
/>
{/* Line from arc edge to label */}
<line
x1={lineEndX}
y1={lineEndY}
x2={labelX}
y2={labelY}
stroke={isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400}
strokeWidth={1}
/>
{/* Label text */}
<text
x={labelX}
y={labelY - 8}
dy=".33em"
fill={isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400}
fontSize={10}
textAnchor={textAnchor}
pointerEvents="none"
>
{shortenedLabel}
</text>
{/* Value text */}
<text
x={labelX}
y={labelY + 8}
dy=".33em"
fill={isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400}
fontSize={10}
fontWeight="bold"
textAnchor={textAnchor}
pointerEvents="none"
>
{displayValue}
</text>
</>
)}
</g>
);
})
}
</Pie>
<ContextMenu
coordinates={coordinates}
popoverPosition={popoverPosition}
title={menuItemsConfig.header as string}
items={menuItemsConfig.items}
onClose={onClose}
/>
{/* Add total value in the center */}
<text
textAnchor="middle"
dominantBaseline="central"
fill={isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400}
>
<tspan fontSize={numericFontSize} fontWeight="bold">
{numericTotal}
</tspan>
{unitTotal && (
<tspan fontSize={unitFontSize} opacity={0.9} dx={2}>
{unitTotal}
</tspan>
)}
</text>
</Group>
</svg>
{tooltipOpen && tooltipData && (
<TooltipInPortal
top={tooltipTop}
left={tooltipLeft}
style={{
...tooltipStyles,
background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
color: isDarkMode ? Color.BG_VANILLA_100 : Color.BG_INK_400,
}}
className="piechart-tooltip"
>
<div
style={{
background: tooltipData.color,
}}
className="piechart-indicator"
/>
{tooltipData.key}
<div className="tooltip-value">{tooltipData.value}</div>
</TooltipInPortal>
)}
</div>
<div className="piechart-legend">
{pieChartData.map((data) => (
<div
key={data.label}
className="piechart-legend-item"
onMouseEnter={(): void => {
setActive(data);
}}
onMouseLeave={(): void => {
setActive(null);
}}
>
<div
style={{
backgroundColor: getFillColor(data.color),
}}
className="piechart-legend-label"
/>
{data.label}
</div>
))}
</div>
</>
)}
</div>
);
}
export default PiePanelWrapper;