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.

13.5 KB
Raw Blame
import uPlot from 'uplot';

export function pointWithin(
	px: number,
	py: number,
	rlft: number,
	rtop: number,
	rrgt: number,
	rbtm: number,
): boolean {
	return px >= rlft && px <= rrgt && py >= rtop && py <= rbtm;
}
const MAX_OBJECTS = 10;
const MAX_LEVELS = 4;

export class Quadtree {
	x: number;

	y: number;

	w: number;

	h: number;

	l: number;

	o: any[];

	q: Quadtree[] | null;

	constructor(x: number, y: number, w: number, h: number, l?: number) {
		this.x = x;
		this.y = y;
		this.w = w;
		this.h = h;
		this.l = l || 0;
		this.o = [];
		this.q = null;
	}

	split(): void {
		const w = this.w / 2;
		const h = this.h / 2;
		const l = this.l + 1;

		this.q = [
			// top right
			new Quadtree(this.x + w, this.y, w, h, l),
			// top left
			new Quadtree(this.x, this.y, w, h, l),
			// bottom left
			new Quadtree(this.x, this.y + h, w, h, l),
			// bottom right
			new Quadtree(this.x + w, this.y + h, w, h, l),
		];
	}

	quads(
		x: number,
		y: number,
		w: number,
		h: number,
		cb: (quad: Quadtree) => void,
	): void {
		const { q } = this;
		const hzMid = this.x + this.w / 2;
		const vtMid = this.y + this.h / 2;
		const startIsNorth = y < vtMid;
		const startIsWest = x < hzMid;
		const endIsEast = x + w > hzMid;
		const endIsSouth = y + h > vtMid;
		if (q) {
			// top-right quad
			if (startIsNorth && endIsEast) {
				cb(q[0]);
			}
			// top-left quad
			if (startIsWest && startIsNorth) {
				cb(q[1]);
			}
			// bottom-left quad
			if (startIsWest && endIsSouth) {
				cb(q[2]);
			}
			// bottom-right quad
			if (endIsEast && endIsSouth) {
				cb(q[3]);
			}
		}
	}

	add(o: any): void {
		if (this.q != null) {
			this.quads(o.x, o.y, o.w, o.h, (q) => {
				q.add(o);
			});
		} else {
			const os = this.o;

			os.push(o);

			if (os.length > MAX_OBJECTS && this.l < MAX_LEVELS) {
				this.split();

				for (let i = 0; i < os.length; i++) {
					const oi = os[i];

					this.quads(oi.x, oi.y, oi.w, oi.h, (q) => {
						q.add(oi);
					});
				}

				this.o.length = 0;
			}
		}
	}

	get(x: number, y: number, w: number, h: number, cb: (o: any) => void): void {
		const os = this.o;

		for (let i = 0; i < os.length; i++) {
			cb(os[i]);
		}

		if (this.q != null) {
			this.quads(x, y, w, h, (q) => {
				q.get(x, y, w, h, cb);
			});
		}
	}

	clear(): void {
		this.o.length = 0;
		this.q = null;
	}
}

Object.assign(Quadtree.prototype, {
	split: Quadtree.prototype.split,
	quads: Quadtree.prototype.quads,
	add: Quadtree.prototype.add,
	get: Quadtree.prototype.get,
	clear: Quadtree.prototype.clear,
});

const { round, min, ceil } = Math;

function roundDec(val: number, dec: number): number {
	return Math.round(val * 10 ** dec) / 10 ** dec;
}

export const SPACE_BETWEEN = 1;
export const SPACE_AROUND = 2;
export const SPACE_EVENLY = 3;
export const inf = Infinity;

const coord = (i: number, offs: number, iwid: number, gap: number): number =>
	roundDec(offs + i * (iwid + gap), 6);

export function distr(
	numItems: number,
	sizeFactor: number,
	justify: number,
	onlyIdx: number | null,
	each: (i: number, offPct: number, dimPct: number) => void,
): void {
	const space = 1 - sizeFactor;

	let gap = 0;
	if (justify === SPACE_BETWEEN) {
		gap = space / (numItems - 1);
	} else if (justify === SPACE_AROUND) {
		gap = space / numItems;
	} else if (justify === SPACE_EVENLY) {
		gap = space / (numItems + 1);
	}

	if (Number.isNaN(gap) || gap === Infinity) {
		gap = 0;
	}

	let offs = 0;
	if (justify === SPACE_AROUND) {
		offs = gap / 2;
	} else if (justify === SPACE_EVENLY) {
		offs = gap;
	}

	const iwid = sizeFactor / numItems;
	const iwidRounded = roundDec(iwid, 6);

	if (onlyIdx == null) {
		for (let i = 0; i < numItems; i++) {
			each(i, coord(i, offs, iwid, gap), iwidRounded);
		}
	} else {
		each(onlyIdx, coord(onlyIdx, offs, iwid, gap), iwidRounded);
	}
}

function timelinePlugin(opts: any): any {
	const { mode, count, fill, stroke, laneWidthOption, showGrid } = opts;

	const pxRatio = devicePixelRatio;

	const laneWidth = laneWidthOption ?? 0.9;

	const laneDistr = SPACE_BETWEEN;

	const font = `${round(14 * pxRatio)}px Geist Mono`;

	function walk(
		yIdx: number | null,
		count: number,
		dim: number,
		draw: (iy: number, y0: number, hgt: number) => void,
	): void {
		distr(
			count,
			laneWidth,
			laneDistr,
			yIdx,
			(i: number, offPct: number, dimPct: number) => {
				const laneOffPx = dim * offPct;
				const laneWidPx = dim * dimPct;

				draw(i, laneOffPx, laneWidPx);
			},
		);
	}

	const size = opts.size ?? [0.6, Infinity];
	const align = opts.align ?? 0;

	const gapFactor = 1 - size[0];
	const maxWidth = (size[1] ?? inf) * pxRatio;

	const fillPaths = new Map();
	const strokePaths = new Map();

	function drawBoxes(ctx: CanvasRenderingContext2D): void {
		fillPaths.forEach((fillPath, fillStyle) => {
			ctx.fillStyle = fillStyle;
			ctx.fill(fillPath);
		});

		strokePaths.forEach((strokePath, strokeStyle) => {
			ctx.strokeStyle = strokeStyle;
			ctx.stroke(strokePath);
		});

		fillPaths.clear();
		strokePaths.clear();
	}
	let qt: Quadtree;

	function putBox(
		ctx: CanvasRenderingContext2D,
		rect: (path: Path2D, x: number, y: number, w: number, h: number) => void,
		xOff: number,
		yOff: number,
		lft: number,
		top: number,
		wid: number,
		hgt: number,
		strokeWidth: number,
		iy: number,
		ix: number,
		value: number | null,
	): void {
		const fillStyle = fill(iy + 1, ix, value);
		let fillPath = fillPaths.get(fillStyle);

		if (fillPath == null) {
			fillPaths.set(fillStyle, (fillPath = new Path2D()));
		}

		rect(fillPath, lft, top, wid, hgt);

		if (strokeWidth) {
			const strokeStyle = stroke(iy + 1, ix, value);
			let strokePath = strokePaths.get(strokeStyle);

			if (strokePath == null) {
				strokePaths.set(strokeStyle, (strokePath = new Path2D()));
			}

			rect(
				strokePath,
				lft + strokeWidth / 2,
				top + strokeWidth / 2,
				wid - strokeWidth,
				hgt - strokeWidth,
			);
		}

		qt.add({
			x: round(lft - xOff),
			y: round(top - yOff),
			w: wid,
			h: hgt,
			sidx: iy + 1,
			didx: ix,
		});
	}

	// eslint-disable-next-line sonarjs/cognitive-complexity
	function drawPaths(u: uPlot, sidx: number, idx0: number, idx1: number): null {
		uPlot.orient(
			u,
			sidx,
			(
				series,
				dataX,
				dataY,
				scaleX,
				scaleY,
				valToPosX,
				valToPosY,
				xOff,
				yOff,
				xDim,
				yDim,
				moveTo,
				lineTo,
				rect,
			) => {
				const strokeWidth = round((series.width || 0) * pxRatio);

				u.ctx.save();
				rect(u.ctx, u.bbox.left, u.bbox.top, u.bbox.width, u.bbox.height);
				u.ctx.clip();

				walk(sidx - 1, count, yDim, (iy: number, y0: number, hgt: number) => {
					// draw spans
					if (mode === 1) {
						for (let ix = 0; ix < dataY.length; ix++) {
							if (dataY[ix] != null) {
								const lft = round(valToPosX(dataX[ix], scaleX, xDim, xOff));

								let nextIx = ix;
								// eslint-disable-next-line no-empty
								while (dataY[++nextIx] === undefined && nextIx < dataY.length) {}

								// to now (not to end of chart)
								const rgt =
									nextIx === dataY.length
										? xOff + xDim + strokeWidth
										: round(valToPosX(dataX[nextIx], scaleX, xDim, xOff));

								putBox(
									u.ctx,
									rect,
									xOff,
									yOff,
									lft,
									round(yOff + y0),
									rgt - lft,
									round(hgt),
									strokeWidth,
									iy,
									ix,
									dataY[ix],
								);

								ix = nextIx - 1;
							}
						}
					}
					// draw matrix
					else {
						const colWid =
							valToPosX(dataX[1], scaleX, xDim, xOff) -
							valToPosX(dataX[0], scaleX, xDim, xOff);
						const gapWid = colWid * gapFactor;
						const barWid = round(min(maxWidth, colWid - gapWid) - strokeWidth);
						let xShift;
						if (align === 1) {
							xShift = 0;
						} else if (align === -1) {
							xShift = barWid;
						} else {
							xShift = barWid / 2;
						}

						for (let ix = idx0; ix <= idx1; ix++) {
							if (dataY[ix] != null) {
								// TODO: all xPos can be pre-computed once for all series in aligned set
								const lft = valToPosX(dataX[ix], scaleX, xDim, xOff);

								putBox(
									u.ctx,
									rect,
									xOff,
									yOff,
									round(lft - xShift),
									round(yOff + y0),
									barWid,
									round(hgt),
									strokeWidth,
									iy,
									ix,
									dataY[ix],
								);
							}
						}
					}
				});

				u.ctx.lineWidth = strokeWidth;
				drawBoxes(u.ctx);

				u.ctx.restore();
			},
		);

		return null;
	}
	const yMids = Array(count).fill(0);
	function drawPoints(u: uPlot, sidx: number): boolean {
		u.ctx.save();
		u.ctx.rect(u.bbox.left, u.bbox.top, u.bbox.width, u.bbox.height);
		u.ctx.clip();

		const { ctx } = u;
		ctx.font = font;
		ctx.fillStyle = 'black';
		ctx.textAlign = mode === 1 ? 'left' : 'center';
		ctx.textBaseline = 'middle';

		uPlot.orient(
			u,
			sidx,
			(
				series,
				dataX,
				dataY,
				scaleX,
				scaleY,
				valToPosX,
				valToPosY,
				xOff,
				yOff,
				xDim,
			) => {
				const strokeWidth = round((series.width || 0) * pxRatio);
				const textOffset = mode === 1 ? strokeWidth + 2 : 0;

				const y = round(yOff + yMids[sidx - 1]);
				if (opts.displayTimelineValue) {
					for (let ix = 0; ix < dataY.length; ix++) {
						if (dataY[ix] != null) {
							const x = valToPosX(dataX[ix], scaleX, xDim, xOff) + textOffset;
							u.ctx.fillText(String(dataY[ix]), x, y);
						}
					}
				}
			},
		);

		u.ctx.restore();

		return false;
	}

	const hovered = Array(count).fill(null);

	const ySplits = Array(count).fill(0);

	const fmtDate = uPlot.fmtDate('{YYYY}-{MM}-{DD} {HH}:{mm}:{ss}');
	let legendTimeValueEl: HTMLElement | null = null;

	return {
		hooks: {
			init: (u: uPlot): void => {
				legendTimeValueEl = u.root.querySelector('.u-series:first-child .u-value');
			},
			drawClear: (u: uPlot): void => {
				qt = qt || new Quadtree(0, 0, u.bbox.width, u.bbox.height);

				qt.clear();

				// force-clear the path cache to cause drawBars() to rebuild new quadtree
				u.series.forEach((s: any) => {
					s._paths = null;
				});
			},
			setCursor: (u: {
				posToVal: (arg0: any, arg1: string) => any;
				cursor: { left: any };
				scales: { x: { time: any } };
			}): any => {
				if (mode === 1 && legendTimeValueEl) {
					const val = u.posToVal(u.cursor.left, 'x');
					legendTimeValueEl.textContent = u.scales.x.time
						? fmtDate(new Date(val * 1e3))
						: val.toFixed(2);
				}
			},
		},
		// eslint-disable-next-line sonarjs/cognitive-complexity
		opts: (u: { series: { label: any }[] }, opts: any): any => {
			uPlot.assign(opts, {
				cursor: {
					//	x: false,
					y: false,
					dataIdx: (
						u: { cursor: { left: number } },
						seriesIdx: number,
						closestIdx: any,
					) => {
						if (seriesIdx === 0) {
							return closestIdx;
						}

						const cx = round(u.cursor.left * pxRatio);

						if (cx >= 0) {
							const cy = yMids[seriesIdx - 1];

							hovered[seriesIdx - 1] = null;

							qt.get(cx, cy, 1, 1, (o: { x: any; y: any; w: any; h: any }) => {
								if (pointWithin(cx, cy, o.x, o.y, o.x + o.w, o.y + o.h)) {
									hovered[seriesIdx - 1] = o;
								}
							});
						}

						return hovered[seriesIdx - 1]?.didx;
					},
					points: {
						fill: 'rgba(0,0,0,0.3)',
						bbox: (u: any, seriesIdx: number) => {
							const hRect = hovered[seriesIdx - 1];

							return {
								left: hRect ? round(hRect.x / devicePixelRatio) : -10,
								top: hRect ? round(hRect.y / devicePixelRatio) : -10,
								width: hRect ? round(hRect.w / devicePixelRatio) : 0,
								height: hRect ? round(hRect.h / devicePixelRatio) : 0,
							};
						},
					},
				},
				scales: {
					x: {
						range(u: { data: number[][] }, min: number, max: number) {
							if (mode === 2) {
								const colWid = u.data[0][1] - u.data[0][0];
								const scalePad = colWid / 2;

								if (min <= u.data[0][0]) {
									min = u.data[0][0] - scalePad;
								}

								const lastIdx = u.data[0].length - 1;

								if (max >= u.data[0][lastIdx]) {
									max = u.data[0][lastIdx] + scalePad;
								}
							}

							return [min, max];
						},
					},
					y: {
						range: [0, 1],
					},
				},
			});

			uPlot.assign(opts.axes[0], {
				splits:
					mode === 2
						? (
								u: { data: any[][] },
								scaleMin: number,
								scaleMax: number,
								foundIncr: number,
							): any => {
								const splits = [];

								const dataIncr = u.data[0][1] - u.data[0][0];
								const skipFactor = ceil(foundIncr / dataIncr);

								for (let i = 0; i < u.data[0].length; i += skipFactor) {
									const v = u.data[0][i];

									if (v >= scaleMin && v <= scaleMax) {
										splits.push(v);
									}
								}

								return splits;
							}
						: null,
				grid: {
					show: showGrid ?? mode !== 2,
				},
			});

			uPlot.assign(opts.axes[1], {
				splits: (u: {
					bbox: { height: any };
					posToVal: (arg0: number, arg1: string) => any;
				}) => {
					walk(null, count, u.bbox.height, (iy: any, y0: number, hgt: number) => {
						// vertical midpoints of each series' timeline (stored relative to .u-over)
						yMids[iy] = round(y0 + hgt / 2);
						ySplits[iy] = u.posToVal(yMids[iy] / pxRatio, 'y');
					});

					return ySplits;
				},
				values: () =>
					Array(count)
						.fill(null)
						.map((v, i) => u.series[i + 1].label),
				gap: 15,
				size: 70,
				grid: { show: false },
				ticks: { show: false },

				side: 3,
			});

			opts.series.forEach((s: any, i: number) => {
				if (i > 0) {
					uPlot.assign(s, {
						//	width: 0,
						//	pxAlign: false,
						//	stroke: "rgba(255,0,0,0.5)",
						paths: drawPaths,
						points: {
							show: drawPoints,
						},
					});
				}
			});
		},
	};
}

export default timelinePlugin;