toilscript 0.1.50 → 0.1.52

package/dist/web.js

@@ -1,8 +1,8 @@
-var ASSEMBLYSCRIPT_VERSION = "0.1.50";
+var ASSEMBLYSCRIPT_VERSION = "0.1.52";
   var ASSEMBLYSCRIPT_IMPORTMAP = {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.50/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.50/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.52/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.52/dist/cli.js",
     "binaryen": "https://cdn.jsdelivr.net/npm/binaryen@130.0.0-nightly.20260609/index.js",
     "long": "https://cdn.jsdelivr.net/npm/long@5.3.2/index.js"
   }

package/package.json

@@ -8,7 +8,7 @@
     "toilscript",
     "wasm"
   ],
-  "version": "0.1.50",
+  "version": "0.1.52",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dacely-cloud/toilscript",

package/std/assembly/bindings/toildb.ts

@@ -283,6 +283,12 @@ export namespace analyticsHost {
   @external("env", "analytics_read")
   export declare function read(domainPtr: usize, domainLen: i32): i32;
 
+  // analytics_series(domain, metricId, range): frame length (v2 series frame) stashed for takeResult,
+  // or a negative status (-2 absent / -3 forbidden / bad metric or range).
+  // @ts-ignore: decorator
+  @external("env", "analytics_series")
+  export declare function series(domainPtr: usize, domainLen: i32, metricId: i32, range: i32): i32;
+
   // analytics_list_sites(cursor, limit): frame length (count u32 | (u32 nameLen, name)* |
   // has_more u8) stashed for takeResult; -3 forbidden when the caller is not dacely.com.
   // @ts-ignore: decorator

package/std/assembly/toildb.ts

@@ -438,16 +438,172 @@ export class Counter<K> {
   }
 }
 
-/// One tenant's analytics snapshot (the metering counters + plan limits), read via the
-/// `Analytics` API. `lifetime` holds the per-domain lifetime totals by metric name
-/// (`requests`, `bytes_served`, `status_2xx`.., `db_ops`, `stream_*`, ...); the request
-/// windows pair the current minute/day usage with the plan cap (cap 0 = unlimited).
+/// Every per-domain metric, by stable numeric id. This is the WIRE CONTRACT shared with the edge
+/// (`src/analytics/metric_id.rs`) and the dev server; it orders the snapshot frame and addresses a
+/// time-series. Ids `0..=42` are cumulative COUNTERS (a rate is `value / seconds`); `43..=46` are the
+/// avg/peak series of the two GAUGES. Append-only: never renumber.
+export enum MetricId {
+  Requests = 0,
+  BytesOutL1 = 1,
+  BytesInL1 = 2,
+  Status2xx = 3,
+  Status3xx = 4,
+  Status4xx = 5,
+  Status5xx = 6,
+  StaticHits = 7,
+  WasmDispatches = 8,
+  ExecutorFullRejects = 9,
+  UnknownHostRejects = 10,
+  RateLimitedRejects = 11,
+  GasUsed = 12,
+  DbOps = 13,
+  DbReads = 14,
+  DbWrites = 15,
+  DbErrors = 16,
+  DbLatencyNsSum = 17,
+  StreamAccepts = 18,
+  StreamRejectWrongNode = 19,
+  StreamRejectCapacity = 20,
+  StreamRejectArtifact = 21,
+  StreamRejectGuest = 22,
+  StreamTraps = 23,
+  StreamIdleTimeouts = 24,
+  StreamBytesIn = 25,
+  StreamBytesOut = 26,
+  StreamBackpressureEvents = 27,
+  StreamCloses = 28,
+  StreamDisconnects = 29,
+  DaemonStarts = 30,
+  DaemonStartFailures = 31,
+  DaemonTicksFired = 32,
+  DaemonTicksSkippedNotLeader = 33,
+  DaemonTicksFailed = 34,
+  DaemonLeaderAcquires = 35,
+  DaemonLeaderFenced = 36,
+  DaemonHttpCallAttempts = 37,
+  DaemonHttpCallFailures = 38,
+  MemGrownBytes = 39,
+  Emails = 40,
+  CacheHits = 41,
+  CacheMisses = 42,
+  ConnectedStreamsAvg = 43,
+  ConnectedStreamsPeak = 44,
+  CommittedMemoryAvg = 45,
+  CommittedMemoryPeak = 46,
+}
+
+/// The number of cumulative counter metrics (`MetricId 0..=42`) = the length of the snapshot's lifetime
+/// section.
+export const METRIC_COUNTERS: i32 = 43;
+
+/// A dashboard time range for `Analytics.series`. Short ranges (1h/6h) read the per-MINUTE ring; the rest
+/// read the per-HOUR ring (30-day retention).
+export enum AnalyticsRange {
+  H1 = 0,
+  H6 = 1,
+  H12 = 2,
+  H24 = 3,
+  D3 = 4,
+  D7 = 5,
+  D14 = 6,
+  D30 = 7,
+}
+
+/// One tenant's analytics snapshot: the lifetime totals (indexed by `MetricId`, NO string keys), the two
+/// live gauge levels, and the request windows paired with the plan caps (cap 0 = unlimited). Read every
+/// value either by the typed getter (`stats.requests`) or by id (`stats.metric(MetricId.Requests)`).
 export class TenantStats {
-  lifetime: Map<string, i64> = new Map<string, i64>();
-  reqMinuteUsed: i64 = 0;
+  /// Lifetime totals indexed by `MetricId` (length `METRIC_COUNTERS`). Prefer the named getters below.
+  life: StaticArray<u64> = new StaticArray<u64>(METRIC_COUNTERS);
+  /// Live gauges (current level, not a total).
+  connectedStreams: u64 = 0;
+  committedMemory: u64 = 0;
+  /// Request windows: current bucket usage + plan cap (0 = unlimited).
+  reqMinuteUsed: u64 = 0;
   reqMinuteCap: u64 = 0;
-  reqDayUsed: i64 = 0;
+  reqDayUsed: u64 = 0;
   reqDayCap: u64 = 0;
+  /// Edge wall-clock (ms) when the snapshot was read.
+  nowMs: u64 = 0;
+
+  /// Any counter metric by id (0 for an out-of-range id).
+  metric(id: MetricId): u64 {
+    return <i32>id < METRIC_COUNTERS ? this.life[<i32>id] : 0;
+  }
+
+  // Typed getters for every counter (the catalog: no magic strings, self-documenting).
+  get requests(): u64 { return this.life[MetricId.Requests]; }
+  get bytesOutL1(): u64 { return this.life[MetricId.BytesOutL1]; }
+  get bytesInL1(): u64 { return this.life[MetricId.BytesInL1]; }
+  get status2xx(): u64 { return this.life[MetricId.Status2xx]; }
+  get status3xx(): u64 { return this.life[MetricId.Status3xx]; }
+  get status4xx(): u64 { return this.life[MetricId.Status4xx]; }
+  get status5xx(): u64 { return this.life[MetricId.Status5xx]; }
+  get staticHits(): u64 { return this.life[MetricId.StaticHits]; }
+  get wasmDispatches(): u64 { return this.life[MetricId.WasmDispatches]; }
+  get executorFullRejects(): u64 { return this.life[MetricId.ExecutorFullRejects]; }
+  get unknownHostRejects(): u64 { return this.life[MetricId.UnknownHostRejects]; }
+  get rateLimitedRejects(): u64 { return this.life[MetricId.RateLimitedRejects]; }
+  get gasUsed(): u64 { return this.life[MetricId.GasUsed]; }
+  get dbOps(): u64 { return this.life[MetricId.DbOps]; }
+  get dbReads(): u64 { return this.life[MetricId.DbReads]; }
+  get dbWrites(): u64 { return this.life[MetricId.DbWrites]; }
+  get dbErrors(): u64 { return this.life[MetricId.DbErrors]; }
+  get dbLatencyNsSum(): u64 { return this.life[MetricId.DbLatencyNsSum]; }
+  get streamAccepts(): u64 { return this.life[MetricId.StreamAccepts]; }
+  get streamRejectWrongNode(): u64 { return this.life[MetricId.StreamRejectWrongNode]; }
+  get streamRejectCapacity(): u64 { return this.life[MetricId.StreamRejectCapacity]; }
+  get streamRejectArtifact(): u64 { return this.life[MetricId.StreamRejectArtifact]; }
+  get streamRejectGuest(): u64 { return this.life[MetricId.StreamRejectGuest]; }
+  get streamTraps(): u64 { return this.life[MetricId.StreamTraps]; }
+  get streamIdleTimeouts(): u64 { return this.life[MetricId.StreamIdleTimeouts]; }
+  get streamBytesIn(): u64 { return this.life[MetricId.StreamBytesIn]; }
+  get streamBytesOut(): u64 { return this.life[MetricId.StreamBytesOut]; }
+  get streamBackpressureEvents(): u64 { return this.life[MetricId.StreamBackpressureEvents]; }
+  get streamCloses(): u64 { return this.life[MetricId.StreamCloses]; }
+  get streamDisconnects(): u64 { return this.life[MetricId.StreamDisconnects]; }
+  get daemonStarts(): u64 { return this.life[MetricId.DaemonStarts]; }
+  get daemonStartFailures(): u64 { return this.life[MetricId.DaemonStartFailures]; }
+  get daemonTicksFired(): u64 { return this.life[MetricId.DaemonTicksFired]; }
+  get daemonTicksSkippedNotLeader(): u64 { return this.life[MetricId.DaemonTicksSkippedNotLeader]; }
+  get daemonTicksFailed(): u64 { return this.life[MetricId.DaemonTicksFailed]; }
+  get daemonLeaderAcquires(): u64 { return this.life[MetricId.DaemonLeaderAcquires]; }
+  get daemonLeaderFenced(): u64 { return this.life[MetricId.DaemonLeaderFenced]; }
+  get daemonHttpCallAttempts(): u64 { return this.life[MetricId.DaemonHttpCallAttempts]; }
+  get daemonHttpCallFailures(): u64 { return this.life[MetricId.DaemonHttpCallFailures]; }
+  get memGrownBytes(): u64 { return this.life[MetricId.MemGrownBytes]; }
+  get emails(): u64 { return this.life[MetricId.Emails]; }
+  get cacheHits(): u64 { return this.life[MetricId.CacheHits]; }
+  get cacheMisses(): u64 { return this.life[MetricId.CacheMisses]; }
+
+  /// Mean host-observed DB op latency (ns), or 0 with no ops.
+  get meanDbLatencyNs(): u64 {
+    const ops = this.dbOps;
+    return ops > 0 ? this.dbLatencyNsSum / ops : 0;
+  }
+
+  /// Fraction of cacheable responses served from cache (`hits / (hits + misses)`),
+  /// 0.0 when there were no cacheable responses.
+  get cacheRatio(): f64 {
+    const hits = this.cacheHits;
+    const total = hits + this.cacheMisses;
+    return total > 0 ? <f64>hits / <f64>total : 0.0;
+  }
+}
+
+/// One metric's time series for a range: `points` oldest→newest, `bucketSecs` the per-bucket width, and
+/// `headMs` the newest bucket's end. Rates are derived, never stored.
+export class Series {
+  metric: MetricId = MetricId.Requests;
+  bucketSecs: u32 = 0;
+  headMs: u64 = 0;
+  points: i64[] = [];
+
+  /// Per-second rate of bucket `i` (its total divided by the bucket width). 0 for an out-of-range index.
+  ratePerSec(i: i32): f64 {
+    if (i < 0 || i >= this.points.length || this.bucketSecs == 0) return 0;
+    return <f64>this.points[i] / <f64>this.bucketSecs;
+  }
 }
 
 /// A page of site names from `Analytics.listSites` (dacely.com only). When `hasMore` is
@@ -465,19 +621,39 @@ export class Analytics {
   private static decode(buf: Uint8Array): TenantStats {
     const r = new DataReader(buf);
     const stats = new TenantStats();
-    r.readU16(); // frame version (currently 1)
-    const count = r.readU32();
-    for (let i: u32 = 0; i < count && r.ok; i++) {
-      const name = r.readString();
-      stats.lifetime.set(name, r.readI64());
+    const version = r.readU16();
+    if (version < 2) return stats; // pre-v2 edge: refuse rather than mis-decode
+    stats.nowMs = r.readU64();
+    const count = <i32>r.readU32();
+    for (let i: i32 = 0; i < count && r.ok; i++) {
+      // Wire fields are non-negative i64; read the same bytes as u64.
+      const v = r.readU64();
+      if (i < METRIC_COUNTERS) stats.life[i] = v; // ignore any extra (forward-compat)
     }
-    stats.reqMinuteUsed = r.readI64();
+    stats.connectedStreams = r.readU64();
+    stats.committedMemory = r.readU64();
+    stats.reqMinuteUsed = r.readU64();
     stats.reqMinuteCap = r.readU64();
-    stats.reqDayUsed = r.readI64();
+    stats.reqDayUsed = r.readU64();
     stats.reqDayCap = r.readU64();
     return stats;
   }
 
+  private static decodeSeries(buf: Uint8Array): Series {
+    const r = new DataReader(buf);
+    const out = new Series();
+    const version = r.readU16();
+    if (version < 2) return out;
+    out.metric = <MetricId>r.readU16();
+    out.bucketSecs = r.readU32();
+    out.headMs = r.readU64();
+    const count = <i32>r.readU32();
+    const pts = new Array<i64>(count);
+    for (let i: i32 = 0; i < count && r.ok; i++) pts[i] = r.readI64();
+    out.points = pts;
+    return out;
+  }
+
   /// This site's own analytics. Returns empty stats if unavailable.
   static self(): TenantStats {
     const status = analyticsHost.read(0, 0);
@@ -494,6 +670,21 @@ export class Analytics {
     return Analytics.decode(__toildbTake(status));
   }
 
+  /// This site's time-series for `metric` over `range` (for graphs). Empty series if unavailable.
+  static series(metric: MetricId, range: AnalyticsRange): Series {
+    const status = analyticsHost.series(0, 0, <i32>metric, <i32>range);
+    if (status < 0) return new Series();
+    return Analytics.decodeSeries(__toildbTake(status));
+  }
+
+  /// Another site's time-series (dacely.com only, else `null`).
+  static siteSeries(domain: string, metric: MetricId, range: AnalyticsRange): Series | null {
+    const db = Uint8Array.wrap(String.UTF8.encode(domain));
+    const status = analyticsHost.series(db.dataStart, db.byteLength, <i32>metric, <i32>range);
+    if (status < 0) return null;
+    return Analytics.decodeSeries(__toildbTake(status));
+  }
+
   /// Enumerate sites, paginated. ONLY `dacely.com` gets results; any other caller gets an
   /// empty list. `cursor` is the previous page's last name (`""` = from the start); reads up
   /// to `limit` names. When `hasMore` is true, pass the last `sites` entry as the next cursor.

package/std/assembly/toilscript.d.ts

@@ -282,19 +282,99 @@ declare class Events<K, V> {
   latest(key: K, limit: i32): V[];
 }
 
-/** One tenant's analytics snapshot: per-metric lifetime totals + the request rate
- *  windows (current usage paired with the plan cap; cap 0 = unlimited). */
+/** Every per-domain metric, by stable numeric id (the wire contract). `0..=42` are cumulative
+ *  COUNTERS (rate = value/seconds); `43..=46` are the avg/peak series of the two GAUGES. */
+declare const enum MetricId {
+  Requests = 0, BytesOutL1 = 1, BytesInL1 = 2,
+  Status2xx = 3, Status3xx = 4, Status4xx = 5, Status5xx = 6,
+  StaticHits = 7, WasmDispatches = 8,
+  ExecutorFullRejects = 9, UnknownHostRejects = 10, RateLimitedRejects = 11, GasUsed = 12,
+  DbOps = 13, DbReads = 14, DbWrites = 15, DbErrors = 16, DbLatencyNsSum = 17,
+  StreamAccepts = 18, StreamRejectWrongNode = 19, StreamRejectCapacity = 20, StreamRejectArtifact = 21,
+  StreamRejectGuest = 22, StreamTraps = 23, StreamIdleTimeouts = 24, StreamBytesIn = 25,
+  StreamBytesOut = 26, StreamBackpressureEvents = 27, StreamCloses = 28, StreamDisconnects = 29,
+  DaemonStarts = 30, DaemonStartFailures = 31, DaemonTicksFired = 32, DaemonTicksSkippedNotLeader = 33,
+  DaemonTicksFailed = 34, DaemonLeaderAcquires = 35, DaemonLeaderFenced = 36,
+  DaemonHttpCallAttempts = 37, DaemonHttpCallFailures = 38, MemGrownBytes = 39, Emails = 40,
+  CacheHits = 41, CacheMisses = 42,
+  ConnectedStreamsAvg = 43, ConnectedStreamsPeak = 44, CommittedMemoryAvg = 45, CommittedMemoryPeak = 46,
+}
+
+/** A dashboard time range for `Analytics.series`. 1h/6h are per-minute; the rest per-hour (30-day). */
+declare const enum AnalyticsRange {
+  H1 = 0, H6 = 1, H12 = 2, H24 = 3, D3 = 4, D7 = 5, D14 = 6, D30 = 7,
+}
+
+/** One tenant's analytics snapshot: lifetime totals (indexed by `MetricId`, no string keys), the two
+ *  live gauge levels, and the request windows (current usage + plan cap; cap 0 = unlimited). Read a
+ *  value by typed getter (`stats.requests`) or by id (`stats.metric(MetricId.Requests)`). */
 declare class TenantStats {
-  lifetime: Map<string, i64>;
-  reqMinuteUsed: i64;
+  metric(id: MetricId): u64;
+  readonly requests: u64;
+  readonly bytesOutL1: u64;
+  readonly bytesInL1: u64;
+  readonly status2xx: u64;
+  readonly status3xx: u64;
+  readonly status4xx: u64;
+  readonly status5xx: u64;
+  readonly staticHits: u64;
+  readonly wasmDispatches: u64;
+  readonly executorFullRejects: u64;
+  readonly unknownHostRejects: u64;
+  readonly rateLimitedRejects: u64;
+  readonly gasUsed: u64;
+  readonly dbOps: u64;
+  readonly dbReads: u64;
+  readonly dbWrites: u64;
+  readonly dbErrors: u64;
+  readonly dbLatencyNsSum: u64;
+  readonly meanDbLatencyNs: u64;
+  readonly streamAccepts: u64;
+  readonly streamRejectWrongNode: u64;
+  readonly streamRejectCapacity: u64;
+  readonly streamRejectArtifact: u64;
+  readonly streamRejectGuest: u64;
+  readonly streamTraps: u64;
+  readonly streamIdleTimeouts: u64;
+  readonly streamBytesIn: u64;
+  readonly streamBytesOut: u64;
+  readonly streamBackpressureEvents: u64;
+  readonly streamCloses: u64;
+  readonly streamDisconnects: u64;
+  readonly daemonStarts: u64;
+  readonly daemonStartFailures: u64;
+  readonly daemonTicksFired: u64;
+  readonly daemonTicksSkippedNotLeader: u64;
+  readonly daemonTicksFailed: u64;
+  readonly daemonLeaderAcquires: u64;
+  readonly daemonLeaderFenced: u64;
+  readonly daemonHttpCallAttempts: u64;
+  readonly daemonHttpCallFailures: u64;
+  readonly memGrownBytes: u64;
+  readonly emails: u64;
+  readonly cacheHits: u64;
+  readonly cacheMisses: u64;
+  /** Fraction of cacheable responses served from cache (`hits / (hits + misses)`), 0.0 when none. */
+  readonly cacheRatio: f64;
+  connectedStreams: u64;
+  committedMemory: u64;
+  reqMinuteUsed: u64;
   reqMinuteCap: u64;
-  reqDayUsed: i64;
+  reqDayUsed: u64;
   reqDayCap: u64;
+  nowMs: u64;
+}
+
+/** One metric's time series for a range: `points` oldest→newest, `bucketSecs` bucket width,
+ *  `headMs` newest bucket end. `ratePerSec(i)` derives the per-second rate of point `i`. */
+declare class Series {
+  metric: MetricId;
+  bucketSecs: u32;
+  headMs: u64;
+  points: i64[];
+  ratePerSec(i: i32): f64;
 }
 
-/** Per-domain analytics. `Analytics.self()` reads this site's own stats; the privileged
- *  `dacely.com` domain may read any site via `Analytics.site(domain)` (any other caller,
- *  or an unknown domain, gets `null`). The calling domain is decided host-side. */
 /** A page of site names from `Analytics.listSites` (dacely.com only). When `hasMore` is
  *  true, pass the last `sites` entry back as the next call's cursor. */
 declare class SiteList {
@@ -302,9 +382,14 @@ declare class SiteList {
   hasMore: bool;
 }
 
+/** Per-domain analytics. `Analytics.self()` reads this site's own stats; the privileged
+ *  `dacely.com` domain may read any site via `Analytics.site(domain)` (any other caller,
+ *  or an unknown domain, gets `null`). The calling domain is decided host-side. */
 declare class Analytics {
   static self(): TenantStats;
   static site(domain: string): TenantStats | null;
+  static series(metric: MetricId, range: AnalyticsRange): Series;
+  static siteSeries(domain: string, metric: MetricId, range: AnalyticsRange): Series | null;
   static listSites(cursor?: string, limit?: i32): SiteList;
 }