@payloops/processor-core 0.0.8 → 0.0.10

package/README.md

@@ -133,7 +133,7 @@ Activities are the building blocks that workflows orchestrate:
 ### Prerequisites
 
 - Node.js 22+
-- pnpm
+- npm
 - Temporal server (via Docker)
 - PostgreSQL (via Docker)
 
@@ -141,7 +141,7 @@ Activities are the building blocks that workflows orchestrate:
 
 ```bash
 # Install dependencies
-pnpm install
+npm install
 
 # Copy environment template
 cp .env.example .env
@@ -150,18 +150,18 @@ cp .env.example .env
 docker-compose up -d temporal
 
 # Start worker in development mode
-pnpm dev
+npm dev
 ```
 
 ### Available Scripts
 
 | Command | Description |
 |---------|-------------|
-| `pnpm dev` | Start worker with hot reload |
-| `pnpm build` | Build for production |
-| `pnpm start` | Run production worker |
-| `pnpm typecheck` | Run TypeScript compiler |
-| `pnpm lint` | Run ESLint |
+| `npm dev` | Start worker with hot reload |
+| `npm build` | Build for production |
+| `npm start` | Run production worker |
+| `npm typecheck` | Run TypeScript compiler |
+| `npm lint` | Run ESLint |
 
 ## Configuration
 

package/dist/lib/observability/index.d.ts

@@ -1 +1,49 @@
 export * from '@payloops/observability';
+export { OpenTelemetryActivityInboundInterceptor, makeWorkflowExporter } from '@temporalio/interceptors-opentelemetry';
+import { Context } from '@temporalio/activity';
+import { ActivityInboundCallsInterceptor, ActivityExecuteInput, Next } from '@temporalio/worker';
+
+/**
+ * Temporal Worker Interceptors with OpenTelemetry trace context propagation
+ *
+ * This module provides interceptors that:
+ * 1. Propagate trace context from workflow headers to activity spans
+ * 2. Add structured logging with trace context
+ * 3. Create proper parent-child span relationships
+ */
+
+interface WorkerInterceptorsConfig {
+    /** Service/processor name for logging */
+    serviceName: string;
+}
+/**
+ * Creates an activity interceptor that combines OpenTelemetry tracing with structured logging
+ *
+ * Uses Temporal's OpenTelemetryActivityInboundInterceptor for trace propagation,
+ * and wraps it with additional structured logging that includes trace IDs.
+ */
+declare class TracingActivityInterceptor implements ActivityInboundCallsInterceptor {
+    private readonly otelInterceptor;
+    private readonly config;
+    private readonly ctx;
+    constructor(ctx: Context, config: WorkerInterceptorsConfig);
+    execute(input: ActivityExecuteInput, next: Next<ActivityInboundCallsInterceptor, 'execute'>): Promise<unknown>;
+}
+/**
+ * Creates worker interceptors configuration with OpenTelemetry trace propagation
+ *
+ * @example
+ * ```typescript
+ * import { createWorkerInterceptors } from '@payloops/processor-core/observability';
+ *
+ * const worker = await Worker.create({
+ *   // ... other config
+ *   interceptors: createWorkerInterceptors({ serviceName: 'stripe-processor' }),
+ * });
+ * ```
+ */
+declare function createWorkerInterceptors(config: WorkerInterceptorsConfig): {
+    activityInbound: ((ctx: Context) => TracingActivityInterceptor)[];
+};
+
+export { type WorkerInterceptorsConfig, createWorkerInterceptors };

package/dist/lib/observability/index.js

@@ -1,2 +1,83 @@
 // src/lib/observability/index.ts
 export * from "@payloops/observability";
+import {
+  makeWorkflowExporter,
+  OpenTelemetryActivityInboundInterceptor as OpenTelemetryActivityInboundInterceptor2
+} from "@temporalio/interceptors-opentelemetry";
+
+// src/lib/observability/interceptors.ts
+import { trace } from "@opentelemetry/api";
+import {
+  OpenTelemetryActivityInboundInterceptor
+} from "@temporalio/interceptors-opentelemetry";
+import { logger } from "@payloops/observability";
+var TracingActivityInterceptor = class {
+  otelInterceptor;
+  config;
+  ctx;
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.otelInterceptor = new OpenTelemetryActivityInboundInterceptor(ctx);
+  }
+  async execute(input, next) {
+    const activityType = this.ctx.info.activityType;
+    const workflowId = this.ctx.info.workflowExecution.workflowId;
+    const startTime = Date.now();
+    const currentSpan = trace.getActiveSpan();
+    const spanContext = currentSpan?.spanContext();
+    logger.info(
+      {
+        activity: activityType,
+        workflowId,
+        processor: this.config.serviceName,
+        trace_id: spanContext?.traceId,
+        span_id: spanContext?.spanId
+      },
+      "Activity started"
+    );
+    try {
+      const result = await this.otelInterceptor.execute(input, next);
+      const finalSpan = trace.getActiveSpan();
+      const finalSpanContext = finalSpan?.spanContext();
+      logger.info(
+        {
+          activity: activityType,
+          workflowId,
+          duration: Date.now() - startTime,
+          trace_id: finalSpanContext?.traceId ?? spanContext?.traceId,
+          span_id: finalSpanContext?.spanId ?? spanContext?.spanId
+        },
+        "Activity completed"
+      );
+      return result;
+    } catch (error) {
+      const finalSpan = trace.getActiveSpan();
+      const finalSpanContext = finalSpan?.spanContext();
+      logger.error(
+        {
+          activity: activityType,
+          workflowId,
+          error,
+          duration: Date.now() - startTime,
+          trace_id: finalSpanContext?.traceId ?? spanContext?.traceId,
+          span_id: finalSpanContext?.spanId ?? spanContext?.spanId
+        },
+        "Activity failed"
+      );
+      throw error;
+    }
+  }
+};
+function createWorkerInterceptors(config) {
+  return {
+    activityInbound: [
+      (ctx) => new TracingActivityInterceptor(ctx, config)
+    ]
+  };
+}
+export {
+  OpenTelemetryActivityInboundInterceptor2 as OpenTelemetryActivityInboundInterceptor,
+  createWorkerInterceptors,
+  makeWorkflowExporter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloops/processor-core",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,12 +30,18 @@
     "release:major": "npm run build && npm run typecheck && npm version major && git push && git push --tags"
   },
   "dependencies": {
-    "@payloops/observability": "^0.0.1"
+    "@payloops/observability": "^0.0.13",
+    "@temporalio/interceptors-opentelemetry": "^1.11.7",
+    "@temporalio/worker": "^1.11.7",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-trace-base": "^1.25.1"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/node": "^22.0.0",
     "eslint": "^9.0.0",
     "tsup": "^8.3.5",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.0"
   }
 }