@hatchet-dev/typescript-sdk 1.18.0 → 1.19.0

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();
@@ -106,18 +129,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

@@ -117,35 +117,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -62,10 +62,10 @@
   },
   "optionalDependencies": {
     "@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.0";

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.0';