arvo-event-handler 3.0.8 → 3.0.11

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.js

@@ -50,6 +50,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeWithOrchestrationWrapper = exports.returnEventsWithLogging = void 0;
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
+var utils_1 = require("../../utils");
 var handlerErrors_1 = require("../handlerErrors");
 var acquireLockWithValidation_1 = require("./acquireLockWithValidation");
 var validateAndParseSubject_1 = require("./validateAndParseSubject");
@@ -70,158 +71,150 @@ exports.returnEventsWithLogging = returnEventsWithLogging;
  * - Error handling and system error generation
  */
 var executeWithOrchestrationWrapper = function (_a, coreExecutionFn_1) { return __awaiter(void 0, [_a, coreExecutionFn_1], void 0, function (_b, coreExecutionFn) {
-    var _c;
-    var event = _b.event, opentelemetry = _b.opentelemetry, spanName = _b.spanName, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, domain = _b.domain, _handlerType = _b._handlerType;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0: return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan({
-                    name: spanName,
-                    spanOptions: {
-                        kind: api_1.SpanKind.PRODUCER,
-                        attributes: __assign((_c = {}, _c[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _c[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _c), Object.fromEntries(Object.entries(event.otelAttributes).map(function (_a) {
-                            var key = _a[0], value = _a[1];
-                            return ["to_process.0.".concat(key), value];
-                        }))),
-                    },
-                    context: opentelemetry.inheritFrom === 'EVENT'
-                        ? {
-                            inheritFrom: 'TRACE_HEADERS',
-                            traceHeaders: {
-                                traceparent: event.traceparent,
-                                tracestate: event.tracestate,
-                            },
-                        }
-                        : {
-                            inheritFrom: 'CONTEXT',
-                            context: api_1.context.active(),
-                        },
-                    disableSpanManagement: true,
-                    fn: function (span) { return __awaiter(void 0, void 0, void 0, function () {
-                        var otelHeaders, orchestrationParentSubject, initEventId, acquiredLock, parsedEventSubject, state, _a, emittables, newState, i, _i, _b, _c, key, value, error_1, _d, errorToThrow, errorEvents;
-                        var _e, _f, _g, _h;
-                        return __generator(this, function (_j) {
-                            switch (_j.label) {
-                                case 0:
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "Starting execution for ".concat(event.type, " on subject ").concat(event.subject),
-                                    }, span);
-                                    otelHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                    orchestrationParentSubject = null;
-                                    initEventId = null;
-                                    acquiredLock = null;
-                                    _j.label = 1;
-                                case 1:
-                                    _j.trys.push([1, 6, 8, 10]);
-                                    parsedEventSubject = (0, validateAndParseSubject_1.validateAndParseSubject)(event, source, syncEventResource, span, 'orchestrator');
-                                    if (!parsedEventSubject) {
-                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
-                                    }
-                                    return [4 /*yield*/, (0, acquireLockWithValidation_1.acquireLockWithValidation)(syncEventResource, event, span)];
-                                case 2:
-                                    // Lock acquisition
-                                    acquiredLock = _j.sent();
-                                    return [4 /*yield*/, syncEventResource.acquireState(event, span)];
-                                case 3:
-                                    state = _j.sent();
-                                    if ((state === null || state === void 0 ? void 0 : state.executionStatus) === 'failure') {
-                                        (0, arvo_core_1.logToSpan)({
-                                            level: 'WARNING',
-                                            message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
-                                        }, span);
-                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
-                                    }
-                                    orchestrationParentSubject = (_e = state === null || state === void 0 ? void 0 : state.parentSubject) !== null && _e !== void 0 ? _e : null;
-                                    initEventId = (_f = state === null || state === void 0 ? void 0 : state.initEventId) !== null && _f !== void 0 ? _f : null;
-                                    if (!state) {
+    var otelConfig;
+    var event = _b.event, opentelemetry = _b.opentelemetry, spanOptions = _b.spanOptions, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, domain = _b.domain, _handlerType = _b._handlerType;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)(spanOptions.spanName({ selfContractUri: selfContract.uri, consumedEvent: event }), spanOptions, opentelemetry, event);
+                return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(void 0, void 0, void 0, function () {
+                            var _i, _a, _b, key, value, otelHeaders, orchestrationParentSubject, initEventId, acquiredLock, parsedEventSubject, state, _c, emittables, newState, i, _d, _e, _f, key, value, error_1, _g, errorToThrow, errorEvents;
+                            var _h, _j, _k, _l;
+                            return __generator(this, function (_m) {
+                                switch (_m.label) {
+                                    case 0:
+                                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                                        span.setAttribute('arvo.handler.execution.type', _handlerType);
+                                        span.setAttribute('arvo.handler.execution.status', 'normal');
+                                        for (_i = 0, _a = Object.entries(event.otelAttributes); _i < _a.length; _i++) {
+                                            _b = _a[_i], key = _b[0], value = _b[1];
+                                            span.setAttribute("consumable.0.".concat(key), value);
+                                        }
                                         (0, arvo_core_1.logToSpan)({
                                             level: 'INFO',
-                                            message: "Initializing new execution state for subject: ".concat(event.subject),
-                                        });
-                                        if (event.type !== source) {
+                                            message: "Starting execution for ".concat(event.type, " on subject ").concat(event.subject),
+                                        }, span);
+                                        otelHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
+                                        orchestrationParentSubject = null;
+                                        initEventId = null;
+                                        acquiredLock = null;
+                                        _m.label = 1;
+                                    case 1:
+                                        _m.trys.push([1, 6, 8, 10]);
+                                        parsedEventSubject = (0, validateAndParseSubject_1.validateAndParseSubject)(event, source, syncEventResource, span, 'orchestrator');
+                                        if (!parsedEventSubject) {
+                                            return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
+                                        }
+                                        return [4 /*yield*/, (0, acquireLockWithValidation_1.acquireLockWithValidation)(syncEventResource, event, span)];
+                                    case 2:
+                                        // Lock acquisition
+                                        acquiredLock = _m.sent();
+                                        return [4 /*yield*/, syncEventResource.acquireState(event, span)];
+                                    case 3:
+                                        state = _m.sent();
+                                        if ((state === null || state === void 0 ? void 0 : state.executionStatus) === 'failure') {
+                                            span.setAttribute('arvo.handler.execution.status', state.executionStatus);
                                             (0, arvo_core_1.logToSpan)({
                                                 level: 'WARNING',
-                                                message: "Invalid initialization event detected. Expected type '".concat(source, "' but received '").concat(event.type, "'."),
+                                                message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
+                                            }, span);
+                                            span.setStatus({
+                                                code: api_1.SpanStatusCode.ERROR,
+                                                message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
                                             });
                                             return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
                                         }
-                                    }
-                                    else {
+                                        orchestrationParentSubject = (_h = state === null || state === void 0 ? void 0 : state.parentSubject) !== null && _h !== void 0 ? _h : null;
+                                        initEventId = (_j = state === null || state === void 0 ? void 0 : state.initEventId) !== null && _j !== void 0 ? _j : null;
+                                        if (!state) {
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Initializing new execution state for subject: ".concat(event.subject),
+                                            });
+                                            if (event.type !== source) {
+                                                (0, arvo_core_1.logToSpan)({
+                                                    level: 'WARNING',
+                                                    message: "Invalid initialization event detected. Expected type '".concat(source, "' but received '").concat(event.type, "'."),
+                                                });
+                                                return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
+                                            }
+                                        }
+                                        else {
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Resuming execution with existing state for subject: ".concat(event.subject),
+                                            });
+                                        }
+                                        // Extract parent subject from init event if applicable
+                                        if (event.type === source) {
+                                            orchestrationParentSubject = (_l = (_k = event === null || event === void 0 ? void 0 : event.data) === null || _k === void 0 ? void 0 : _k.parentSubject$$) !== null && _l !== void 0 ? _l : null;
+                                        }
+                                        return [4 /*yield*/, coreExecutionFn({
+                                                span: span,
+                                                otelHeaders: otelHeaders,
+                                                orchestrationParentSubject: orchestrationParentSubject,
+                                                initEventId: initEventId !== null && initEventId !== void 0 ? initEventId : event.id,
+                                                parsedEventSubject: parsedEventSubject,
+                                                state: state,
+                                                _handlerType: _handlerType,
+                                            })];
+                                    case 4:
+                                        _c = _m.sent(), emittables = _c.emittables, newState = _c.newState;
+                                        // Add OpenTelemetry attributes for emitted events
+                                        for (i = 0; i < emittables.length; i++) {
+                                            for (_d = 0, _e = Object.entries(emittables[i].otelAttributes); _d < _e.length; _d++) {
+                                                _f = _e[_d], key = _f[0], value = _f[1];
+                                                span.setAttribute("emittables.".concat(i, ".").concat(key), value);
+                                            }
+                                        }
+                                        // Persist state
+                                        return [4 /*yield*/, syncEventResource.persistState(event, newState, state, span)];
+                                    case 5:
+                                        // Persist state
+                                        _m.sent();
                                         (0, arvo_core_1.logToSpan)({
                                             level: 'INFO',
-                                            message: "Resuming execution with existing state for subject: ".concat(event.subject),
+                                            message: "State update persisted in memory for subject ".concat(event.subject),
                                         });
-                                    }
-                                    // Extract parent subject from init event if applicable
-                                    if (event.type === source) {
-                                        orchestrationParentSubject = (_h = (_g = event === null || event === void 0 ? void 0 : event.data) === null || _g === void 0 ? void 0 : _g.parentSubject$$) !== null && _h !== void 0 ? _h : null;
-                                    }
-                                    return [4 /*yield*/, coreExecutionFn({
-                                            span: span,
-                                            otelHeaders: otelHeaders,
-                                            orchestrationParentSubject: orchestrationParentSubject,
-                                            initEventId: initEventId !== null && initEventId !== void 0 ? initEventId : event.id,
-                                            parsedEventSubject: parsedEventSubject,
-                                            state: state,
-                                            _handlerType: _handlerType,
-                                        })];
-                                case 4:
-                                    _a = _j.sent(), emittables = _a.emittables, newState = _a.newState;
-                                    span.setAttribute("arvo.".concat(_handlerType, ".execution.status"), newState.executionStatus);
-                                    // Add OpenTelemetry attributes for emitted events
-                                    for (i = 0; i < emittables.length; i++) {
-                                        for (_i = 0, _b = Object.entries(emittables[i].otelAttributes); _i < _b.length; _i++) {
-                                            _c = _b[_i], key = _c[0], value = _c[1];
-                                            span.setAttribute("to_emit.".concat(i, ".").concat(key), value);
-                                        }
-                                    }
-                                    // Persist state
-                                    return [4 /*yield*/, syncEventResource.persistState(event, newState, state, span)];
-                                case 5:
-                                    // Persist state
-                                    _j.sent();
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "State update persisted in memory for subject ".concat(event.subject),
-                                    });
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "Execution successfully completed and emitted ".concat(emittables.length, " events"),
-                                    });
-                                    return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: emittables }, span)];
-                                case 6:
-                                    error_1 = _j.sent();
-                                    return [4 /*yield*/, (0, handlerErrors_1.handleOrchestrationErrors)(_handlerType, {
-                                            error: error_1,
-                                            event: event,
-                                            otelHeaders: otelHeaders,
-                                            orchestrationParentSubject: orchestrationParentSubject,
-                                            initEventId: initEventId,
-                                            selfContract: selfContract,
-                                            systemErrorDomain: systemErrorDomain,
-                                            executionunits: executionunits,
-                                            source: source,
-                                            domain: domain,
-                                            syncEventResource: syncEventResource,
-                                        }, span)];
-                                case 7:
-                                    _d = _j.sent(), errorToThrow = _d.errorToThrow, errorEvents = _d.events;
-                                    if (errorToThrow)
-                                        throw errorToThrow;
-                                    return [2 /*return*/, {
-                                            events: errorEvents,
-                                        }];
-                                case 8: return [4 /*yield*/, syncEventResource.releaseLock(event, acquiredLock, span)];
-                                case 9:
-                                    _j.sent();
-                                    span.end();
-                                    return [7 /*endfinally*/];
-                                case 10: return [2 /*return*/];
-                            }
-                        });
-                    }); },
-                })];
-            case 1: return [2 /*return*/, _d.sent()];
+                                        (0, arvo_core_1.logToSpan)({
+                                            level: 'INFO',
+                                            message: "Execution successfully completed and emitted ".concat(emittables.length, " events"),
+                                        });
+                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: emittables }, span)];
+                                    case 6:
+                                        error_1 = _m.sent();
+                                        span.setAttribute('arvo.handler.execution.status', 'failure');
+                                        return [4 /*yield*/, (0, handlerErrors_1.handleOrchestrationErrors)(_handlerType, {
+                                                error: error_1,
+                                                event: event,
+                                                otelHeaders: otelHeaders,
+                                                orchestrationParentSubject: orchestrationParentSubject,
+                                                initEventId: initEventId,
+                                                selfContract: selfContract,
+                                                systemErrorDomain: systemErrorDomain,
+                                                executionunits: executionunits,
+                                                source: source,
+                                                domain: domain,
+                                                syncEventResource: syncEventResource,
+                                                handlerType: _handlerType,
+                                            }, span)];
+                                    case 7:
+                                        _g = _m.sent(), errorToThrow = _g.errorToThrow, errorEvents = _g.events;
+                                        if (errorToThrow)
+                                            throw errorToThrow;
+                                        return [2 /*return*/, {
+                                                events: errorEvents,
+                                            }];
+                                    case 8: return [4 /*yield*/, syncEventResource.releaseLock(event, acquiredLock, span)];
+                                    case 9:
+                                        _m.sent();
+                                        span.end();
+                                        return [7 /*endfinally*/];
+                                    case 10: return [2 /*return*/];
+                                }
+                            });
+                        }); } }))];
+            case 1: return [2 /*return*/, _c.sent()];
         }
     });
 }); };

package/dist/ArvoOrchestrationUtils/servicesValidation.d.ts

@@ -0,0 +1,22 @@
+import type { ArvoContract, VersionedArvoContract } from 'arvo-core';
+import { type ArvoOrchestrationHandlerType } from './types';
+/**
+ * Validates that all service contracts in a collection have unique URIs.
+ *
+ * Iterates through the provided contracts and checks if any URI appears more than once.
+ * Multiple versions of the same contract (with the same URI) are not allowed.
+ *
+ * @param contracts - A record mapping contract keys to their respective ArvoContract objects
+ * @returns An object with a boolean result indicating if all contracts are unique, and the error keys if not
+ */
+export declare const areServiceContractsUnique: (contracts: Record<string, ArvoContract | VersionedArvoContract<any, any>>) => {
+    result: false;
+    keys: [string, string];
+    contractUri: string;
+} | {
+    result: true;
+};
+export declare const servicesValidation: (contracts: {
+    self: ArvoContract | VersionedArvoContract<any, any>;
+    services: Record<string, VersionedArvoContract<any, any>>;
+}, _handlerType: ArvoOrchestrationHandlerType) => void;

package/dist/ArvoOrchestrationUtils/servicesValidation.js

@@ -0,0 +1,56 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servicesValidation = exports.areServiceContractsUnique = void 0;
+var uuid_1 = require("uuid");
+var errors_1 = require("../errors");
+var types_1 = require("./types");
+/**
+ * Validates that all service contracts in a collection have unique URIs.
+ *
+ * Iterates through the provided contracts and checks if any URI appears more than once.
+ * Multiple versions of the same contract (with the same URI) are not allowed.
+ *
+ * @param contracts - A record mapping contract keys to their respective ArvoContract objects
+ * @returns An object with a boolean result indicating if all contracts are unique, and the error keys if not
+ */
+var areServiceContractsUnique = function (contracts) {
+    var uriToKeyMap = {};
+    for (var _i = 0, _a = Object.entries(contracts); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], contract = _b[1];
+        if (uriToKeyMap[contract.uri]) {
+            return {
+                result: false,
+                keys: [key, uriToKeyMap[contract.uri]],
+                contractUri: contract.uri,
+            };
+        }
+        uriToKeyMap[contract.uri] = key;
+    }
+    return {
+        result: true,
+    };
+};
+exports.areServiceContractsUnique = areServiceContractsUnique;
+var servicesValidation = function (contracts, _handlerType) {
+    var _a;
+    var __areServiceContractsUnique = (0, exports.areServiceContractsUnique)(contracts.services);
+    if (!__areServiceContractsUnique.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", the service contracts must have unique URIs. Multiple versions of the same contract are not allow. The contracts '").concat(__areServiceContractsUnique.keys[0], "' and '").concat(__areServiceContractsUnique.keys[1], "' have the same URI '").concat(__areServiceContractsUnique.contractUri, "'"));
+    }
+    var __checkIfSelfIsAService = (0, exports.areServiceContractsUnique)(__assign(__assign({}, contracts.services), (_a = {}, _a[(0, uuid_1.v4)()] = contracts.self, _a)));
+    if (!__checkIfSelfIsAService.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", Circular dependency detected: Machine with URI '").concat(contracts.self.uri, "' is registered as service '").concat(__checkIfSelfIsAService.keys[1], "'. Self-referential services create execution loops and are prohibited."));
+    }
+};
+exports.servicesValidation = servicesValidation;

package/dist/ArvoOrchestrationUtils/types.d.ts

@@ -1 +1,7 @@
-export type ArvoOrchestrationHandlerType = 'orchestrator' | 'resumable';
+export declare const ArvoOrchestrationHandlerMap: {
+    readonly orchestrator: "ArvoOrchestrator";
+    readonly resumable: "ArvoResumable";
+    readonly machine: "ArvoMachine";
+    readonly handler: "ArvoEventHandler";
+};
+export type ArvoOrchestrationHandlerType = keyof typeof ArvoOrchestrationHandlerMap;

package/dist/ArvoOrchestrationUtils/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArvoOrchestrationHandlerMap = void 0;
+exports.ArvoOrchestrationHandlerMap = {
+    orchestrator: 'ArvoOrchestrator',
+    resumable: 'ArvoResumable',
+    machine: 'ArvoMachine',
+    handler: 'ArvoEventHandler',
+};

package/dist/ArvoOrchestrator/factory.d.ts

@@ -1,5 +1,5 @@
 import { ArvoOrchestrator } from '.';
-import type { ICreateArvoOrchestrator } from './types';
+import type { CreateArvoOrchestratorParam } from './types';
 /**
  * Creates a new Arvo orchestrator instance with default components.
  * For custom components, use ArvoOrchestrator constructor directly.
@@ -26,4 +26,4 @@ import type { ICreateArvoOrchestrator } from './types';
  * });
  * ```
  */
-export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, }: ICreateArvoOrchestrator) => ArvoOrchestrator;
+export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, spanOptions, }: CreateArvoOrchestratorParam) => ArvoOrchestrator;

package/dist/ArvoOrchestrator/factory.js

@@ -41,7 +41,7 @@ var errors_1 = require("../errors");
  * ```
  */
 var createArvoOrchestrator = function (_a) {
-    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain;
+    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
     if (!(machines === null || machines === void 0 ? void 0 : machines.length)) {
         throw new Error('At least one machine must be provided');
     }
@@ -66,6 +66,7 @@ var createArvoOrchestrator = function (_a) {
         executionEngine: new MachineExecutionEngine_1.MachineExecutionEngine(),
         requiresResourceLocking: requiresResourceLocking,
         systemErrorDomain: systemErrorDomain,
+        spanOptions: spanOptions,
     });
 };
 exports.createArvoOrchestrator = createArvoOrchestrator;

package/dist/ArvoOrchestrator/index.d.ts

@@ -16,6 +16,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
     readonly executionEngine: IMachineExectionEngine;
     readonly syncEventResource: SyncEventResource<MachineMemoryRecord>;
     readonly systemErrorDomain?: (string | null)[];
+    private readonly spanOptions;
     get source(): any;
     get requiresResourceLocking(): boolean;
     get memory(): IMachineMemory<MachineMemoryRecord>;
@@ -25,7 +26,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
      * @param params - Configuration parameters
      * @throws Error if machines in registry have different sources
      */
-    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, }: ArvoOrchestratorParam);
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, spanOptions, }: ArvoOrchestratorParam);
     /**
      * Core orchestration method that executes state machines in response to events.
      *

package/dist/ArvoOrchestrator/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -37,6 +48,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoOrchestrator = void 0;
+var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var createEmitableEvent_1 = require("../ArvoOrchestrationUtils/createEmitableEvent");
 var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
@@ -53,13 +65,16 @@ var ArvoOrchestrator = /** @class */ (function () {
      * @throws Error if machines in registry have different sources
      */
     function ArvoOrchestrator(_a) {
-        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain;
+        var _b;
+        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
+        var _c, _d, _e, _f, _g, _h, _j;
         this.systemErrorDomain = [];
         this.executionunits = executionunits;
         this.registry = registry;
         this.executionEngine = executionEngine;
         this.syncEventResource = new SyncEventResource_1.SyncEventResource(memory, requiresResourceLocking);
         this.systemErrorDomain = systemErrorDomain;
+        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, spanOptions), { attributes: __assign(__assign((_b = {}, _b[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _b[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _b), ((_c = spanOptions === null || spanOptions === void 0 ? void 0 : spanOptions.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': (_j = (_h = (_g = (_f = (_e = (_d = this === null || this === void 0 ? void 0 : this.registry) === null || _d === void 0 ? void 0 : _d.machines) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.contracts) === null || _g === void 0 ? void 0 : _g.self) === null || _h === void 0 ? void 0 : _h.uri) !== null && _j !== void 0 ? _j : 'N/A' }) });
     }
     Object.defineProperty(ArvoOrchestrator.prototype, "source", {
         get: function () {
@@ -101,19 +116,19 @@ var ArvoOrchestrator = /** @class */ (function () {
      * @throws {ContractViolation} Schema/contract mismatch
      * @throws {ConfigViolation} Missing/invalid machine version
      */
-    ArvoOrchestrator.prototype.execute = function (event_1) {
-        return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
+    ArvoOrchestrator.prototype.execute = function (event, opentelemetry) {
+        return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            if (opentelemetry === void 0) { opentelemetry = {
-                inheritFrom: 'EVENT',
-            }; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, (0, orchestrationExecutionWrapper_1.executeWithOrchestrationWrapper)({
                             _handlerType: 'orchestrator',
                             event: event,
-                            opentelemetry: opentelemetry,
-                            spanName: "Orchestrator<".concat(this.registry.machines[0].contracts.self.uri, ">@<").concat(event.type, ">"),
+                            opentelemetry: opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' },
+                            spanOptions: __assign({ spanName: function (_a) {
+                                    var selfContractUri = _a.selfContractUri, consumedEvent = _a.consumedEvent;
+                                    return "Orchestrator<".concat(selfContractUri, ">@<").concat(consumedEvent.type, ">");
+                                } }, this.spanOptions),
                             source: this.source,
                             syncEventResource: this.syncEventResource,
                             executionunits: this.executionunits,

package/dist/ArvoOrchestrator/types.d.ts

@@ -5,6 +5,7 @@ import type { OrchestrationExecutionMemoryRecord } from '../ArvoOrchestrationUti
 import type { IMachineExectionEngine } from '../MachineExecutionEngine/interface';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import type { IMachineRegistry } from '../MachineRegistry/interface';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 export type TryFunctionOutput<TData, TError extends Error> = {
     type: 'success';
     data: TData;
@@ -82,24 +83,6 @@ export type ArvoOrchestratorParam = {
     /** Engine responsible for machine execution */
     executionEngine: IMachineExectionEngine;
     requiresResourceLocking: boolean;
-    /**
-     * Optional configuration to customize where system error events are emitted.
-     */
-    systemErrorDomain?: (string | null)[];
-};
-/**
- * Configuration interface for creating an Arvo orchestrator instance.
- */
-export interface ICreateArvoOrchestrator {
-    /** Memory interface for storing and retrieving machine state */
-    memory: IMachineMemory<MachineMemoryRecord>;
-    /** The cost of the execution of the orchestrator */
-    executionunits: number;
-    /**
-     * Collection of state machines to be managed by the orchestrator.
-     * All machines must have the same source identifier.
-     */
-    machines: ArvoMachine<any, any, any, any, any>[];
     /**
      * Optional configuration to customize where system error events are emitted.
      *
@@ -114,4 +97,18 @@ export interface ICreateArvoOrchestrator {
      * @default undefined — uses standard fallback broadcast domains
      */
     systemErrorDomain?: (string | null)[];
-}
+    /**
+     * The OpenTelemetry span options
+     */
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
+};
+/**
+ * Configuration interface for creating an Arvo orchestrator instance.
+ */
+export type CreateArvoOrchestratorParam = Pick<ArvoOrchestratorParam, 'memory' | 'executionunits' | 'spanOptions' | 'systemErrorDomain'> & {
+    /**
+     * Collection of state machines to be managed by the orchestrator.
+     * All machines must have the same source identifier.
+     */
+    machines: ArvoMachine<any, any, any, any, any>[];
+};

package/dist/ArvoResumable/factory.d.ts

@@ -1,6 +1,7 @@
 import type { ArvoOrchestratorContract, VersionedArvoContract } from 'arvo-core';
 import { ArvoResumable } from '.';
 import type { IMachineMemory } from '../MachineMemory/interface';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoResumableHandler, ArvoResumableState } from './types';
 /**
  * Factory function for creating ArvoResumable orchestrator instances
@@ -39,4 +40,5 @@ export declare const createArvoResumable: <TMemory extends Record<string, any>,
     executionunits?: number;
     requiresResourceLocking?: boolean;
     systemErrorDomain?: (string | null)[];
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
 }) => ArvoResumable<TMemory, TSelfContract, TServiceContract>;