@flowrensic/node 0.1.1 → 0.1.2

package/README.md

@@ -1,26 +1,62 @@
 # @flowrensic/node
 
-Publishes what a Temporal worker knows about every activity attempt.
+Replay the histories your workflows already produced, against the code you are
+about to ship.
 
-    import { createAttemptSink, flowrensicInterceptor } from '@flowrensic/node';
+Flowrensic keeps what a Temporal server recorded. This package fetches a set and
+replays it through Temporal's own replayer, in your tests, against your
+checkout. Histories in a repo go stale on the next deploy and nobody can say
+which are still safe to delete.
 
-    const sink = createAttemptSink({ baseUrl: 'https://flowrensic.example' });
+Server: `flowrensic/flowrensic` on Docker Hub. Temporal is the supported engine.
 
-    const worker = await Worker.create({
-      // ...
-      interceptors: { activity: [flowrensicInterceptor(sink, namespaceId)] },
-    });
+## Replay
 
-`namespaceId` is the namespace this worker is pointed at, from `RegisterNamespace`. Prod, staging,
-qa and ci report separately because each is its own environment in the catalog.
+    docker run --rm -v "$PWD/replay-set:/out" --entrypoint /flowrensic \
+      flowrensic/flowrensic replay fetch \
+      --server http://flowrensic:8080 --workflow-type OrderWorkflow --out /out
 
-One event per attempt, not per activity: the gap between the two is the retry count. Everything
-Temporal's own OpenTelemetry spans throw away is carried here, including the attempt number, the
-workflow type, the task queue and the failure classification.
+```ts
+import { replayFetchedSet } from '@flowrensic/node';
 
-Activity inbound only. Emitting from a workflow interceptor would be non-determinism in the product
-that sells determinism analysis.
+const report = await replayFetchedSet({
+  dir: 'replay-set',
+  workflowsPath: require.resolve('./workflows'),
+  codeVersion: process.env.GIT_SHA,
+  baseUrl: 'http://flowrensic:8080',
+});
 
-Publishing failures are swallowed. Telemetry must never fail the activity it measures.
+if (report.failed > 0) throw new Error(`${report.failed} histories no longer replay`);
+```
 
-Not published to npm yet.
+Verdicts go back against the run and the version, so a break points at the
+change that caused it.
+
+The server picks the set: recent histories, versions still running somewhere,
+outcomes that differ. Newest-ten on a healthy workflow type is ten completions
+and not one failure.
+
+## Activity telemetry
+
+```ts
+import { createAttemptSink, flowrensicInterceptor } from '@flowrensic/node';
+
+const sink = createAttemptSink({ baseUrl: 'http://flowrensic:8080' });
+
+const worker = await Worker.create({
+  // ...
+  interceptors: { activity: [flowrensicInterceptor(sink, namespaceId)] },
+});
+```
+
+One event per attempt, not per activity: the gap between the two is the retry
+count. `namespaceId` comes from `RegisterNamespace`, so each environment reports
+separately.
+
+Activity inbound only, and publishing failures are swallowed. Telemetry must
+never fail the activity it measures.
+
+## Peers
+
+`@temporalio/worker`, `@temporalio/common`, `@temporalio/activity`, 1.24 or
+newer. The replay has to run on the same SDK your workers do.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowrensic/node",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Replay runner and activity interceptor for Temporal workers, for use with Flowrensic.",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,5 +40,16 @@
   "publishConfig": {
     "access": "public"
   },
-  "types": "./dist/index.d.ts"
+  "types": "./dist/index.d.ts",
+  "keywords": [
+    "temporal",
+    "temporalio",
+    "durable-execution",
+    "workflow",
+    "replay",
+    "non-determinism",
+    "testing",
+    "flowrensic"
+  ],
+  "homepage": "https://flowrensic.com"
 }