arvo-event-handler 2.0.3 → 2.1.0

package/dist/MultiArvoEventHandler/index.d.ts

@@ -1,113 +1,48 @@
-import { SpanKind } from '@opentelemetry/api';
-import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from 'arvo-core';
-import { IMultiArvoEventHandler } from './types';
+import { SpanOptions } from '@opentelemetry/api';
+import { ArvoEvent } from 'arvo-core';
+import { IMultiArvoEventHandler, MultiArvoEventHandlerFunction } from './types';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { OpenTelemetryConfig } from '../OpenTelemetry/types';
+import { ArvoEventHandlerOpenTelemetryOptions } from '../types';
 /**
- * Represents a Multi ArvoEvent handler that can process multiple event types.
+ * MultiArvoEventHandler processes multiple event types without being bound to specific contracts.
+ * Manages event execution, telemetry tracking, and error handling for diverse event streams.
  *
- * @remarks
- * Unlike ArvoEventHandler, which is bound to a specific ArvoContract and handles
- * events of a single type, MultiArvoEventHandler can handle multiple event types
- * without being tied to a specific contract. This makes it more flexible for
- * scenarios where you need to process various event types with a single handler.
+ * @example
+ * const handler = createMultiArvoEventHandler({
+ *   source: "order.handler",
+ *   executionunits: 1,
+ *   handler: async ({ event }) => {
+ *     // Handle multiple event types
+ *   }
+ * });
  */
 export default class MultiArvoEventHandler extends AbstractArvoEventHandler {
-    /** The default execution cost associated with this handler */
+    /** Computational cost metric for handler operations */
     readonly executionunits: number;
-    /**
-     * The source identifier for events produced by this handler
-     *
-     * @remarks
-     * The handler listens to the events with field `event.to` equal
-     * to the this `source` value. If the event does not confirm to
-     * this, a system error event is returned
-     *
-     * For all the events which are emitted by the handler, this is
-     * the source field value of them all.
-     */
+    /** Source identifier for event routing */
     readonly source: string;
-    readonly openInferenceSpanKind: OpenInferenceSpanKind;
-    readonly arvoExecutionSpanKind: ArvoExecutionSpanKind;
-    readonly openTelemetrySpanKind: SpanKind;
-    private readonly _handler;
+    /** OpenTelemetry configuration */
+    readonly spanOptions: SpanOptions;
+    /** Event processing function */
+    readonly handler: MultiArvoEventHandlerFunction;
     /**
-     * Creates an instance of MultiArvoEventHandler.
-     *
-     * @param param - The configuration parameters for the event handler.
-     * @throws {Error} Throws an error if the provided source is invalid.
+     * Creates handler instance with specified configuration.
+     * @param param Handler configuration including source and execution parameters
+     * @throws When source contains invalid characters
      */
     constructor(param: IMultiArvoEventHandler);
     /**
-     * Executes the event handler for a given event.
-     *
-     * @param event - The event to handle.
-     * @param opentelemetry - Configuration for OpenTelemetry integration, including tracing options
-     *                        and context inheritance settings.
-     * @returns A promise that resolves to an array of resulting ArvoEvents.
-     *
-     * @remarks
-     * This method performs the following steps:
-     * 1. Creates an OpenTelemetry span for the execution.
-     * 2. Validates that the event's 'to' field matches the handler's 'source'.
-     * 3. Executes the handler function.
-     * 4. Creates and returns the result event(s).
-     * 5. Handles any errors and creates an error event if necessary.
-     *
-     * All telemetry data is properly set and propagated throughout the execution.
-     *
-     * @example
-     * ```typescript
-     * const handler = new MultiArvoEventHandler({
-     *    source: 'com.multi.handler',
-     *    ...
-     * });
-     * const inputEvent: ArvoEvent = createArvoEvent({ ... });
-     * const resultEvents = await handler.execute(inputEvent);
-     * ```
-     *
-     * @throws {Error} Throws an error if the event's 'to' field doesn't match the handler's 'source'.
-     * All other errors thrown during the execution are returned as a system error event.
-     *
-     * **Routing**
+     * Processes an event through configured handler function. Creates telemetry span,
+     * validates event destination, executes handler, and manages errors.
      *
-     * The routing of the resulting events is determined as follows:
-     * - The `to` field of the output event is set in this priority:
-     *   1. The `to` field provided by the handler result
-     *   2. The `redirectto` field from the input event
-     *   3. The `source` field from the input event (as a form of reply)
-     * - For system error events, the `to` field is always set to the `source` of the input event.
-     *
-     * **Telemetry**
-     *
-     * - Creates a new span for each execution as per the traceparent and tracestate field
-     *   of the event. If those are not present, then a brand new span is created and distributed
-     *   tracing is disabled
-     * - Sets span attributes for input and output events
-     * - Propagates trace context to output events
-     * - Handles error cases and sets appropriate span status
-     *
-     * **Event Validation**
-     *
-     * - Checks if the event's 'to' field matches the handler's 'source'.
-     * - If they don't match, an error is thrown with a descriptive message.
-     * - This ensures that the handler only processes events intended for it.
+     * @param event Event to process
+     * @param opentelemetry Telemetry context configuration
+     * @returns Resulting events or error events
      */
-    execute(event: ArvoEvent, opentelemetry?: OpenTelemetryConfig): Promise<ArvoEvent[]>;
+    execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<ArvoEvent[]>;
     /**
-     * Provides the schema for system error events.
-     *
-     * @returns An object containing the error event type and schema.
-     *
-     * @remarks
-     * This getter defines the structure for system error events that may be emitted
-     * when an unexpected error occurs during event handling. The error event type
-     * is prefixed with 'sys.' followed by the handler's source and '.error'.
-     * The schema used for these error events is the standard ArvoErrorSchema.
-     *
-     * @example
-     * // If the handler's source is 'user.service'
-     * // The system error event type would be 'sys.user.service.error'
+     * System error schema configuration.
+     * Error events follow format: sys.<handler-source>.error
      */
     get systemErrorSchema(): {
         type: string;
@@ -116,12 +51,12 @@ export default class MultiArvoEventHandler extends AbstractArvoEventHandler {
             errorMessage: import("zod").ZodString;
             errorStack: import("zod").ZodNullable<import("zod").ZodString>;
         }, "strip", import("zod").ZodTypeAny, {
-            errorMessage: string;
             errorName: string;
+            errorMessage: string;
             errorStack: string | null;
         }, {
-            errorMessage: string;
             errorName: string;
+            errorMessage: string;
             errorStack: string | null;
         }>;
     };

package/dist/MultiArvoEventHandler/index.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+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) {
@@ -58,119 +69,73 @@ var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var utils_1 = require("../utils");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
-var OpenTelemetry_1 = require("../OpenTelemetry");
-var utils_2 = require("../OpenTelemetry/utils");
 /**
- * Represents a Multi ArvoEvent handler that can process multiple event types.
+ * MultiArvoEventHandler processes multiple event types without being bound to specific contracts.
+ * Manages event execution, telemetry tracking, and error handling for diverse event streams.
  *
- * @remarks
- * Unlike ArvoEventHandler, which is bound to a specific ArvoContract and handles
- * events of a single type, MultiArvoEventHandler can handle multiple event types
- * without being tied to a specific contract. This makes it more flexible for
- * scenarios where you need to process various event types with a single handler.
+ * @example
+ * const handler = createMultiArvoEventHandler({
+ *   source: "order.handler",
+ *   executionunits: 1,
+ *   handler: async ({ event }) => {
+ *     // Handle multiple event types
+ *   }
+ * });
  */
 var MultiArvoEventHandler = /** @class */ (function (_super) {
     __extends(MultiArvoEventHandler, _super);
     /**
-     * Creates an instance of MultiArvoEventHandler.
-     *
-     * @param param - The configuration parameters for the event handler.
-     * @throws {Error} Throws an error if the provided source is invalid.
+     * Creates handler instance with specified configuration.
+     * @param param Handler configuration including source and execution parameters
+     * @throws When source contains invalid characters
      */
     function MultiArvoEventHandler(param) {
-        var _a, _b, _c;
+        var _a;
+        var _b, _c;
         var _this = _super.call(this) || this;
-        _this.openInferenceSpanKind = arvo_core_1.OpenInferenceSpanKind.CHAIN;
-        _this.arvoExecutionSpanKind = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER;
-        _this.openTelemetrySpanKind = api_1.SpanKind.INTERNAL;
         _this.executionunits = param.executionunits;
-        _this._handler = param.handler;
+        _this.handler = param.handler;
         if (!(0, utils_1.isLowerAlphanumeric)(param.source)) {
-            throw new Error("Invalid 'source' = '".concat(param.source, "'. The 'source' must only contain alphanumeric characters e.g. test.handler"));
+            throw new Error("Invalid source identifier '".concat(param.source, "': Must contain only alphanumeric characters (example: order.handler)"));
         }
         _this.source = param.source;
-        _this.arvoExecutionSpanKind =
-            ((_a = param.spanKind) === null || _a === void 0 ? void 0 : _a.arvoExecution) || _this.arvoExecutionSpanKind;
-        _this.openInferenceSpanKind =
-            ((_b = param.spanKind) === null || _b === void 0 ? void 0 : _b.openInference) || _this.openInferenceSpanKind;
-        _this.openTelemetrySpanKind =
-            ((_c = param.spanKind) === null || _c === void 0 ? void 0 : _c.openTelemetry) || _this.openTelemetrySpanKind;
+        _this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.CONSUMER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_c = (_b = param.spanOptions) === null || _b === void 0 ? void 0 : _b.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.handler.source': _this.source }) });
         return _this;
     }
     /**
-     * Executes the event handler for a given event.
-     *
-     * @param event - The event to handle.
-     * @param opentelemetry - Configuration for OpenTelemetry integration, including tracing options
-     *                        and context inheritance settings.
-     * @returns A promise that resolves to an array of resulting ArvoEvents.
-     *
-     * @remarks
-     * This method performs the following steps:
-     * 1. Creates an OpenTelemetry span for the execution.
-     * 2. Validates that the event's 'to' field matches the handler's 'source'.
-     * 3. Executes the handler function.
-     * 4. Creates and returns the result event(s).
-     * 5. Handles any errors and creates an error event if necessary.
-     *
-     * All telemetry data is properly set and propagated throughout the execution.
-     *
-     * @example
-     * ```typescript
-     * const handler = new MultiArvoEventHandler({
-     *    source: 'com.multi.handler',
-     *    ...
-     * });
-     * const inputEvent: ArvoEvent = createArvoEvent({ ... });
-     * const resultEvents = await handler.execute(inputEvent);
-     * ```
-     *
-     * @throws {Error} Throws an error if the event's 'to' field doesn't match the handler's 'source'.
-     * All other errors thrown during the execution are returned as a system error event.
+     * Processes an event through configured handler function. Creates telemetry span,
+     * validates event destination, executes handler, and manages errors.
      *
-     * **Routing**
-     *
-     * The routing of the resulting events is determined as follows:
-     * - The `to` field of the output event is set in this priority:
-     *   1. The `to` field provided by the handler result
-     *   2. The `redirectto` field from the input event
-     *   3. The `source` field from the input event (as a form of reply)
-     * - For system error events, the `to` field is always set to the `source` of the input event.
-     *
-     * **Telemetry**
-     *
-     * - Creates a new span for each execution as per the traceparent and tracestate field
-     *   of the event. If those are not present, then a brand new span is created and distributed
-     *   tracing is disabled
-     * - Sets span attributes for input and output events
-     * - Propagates trace context to output events
-     * - Handles error cases and sets appropriate span status
-     *
-     * **Event Validation**
-     *
-     * - Checks if the event's 'to' field matches the handler's 'source'.
-     * - If they don't match, an error is thrown with a descriptive message.
-     * - This ensures that the handler only processes events intended for it.
+     * @param event Event to process
+     * @param opentelemetry Telemetry context configuration
+     * @returns Resulting events or error events
      */
-    MultiArvoEventHandler.prototype.execute = function (event, opentelemetry) {
-        return __awaiter(this, void 0, void 0, function () {
-            var span;
+    MultiArvoEventHandler.prototype.execute = function (event_1) {
+        return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
             var _this = this;
+            if (opentelemetry === void 0) { opentelemetry = {
+                inheritFrom: 'EVENT',
+            }; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        span = (0, utils_2.createOtelSpan)({
-                            spanName: "MutliArvoEventHandler.source<".concat(this.source, ">.execute<").concat(event.type, ">"),
-                            spanKinds: {
-                                kind: this.openTelemetrySpanKind,
-                                openInference: this.openInferenceSpanKind,
-                                arvoExecution: this.arvoExecutionSpanKind,
-                            },
-                            event: event,
-                            opentelemetryConfig: opentelemetry,
-                        });
-                        return [4 /*yield*/, api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () { return __awaiter(_this, void 0, void 0, function () {
-                                var otelSpanHeaders, _handlerOutput, outputs, error_1;
+                    case 0: return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan({
+                            name: 'MutliArvoEventHandler',
+                            spanOptions: this.spanOptions,
+                            disableSpanManagement: true,
+                            context: opentelemetry.inheritFrom === 'EVENT'
+                                ? {
+                                    inheritFrom: 'TRACE_HEADERS',
+                                    traceHeaders: {
+                                        traceparent: event.traceparent,
+                                        tracestate: event.tracestate,
+                                    },
+                                }
+                                : {
+                                    inheritFrom: 'CONTEXT',
+                                    context: api_1.context.active(),
+                                },
+                            fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
+                                var otelSpanHeaders, _handlerOutput, outputs, resultingEvents, error_1;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
@@ -183,12 +148,17 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
                                                 var key = _a[0], value = _a[1];
                                                 return span.setAttribute("to_process.0.".concat(key), value);
                                             });
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Initiating event resolution - Type: ".concat(event.type, ", Source: ").concat(event.source, ", Destination: ").concat(event.to),
+                                            });
                                             if (event.to !== this.source) {
-                                                throw new Error((0, arvo_core_1.cleanString)("\n            Invalid event. The 'event.to' is ".concat(event.to, " while this handler \n            listens to only 'event.to' equal to ").concat(this.source, ". If this is a mistake,\n            please update the 'source' field of the handler\n          ")));
+                                                throw new Error("Event destination mismatch: Expected '".concat(this.source, "', received '").concat(event.to, "'"));
                                             }
-                                            return [4 /*yield*/, this._handler({
+                                            return [4 /*yield*/, this.handler({
                                                     event: event,
                                                     source: this.source,
+                                                    span: span
                                                 })];
                                         case 2:
                                             _handlerOutput = _a.sent();
@@ -201,27 +171,23 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
                                             else {
                                                 outputs = [_handlerOutput];
                                             }
-                                            return [2 /*return*/, (0, utils_1.eventHandlerOutputEventCreator)(outputs, otelSpanHeaders, this.source, event, this.executionunits, function (param, extension) {
-                                                    var _a;
-                                                    return (0, arvo_core_1.createArvoEvent)(param, extension, {
-                                                        tracer: (_a = opentelemetry === null || opentelemetry === void 0 ? void 0 : opentelemetry.tracer) !== null && _a !== void 0 ? _a : (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
-                                                    });
-                                                })];
+                                            resultingEvents = (0, utils_1.eventHandlerOutputEventCreator)(outputs, otelSpanHeaders, this.source, event, this.executionunits, function (param, extensions) { return (0, arvo_core_1.createArvoEvent)(param, extensions); });
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Event processing completed successfully - Generated ".concat(resultingEvents.length, " new event(s)"),
+                                            });
+                                            return [2 /*return*/, resultingEvents];
                                         case 3:
                                             error_1 = _a.sent();
-                                            return [2 /*return*/, (0, utils_1.createHandlerErrorOutputEvent)(error_1, otelSpanHeaders, "sys.".concat(this.source, ".error"), this.source, event, this.executionunits, function (param, extension) {
-                                                    var _a;
-                                                    return (0, arvo_core_1.createArvoEvent)(param, extension, {
-                                                        tracer: (_a = opentelemetry === null || opentelemetry === void 0 ? void 0 : opentelemetry.tracer) !== null && _a !== void 0 ? _a : (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
-                                                    });
-                                                })];
+                                            return [2 /*return*/, (0, utils_1.createHandlerErrorOutputEvent)(error_1, otelSpanHeaders, "sys.".concat(this.source, ".error"), this.source, event, this.executionunits, function (param, extensions) { return (0, arvo_core_1.createArvoEvent)(param, extensions); })];
                                         case 4:
                                             span.end();
                                             return [7 /*endfinally*/];
                                         case 5: return [2 /*return*/];
                                     }
                                 });
-                            }); })];
+                            }); },
+                        })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -229,19 +195,8 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
     };
     Object.defineProperty(MultiArvoEventHandler.prototype, "systemErrorSchema", {
         /**
-         * Provides the schema for system error events.
-         *
-         * @returns An object containing the error event type and schema.
-         *
-         * @remarks
-         * This getter defines the structure for system error events that may be emitted
-         * when an unexpected error occurs during event handling. The error event type
-         * is prefixed with 'sys.' followed by the handler's source and '.error'.
-         * The schema used for these error events is the standard ArvoErrorSchema.
-         *
-         * @example
-         * // If the handler's source is 'user.service'
-         * // The system error event type would be 'sys.user.service.error'
+         * System error schema configuration.
+         * Error events follow format: sys.<handler-source>.error
          */
         get: function () {
             return {

package/dist/MultiArvoEventHandler/types.d.ts

@@ -1,5 +1,5 @@
-import { SpanKind } from '@opentelemetry/api';
-import { ArvoEvent, ArvoExecutionSpanKind, CreateArvoEvent, OpenInferenceSpanKind } from 'arvo-core';
+import { Span, SpanOptions } from '@opentelemetry/api';
+import { ArvoEvent, CreateArvoEvent } from 'arvo-core';
 /**
  * Represents the input for a Multi ArvoEvent handler function.
  */
@@ -8,6 +8,8 @@ export type MultiArvoEventHandlerFunctionInput = {
     event: ArvoEvent;
     /** The source field data of the handler */
     source: string;
+    /** The OpenTelemetry span */
+    span: Span;
 };
 /**
  * Represents the output of a Multi ArvoEvent handler function.
@@ -57,16 +59,6 @@ export interface IMultiArvoEventHandler {
      * @returns A promise of object containing the created ArvoEvent and optional extensions.
      */
     handler: MultiArvoEventHandlerFunction;
-    /**
-     * The OpenTelemetry span kind attributes for the handler
-     * executor.
-     * @param [openInference] - The OpenInference span kind. Default is "CHAIN"
-     * @param [arvoExecution] - The ArvoExecution span kind. Default is "EVENT_HANDLER"
-     * @param [openTelemetry] - The OpenTelemetry span kind. Default is "INTERNAL"
-     */
-    spanKind?: {
-        openInference?: OpenInferenceSpanKind;
-        arvoExecution?: ArvoExecutionSpanKind;
-        openTelemetry?: SpanKind;
-    };
+    /** The OpenTelemetry span options */
+    spanOptions?: SpanOptions;
 }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import ArvoEventHandler from './ArvoEventHandler';
 import { ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunction, IArvoEventHandler } from './ArvoEventHandler/types';
 import { createArvoEventHandler } from './ArvoEventHandler/helpers';
-import { PartialExcept } from './types';
+import { PartialExcept, ArvoEventHandlerOpenTelemetryOptions } from './types';
 import MultiArvoEventHandler from './MultiArvoEventHandler';
 import { MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler } from './MultiArvoEventHandler/types';
 import { createMultiArvoEventHandler } from './MultiArvoEventHandler/helpers';
@@ -10,7 +10,5 @@ import { IArvoEventRouter } from './ArvoEventRouter/types';
 import { ArvoEventRouter } from './ArvoEventRouter';
 import { createArvoEventRouter } from './ArvoEventRouter/helpers';
 import AbstractArvoEventHandler from './AbstractArvoEventHandler';
-import { createOtelSpan } from './OpenTelemetry/utils';
-import { OpenTelemetryConfig } from './OpenTelemetry/types';
 import { deleteOtelHeaders } from './ArvoEventRouter/utils';
-export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventRouter, ArvoEventRouter, createArvoEventRouter, AbstractArvoEventHandler, OpenTelemetryConfig, createOtelSpan, deleteOtelHeaders, };
+export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventRouter, ArvoEventRouter, createArvoEventRouter, AbstractArvoEventHandler, deleteOtelHeaders, ArvoEventHandlerOpenTelemetryOptions, };

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteOtelHeaders = exports.createOtelSpan = exports.AbstractArvoEventHandler = exports.createArvoEventRouter = exports.ArvoEventRouter = exports.coalesceOrDefault = exports.coalesce = exports.getValueOrDefault = exports.isNullOrUndefined = exports.createMultiArvoEventHandler = exports.MultiArvoEventHandler = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
+exports.deleteOtelHeaders = exports.AbstractArvoEventHandler = exports.createArvoEventRouter = exports.ArvoEventRouter = exports.coalesceOrDefault = exports.coalesce = exports.getValueOrDefault = exports.isNullOrUndefined = exports.createMultiArvoEventHandler = exports.MultiArvoEventHandler = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
 var ArvoEventHandler_1 = __importDefault(require("./ArvoEventHandler"));
 exports.ArvoEventHandler = ArvoEventHandler_1.default;
 var helpers_1 = require("./ArvoEventHandler/helpers");
@@ -23,7 +23,5 @@ var helpers_3 = require("./ArvoEventRouter/helpers");
 Object.defineProperty(exports, "createArvoEventRouter", { enumerable: true, get: function () { return helpers_3.createArvoEventRouter; } });
 var AbstractArvoEventHandler_1 = __importDefault(require("./AbstractArvoEventHandler"));
 exports.AbstractArvoEventHandler = AbstractArvoEventHandler_1.default;
-var utils_2 = require("./OpenTelemetry/utils");
-Object.defineProperty(exports, "createOtelSpan", { enumerable: true, get: function () { return utils_2.createOtelSpan; } });
-var utils_3 = require("./ArvoEventRouter/utils");
-Object.defineProperty(exports, "deleteOtelHeaders", { enumerable: true, get: function () { return utils_3.deleteOtelHeaders; } });
+var utils_2 = require("./ArvoEventRouter/utils");
+Object.defineProperty(exports, "deleteOtelHeaders", { enumerable: true, get: function () { return utils_2.deleteOtelHeaders; } });

package/dist/types.d.ts

@@ -15,3 +15,6 @@
  * // Equivalent to: { id: number; name?: string; email?: string; }
  */
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
+export type ArvoEventHandlerOpenTelemetryOptions = {
+    inheritFrom: 'EVENT' | 'CONTEXT';
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "Type-safe event handler system with versioning, telemetry, and contract validation for distributed Arvo event-driven architectures, featuring routing and multi-handler support.",
   "main": "dist/index.js",
   "scripts": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^1.27.0",
-    "arvo-core": "^2.0.10",
+    "arvo-core": "^2.1.10",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   }

package/dist/OpenTelemetry/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Returns a tracer instance for the ArvoEventHandler package.
- */
-export declare const fetchOpenTelemetryTracer: () => import("@opentelemetry/api").Tracer;

package/dist/OpenTelemetry/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOpenTelemetryTracer = void 0;
-var api_1 = require("@opentelemetry/api");
-/**
- * Returns a tracer instance for the ArvoEventHandler package.
- */
-var fetchOpenTelemetryTracer = function () {
-    return api_1.trace.getTracer('arvo-instrumentation');
-};
-exports.fetchOpenTelemetryTracer = fetchOpenTelemetryTracer;

package/dist/OpenTelemetry/types.d.ts

@@ -1,48 +0,0 @@
-import { SpanKind, Tracer } from '@opentelemetry/api';
-import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from 'arvo-core';
-export type PackageJson = {
-    name: string;
-    version: string;
-    [key: string]: any;
-};
-/**
- * Configuration options for OpenTelemetry integration in execution context.
- *
- * This type defines how tracing should be configured and inherited within
- * the execution pipeline.
- */
-export type OpenTelemetryConfig = {
-    /**
-     * Specifies the context from which to inherit OpenTelemetry context.
-     * - 'event': Inherits context from the event that triggered the execution
-     * - 'execution': Inherits context from the parent execution context
-     */
-    inheritFrom: 'event' | 'execution';
-    /**
-     * Optional OpenTelemetry tracer instance to use for creating spans.
-     * If not provided, a default tracer may be used depending on the implementation.
-     */
-    tracer: Tracer | null;
-};
-/**
- * Interface defining the required parameters for creating a handler execution span.
- *
- * @interface ICreateHandlerExecutionSpan
- * @property {string} spanName - The name to be assigned to the created span
- * @property {Object} spanKinds - Object containing different span kind classifications
- * @property {SpanKind} spanKinds.kind - OpenTelemetry span kind
- * @property {OpenInferenceSpanKind} spanKinds.openInference - OpenInference-specific span classification
- * @property {ArvoExecutionSpanKind} spanKinds.arvoExecution - Arvo execution-specific span classification
- * @property {ArvoEvent} event - The Arvo event associated with this span
- * @property {EventHandlerExecutionOtelConfiguration} opentelemetryConfig - Configuration for OpenTelemetry behavior
- */
-export interface ICreateOtelSpan {
-    spanName: string;
-    spanKinds: {
-        kind: SpanKind;
-        openInference: OpenInferenceSpanKind;
-        arvoExecution: ArvoExecutionSpanKind;
-    };
-    event: ArvoEvent;
-    opentelemetryConfig?: OpenTelemetryConfig;
-}

package/dist/OpenTelemetry/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });