@tangle-network/sdk-telemetry 0.7.4 → 0.7.6

package/dist/lifecycle-wall-DXtpIkqi.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle-wall-DXtpIkqi.mjs","names":[],"sources":["../src/lifecycle-wall.ts"],"sourcesContent":["/**\n * The `ready` span carries the end-to-end create wall (caller start → the end\n * of createSidecar). These operations run AFTER `ready` is stamped, so they sit\n * OUTSIDE the ready window and must never be summed into the leaf total or the\n * residual goes negative.\n */\nconst CREATE_POST_READY_OPERATIONS = new Set([\n  \"orchestrator.container_lookup\",\n  \"orchestrator.snapshot_restore_check\",\n  \"orchestrator.provision_finalize\",\n]);\n\n/**\n * Per-flow shape of the accounting window. `totalOperation` is the span whose\n * wall the named leaves must tile; `postReadyOperations` run AFTER it is\n * stamped (excluded from the leaf sum); `prepUmbrella` is the optional\n * create-style split of an entry umbrella minus its measured leaf children. Absent\n * `prepUmbrella` ⇒ `prepUnaccountedMs` is always 0 and the whole dark falls\n * into `unaccountedMs` (the shape every non-create flow uses).\n */\nexport type FlowAccountingSpec = {\n  totalOperation: string;\n  postReadyOperations?: ReadonlySet<string>;\n  prepUmbrella?: { operation: string };\n};\n\nexport const CREATE_ACCOUNTING_SPEC: FlowAccountingSpec = {\n  totalOperation: \"orchestrator.ready\",\n  postReadyOperations: CREATE_POST_READY_OPERATIONS,\n  prepUmbrella: {\n    operation: \"orchestrator.provision_prep\",\n  },\n};\n\nexport const RESUME_ACCOUNTING_SPEC: FlowAccountingSpec = {\n  // resumeSidecar (and the reprovision fallback assembly in resume()) stamps\n  // `orchestrator.ready` from the route's startupStartedAt — the resume total\n  // span. `sidecar_resume` brackets that stamp and is the parent of every\n  // host-side span, so the leaf rule already excludes it; `connection_build`\n  // and `metering_restart` run after resumeSidecar returns, hence after the\n  // stamp, and are excluded here.\n  totalOperation: \"orchestrator.ready\",\n  postReadyOperations: new Set([\n    \"orchestrator.connection_build\",\n    \"orchestrator.metering_restart\",\n  ]),\n};\n\nexport const STOP_ACCOUNTING_SPEC: FlowAccountingSpec = {\n  totalOperation: \"orchestrator.stop_complete\",\n};\n\nexport const DELETE_ACCOUNTING_SPEC: FlowAccountingSpec = {\n  totalOperation: \"orchestrator.delete_complete\",\n};\n\nexport interface LifecycleStageTiming {\n  operation: string;\n  durationMs?: number;\n  parent?: string | null;\n}\ntype Values = Readonly<Record<string, number>>;\nexport interface LifecycleWallSample {\n  wallMs: number;\n  httpMs: number;\n  hops?: Values;\n  spanOps?: readonly LifecycleStageTiming[];\n  spanLeaves?: Values;\n  spanTotalMs?: number | null;\n  orchStages?: Values | null;\n  jobPhases?: Values | null;\n  jobMs?: number | null;\n  settleMs?: number | null;\n  spanAccountedMs?: number;\n}\nexport interface LifecycleWallFlow extends Partial<FlowAccountingSpec> {\n  workerTotalHop: string;\n  addPreHandler: boolean;\n  settleHop?: string;\n  workerNamedHops?: readonly string[];\n}\n\n/**\n * A flat `{name: ms}` ledger read as the tree its names describe.\n *\n * Every producer in this repo emits nested stages FLAT, with the containment\n * in the name: `capture.<hostPhase>` and `capture.restic_<phase>` inside\n * `capture` (snapshot-helpers.ts), `materialize.parentRead|precreate|\n * branchComplete|host.*|child.*|residual` inside `materialize` (branch.ts),\n * `delete.<hostPhase>` inside `delete` and `restore_workspace.<phase>` inside\n * `restore_workspace` (snapshots.ts). Summing every entry as a sibling counts\n * the children inside their parent a second time and reports a wall the\n * orchestrator never spent.\n *\n * So a dotted name is NEVER top-level. It attaches to the longest prefix that\n * exists as a stage; when no prefix exists — the restore job's `host.<phase>`,\n * which the queue records inside `restore_workspace` without naming it\n * (snapshot-job-queue.ts:394) — it is still excluded from the top-level sum\n * and reported as a child of the ledger at large. Excluding it can only leave\n * MORE time unnamed, never fabricate a reconciliation.\n */\nexport function stageTree(stages: Readonly<Record<string, number>>) {\n  const present = new Set(Object.keys(stages));\n  const parentOf = (name: string) => {\n    let cut = name.lastIndexOf(\".\");\n    while (cut > 0) {\n      const candidate = name.slice(0, cut);\n      if (present.has(candidate)) return candidate;\n      cut = candidate.lastIndexOf(\".\");\n    }\n    return name.includes(\".\") ? \"\" : null;\n  };\n  const nodes = Object.entries(stages).map(([name, ms]) => ({\n    name,\n    ms,\n    parent: parentOf(name),\n  }));\n  const topLevel = nodes.filter((node) => node.parent === null);\n  return {\n    nodes,\n    topLevel,\n    /** Children whose declared parent is not in the ledger; never summed. */\n    orphans: nodes.filter((node) => node.parent === \"\"),\n    topLevelMs: topLevel.reduce((sum, node) => sum + node.ms, 0),\n  };\n}\n\n/**\n * A response's span tree as `<stage>.<path>` rows and each parent's wall minus\n * its children as `<parent>.unattributed` (0 when children overlap), residuals\n * first so a capped header keeps them. Unparented spans nest in the total span.\n */\nexport function spanTreeStages(\n  stage: string,\n  stageMs: Readonly<Record<string, number>>,\n  operations: readonly (LifecycleStageTiming & { status?: string })[] = [],\n  spec?: Partial<FlowAccountingSpec>,\n): Record<string, number> {\n  const total = spec?.totalOperation ?? \"\";\n  const byName = new Map(operations.map((op) => [op.operation, op]));\n  const path = (op: LifecycleStageTiming, depth = 0): string => {\n    const outside =\n      op.operation === total || spec?.postReadyOperations?.has(op.operation);\n    const parent = byName.get(op.parent ?? (outside ? \"\" : total));\n    const name = op.operation.slice(op.operation.lastIndexOf(\".\") + 1);\n    return `${parent && depth < 8 ? path(parent, depth + 1) : stage}.${name}`;\n  };\n  const rows: Record<string, number> = { [stage]: stageMs[stage] ?? 0 };\n  for (const { durationMs: ms, status, ...op } of operations)\n    if (status === \"completed\" && typeof ms === \"number\" && ms >= 0)\n      rows[path(op)] = (rows[path(op)] ?? 0) + ms;\n  const residuals: Record<string, number> = {};\n  for (const [parent, ms] of Object.entries(rows)) {\n    const kids = Object.keys(rows).filter(\n      (name) =>\n        name.startsWith(`${parent}.`) &&\n        !name.slice(parent.length + 1).includes(\".\"),\n    );\n    if (kids.length)\n      residuals[`${parent}.unattributed`] = Math.max(\n        0,\n        kids.reduce((rest, kid) => rest - (rows[kid] ?? 0), ms),\n      );\n  }\n  delete rows[stage];\n  return { ...residuals, ...rows };\n}\n\n/**\n * Hops that describe the SHAPE of the request rather than a slice of it: the\n * three nested walls, the transport the walls imply, and the retry counter.\n * They are the terms of the summary line, so ranking them again as sub-stages\n * would print the same milliseconds twice under a second name. `preHandler`\n * joins them because it is the umbrella over the `mw.*` own-times, which ARE\n * ranked.\n */\nconst SHAPE_HOPS = new Set([\n  \"preHandler\",\n  \"total\",\n  \"serverWall\",\n  \"orchestrator\",\n  \"orchestratorServer\",\n  \"transportMarkup\",\n  \"orchestratorRetries\",\n]);\n\n/** Parent operations contain their descendants and are never counted as leaves. */\nexport function parentOperations(\n  operations: readonly LifecycleStageTiming[],\n): ReadonlySet<string> {\n  return new Set(\n    operations.flatMap((op) =>\n      typeof op.parent === \"string\" ? [op.parent] : [],\n    ),\n  );\n}\n\n/**\n * The measured leaves of one response's span tree, per the flow's own spec.\n *\n * Identical rule to the orchestrator's `computeFlowAccountingResiduals`: drop\n * the total span (it is the window), drop the spans stamped after it closes,\n * and drop any span another span names as its parent (a parent re-measures its\n * children). What is left sums to the window minus its named residual.\n */\nexport function leafOperations<T extends LifecycleStageTiming>(\n  operations: readonly T[],\n  excluded: ReadonlySet<string> = new Set(),\n  parents = parentOperations(operations),\n) {\n  return operations.filter(\n    (op): op is T & { durationMs: number } =>\n      !excluded.has(op.operation) &&\n      !parents.has(op.operation) &&\n      typeof op.durationMs === \"number\" &&\n      Number.isFinite(op.durationMs),\n  );\n}\n\nexport function operationLeafDurations(\n  operations: readonly LifecycleStageTiming[],\n  excluded: ReadonlySet<string> = new Set(),\n) {\n  const leaves = new Map<string, number>();\n  for (const op of leafOperations(operations, excluded))\n    leaves.set(op.operation, (leaves.get(op.operation) ?? 0) + op.durationMs);\n  return leaves;\n}\n\nconst difference = (a: number | null, b: number | null) =>\n  a === null || b === null ? null : a - b;\nconst positiveDifference = (a: number | null, b: number | null) => {\n  const value = difference(a, b);\n  return value === null ? null : Math.max(0, value);\n};\n\n/**\n * Partition one input before aggregation: null is unavailable; a negative\n * residual is overlapping evidence, never an instruction to publish zero.\n * Callers retain their population grouping, medians and display labels.\n */\nexport function partitionLifecycleWalls(\n  sample: LifecycleWallSample,\n  flow: LifecycleWallFlow,\n) {\n  const present = (value: number | null | undefined) =>\n    typeof value === \"number\" && Number.isFinite(value) ? value : null;\n  const finiteStages = (values?: Values | null) =>\n    Object.fromEntries(\n      Object.entries(values ?? {}).filter(([, ms]) => Number.isFinite(ms)),\n    );\n  const hops = sample.hops ?? {};\n  const hop = (key: string) => (Number.isFinite(hops[key]) ? hops[key] : null);\n  const handler = hop(flow.workerTotalHop);\n  const preHandler = hop(\"preHandler\");\n  const hold = flow.settleHop ? (hop(flow.settleHop) ?? 0) : 0;\n  const workerWallMs =\n    handler === null\n      ? null\n      : Math.max(0, handler - hold) +\n        (flow.addPreHandler ? (preHandler ?? 0) : 0);\n  const roundTripMs = hop(\"orchestrator\");\n  const orchServerMs = hop(\"orchestratorServer\");\n  const orchWall = roundTripMs ?? orchServerMs;\n  const terms = {\n    edge: positiveDifference(sample.httpMs, workerWallMs),\n    worker: positiveDifference(workerWallMs, orchWall ?? 0),\n    transport: positiveDifference(roundTripMs, orchServerMs),\n    orch: orchServerMs ?? roundTripMs,\n    job: present(sample.jobMs),\n    settle: present(sample.settleMs),\n    dark: 0,\n  };\n  terms.dark =\n    sample.wallMs -\n    Object.values(terms).reduce<number>((sum, ms) => sum + (ms ?? 0), 0);\n  const postReady = flow.postReadyOperations ?? new Set();\n  const rawLeaves =\n    sample.spanLeaves ??\n    Object.fromEntries(operationLeafDurations(sample.spanOps ?? []));\n  const spanLeaves = Object.fromEntries(\n    Object.entries(rawLeaves).filter(\n      ([name, ms]) =>\n        name !== flow.totalOperation &&\n        !postReady.has(name) &&\n        Number.isFinite(ms),\n    ),\n  );\n  /**\n   * The Worker's own handler stages: its ledger minus the three nested walls,\n   * the transport they imply and the middleware own-times, which are ranked\n   * separately because they run OUTSIDE the handler's `total`.\n   */\n  const workerStages = Object.fromEntries(\n    Object.entries(hops).filter(\n      ([name]) =>\n        Number.isFinite(hops[name]) &&\n        !SHAPE_HOPS.has(name) &&\n        name !== flow.settleHop &&\n        !name.startsWith(\"orch.\") &&\n        !name.startsWith(\"mw.\"),\n    ),\n  );\n  const orchTree = stageTree(finiteStages(sample.orchStages));\n  const jobTree = stageTree(finiteStages(sample.jobPhases));\n  const spanSum = Object.values(spanLeaves).reduce((sum, ms) => sum + ms, 0);\n  const workerNamed =\n    (flow.addPreHandler ? (preHandler ?? 0) : 0) +\n    (flow.workerNamedHops\n      ? flow.workerNamedHops.reduce((sum, key) => sum + (hop(key) ?? 0), 0)\n      : stageTree(workerStages).topLevelMs);\n  const workerUnattributedMs = difference(terms.worker, workerNamed);\n  const orchNamed = orchTree.topLevel.length\n    ? orchTree.topLevelMs\n    : spanSum > 0\n      ? spanSum\n      : 0;\n  const orchUnattributedMs = difference(terms.orch, orchNamed);\n  const jobUnattributedMs = difference(terms.job, jobTree.topLevelMs);\n  const unnamedMs =\n    Math.max(0, workerUnattributedMs ?? terms.worker ?? 0) +\n    Math.max(0, orchUnattributedMs ?? terms.orch ?? 0) +\n    Math.max(0, jobUnattributedMs ?? terms.job ?? 0) +\n    Math.max(0, terms.dark);\n  const measuredTotal = (sample.spanOps ?? []).find(\n    (op) => op.operation === flow.totalOperation,\n  )?.durationMs;\n  const spanTotalMs = present(sample.spanTotalMs ?? measuredTotal);\n  const readySum = sample.spanAccountedMs ?? spanSum;\n  const readyTerm = spanTotalMs ?? readySum;\n  const orchTerm = roundTripMs ?? orchServerMs ?? readyTerm;\n  let clampedMs = 0;\n  const diff = (a: number | null, b: number | null) => {\n    const delta = difference(a, b);\n    if (delta === null) return null;\n    clampedMs += Math.max(0, -delta);\n    return Math.max(0, delta);\n  };\n  const transportMs = diff(roundTripMs, orchServerMs);\n  const afterSpanMs = diff(orchServerMs, spanTotalMs);\n  const pathSum = workerNamed + orchTerm;\n  const outerMs =\n    workerWallMs === null\n      ? diff(\n          sample.wallMs - readyTerm,\n          workerNamed + (transportMs ?? 0) + (afterSpanMs ?? 0),\n        )\n      : diff(sample.wallMs, workerWallMs);\n  const window = {\n    transportMs,\n    afterSpanMs,\n    outerMs,\n    workerUnattributedMs: positiveDifference(workerWallMs, pathSum),\n    workerOwnMs: positiveDifference(workerWallMs, orchTerm),\n    gaps: {\n      overlapMs: positiveDifference(readySum, spanTotalMs) ?? 0,\n      underTileMs: positiveDifference(spanTotalMs, readySum) ?? 0,\n      workerOverlapMs: positiveDifference(pathSum, workerWallMs) ?? 0,\n      unrowedMs:\n        workerWallMs === null\n          ? 0\n          : Math.max(\n              0,\n              orchTerm - readyTerm - (transportMs ?? 0) - (afterSpanMs ?? 0),\n            ),\n      clampedMs,\n    },\n  };\n  return {\n    wallMs: sample.wallMs,\n    httpMs: sample.httpMs,\n    workerWallMs,\n    roundTripMs,\n    orchServerMs,\n    orchIncludesTransport: orchServerMs === null && roundTripMs !== null,\n    workerIncludesTransport: roundTripMs === null && orchServerMs !== null,\n    terms,\n    workerUnattributedMs,\n    orchUnattributedMs,\n    jobUnattributedMs,\n    unnamedMs,\n    unnamedShare: sample.wallMs > 0 ? unnamedMs / sample.wallMs : 0,\n    overcountMs: Math.max(0, -terms.dark),\n    spanLeaves,\n    workerStages,\n    orchTree,\n    jobTree,\n    spanTotalMs,\n    window,\n  };\n}\n"],"mappings":"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"}