whet 0.1.1 → 0.4.0

package/bin/whet/profiler/Profiler.js

@@ -0,0 +1,351 @@
+import {SpanStats} from "./SpanStats.js"
+import {SpanRecorder} from "./SpanRecorder.js"
+import {Span, SpanEventType, SpanStatus} from "./Span.js"
+import {AsyncLocalStorage} from "node:async_hooks"
+import {IntMap} from "../../haxe/ds/IntMap.js"
+import {EsMap} from "../../genes/util/EsMap.js"
+import {Register} from "../../genes/Register.js"
+import {Std} from "../../Std.js"
+import {Reflect as Reflect__1} from "../../Reflect.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const Profiler = Register.global("$hxClasses")["whet.profiler.Profiler"] = 
+class Profiler extends Register.inherits() {
+	[Register.new](config) {
+		this.nextSpanId = 0;
+		this.listeners = [];
+		this.recorder = new SpanRecorder((config != null && config.maxSpans != null) ? config.maxSpans : 10000);
+		this.stats = new SpanStats();
+		this.context = new AsyncLocalStorage();
+		this.baseEpochUs = Date.now() * 1000;
+		this.basePerfUs = performance.now() * 1000;
+	}
+	
+	/**
+	Primary API: wraps an async operation with timing and ALS context.
+	*/
+	withSpan(stone, op, fn, meta) {
+		let parent = this.context.getStore();
+		let span = new Span(this.nextSpanId++, (parent != null) ? parent.id : null, stone.id, op, performance.now(), meta);
+		span.estimatedDuration = this.stats.getEstimate(stone.id, op);
+		this.emit(SpanEventType.Start, span);
+		let _gthis = this;
+		return this.context.run(span, function () {
+			return fn().then(function (result) {
+				span.endTime = performance.now();
+				span.duration = span.endTime - span.startTime;
+				span.status = SpanStatus.Ok;
+				_gthis.recorder.record(span);
+				_gthis.stats.update(stone.id, op, span.duration);
+				_gthis.emit(SpanEventType.End, span);
+				return result;
+			})["catch"](function (err) {
+				span.endTime = performance.now();
+				span.duration = span.endTime - span.startTime;
+				span.status = SpanStatus.Error(Std.string(err));
+				_gthis.recorder.record(span);
+				_gthis.emit(SpanEventType.End, span);
+				return Promise.reject(err);
+			});
+		});
+	}
+	
+	/**
+	Secondary API: manual start for spans where no function can be wrapped (e.g. LockWait).
+	*/
+	startSpan(stone, op, meta) {
+		let parent = this.context.getStore();
+		let span = new Span(this.nextSpanId++, (parent != null) ? parent.id : null, stone.id, op, performance.now(), meta);
+		span.estimatedDuration = this.stats.getEstimate(stone.id, op);
+		this.emit(SpanEventType.Start, span);
+		return span;
+	}
+	
+	/**
+	Complete a manually started span.
+	*/
+	endSpan(span) {
+		span.endTime = performance.now();
+		span.duration = span.endTime - span.startTime;
+		span.status = SpanStatus.Ok;
+		this.recorder.record(span);
+		this.stats.update(span.stone, span.operation, span.duration);
+		this.emit(SpanEventType.End, span);
+	}
+	
+	/**
+	Returns the current span from AsyncLocalStorage context, or null if none.
+	*/
+	getCurrentSpan() {
+		return this.context.getStore();
+	}
+	
+	/**
+	Subscribe to span events. Returns unsubscribe function.
+	*/
+	subscribe(listener) {
+		this.listeners.push(listener);
+		let _gthis = this;
+		return function () {
+			HxOverrides.remove(_gthis.listeners, listener);
+		};
+	}
+	
+	/**
+	Export spans in the given format ("json" or "trace"). Defaults to "json".
+	*/
+	export(format) {
+		if (format == "trace") {
+			return this.exportChromeTrace();
+		} else {
+			return this.exportJson();
+		};
+	}
+	
+	/**
+	Return spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId) {
+		return this.recorder.getSpansSince(sinceId);
+	}
+	
+	/**
+	Return aggregated profiling summary.
+	*/
+	getSummary() {
+		let spans = this.recorder.getSpans();
+		let byStone = {};
+		let byOperation = {};
+		let cacheHits = 0;
+		let cacheLookups = 0;
+		let _g = 0;
+		while (_g < spans.length) {
+			let span = spans[_g];
+			++_g;
+			let opKey = span.operation;
+			let opEntry = byOperation[opKey];
+			if (opEntry == null) {
+				opEntry = {"count": 0, "totalMs": 0.0};
+				byOperation[opKey] = opEntry;
+			};
+			opEntry.count++;
+			opEntry.totalMs += span.duration;
+			if (opKey == "Generate") {
+				Profiler.ensureStoneEntry(byStone, span.stone);
+				let entry = byStone[span.stone];
+				entry.generates++;
+				entry.totalDuration += span.duration;
+				entry.avgDuration = entry.totalDuration / entry.generates;
+				entry.lastDuration = span.duration;
+			};
+			if (span.metadata != null) {
+				let meta = span.metadata;
+				if (meta.cacheResult != null) {
+					++cacheLookups;
+					if (meta.cacheResult == "hit") {
+						++cacheHits;
+						Profiler.ensureStoneEntry(byStone, span.stone);
+						byStone[span.stone].cacheHits++;
+					};
+				};
+			};
+		};
+		return {"byStone": byStone, "byOperation": byOperation, "cacheHitRate": (cacheLookups > 0) ? cacheHits / cacheLookups : 0.0};
+	}
+	exportJson() {
+		let spans = this.recorder.getSpans();
+		let _g = [];
+		let _g1 = 0;
+		while (_g1 < spans.length) _g.push(this.serializeSpan(spans[_g1++]));
+		let stoneSet_inst = new Map();
+		let generateCount = 0;
+		let cacheHits = 0;
+		let cacheLookups = 0;
+		let _g2 = 0;
+		while (_g2 < spans.length) {
+			let span = spans[_g2];
+			++_g2;
+			stoneSet_inst.set(span.stone, true);
+			if (span.operation == "Generate") {
+				++generateCount;
+			};
+			if (span.metadata != null) {
+				let meta = span.metadata;
+				if (meta.cacheResult != null) {
+					++cacheLookups;
+					if (meta.cacheResult == "hit") {
+						++cacheHits;
+					};
+				};
+			};
+		};
+		let stoneCount = 0;
+		let _ = EsMap.adaptIterator(stoneSet_inst.values());
+		while (_.hasNext()) {
+			_.next();
+			++stoneCount;
+		};
+		return {"spans": _g, "meta": {"spanCount": spans.length, "stoneCount": stoneCount, "totalGenerations": generateCount, "cacheHitRate": (cacheLookups > 0) ? cacheHits / cacheLookups : 0.0}};
+	}
+	exportChromeTrace() {
+		let spans = this.recorder.getSpans();
+		let spanById_inst = new Map();
+		let _g = 0;
+		while (_g < spans.length) {
+			let span = spans[_g];
+			++_g;
+			spanById_inst.set(span.id, span);
+		};
+		let childrenOf_inst = new Map();
+		let roots = [];
+		let _g1 = 0;
+		while (_g1 < spans.length) {
+			let span = spans[_g1];
+			++_g1;
+			let pid = span.parentId;
+			if (pid == null || !spanById_inst.has(pid)) {
+				roots.push(span);
+			} else {
+				if (!childrenOf_inst.has(pid)) {
+					childrenOf_inst.set(pid, []);
+				};
+				childrenOf_inst.get(pid).push(span);
+			};
+		};
+		let spanTid_inst = new Map();
+		let nextTid = 1;
+		let assignTids = null;
+		assignTids = function (span, tid) {
+			spanTid_inst.set(span.id, tid);
+			let children = childrenOf_inst.get(span.id);
+			if (children == null || children.length == 0) {
+				return;
+			};
+			children.sort(function (a, b) {
+				return Reflect__1.compare(a.startTime, b.startTime);
+			});
+			let laneEndTimes = [];
+			let laneTids = [];
+			let _g = 0;
+			while (_g < children.length) {
+				let child = children[_g];
+				++_g;
+				let lane = -1;
+				let _g1 = 0;
+				let _g2 = laneEndTimes.length;
+				while (_g1 < _g2) {
+					let i = _g1++;
+					if (laneEndTimes[i] <= child.startTime) {
+						lane = i;
+						break;
+					};
+				};
+				if (lane == -1) {
+					lane = laneEndTimes.length;
+					let assignTids;
+					if (lane == 0) {
+						assignTids = tid;
+					} else {
+						nextTid += 1;
+						assignTids = nextTid - 1;
+					};
+					laneTids.push(assignTids);
+					laneEndTimes.push(child.endTime);
+				} else {
+					laneEndTimes[lane] = child.endTime;
+				};
+				assignTids(child, laneTids[lane]);
+			};
+		};
+		roots.sort(function (a, b) {
+			return Reflect__1.compare(a.startTime, b.startTime);
+		});
+		let _g2 = 0;
+		while (_g2 < roots.length) {
+			nextTid += 1;
+			assignTids(roots[_g2++], nextTid - 1);
+		};
+		let events = [];
+		let tidNames = new IntMap();
+		let _g3 = 0;
+		while (_g3 < spans.length) {
+			let span = spans[_g3];
+			++_g3;
+			let tid = spanTid_inst.get(span.id);
+			if (tid != null && !tidNames.inst.has(tid)) {
+				tidNames.inst.set(tid, span.stone);
+			};
+		};
+		let map = tidNames;
+		let _g_keys = map.keys();
+		while (_g_keys.hasNext()) {
+			let key = _g_keys.next();
+			events.push({"ph": "M", "pid": 1, "tid": key, "name": "thread_name", "args": {"name": map.get(key)}});
+		};
+		let flowId = 0;
+		let _g4 = 0;
+		while (_g4 < spans.length) {
+			let span = spans[_g4];
+			++_g4;
+			let tid = spanTid_inst.get(span.id);
+			if (tid == null) {
+				continue;
+			};
+			let ts = this.baseEpochUs + (span.startTime * 1000 - this.basePerfUs);
+			events.push({"ph": "X", "name": span.operation + " " + span.stone, "cat": "whet", "ts": ts, "dur": span.duration * 1000, "pid": 1, "tid": tid, "args": (span.metadata != null) ? span.metadata : {}});
+			if (span.parentId != null) {
+				let parent = spanById_inst.get(span.parentId);
+				if (parent != null) {
+					let parentTid = spanTid_inst.get(parent.id);
+					if (parentTid != null && parentTid != tid) {
+						events.push({"ph": "s", "id": flowId, "pid": 1, "tid": parentTid, "ts": this.baseEpochUs + (parent.startTime * 1000 - this.basePerfUs), "name": "trigger", "cat": "flow"});
+						events.push({"ph": "f", "bp": "e", "id": flowId, "pid": 1, "tid": tid, "ts": ts, "name": "trigger", "cat": "flow"});
+						++flowId;
+					};
+				};
+			};
+		};
+		return {"traceEvents": events};
+	}
+	serializeSpan(span) {
+		let _g = span.status;
+		let tmp;
+		switch (_g._hx_index) {
+			case 0:
+				tmp = "ok";
+				break
+			case 1:
+				tmp = "error: " + _g.msg;
+				break
+			
+		};
+		return {"id": span.id, "parentId": span.parentId, "stone": span.stone, "operation": span.operation, "startTime": span.startTime, "endTime": span.endTime, "duration": span.duration, "estimatedDuration": span.estimatedDuration, "metadata": span.metadata, "status": tmp};
+	}
+	emit(type, span) {
+		let event = {"type": type, "span": span};
+		let _g = 0;
+		let _g1 = this.listeners;
+		while (_g < _g1.length) _g1[_g++](event);
+	}
+	static ensureStoneEntry(byStone, stone) {
+		if (!Object.prototype.hasOwnProperty.call(byStone, stone)) {
+			byStone[stone] = {"generates": 0, "totalDuration": 0.0, "avgDuration": 0.0, "lastDuration": 0.0, "cacheHits": 0};
+		};
+	}
+	static get __name__() {
+		return "whet.profiler.Profiler"
+	}
+	get __class__() {
+		return Profiler
+	}
+}
+Profiler.prototype.recorder = null;
+Profiler.prototype.stats = null;
+Profiler.prototype.listeners = null;
+Profiler.prototype.context = null;
+Profiler.prototype.baseEpochUs = null;
+Profiler.prototype.basePerfUs = null;
+Profiler.prototype.nextSpanId = null;
+

package/bin/whet/profiler/Span.d.ts

@@ -0,0 +1,90 @@
+
+export declare class Span<T> {
+	constructor(id: number, parentId: null | number, stone: string, op: string, startTime: number, metadata?: null | T)
+	id: number
+	parentId: null | number
+	stone: string
+	operation: string
+	startTime: number
+	endTime: number
+	duration: number
+	estimatedDuration: number
+	metadata: T
+	status: SpanStatus
+}
+
+export type AnySpan = Span<any>
+
+export declare namespace SpanStatus {
+	export type Ok = {_hx_index: 0, __enum__: "whet.profiler.SpanStatus"}
+	export const Ok: Ok
+	export type Error = {_hx_index: 1, msg: string, __enum__: "whet.profiler.SpanStatus"}
+	export const Error: (msg: string) => SpanStatus
+}
+
+export declare type SpanStatus = 
+	| SpanStatus.Ok
+	| SpanStatus.Error
+
+export declare namespace SpanEventType {
+	export type Start = {_hx_index: 0, __enum__: "whet.profiler.SpanEventType"}
+	export const Start: Start
+	export type End = {_hx_index: 1, __enum__: "whet.profiler.SpanEventType"}
+	export const End: End
+}
+
+export declare type SpanEventType = 
+	| SpanEventType.Start
+	| SpanEventType.End
+
+export type SpanEvent = {
+	span: AnySpan, 
+	type: SpanEventType
+}
+
+/**
+Metadata types per span operation.
+*/
+export type LockWaitMeta = {
+	queueLength?: null | number, 
+	queuePosition?: null | number
+}
+
+export type LockHeldMeta = {
+	cacheResult?: null | string
+}
+
+export type HashMeta = {
+	dependencyCount?: null | number, 
+	hashHex?: null | string
+}
+
+export type GenerateMeta = {
+	outputCount?: null | number, 
+	totalBytes?: null | number
+}
+
+export type GeneratePartialMeta = {
+	outputBytes?: null | number, 
+	sourceId?: null | string
+}
+
+export type DepResolveMeta = {
+	dependencyIds?: null | string[]
+}
+
+export type CacheWriteMeta = {
+	entryCount?: null | number, 
+	strategy?: null | string
+}
+
+export type ListMeta = {
+	resultCount?: null | number
+}
+
+export type ServeMeta = {
+	method?: null | string, 
+	path?: null | string, 
+	responseBytes?: null | number, 
+	statusCode?: null | number
+}

package/bin/whet/profiler/Span.js

@@ -0,0 +1,56 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Span = Register.global("$hxClasses")["whet.profiler.Span"] = 
+class Span extends Register.inherits() {
+	[Register.new](id, parentId, stone, op, startTime, metadata) {
+		this.id = id;
+		this.parentId = parentId;
+		this.stone = stone;
+		this.operation = op;
+		this.startTime = startTime;
+		this.metadata = metadata;
+		this.estimatedDuration = 0;
+		this.status = SpanStatus.Ok;
+	}
+	static get __name__() {
+		return "whet.profiler.Span"
+	}
+	get __class__() {
+		return Span
+	}
+}
+Span.prototype.id = null;
+Span.prototype.parentId = null;
+Span.prototype.stone = null;
+Span.prototype.operation = null;
+Span.prototype.startTime = null;
+Span.prototype.endTime = null;
+Span.prototype.duration = null;
+Span.prototype.estimatedDuration = null;
+Span.prototype.metadata = null;
+Span.prototype.status = null;
+
+
+export const SpanStatus = 
+Register.global("$hxEnums")["whet.profiler.SpanStatus"] = 
+{
+	__ename__: "whet.profiler.SpanStatus",
+	
+	Ok: {_hx_name: "Ok", _hx_index: 0, __enum__: "whet.profiler.SpanStatus"},
+	Error: Object.assign((msg) => ({_hx_index: 1, __enum__: "whet.profiler.SpanStatus", "msg": msg}), {_hx_name: "Error", __params__: ["msg"]})
+}
+SpanStatus.__constructs__ = [SpanStatus.Ok, SpanStatus.Error]
+SpanStatus.__empty_constructs__ = [SpanStatus.Ok]
+
+export const SpanEventType = 
+Register.global("$hxEnums")["whet.profiler.SpanEventType"] = 
+{
+	__ename__: "whet.profiler.SpanEventType",
+	
+	Start: {_hx_name: "Start", _hx_index: 0, __enum__: "whet.profiler.SpanEventType"},
+	End: {_hx_name: "End", _hx_index: 1, __enum__: "whet.profiler.SpanEventType"}
+}
+SpanEventType.__constructs__ = [SpanEventType.Start, SpanEventType.End]
+SpanEventType.__empty_constructs__ = [SpanEventType.Start, SpanEventType.End]

package/bin/whet/profiler/SpanRecorder.d.ts

@@ -0,0 +1,20 @@
+import {AnySpan} from "./Span"
+
+export declare class SpanRecorder {
+	constructor(maxSize: number)
+	maxSize: number
+	totalCount: number
+	protected buffer: AnySpan[]
+	protected writeIndex: number
+	record(span: AnySpan): void
+	
+	/**
+	Returns all recorded spans in chronological order.
+	*/
+	getSpans(): AnySpan[]
+	
+	/**
+	Returns spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId: number): AnySpan[]
+}

package/bin/whet/profiler/SpanRecorder.js

@@ -0,0 +1,63 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const SpanRecorder = Register.global("$hxClasses")["whet.profiler.SpanRecorder"] = 
+class SpanRecorder extends Register.inherits() {
+	[Register.new](maxSize) {
+		this.writeIndex = 0;
+		this.totalCount = 0;
+		this.maxSize = maxSize;
+		this.buffer = new Array(maxSize);
+	}
+	record(span) {
+		this.buffer[this.writeIndex % this.maxSize] = span;
+		this.writeIndex++;
+		this.totalCount++;
+	}
+	
+	/**
+	Returns all recorded spans in chronological order.
+	*/
+	getSpans() {
+		let count = (this.writeIndex < this.maxSize) ? this.writeIndex : this.maxSize;
+		let result = new Array();
+		result.length = count;
+		let start = (this.writeIndex < this.maxSize) ? 0 : this.writeIndex % this.maxSize;
+		let _g = 0;
+		let _g1 = count;
+		while (_g < _g1) {
+			let i = _g++;
+			result[i] = this.buffer[(start + i) % this.maxSize];
+		};
+		return result;
+	}
+	
+	/**
+	Returns spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId) {
+		let all = this.getSpans();
+		let result = [];
+		let _g = 0;
+		while (_g < all.length) {
+			let span = all[_g];
+			++_g;
+			if (span.id > sinceId) {
+				result.push(span);
+			};
+		};
+		return result;
+	}
+	static get __name__() {
+		return "whet.profiler.SpanRecorder"
+	}
+	get __class__() {
+		return SpanRecorder
+	}
+}
+SpanRecorder.prototype.maxSize = null;
+SpanRecorder.prototype.totalCount = null;
+SpanRecorder.prototype.buffer = null;
+SpanRecorder.prototype.writeIndex = null;
+

package/bin/whet/profiler/SpanStats.d.ts

@@ -0,0 +1,15 @@
+import {Map as Map__1} from "../../Map"
+
+export declare class SpanStats {
+	constructor()
+	protected data: Map__1<string, StatEntry>
+	getEstimate(stoneId: string, op: string): number
+	update(stoneId: string, op: string, duration: number): void
+	getSummary(): any
+}
+
+export type StatEntry = {
+	count: number, 
+	lastDuration: number, 
+	totalDuration: number
+}

package/bin/whet/profiler/SpanStats.js

@@ -0,0 +1,49 @@
+import {StringMap} from "../../haxe/ds/StringMap.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const SpanStats = Register.global("$hxClasses")["whet.profiler.SpanStats"] = 
+class SpanStats extends Register.inherits() {
+	[Register.new]() {
+		this.data = new StringMap();
+	}
+	getEstimate(stoneId, op) {
+		let entry = this.data.inst.get("" + stoneId + ":" + op);
+		if (entry != null) {
+			return entry.lastDuration;
+		} else {
+			return 0;
+		};
+	}
+	update(stoneId, op, duration) {
+		let key = "" + stoneId + ":" + op;
+		let entry = this.data.inst.get(key);
+		if (entry == null) {
+			this.data.inst.set(key, {"lastDuration": duration, "totalDuration": duration, "count": 1});
+		} else {
+			entry.lastDuration = duration;
+			entry.totalDuration += duration;
+			entry.count++;
+		};
+	}
+	getSummary() {
+		let result = {};
+		let this1 = this.data;
+		let _g_keys = this1.keys();
+		while (_g_keys.hasNext()) {
+			let key = _g_keys.next();
+			let _g_value = this1.get(key);
+			result[key] = {"lastDuration": _g_value.lastDuration, "avgDuration": _g_value.totalDuration / _g_value.count, "count": _g_value.count};
+		};
+		return result;
+	}
+	static get __name__() {
+		return "whet.profiler.SpanStats"
+	}
+	get __class__() {
+		return SpanStats
+	}
+}
+SpanStats.prototype.data = null;
+

package/bin/whet/route/Router.d.ts

@@ -11,6 +11,11 @@ export declare class Router {
 	protected routes: RoutePath[]
 	route(r: RoutePathType): void
 	
+	/**
+	Remove all routes.
+	*/
+	clearRoutes(): void
+	
 	/**
 	Recursively collect all Stone IDs referenced in this Router's routes.
 	*/