arvo-event-handler 3.0.8 → 3.0.11

package/dist/ArvoEventHandler/index.d.ts

@@ -1,7 +1,6 @@
-import { type SpanOptions } from '@opentelemetry/api';
 import { type ArvoContract, type ArvoEvent } from 'arvo-core';
 import type IArvoEventHandler from '../IArvoEventHandler';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoEventHandlerFunction, ArvoEventHandlerParam } from './types';
 /**
  * `ArvoEventHandler` is the foundational component for building stateless,
@@ -89,7 +88,7 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     /** Computational cost metric associated with event handling operations */
     readonly executionunits: number;
     /** OpenTelemetry configuration for event handling spans */
-    readonly spanOptions: SpanOptions;
+    readonly spanOptions: ArvoEventHandlerOtelSpanOptions;
     /** Version-specific event handler implementation map */
     readonly handler: ArvoEventHandlerFunction<TContract>;
     /** The source identifier for events produced by this handler */

package/dist/ArvoEventHandler/index.js

@@ -61,6 +61,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var ArvoDomain_1 = require("../ArvoDomain");
+var handlerErrors_1 = require("../ArvoOrchestrationUtils/handlerErrors");
+var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
 /**
@@ -208,32 +210,32 @@ var ArvoEventHandler = /** @class */ (function () {
      *                           in handler configuration, or when contract URI mismatch occurs
      * @throws {ExecutionViolation} for explicitly handled runtime errors that should bubble up
      */
-    ArvoEventHandler.prototype.execute = function (event_1) {
-        return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
+    ArvoEventHandler.prototype.execute = function (event, opentelemetry) {
+        return __awaiter(this, void 0, void 0, function () {
             var otelConfig;
             var _this = this;
-            if (opentelemetry === void 0) { opentelemetry = {
-                inheritFrom: 'EVENT',
-            }; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)("Handler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry, event);
+                        otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)(((_b = (_a = this.spanOptions).spanName) === null || _b === void 0 ? void 0 : _b.call(_a, { selfContractUri: this.contract.uri, consumedEvent: event })) ||
+                            "Handler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' }, event);
                         return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
-                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract_1, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, result, _j, _k, _dom, _l, _m, _o, key, value;
-                                    var _this = this;
-                                    var _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
-                                    return __generator(this, function (_z) {
-                                        switch (_z.label) {
+                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract_1, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, errorEvents, _j, _k, _l, errEvtIdx, errEvt, _m, _o, _p, key, value;
+                                    var _q, _r, _s, _t, _u, _v;
+                                    return __generator(this, function (_w) {
+                                        switch (_w.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _z.label = 1;
+                                                _w.label = 1;
                                             case 1:
-                                                _z.trys.push([1, 3, 4, 5]);
+                                                _w.trys.push([1, 3, 4, 5]);
+                                                span.setAttribute('arvo.handler.execution.status', 'normal');
+                                                span.setAttribute('arvo.handler.execution.type', 'handler');
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                                                 for (_i = 0, _a = Object.entries(event.otelAttributes); _i < _a.length; _i++) {
                                                     _b = _a[_i], key = _b[0], value = _b[1];
-                                                    span.setAttribute("to_process.0.".concat(key), value);
+                                                    span.setAttribute("consumable.0.".concat(key), value);
                                                 }
                                                 if (this.contract.type !== event.type) {
                                                     throw new errors_1.ConfigViolation("Event type mismatch: Received '".concat(event.type, "', expected '").concat(this.contract.type, "'"));
@@ -256,9 +258,9 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     });
                                                 }
                                                 try {
-                                                    handlerContract_1 = this.contract.version((_p = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _p !== void 0 ? _p : 'latest');
+                                                    handlerContract_1 = this.contract.version((_q = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _q !== void 0 ? _q : 'latest');
                                                 }
-                                                catch (_0) {
+                                                catch (_x) {
                                                     throw new errors_1.ConfigViolation("Invalid contract version: ".concat(parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version, ". Available versions: ").concat(Object.keys(this.contract.versions).join(', ')));
                                                 }
                                                 (0, arvo_core_1.logToSpan)({
@@ -289,7 +291,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                                         spanHeaders: otelSpanHeaders,
                                                     })];
                                             case 2:
-                                                _handleOutput = _z.sent();
+                                                _handleOutput = _w.sent();
                                                 if (!_handleOutput)
                                                     return [2 /*return*/, {
                                                             events: [],
@@ -306,85 +308,65 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     item = outputs_1[_c];
                                                     try {
                                                         __extensions = item.__extensions, handlerResult = __rest(item, ["__extensions"]);
-                                                        domains = (_r = (_q = handlerResult.domain) === null || _q === void 0 ? void 0 : _q.map(function (item) {
+                                                        domains = (_s = (_r = handlerResult.domain) === null || _r === void 0 ? void 0 : _r.map(function (item) {
                                                             return (0, ArvoDomain_1.resolveEventDomain)({
                                                                 domainToResolve: item,
                                                                 handlerSelfContract: handlerContract_1,
                                                                 eventContract: handlerContract_1,
                                                                 triggeringEvent: event,
                                                             });
-                                                        })) !== null && _r !== void 0 ? _r : [null];
+                                                        })) !== null && _s !== void 0 ? _s : [null];
                                                         for (_d = 0, _e = Array.from(new Set(domains)); _d < _e.length; _d++) {
                                                             _dom = _e[_d];
                                                             result.push((0, arvo_core_1.createArvoEventFactory)(handlerContract_1).emits(__assign(__assign({}, handlerResult), { traceparent: otelSpanHeaders.traceparent || undefined, tracestate: otelSpanHeaders.tracestate || undefined, source: this.source, subject: event.subject, 
                                                                 // 'source'
                                                                 // prioritise returned 'to', 'redirectto' and then
-                                                                to: (0, utils_1.coalesceOrDefault)([handlerResult.to, event.redirectto], event.source), executionunits: (0, utils_1.coalesce)(handlerResult.executionunits, this.executionunits), accesscontrol: (_t = (_s = handlerResult.accesscontrol) !== null && _s !== void 0 ? _s : event.accesscontrol) !== null && _t !== void 0 ? _t : undefined, parentid: event.id, domain: _dom }), __extensions));
+                                                                to: (0, utils_1.coalesceOrDefault)([handlerResult.to, event.redirectto], event.source), executionunits: (0, utils_1.coalesce)(handlerResult.executionunits, this.executionunits), accesscontrol: (_u = (_t = handlerResult.accesscontrol) !== null && _t !== void 0 ? _t : event.accesscontrol) !== null && _u !== void 0 ? _u : undefined, parentid: event.id, domain: _dom }), __extensions));
                                                             for (_f = 0, _g = Object.entries(result[result.length - 1].otelAttributes); _f < _g.length; _f++) {
                                                                 _h = _g[_f], key = _h[0], value = _h[1];
-                                                                span.setAttribute("to_emit.".concat(result.length - 1, ".").concat(key), value);
+                                                                span.setAttribute("emittables.".concat(result.length - 1, ".").concat(key), value);
                                                             }
                                                         }
                                                     }
                                                     catch (e) {
-                                                        throw new errors_1.ContractViolation((_u = e === null || e === void 0 ? void 0 : e.message) !== null && _u !== void 0 ? _u : 'Invalid data');
+                                                        throw new errors_1.ContractViolation((_v = e === null || e === void 0 ? void 0 : e.message) !== null && _v !== void 0 ? _v : 'Invalid data');
                                                     }
                                                 }
-                                                (0, arvo_core_1.logToSpan)({
-                                                    level: 'INFO',
-                                                    message: "Event processing completed successfully. Generated ".concat(result.length, " event(s)"),
-                                                });
-                                                (0, arvo_core_1.logToSpan)({
-                                                    level: 'INFO',
-                                                    message: 'Event handled successfully',
-                                                });
-                                                return [2 /*return*/, {
-                                                        events: result,
-                                                    }];
+                                                return [2 /*return*/, (0, orchestrationExecutionWrapper_1.returnEventsWithLogging)({ events: result }, span)];
                                             case 3:
-                                                error_1 = _z.sent();
+                                                error_1 = _w.sent();
+                                                span.setAttribute('arvo.handler.execution.status', 'failure');
                                                 (0, arvo_core_1.exceptionToSpan)(error_1);
                                                 span.setStatus({
                                                     code: api_1.SpanStatusCode.ERROR,
                                                     message: "Event processing failed: ".concat(error_1.message),
                                                 });
-                                                if (error_1.name.includes('ViolationError')) {
+                                                if ((0, arvo_core_1.isViolationError)(error_1)) {
                                                     throw error_1;
                                                 }
-                                                result = [];
-                                                for (_j = 0, _k = Array.from(new Set(this.systemErrorDomain
-                                                    ? this.systemErrorDomain.map(function (item) {
-                                                        return (0, ArvoDomain_1.resolveEventDomain)({
-                                                            domainToResolve: item,
-                                                            handlerSelfContract: _this.contract.version('latest'),
-                                                            eventContract: _this.contract.version('latest'),
-                                                            triggeringEvent: event,
-                                                        });
-                                                    })
-                                                    : [event.domain, this.domain, null])); _j < _k.length; _j++) {
-                                                    _dom = _k[_j];
-                                                    result.push((0, arvo_core_1.createArvoEventFactory)(this.contract.version('latest')).systemError({
-                                                        source: this.source,
-                                                        subject: event.subject,
-                                                        // The system error must always got back to
-                                                        // the source
-                                                        to: event.source,
-                                                        error: error_1,
-                                                        executionunits: this.executionunits,
-                                                        traceparent: (_v = otelSpanHeaders.traceparent) !== null && _v !== void 0 ? _v : undefined,
-                                                        tracestate: (_w = otelSpanHeaders.tracestate) !== null && _w !== void 0 ? _w : undefined,
-                                                        accesscontrol: (_x = event.accesscontrol) !== null && _x !== void 0 ? _x : undefined,
-                                                        parentid: (_y = event.id) !== null && _y !== void 0 ? _y : undefined,
-                                                        domain: _dom,
-                                                    }));
-                                                    for (_l = 0, _m = Object.entries(result[result.length - 1].otelAttributes); _l < _m.length; _l++) {
-                                                        _o = _m[_l], key = _o[0], value = _o[1];
-                                                        span.setAttribute("to_emit.".concat(result.length - 1, ".").concat(key), value);
+                                                errorEvents = (0, handlerErrors_1.createSystemErrorEvents)({
+                                                    error: error_1,
+                                                    event: event,
+                                                    otelHeaders: otelSpanHeaders,
+                                                    orchestrationParentSubject: null,
+                                                    initEventId: event.id,
+                                                    selfContract: this.contract.version('any'),
+                                                    systemErrorDomain: undefined,
+                                                    executionunits: this.executionunits,
+                                                    source: this.source,
+                                                    domain: this.domain,
+                                                    handlerType: 'handler',
+                                                });
+                                                for (_j = 0, _k = Object.entries(errorEvents); _j < _k.length; _j++) {
+                                                    _l = _k[_j], errEvtIdx = _l[0], errEvt = _l[1];
+                                                    for (_m = 0, _o = Object.entries(errEvt.otelAttributes); _m < _o.length; _m++) {
+                                                        _p = _o[_m], key = _p[0], value = _p[1];
+                                                        span.setAttribute("emittables.".concat(errEvtIdx, ".").concat(key), value);
                                                     }
                                                 }
-                                                return [2 /*return*/, {
-                                                        events: result,
-                                                    }];
+                                                return [2 /*return*/, (0, orchestrationExecutionWrapper_1.returnEventsWithLogging)({
+                                                        events: errorEvents,
+                                                    }, span)];
                                             case 4:
                                                 span.end();
                                                 return [7 /*endfinally*/];
@@ -392,7 +374,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                         }
                                     });
                                 }); } }))];
-                    case 1: return [2 /*return*/, _a.sent()];
+                    case 1: return [2 /*return*/, _c.sent()];
                 }
             });
         });

package/dist/ArvoEventHandler/types.d.ts

@@ -1,6 +1,7 @@
-import type { Span, SpanOptions } from '@opentelemetry/api';
+import type { Span } from '@opentelemetry/api';
 import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, OpenTelemetryHeaders, VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 /**
  * Represents the input for an ArvoEvent handler function.
  */
@@ -90,7 +91,7 @@ export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
     /**
      * The OpenTelemetry span options
      */
-    spanOptions?: SpanOptions;
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
     /**
      * Optional configuration to customize where system error events are emitted.
      *

package/dist/ArvoOrchestrationUtils/createEmitableEvent.js

@@ -151,7 +151,7 @@ var processRawEventsIntoEmittables = function (params, span) {
             emittables.push(evt);
             for (var _e = 0, _f = Object.entries(emittables[emittables.length - 1].otelAttributes); _e < _f.length; _e++) {
                 var _g = _f[_e], key = _g[0], value = _g[1];
-                span.setAttribute("to_emit.".concat(emittables.length - 1, ".").concat(key), value);
+                span.setAttribute("emittables.".concat(emittables.length - 1, ".").concat(key), value);
             }
         }
     }

package/dist/ArvoOrchestrationUtils/handlerErrors.d.ts

@@ -2,7 +2,7 @@ import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract, type ViolationError } from 'arvo-core';
 import type { SyncEventResource } from '../SyncEventResource';
 import type { OrchestrationExecutionMemoryRecord } from './orchestrationExecutionState';
-import type { ArvoOrchestrationHandlerType } from './types';
+import { type ArvoOrchestrationHandlerType } from './types';
 /**
  * Parameters for system error event creation
  */
@@ -17,11 +17,12 @@ export type CreateSystemErrorEventsParams = {
     executionunits: number;
     source: string;
     domain: string | null;
+    handlerType: ArvoOrchestrationHandlerType;
 };
 /**
  * Creates system error events
  */
-export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, }: CreateSystemErrorEventsParams & {
+export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject: _orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, handlerType, }: CreateSystemErrorEventsParams & {
     error: Error;
 }) => ArvoEvent[];
 export declare const handleOrchestrationErrors: (_handlerType: ArvoOrchestrationHandlerType, param: CreateSystemErrorEventsParams & {

package/dist/ArvoOrchestrationUtils/handlerErrors.js

@@ -53,26 +53,31 @@ var arvo_core_1 = require("arvo-core");
 var ArvoDomain_1 = require("../ArvoDomain");
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
+var types_1 = require("./types");
 /**
  * Creates system error events
  */
 var createSystemErrorEvents = function (_a) {
-    var _b, _c, _d, _e;
-    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, domain = _a.domain;
+    var _b, _c, _d, _e, _f;
+    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, _orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, domain = _a.domain, handlerType = _a.handlerType;
     // In case of none transaction errors like errors from
     // the machine or the event creation etc, the are workflow
     // error and shuold be handled by the workflow. Then are
     // called system error and must be sent
     // to the initiator. In as good of a format as possible
     var parsedEventSubject = null;
-    try {
-        parsedEventSubject = arvo_core_1.ArvoOrchestrationSubject.parse(event.subject);
-    }
-    catch (e) {
-        (0, arvo_core_1.logToSpan)({
-            level: 'WARNING',
-            message: "Unable to parse event subject: ".concat(e.message),
-        });
+    var orchestrationParentSubject = null;
+    if (handlerType === 'orchestrator' || handlerType === 'resumable') {
+        orchestrationParentSubject = _orchestrationParentSubject;
+        try {
+            parsedEventSubject = arvo_core_1.ArvoOrchestrationSubject.parse(event.subject);
+        }
+        catch (e) {
+            (0, arvo_core_1.logToSpan)({
+                level: 'WARNING',
+                message: "Unable to parse event subject: ".concat(e.message),
+            });
+        }
     }
     var domainSets = new Set(systemErrorDomain
         ? systemErrorDomain.map(function (item) {
@@ -85,9 +90,10 @@ var createSystemErrorEvents = function (_a) {
         })
         : [event.domain, domain, null]);
     var result = [];
-    for (var _i = 0, _f = Array.from(domainSets); _i < _f.length; _i++) {
-        var _dom = _f[_i];
-        result.push((0, arvo_core_1.createArvoOrchestratorEventFactory)(selfContract).systemError({
+    for (var _i = 0, _g = Array.from(domainSets); _i < _g.length; _i++) {
+        var _dom = _g[_i];
+        var factoryBuilder = handlerType === 'handler' ? arvo_core_1.createArvoEventFactory : arvo_core_1.createArvoOrchestratorEventFactory;
+        result.push(factoryBuilder(selfContract).systemError({
             source: source,
             // If the initiator of the workflow exist then match the
             // subject so that it can incorporate it in its state. If
@@ -96,11 +102,11 @@ var createSystemErrorEvents = function (_a) {
             subject: orchestrationParentSubject !== null && orchestrationParentSubject !== void 0 ? orchestrationParentSubject : event.subject,
             // The system error must always go back to
             // the source which initiated it
-            to: (_b = parsedEventSubject === null || parsedEventSubject === void 0 ? void 0 : parsedEventSubject.execution.initiator) !== null && _b !== void 0 ? _b : event.source,
+            to: (_c = (_b = parsedEventSubject === null || parsedEventSubject === void 0 ? void 0 : parsedEventSubject.execution) === null || _b === void 0 ? void 0 : _b.initiator) !== null && _c !== void 0 ? _c : event.source,
             error: error,
-            traceparent: (_c = otelHeaders.traceparent) !== null && _c !== void 0 ? _c : undefined,
-            tracestate: (_d = otelHeaders.tracestate) !== null && _d !== void 0 ? _d : undefined,
-            accesscontrol: (_e = event.accesscontrol) !== null && _e !== void 0 ? _e : undefined,
+            traceparent: (_d = otelHeaders.traceparent) !== null && _d !== void 0 ? _d : undefined,
+            tracestate: (_e = otelHeaders.tracestate) !== null && _e !== void 0 ? _e : undefined,
+            accesscontrol: (_f = event.accesscontrol) !== null && _f !== void 0 ? _f : undefined,
             executionunits: executionunits,
             // If there is initEventID then use that.
             // Otherwise, use event id. If the error is in init event
@@ -118,10 +124,7 @@ var handleOrchestrationErrors = function (_handlerType, param, span) { return __
     return __generator(this, function (_f) {
         switch (_f.label) {
             case 0:
-                handlerType = {
-                    orchestrator: 'ArvoOrchestrator',
-                    resumable: 'ArvoResumable',
-                }[_handlerType];
+                handlerType = types_1.ArvoOrchestrationHandlerMap[_handlerType];
                 error = (0, utils_1.isError)(param.error)
                     ? param.error
                     : new errors_1.ExecutionViolation("Non-Error object thrown during machine execution: ".concat(typeof param.error, ". This indicates a serious implementation flaw."));
@@ -171,7 +174,7 @@ var handleOrchestrationErrors = function (_handlerType, param, span) { return __
                     _b = _a[_i], errEvtIdx = _b[0], errEvt = _b[1];
                     for (_c = 0, _d = Object.entries(errEvt.otelAttributes); _c < _d.length; _c++) {
                         _e = _d[_c], key = _e[0], value = _e[1];
-                        span.setAttribute("to_emit.".concat(errEvtIdx, ".").concat(key), value);
+                        span.setAttribute("emittables.".concat(errEvtIdx, ".").concat(key), value);
                     }
                 }
                 return [2 /*return*/, {

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.d.ts

@@ -2,13 +2,12 @@ import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestrationSubjectContent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract } from 'arvo-core';
 import type IArvoEventHandler from '../../IArvoEventHandler';
 import type { SyncEventResource } from '../../SyncEventResource';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../../types';
 import type { OrchestrationExecutionMemoryRecord } from '../orchestrationExecutionState';
 import type { ArvoOrchestrationHandlerType } from '../types';
 export type OrchestrationExecutionContext<TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>> = {
     event: ArvoEvent;
     opentelemetry: ArvoEventHandlerOpenTelemetryOptions;
-    spanName: string;
     source: string;
     syncEventResource: SyncEventResource<TState>;
     executionunits: number;
@@ -16,6 +15,9 @@ export type OrchestrationExecutionContext<TState extends OrchestrationExecutionM
     selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
     domain: string | null;
     _handlerType: ArvoOrchestrationHandlerType;
+    spanOptions: ArvoEventHandlerOtelSpanOptions & {
+        spanName: NonNullable<ArvoEventHandlerOtelSpanOptions['spanName']>;
+    };
 };
 export type CoreExecutionFn<TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>> = (params: {
     span: any;
@@ -37,4 +39,4 @@ export declare const returnEventsWithLogging: (param: Awaited<ReturnType<IArvoEv
  * - State management
  * - Error handling and system error generation
  */
-export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanName, source, syncEventResource, executionunits, systemErrorDomain, selfContract, domain, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;
+export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanOptions, source, syncEventResource, executionunits, systemErrorDomain, selfContract, domain, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;