pg-workflows 0.11.0 → 0.12.0

package/dist/index.js

@@ -732,21 +732,32 @@ class WorkflowEngine {
       };
       let step = { ...baseStep };
       const plugins = workflow2.plugins ?? [];
-      for (const plugin of plugins) {
-        const extra = plugin.methods(step);
-        step = { ...step, ...extra };
-      }
       const context = {
         input: run.input,
         workflowId: run.workflowId,
         runId: run.id,
+        resourceId: run.resourceId ?? undefined,
+        attempt: run.retryCount,
         get timeline() {
           return run?.timeline ?? {};
         },
         logger: this.logger,
         step
       };
-      const result = await workflow2.handler(context);
+      for (const plugin of plugins) {
+        const extra = plugin.methods(step, context);
+        step = { ...step, ...extra };
+        context.step = step;
+      }
+      let next = () => workflow2.handler(context);
+      for (const plugin of [...plugins].reverse()) {
+        if (plugin.wrap) {
+          const inner = next;
+          const wrap = plugin.wrap;
+          next = () => wrap(context, inner);
+        }
+      }
+      const result = await next();
       run = await this.getRun({ runId, resourceId: scopedResourceId });
       const isLastParsedStep = run.currentStepId === workflow2.steps[workflow2.steps.length - 1]?.id;
       const hasPluginSteps = (workflow2.plugins?.length ?? 0) > 0;
@@ -1279,8 +1290,183 @@ ${error.stack}` : String(error)
     }, this.db);
   }
 }
+// src/plugins/otel.ts
+import {
+  context as otelContext,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+var DEFAULT_PREFIX = "pg_workflows";
+function isCachedHit(timeline, stepId, kind) {
+  const entry = timeline[stepId];
+  if (entry && typeof entry === "object" && "output" in entry && entry.output !== undefined) {
+    return true;
+  }
+  if (kind === "invokeChildWorkflow" && timeline[invokeChildWorkflowTimelineKey(stepId)]) {
+    return true;
+  }
+  return false;
+}
+function otelPlugin(options = {}) {
+  const tracer = options.tracer ?? trace.getTracer("pg-workflows");
+  const prefix = options.spanNamePrefix ?? DEFAULT_PREFIX;
+  const extraAttrs = options.attributes;
+  return {
+    name: "opentelemetry",
+    methods: (step, context) => {
+      const wrapVoidish = (kind, base) => {
+        return async (stepId, ...args) => {
+          if (isCachedHit(context.timeline, stepId, kind)) {
+            return base(stepId, ...args);
+          }
+          const capturedCtx = otelContext.active();
+          const startTime = new Date;
+          let result;
+          let originalErr;
+          let thrownError;
+          try {
+            result = await base(stepId, ...args);
+          } catch (err) {
+            originalErr = err;
+            thrownError = err instanceof Error ? err : new Error(String(err));
+          }
+          const span = tracer.startSpan(`${prefix}.step.${kind}`, {
+            startTime,
+            attributes: { "step.id": stepId, "step.type": kind }
+          }, capturedCtx);
+          if (thrownError) {
+            span.recordException(thrownError);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: thrownError.message });
+            span.end();
+            throw originalErr;
+          }
+          span.setStatus({ code: SpanStatusCode.OK });
+          span.end();
+          return result;
+        };
+      };
+      return {
+        run: async (stepId, handler) => {
+          if (isCachedHit(context.timeline, stepId, "run")) {
+            return step.run(stepId, handler);
+          }
+          const capturedCtx = otelContext.active();
+          const startTime = new Date;
+          let result;
+          let originalErr;
+          let thrownError;
+          try {
+            result = await step.run(stepId, handler);
+          } catch (err) {
+            originalErr = err;
+            thrownError = err instanceof Error ? err : new Error(String(err));
+          }
+          if (result === undefined && !thrownError) {
+            return;
+          }
+          const span = tracer.startSpan(`${prefix}.step.run`, {
+            startTime,
+            attributes: { "step.id": stepId, "step.type": "run" }
+          }, capturedCtx);
+          if (thrownError) {
+            span.recordException(thrownError);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: thrownError.message });
+            span.end();
+            throw originalErr;
+          }
+          span.setStatus({ code: SpanStatusCode.OK });
+          span.end();
+          return result;
+        },
+        waitFor: wrapVoidish("waitFor", step.waitFor),
+        delay: wrapVoidish("delay", step.delay),
+        sleep: wrapVoidish("delay", step.delay),
+        waitUntil: wrapVoidish("waitUntil", step.waitUntil),
+        pause: wrapVoidish("pause", step.pause),
+        poll: async (stepId, conditionFn, pollOptions) => {
+          const capturedCtx = otelContext.active();
+          const startTime = new Date;
+          let result;
+          let originalErr;
+          let thrownError;
+          try {
+            result = await step.poll(stepId, conditionFn, pollOptions);
+          } catch (err) {
+            originalErr = err;
+            thrownError = err instanceof Error ? err : new Error(String(err));
+          }
+          const span = tracer.startSpan(`${prefix}.step.poll`, {
+            startTime,
+            attributes: { "step.id": stepId, "step.type": "poll" }
+          }, capturedCtx);
+          if (thrownError) {
+            span.recordException(thrownError);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: thrownError.message });
+            span.end();
+            throw originalErr;
+          }
+          span.setStatus({ code: SpanStatusCode.OK });
+          span.end();
+          return result;
+        },
+        invokeChildWorkflow: async (stepId, refOrParams, inputArg, optionsArg) => {
+          if (isCachedHit(context.timeline, stepId, "invokeChildWorkflow")) {
+            return step.invokeChildWorkflow(stepId, refOrParams, inputArg, optionsArg);
+          }
+          const capturedCtx = otelContext.active();
+          const startTime = new Date;
+          let result;
+          let originalErr;
+          let thrownError;
+          try {
+            result = await step.invokeChildWorkflow(stepId, refOrParams, inputArg, optionsArg);
+          } catch (err) {
+            originalErr = err;
+            thrownError = err instanceof Error ? err : new Error(String(err));
+          }
+          const span = tracer.startSpan(`${prefix}.step.invokeChildWorkflow`, {
+            startTime,
+            attributes: { "step.id": stepId, "step.type": "invokeChildWorkflow" }
+          }, capturedCtx);
+          if (thrownError) {
+            span.recordException(thrownError);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: thrownError.message });
+            span.end();
+            throw originalErr;
+          }
+          span.setStatus({ code: SpanStatusCode.OK });
+          span.end();
+          return result;
+        }
+      };
+    },
+    wrap: (context, next) => tracer.startActiveSpan(`${prefix}.workflow.run`, {
+      attributes: {
+        "workflow.id": context.workflowId,
+        "workflow.run_id": context.runId,
+        "workflow.attempt": context.attempt,
+        ...context.resourceId ? { "workflow.resource_id": context.resourceId } : {},
+        ...extraAttrs ? extraAttrs(context) : {}
+      }
+    }, async (span) => {
+      try {
+        const result = await next();
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        span.recordException(error);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    })
+  };
+}
 export {
   workflow,
+  otelPlugin,
   createWorkflowRef,
   WorkflowStatus,
   WorkflowRunNotFoundError,
@@ -1289,5 +1475,5 @@ export {
   WorkflowClient
 };
 
-//# debugId=F9D6596295A7020B64756E2164756E21
+//# debugId=3131CBB2B482181264756E2164756E21
 //# sourceMappingURL=index.js.map