@hatchet-dev/typescript-sdk 1.18.0 → 1.19.1

package/clients/event/event-client.js

@@ -14,6 +14,7 @@ const events_1 = require("../../protoc/events/events");
 const hatchet_error_1 = require("../../util/errors/hatchet-error");
 const retrier_1 = require("../../util/retrier");
 const apply_namespace_1 = require("../../util/apply-namespace");
+const parent_run_context_vars_1 = require("../../v1/parent-run-context-vars");
 var LogLevel;
 (function (LogLevel) {
     LogLevel["INFO"] = "INFO";
@@ -21,6 +22,13 @@ var LogLevel;
     LogLevel["ERROR"] = "ERROR";
     LogLevel["DEBUG"] = "DEBUG";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
+function injectSourceInfo(metadata) {
+    const ctx = parent_run_context_vars_1.parentRunContextManager.getContext();
+    if (!(ctx === null || ctx === void 0 ? void 0 : ctx.parentId) || !(ctx === null || ctx === void 0 ? void 0 : ctx.parentTaskRunExternalId)) {
+        return metadata;
+    }
+    return Object.assign(Object.assign({}, metadata), { hatchet__source_workflow_run_id: ctx.parentId, hatchet__source_step_run_id: ctx.parentTaskRunExternalId });
+}
 class EventClient {
     constructor(config, channel, factory, api) {
         this.config = config;
@@ -35,14 +43,14 @@ class EventClient {
      * Keep the signature in sync with the instrumentor wrapper.
      */
     push(type, input, options = {}) {
+        var _a;
         const namespacedType = (0, apply_namespace_1.applyNamespace)(type, this.config.namespace);
+        const enhancedMetadata = injectSourceInfo((_a = options.additionalMetadata) !== null && _a !== void 0 ? _a : {});
         const req = {
             key: namespacedType,
             payload: JSON.stringify(input),
             eventTimestamp: new Date(),
-            additionalMetadata: options.additionalMetadata
-                ? JSON.stringify(options.additionalMetadata)
-                : undefined,
+            additionalMetadata: Object.keys(enhancedMetadata).length > 0 ? JSON.stringify(enhancedMetadata) : undefined,
             priority: options.priority,
             scope: options.scope,
         };
@@ -62,19 +70,14 @@ class EventClient {
     bulkPush(type, inputs, options = {}) {
         const namespacedType = (0, apply_namespace_1.applyNamespace)(type, this.config.namespace);
         const events = inputs.map((input) => {
+            var _a, _b;
+            const baseMeta = (_b = (_a = input.additionalMetadata) !== null && _a !== void 0 ? _a : options.additionalMetadata) !== null && _b !== void 0 ? _b : {};
+            const enhanced = injectSourceInfo(baseMeta);
             return {
                 key: namespacedType,
                 payload: JSON.stringify(input.payload),
                 eventTimestamp: new Date(),
-                additionalMetadata: (() => {
-                    if (input.additionalMetadata) {
-                        return JSON.stringify(input.additionalMetadata);
-                    }
-                    if (options.additionalMetadata) {
-                        return JSON.stringify(options.additionalMetadata);
-                    }
-                    return undefined;
-                })(),
+                additionalMetadata: Object.keys(enhanced).length > 0 ? JSON.stringify(enhanced) : undefined,
                 priority: input.priority,
                 scope: input.scope,
             };

package/opentelemetry/hatchet-exporter.d.ts

@@ -9,16 +9,28 @@
  * enable_hatchet_otel_collector option.
  */
 import type { ClientConfig } from '../clients/hatchet-client/client-config';
-type SdkTracerProvider = import('@opentelemetry/sdk-trace-base').BasicTracerProvider;
+declare const BatchSpanProcessor: typeof import("@opentelemetry/sdk-trace-base").BatchSpanProcessor;
+type ReadableSpan = import('@opentelemetry/sdk-trace-base').ReadableSpan;
+type SdkSpan = import('@opentelemetry/sdk-trace-base').Span;
+/**
+ * HatchetAttributeSpanProcessor wraps a BatchSpanProcessor and injects
+ * hatchet.* attributes into every span created within a step run context.
+ * This ensures child spans are queryable by the same attributes (e.g.
+ * hatchet.step_run_id) as the parent span.
+ */
+declare class HatchetAttributeSpanProcessor extends BatchSpanProcessor {
+    onStart(span: SdkSpan): void;
+    onEnd(span: ReadableSpan): void;
+}
 export interface HatchetBspConfig {
     scheduledDelayMillis?: number;
     maxExportBatchSize?: number;
     maxQueueSize?: number;
 }
 /**
- * Adds the Hatchet OTLP exporter to the given TracerProvider.
- * The exporter sends spans to the Hatchet engine's collector endpoint
- * using the same connection settings as the Hatchet client.
+ * Creates a SpanProcessor that sends spans to the Hatchet engine's
+ * collector endpoint using the same connection settings as the Hatchet client.
+ * Pass the returned processor to BasicTracerProvider's `spanProcessors` option.
  */
-export declare function addHatchetExporter(tracerProvider: SdkTracerProvider, config: ClientConfig, bspConfig?: HatchetBspConfig): void;
+export declare function createHatchetSpanProcessor(config: ClientConfig, bspConfig?: HatchetBspConfig): InstanceType<typeof HatchetAttributeSpanProcessor>;
 export {};

package/opentelemetry/hatchet-exporter.js

@@ -10,14 +10,23 @@
  * enable_hatchet_otel_collector option.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addHatchetExporter = addHatchetExporter;
+exports.createHatchetSpanProcessor = createHatchetSpanProcessor;
 const hatchet_span_context_1 = require("./hatchet-span-context");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let otelDiag;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    otelDiag = require('@opentelemetry/api').diag;
+}
+catch (_a) {
+    // best-effort
+}
 try {
     require.resolve('@opentelemetry/exporter-trace-otlp-grpc');
     require.resolve('@opentelemetry/sdk-trace-base');
     require.resolve('@opentelemetry/core');
 }
-catch (_a) {
+catch (_b) {
     throw new Error('To use HatchetInstrumentor with enableHatchetCollector, you must install: ' +
         'npm install @opentelemetry/exporter-trace-otlp-grpc @opentelemetry/sdk-trace-base @opentelemetry/core');
 }
@@ -38,24 +47,38 @@ class HatchetExporterWrapper {
         this.inner = inner;
     }
     export(spans, resultCallback) {
+        var _a;
         if (this.retryAt > 0 && Date.now() < this.retryAt) {
             resultCallback({ code: ExportResultCode.SUCCESS });
             return;
         }
-        this.inner.export(spans, (result) => {
-            var _a;
-            if (result.code !== ExportResultCode.SUCCESS && result.error) {
-                const err = result.error;
-                if (err.code === GRPC_STATUS_UNIMPLEMENTED ||
-                    ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toString().includes('UNIMPLEMENTED'))) {
-                    this.retryAt = Date.now() + RETRY_AFTER_MS;
-                    resultCallback({ code: ExportResultCode.SUCCESS });
-                    return;
+        try {
+            this.inner.export(spans, (result) => {
+                var _a;
+                if (result.code !== ExportResultCode.SUCCESS && result.error) {
+                    const err = result.error;
+                    if (err.code === GRPC_STATUS_UNIMPLEMENTED ||
+                        ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toString().includes('UNIMPLEMENTED'))) {
+                        this.retryAt = Date.now() + RETRY_AFTER_MS;
+                        resultCallback({ code: ExportResultCode.SUCCESS });
+                        return;
+                    }
                 }
+                this.retryAt = 0;
+                resultCallback(result);
+            });
+        }
+        catch (e) {
+            if (e instanceof TypeError && ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes("reading 'name'"))) {
+                otelDiag === null || otelDiag === void 0 ? void 0 : otelDiag.error('hatchet instrumentation: OpenTelemetry package version mismatch. ' +
+                    '@opentelemetry/exporter-trace-otlp-grpc and @opentelemetry/sdk-trace-base must be ' +
+                    'from the same release set (1.x + 0.5x.x, or 2.x + 0.20x.x). ' +
+                    'See https://github.com/open-telemetry/opentelemetry-js#version-compatibility');
+                resultCallback({ code: ExportResultCode.SUCCESS });
+                return;
             }
-            this.retryAt = 0;
-            resultCallback(result);
-        });
+            throw e;
+        }
     }
     shutdown() {
         return this.inner.shutdown();
@@ -73,9 +96,19 @@ class HatchetExporterWrapper {
  */
 class HatchetAttributeSpanProcessor extends BatchSpanProcessor {
     onStart(span) {
+        var _a;
         const attrs = hatchet_span_context_1.hatchetSpanAttributes.getStore();
         if (attrs) {
-            span.setAttributes(attrs);
+            const existing = (_a = span.attributes) !== null && _a !== void 0 ? _a : {};
+            const filtered = {};
+            for (const [key, value] of Object.entries(attrs)) {
+                if (!(key in existing)) {
+                    filtered[key] = value;
+                }
+            }
+            if (Object.keys(filtered).length > 0) {
+                span.setAttributes(filtered);
+            }
         }
         super.onStart(span, undefined);
     }
@@ -85,10 +118,14 @@ class HatchetAttributeSpanProcessor extends BatchSpanProcessor {
 }
 function createHatchetExporter(config) {
     const insecure = config.tls_config.tls_strategy === 'none';
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const grpc = require('@grpc/grpc-js');
+    const metadata = new grpc.Metadata();
+    metadata.set('authorization', `Bearer ${config.token}`);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const opts = {
         url: `${insecure ? 'http' : 'https'}://${config.host_port}`,
-        metadata: { authorization: `Bearer ${config.token}` },
+        metadata,
     };
     if (!insecure && config.tls_config.ca_file) {
         try {
@@ -106,18 +143,17 @@ function createHatchetExporter(config) {
     return new OTLPTraceExporter(opts);
 }
 /**
- * Adds the Hatchet OTLP exporter to the given TracerProvider.
- * The exporter sends spans to the Hatchet engine's collector endpoint
- * using the same connection settings as the Hatchet client.
+ * Creates a SpanProcessor that sends spans to the Hatchet engine's
+ * collector endpoint using the same connection settings as the Hatchet client.
+ * Pass the returned processor to BasicTracerProvider's `spanProcessors` option.
  */
-function addHatchetExporter(tracerProvider, config, bspConfig) {
+function createHatchetSpanProcessor(config, bspConfig) {
     const inner = createHatchetExporter(config);
     const exporter = new HatchetExporterWrapper(inner);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const processor = new HatchetAttributeSpanProcessor(exporter, {
+    return new HatchetAttributeSpanProcessor(exporter, {
         scheduledDelayMillis: bspConfig === null || bspConfig === void 0 ? void 0 : bspConfig.scheduledDelayMillis,
         maxExportBatchSize: bspConfig === null || bspConfig === void 0 ? void 0 : bspConfig.maxExportBatchSize,
         maxQueueSize: bspConfig === null || bspConfig === void 0 ? void 0 : bspConfig.maxQueueSize,
     });
-    tracerProvider.addSpanProcessor(processor);
 }

package/opentelemetry/instrumentor.js

@@ -46,6 +46,17 @@ function extractContext(carrier) {
 function injectContext(carrier) {
     propagation.inject(context.active(), carrier);
 }
+function injectSourceInfo(carrier) {
+    const store = hatchet_span_context_1.hatchetSpanAttributes.getStore();
+    if (!store)
+        return;
+    const wfRunId = store['hatchet.workflow_run_id'];
+    const stepRunId = store['hatchet.step_run_id'];
+    if (typeof wfRunId === 'string' && typeof stepRunId === 'string') {
+        carrier['hatchet__source_workflow_run_id'] = wfRunId;
+        carrier['hatchet__source_step_run_id'] = stepRunId;
+    }
+}
 function getActionOtelAttributes(action, excludedAttributes = [], workerId) {
     const attributes = {
         [opentelemetry_1.OTelAttribute.TENANT_ID]: action.tenantId,
@@ -117,35 +128,32 @@ class HatchetInstrumentor extends InstrumentationBase {
     _setupHatchetCollector(clientConfig, bspConfig) {
         try {
             /* eslint-disable @typescript-eslint/no-require-imports */
-            const { addHatchetExporter } = require('./hatchet-exporter.js');
+            const { createHatchetSpanProcessor } = require('./hatchet-exporter.js');
             let config = clientConfig;
             if (!config) {
-                // Load config from environment (same as HatchetClient would)
                 const { ConfigLoader } = require('../util/config-loader/config-loader');
                 config = ConfigLoader.loadClientConfig();
             }
-            // Get the SDK TracerProvider - either from the global provider or create one
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let sdkTracerProvider;
+            const processor = createHatchetSpanProcessor(config, bspConfig);
             try {
                 const sdkTrace = require('@opentelemetry/sdk-trace-base');
                 /* eslint-enable @typescript-eslint/no-require-imports */
-                // Check if the global tracer provider is an SDK TracerProvider
                 const globalProvider = otelApi.trace.getTracerProvider();
-                if (globalProvider instanceof sdkTrace.BasicTracerProvider) {
-                    sdkTracerProvider = globalProvider;
+                if (!(globalProvider instanceof sdkTrace.BasicTracerProvider)) {
+                    const sdkTracerProvider = new sdkTrace.BasicTracerProvider({
+                        spanProcessors: [processor],
+                    });
+                    otelApi.trace.setGlobalTracerProvider(sdkTracerProvider);
                 }
                 else {
-                    // Create a new SDK TracerProvider and set it as global
-                    sdkTracerProvider = new sdkTrace.BasicTracerProvider();
-                    sdkTracerProvider.register();
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    globalProvider.addSpanProcessor(processor);
                 }
             }
             catch (_a) {
                 diag.warn('hatchet instrumentation: @opentelemetry/sdk-trace-base is required for enableHatchetCollector');
                 return;
             }
-            addHatchetExporter(sdkTracerProvider, config, bspConfig);
             diag.info('hatchet instrumentation: Hatchet OTLP collector enabled');
         }
         catch (e) {
@@ -218,6 +226,7 @@ class HatchetInstrumentor extends InstrumentationBase {
                     var _a;
                     const enhancedMetadata = Object.assign({}, ((_a = options.additionalMetadata) !== null && _a !== void 0 ? _a : {}));
                     injectContext(enhancedMetadata);
+                    injectSourceInfo(enhancedMetadata);
                     const enhancedOptions = Object.assign(Object.assign({}, options), { additionalMetadata: enhancedMetadata });
                     const result = original.call(this, type, input, enhancedOptions);
                     return result.finally(() => {
@@ -250,6 +259,7 @@ class HatchetInstrumentor extends InstrumentationBase {
                         var _a;
                         const enhancedMetadata = Object.assign({}, ((_a = input.additionalMetadata) !== null && _a !== void 0 ? _a : {}));
                         injectContext(enhancedMetadata);
+                        injectSourceInfo(enhancedMetadata);
                         return Object.assign(Object.assign({}, input), { additionalMetadata: enhancedMetadata });
                     });
                     const result = original.call(this, type, enhancedInputs, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -61,11 +61,12 @@
     "zod-to-json-schema": "^3.24.1"
   },
   "optionalDependencies": {
+    "@grpc/grpc-js": "^1.14.3",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/core": "^1.30.1",
+    "@opentelemetry/core": "^2.0.0",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.208.0",
     "@opentelemetry/instrumentation": "^0.208.0",
-    "@opentelemetry/sdk-trace-base": "^1.30.1",
+    "@opentelemetry/sdk-trace-base": "^2.0.0",
     "prom-client": "^15.1.3"
   },
   "scripts": {

package/v1/examples/webhooks/workflow.d.ts

@@ -3,3 +3,64 @@ export type WebhookInput = {
     message: string;
 };
 export declare const webhookWorkflow: import("../..").WorkflowDeclaration<WebhookInput, {}, {}>;
+type StripePaymentInput = {
+    type: string;
+    data: {
+        object: {
+            customer: string;
+            amount: number;
+        };
+    };
+};
+export declare const handleStripePayment: import("../..").TaskWorkflowDeclaration<StripePaymentInput, {
+    customer: string;
+    amount: number;
+}, {}, {}, {}, {}>;
+type GitHubPRInput = {
+    action: string;
+    pull_request: {
+        number: number;
+        title: string;
+    };
+    repository: {
+        full_name: string;
+    };
+};
+export declare const handleGitHubPR: import("../..").TaskWorkflowDeclaration<GitHubPRInput, {
+    repo: string;
+    pr: number;
+}, {}, {}, {}, {}>;
+type SlackEventInput = {
+    event: {
+        type: string;
+        user: string;
+        text: string;
+        channel: string;
+    };
+};
+export declare const handleSlackMention: import("../..").TaskWorkflowDeclaration<SlackEventInput, {
+    handled: true;
+}, {}, {}, {}, {}>;
+type SlackCommandInput = {
+    command: string;
+    text: string;
+    user_name: string;
+    response_url: string;
+};
+export declare const handleSlackCommand: import("../..").TaskWorkflowDeclaration<SlackCommandInput, {
+    command: string;
+    args: string;
+}, {}, {}, {}, {}>;
+type SlackInteractionInput = {
+    type: string;
+    actions: Array<{
+        action_id: string;
+    }>;
+    user: {
+        username: string;
+    };
+};
+export declare const handleSlackInteraction: import("../..").TaskWorkflowDeclaration<SlackInteractionInput, {
+    action: string;
+}, {}, {}, {}, {}>;
+export {};

package/v1/examples/webhooks/workflow.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webhookWorkflow = void 0;
+exports.handleSlackInteraction = exports.handleSlackCommand = exports.handleSlackMention = exports.handleGitHubPR = exports.handleStripePayment = exports.webhookWorkflow = void 0;
 const hatchet_client_1 = require("../hatchet-client");
 exports.webhookWorkflow = hatchet_client_1.hatchet.workflow({
     name: 'webhook-workflow',
@@ -21,3 +21,60 @@ exports.webhookWorkflow.task({
         return input;
     }),
 });
+exports.handleStripePayment = hatchet_client_1.hatchet.task({
+    name: 'handle-stripe-payment',
+    on: {
+        event: 'stripe:payment_intent.succeeded',
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const { customer, amount } = input.data.object;
+        console.log(`Payment of ${amount} from ${customer}`);
+        return { customer, amount };
+    }),
+});
+exports.handleGitHubPR = hatchet_client_1.hatchet.task({
+    name: 'handle-github-pr',
+    on: {
+        event: 'github:pull_request:opened',
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const repo = input.repository.full_name;
+        const prNumber = input.pull_request.number;
+        const { title } = input.pull_request;
+        console.log(`PR #${prNumber} opened on ${repo}: ${title}`);
+        return { repo, pr: prNumber };
+    }),
+});
+exports.handleSlackMention = hatchet_client_1.hatchet.task({
+    name: 'handle-slack-mention',
+    on: {
+        event: 'slack:event:app_mention',
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const { user, text, channel } = input.event;
+        console.log(`Mentioned by ${user} in ${channel}: ${text}`);
+        return { handled: true };
+    }),
+});
+exports.handleSlackCommand = hatchet_client_1.hatchet.task({
+    name: 'handle-slack-command',
+    on: {
+        event: 'slack:command:/deploy',
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log(`${input.user_name} ran ${input.command} ${input.text}`);
+        return { command: input.command, args: input.text };
+    }),
+});
+exports.handleSlackInteraction = hatchet_client_1.hatchet.task({
+    name: 'handle-slack-interaction',
+    on: {
+        event: 'slack:interaction:block_actions',
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const [action] = input.actions;
+        console.log(`${input.user.username} clicked button: ${action.action_id}`);
+        return { action: action.action_id };
+    }),
+});
+// !!

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.18.0";
+export declare const HATCHET_VERSION = "1.19.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.18.0';
+exports.HATCHET_VERSION = '1.19.1';