arvo-event-handler 1.1.16 → 1.1.18

package/dist/AbstractArvoEventHandler/index.d.ts

@@ -1,5 +1,5 @@
 import { ArvoContractRecord, ArvoEvent } from 'arvo-core';
-import { ExecutionOpenTelemetryConfiguration } from './types';
+import { OpenTelemetryConfig } from '../OpenTelemetry/types';
 /**
  * Abstract base class for Arvo event handlers.
  *
@@ -11,13 +11,25 @@ import { ExecutionOpenTelemetryConfiguration } from './types';
  * ```
  */
 export default abstract class AbstractArvoEventHandler {
+    /**
+     * The source identifier for the event handler.
+     *
+     * @description
+     * Uniquely identifies the '<ArvoEvent>.type' of events processed by this handler.
+     *
+     * @remarks
+     * - Should be unique across all event handlers in the system
+     * - Typically follows a dotted notation pattern (e.g., 'domain.entity.action')
+     * - Used for routing, logging, and observability purposes
+     */
+    abstract readonly source: string;
     /**
      * Executes the event handling logic for a given Arvo event.
      *
      * @abstract
      * @param {ArvoEvent} event - The Arvo event to be processed. This event should conform
      *                           to the expected schema for the specific handler implementation.
-     * @param {ExecutionOpenTelemetryConfiguration} opentelemetry - Configuration for OpenTelemetry
+     * @param {OpenTelemetryConfig} opentelemetry - Configuration for OpenTelemetry
      *                                                             integration, including tracing options
      *                                                             and context inheritance settings.
      * @returns {Promise<ArvoEvent[]>} A promise that resolves to an array of resulting Arvo events.
@@ -52,7 +64,7 @@ export default abstract class AbstractArvoEventHandler {
      * - Properly handling span lifecycle (creation and completion)
      * - Propagating context appropriately
      */
-    abstract execute(event: ArvoEvent, opentelemetry: ExecutionOpenTelemetryConfiguration): Promise<ArvoEvent[]>;
+    abstract execute(event: ArvoEvent, opentelemetry?: OpenTelemetryConfig): Promise<ArvoEvent[]>;
     /**
      * Provides the schema for system error events.
      *

package/dist/ArvoEventHandler/index.d.ts

@@ -2,7 +2,7 @@ import { ArvoContract, ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind,
 import { IArvoEventHandler } from './types';
 import { SpanKind } from '@opentelemetry/api';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ExecutionOpenTelemetryConfiguration } from '../AbstractArvoEventHandler/types';
+import { OpenTelemetryConfig } from '../OpenTelemetry/types';
 /**
  * Represents an event handler for Arvo contracts.
  *
@@ -91,7 +91,7 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
      * - Propagates trace context to output events
      * - Handles error cases and sets appropriate span status
      */
-    execute(event: ArvoEvent<ResolveArvoContractRecord<TContract['accepts']>, Record<string, any>, TContract['accepts']['type']>, opentelemetry?: ExecutionOpenTelemetryConfiguration): Promise<ArvoEvent[]>;
+    execute(event: ArvoEvent<ResolveArvoContractRecord<TContract['accepts']>, Record<string, any>, TContract['accepts']['type']>, opentelemetry?: OpenTelemetryConfig): Promise<ArvoEvent[]>;
     /**
      * Provides the schema for system error events.
      *

package/dist/ArvoEventHandler/index.js

@@ -60,7 +60,7 @@ var api_1 = require("@opentelemetry/api");
 var utils_1 = require("../utils");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var OpenTelemetry_1 = require("../OpenTelemetry");
-var utils_2 = require("../AbstractArvoEventHandler/utils");
+var utils_2 = require("../OpenTelemetry/utils");
 /**
  * Represents an event handler for Arvo contracts.
  *
@@ -166,7 +166,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        span = (0, utils_2.createHandlerExecutionSpan)({
+                        span = (0, utils_2.createOtelSpan)({
                             spanName: "ArvoEventHandler<".concat(this.contract.uri, ">.execute<").concat(event.type, ">"),
                             spanKinds: {
                                 kind: this.openTelemetrySpanKind,

package/dist/ArvoEventRouter/index.d.ts

@@ -3,7 +3,7 @@ import ArvoEventHandler from '../ArvoEventHandler';
 import { IArvoEventRouter } from './types';
 import { SpanKind } from '@opentelemetry/api';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ExecutionOpenTelemetryConfiguration } from '../AbstractArvoEventHandler/types';
+import { OpenTelemetryConfig } from '../OpenTelemetry/types';
 /**
  * ArvoEventRouter class handles routing of ArvoEvents to appropriate event handlers.
  */
@@ -92,7 +92,7 @@ export declare class ArvoEventRouter extends AbstractArvoEventHandler {
      * - Execution units are tracked for both successful executions and errors.
      * - The router's default execution units are used for error events.
      */
-    execute(event: ArvoEvent, opentelemetry?: ExecutionOpenTelemetryConfiguration): Promise<ArvoEvent[]>;
+    execute(event: ArvoEvent, opentelemetry?: OpenTelemetryConfig): Promise<ArvoEvent[]>;
     /**
      * Provides the schema for system error events.
      *

package/dist/ArvoEventRouter/index.js

@@ -61,7 +61,7 @@ var api_1 = require("@opentelemetry/api");
 var utils_2 = require("./utils");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var OpenTelemetry_1 = require("../OpenTelemetry");
-var utils_3 = require("../AbstractArvoEventHandler/utils");
+var utils_3 = require("../OpenTelemetry/utils");
 /**
  * ArvoEventRouter class handles routing of ArvoEvents to appropriate event handlers.
  */
@@ -174,7 +174,7 @@ var ArvoEventRouter = /** @class */ (function (_super) {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        span = (0, utils_3.createHandlerExecutionSpan)({
+                        span = (0, utils_3.createOtelSpan)({
                             spanName: "ArvoEventRouter.source<".concat((_a = this._source) !== null && _a !== void 0 ? _a : 'arvo.event.router', ">.execute<").concat(event.type, ">"),
                             spanKinds: {
                                 kind: this.openTelemetrySpanKind,

package/dist/MultiArvoEventHandler/index.d.ts

@@ -2,7 +2,7 @@ import { SpanKind } from '@opentelemetry/api';
 import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from 'arvo-core';
 import { IMultiArvoEventHandler } from './types';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ExecutionOpenTelemetryConfiguration } from '../AbstractArvoEventHandler/types';
+import { OpenTelemetryConfig } from '../OpenTelemetry/types';
 /**
  * Represents a Multi ArvoEvent handler that can process multiple event types.
  *
@@ -93,7 +93,7 @@ export default class MultiArvoEventHandler extends AbstractArvoEventHandler {
      * - If they don't match, an error is thrown with a descriptive message.
      * - This ensures that the handler only processes events intended for it.
      */
-    execute(event: ArvoEvent, opentelemetry?: ExecutionOpenTelemetryConfiguration): Promise<ArvoEvent[]>;
+    execute(event: ArvoEvent, opentelemetry?: OpenTelemetryConfig): Promise<ArvoEvent[]>;
     /**
      * Provides the schema for system error events.
      *

package/dist/MultiArvoEventHandler/index.js

@@ -59,7 +59,7 @@ 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("../AbstractArvoEventHandler/utils");
+var utils_2 = require("../OpenTelemetry/utils");
 /**
  * Represents a Multi ArvoEvent handler that can process multiple event types.
  *
@@ -159,7 +159,7 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        span = (0, utils_2.createHandlerExecutionSpan)({
+                        span = (0, utils_2.createOtelSpan)({
                             spanName: "MutliArvoEventHandler.source<".concat(this.source, ">.execute<").concat(event.type, ">"),
                             spanKinds: {
                                 kind: this.openTelemetrySpanKind,

package/dist/OpenTelemetry/index.d.ts

@@ -1,6 +1,4 @@
-import { Context } from '@opentelemetry/api';
 /**
  * Returns a tracer instance for the ArvoEventHandler package.
  */
 export declare const fetchOpenTelemetryTracer: () => import("@opentelemetry/api").Tracer;
-export declare const extractContext: (traceparent: string, tracestate: string | null) => Context;

package/dist/OpenTelemetry/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractContext = exports.fetchOpenTelemetryTracer = void 0;
+exports.fetchOpenTelemetryTracer = void 0;
 var api_1 = require("@opentelemetry/api");
 var utils_1 = require("./utils");
 /**
@@ -11,12 +11,3 @@ var fetchOpenTelemetryTracer = function () {
     return api_1.trace.getTracer(pkg.name, pkg.version);
 };
 exports.fetchOpenTelemetryTracer = fetchOpenTelemetryTracer;
-// Helper function to extract context from traceparent and tracestate
-var extractContext = function (traceparent, tracestate) {
-    var extractedContext = api_1.propagation.extract(api_1.context.active(), {
-        traceparent: traceparent,
-        tracestate: tracestate !== null && tracestate !== void 0 ? tracestate : undefined,
-    });
-    return extractedContext;
-};
-exports.extractContext = extractContext;

package/dist/OpenTelemetry/types.d.ts

@@ -0,0 +1,48 @@
+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/utils.d.ts

@@ -1,9 +1,11 @@
-import { Span, SpanKind, Tracer } from '@opentelemetry/api';
+import { Span, SpanKind, Tracer, Context } from '@opentelemetry/api';
 import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from 'arvo-core';
+import { ICreateOtelSpan } from './types';
 export declare function getPackageInfo(defaultName: string): {
     name: string;
     version: string;
 };
+export declare const extractContext: (traceparent: string, tracestate: string | null) => Context;
 /**
  * Creates an OpenTelemetry span from an ArvoEvent, facilitating distributed tracing in the Arvo system.
  *
@@ -70,4 +72,20 @@ export declare const createSpanFromEvent: (spanName: string, event: ArvoEvent, s
     kind: SpanKind;
     openInference: OpenInferenceSpanKind;
     arvoExecution: ArvoExecutionSpanKind;
-}, tracer?: Tracer) => Span;
+}, tracer: Tracer) => Span;
+/**
+ * Creates an OpenTelemetry span for tracking handler execution.
+ *
+ * This function creates a span either from an existing event or as a new span,
+ * depending on the configuration. It includes attributes for both OpenInference
+ * and Arvo execution span kinds.
+ *
+ * @param params - Parameters for creating the handler execution span
+ * @param params.spanName - Name of the span to be created
+ * @param params.spanKinds - Object containing different span kind classifications
+ * @param params.event - The Arvo event associated with this span
+ * @param params.opentelemetryConfig - OpenTelemetry configuration
+ *
+ * @returns A new OpenTelemetry span configured according to the parameters
+ */
+export declare const createOtelSpan: ({ spanName, spanKinds, event, opentelemetryConfig, }: ICreateOtelSpan) => Span;

package/dist/OpenTelemetry/utils.js

@@ -23,8 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpanFromEvent = void 0;
+exports.createOtelSpan = exports.createSpanFromEvent = exports.extractContext = void 0;
 exports.getPackageInfo = getPackageInfo;
+var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var fs = __importStar(require("fs"));
 var path = __importStar(require("path"));
@@ -45,6 +46,15 @@ function getPackageInfo(defaultName) {
         return { name: defaultName, version: 'Unknown' };
     }
 }
+// Helper function to extract context from traceparent and tracestate
+var extractContext = function (traceparent, tracestate) {
+    var extractedContext = api_1.propagation.extract(api_1.context.active(), {
+        traceparent: traceparent,
+        tracestate: tracestate !== null && tracestate !== void 0 ? tracestate : undefined,
+    });
+    return extractedContext;
+};
+exports.extractContext = extractContext;
 /**
  * Creates an OpenTelemetry span from an ArvoEvent, facilitating distributed tracing in the Arvo system.
  *
@@ -109,7 +119,6 @@ function getPackageInfo(defaultName) {
  */
 var createSpanFromEvent = function (spanName, event, spanKinds, tracer) {
     var _a;
-    if (tracer === void 0) { tracer = (0, _1.fetchOpenTelemetryTracer)(); }
     var spanOptions = {
         kind: spanKinds.kind,
         attributes: (_a = {},
@@ -119,7 +128,7 @@ var createSpanFromEvent = function (spanName, event, spanKinds, tracer) {
     };
     var span;
     if (event.traceparent) {
-        var inheritedContext = (0, _1.extractContext)(event.traceparent, event.tracestate);
+        var inheritedContext = (0, exports.extractContext)(event.traceparent, event.tracestate);
         span = tracer.startSpan(spanName, spanOptions, inheritedContext);
     }
     else {
@@ -128,3 +137,39 @@ var createSpanFromEvent = function (spanName, event, spanKinds, tracer) {
     return span;
 };
 exports.createSpanFromEvent = createSpanFromEvent;
+/**
+ * Creates an OpenTelemetry span for tracking handler execution.
+ *
+ * This function creates a span either from an existing event or as a new span,
+ * depending on the configuration. It includes attributes for both OpenInference
+ * and Arvo execution span kinds.
+ *
+ * @param params - Parameters for creating the handler execution span
+ * @param params.spanName - Name of the span to be created
+ * @param params.spanKinds - Object containing different span kind classifications
+ * @param params.event - The Arvo event associated with this span
+ * @param params.opentelemetryConfig - OpenTelemetry configuration
+ *
+ * @returns A new OpenTelemetry span configured according to the parameters
+ */
+var createOtelSpan = function (_a) {
+    var _b;
+    var _c;
+    var spanName = _a.spanName, spanKinds = _a.spanKinds, event = _a.event, opentelemetryConfig = _a.opentelemetryConfig;
+    opentelemetryConfig = opentelemetryConfig !== null && opentelemetryConfig !== void 0 ? opentelemetryConfig : {
+        inheritFrom: 'event',
+        tracer: null
+    };
+    var spanOptions = {
+        kind: spanKinds.kind,
+        attributes: (_b = {},
+            _b[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = spanKinds.openInference,
+            _b[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = spanKinds.arvoExecution,
+            _b),
+    };
+    var tracer = (_c = opentelemetryConfig.tracer) !== null && _c !== void 0 ? _c : (0, _1.fetchOpenTelemetryTracer)();
+    return opentelemetryConfig.inheritFrom === "event" ?
+        (0, exports.createSpanFromEvent)(spanName, event, spanKinds, tracer) :
+        tracer.startSpan(spanName, spanOptions);
+};
+exports.createOtelSpan = createOtelSpan;

package/dist/index.d.ts

@@ -10,6 +10,6 @@ import { IArvoEventRouter } from './ArvoEventRouter/types';
 import { ArvoEventRouter } from './ArvoEventRouter';
 import { createArvoEventRouter } from './ArvoEventRouter/helpers';
 import AbstractArvoEventHandler from './AbstractArvoEventHandler';
-import { createSpanFromEvent } from './OpenTelemetry/utils';
-import { ExecutionOpenTelemetryConfiguration } from './AbstractArvoEventHandler/types';
-export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventRouter, ArvoEventRouter, createArvoEventRouter, AbstractArvoEventHandler, createSpanFromEvent as createOtelSpanFromEvent, ExecutionOpenTelemetryConfiguration, };
+import { createOtelSpan } from './OpenTelemetry/utils';
+import { OpenTelemetryConfig } from './OpenTelemetry/types';
+export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventRouter, ArvoEventRouter, createArvoEventRouter, AbstractArvoEventHandler, OpenTelemetryConfig as EventHandlerExecutionOtelConfiguration, createOtelSpan as createOtelSpan, };

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.createOtelSpanFromEvent = 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.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;
 var ArvoEventHandler_1 = __importDefault(require("./ArvoEventHandler"));
 exports.ArvoEventHandler = ArvoEventHandler_1.default;
 var helpers_1 = require("./ArvoEventHandler/helpers");
@@ -24,4 +24,4 @@ Object.defineProperty(exports, "createArvoEventRouter", { enumerable: true, get:
 var AbstractArvoEventHandler_1 = __importDefault(require("./AbstractArvoEventHandler"));
 exports.AbstractArvoEventHandler = AbstractArvoEventHandler_1.default;
 var utils_2 = require("./OpenTelemetry/utils");
-Object.defineProperty(exports, "createOtelSpanFromEvent", { enumerable: true, get: function () { return utils_2.createSpanFromEvent; } });
+Object.defineProperty(exports, "createOtelSpan", { enumerable: true, get: function () { return utils_2.createOtelSpan; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "This package contains class and function for event handlers in an Arvo Event Driven system",
   "main": "dist/index.js",
   "scripts": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^1.27.0",
-    "arvo-core": "^1.1.20",
+    "arvo-core": "^1.1.21",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   }

package/dist/AbstractArvoEventHandler/types.d.ts

@@ -1,20 +0,0 @@
-import { Tracer } from '@opentelemetry/api';
-/**
- * Configuration options for OpenTelemetry integration in execution context.
- *
- * This type defines how tracing should be configured and inherited within
- * the execution pipeline.
- */
-export type ExecutionOpenTelemetryConfiguration = {
-    /**
-     * 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;
-};

package/dist/AbstractArvoEventHandler/utils.d.ts

@@ -1,42 +0,0 @@
-import { SpanKind } from "@opentelemetry/api";
-import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from "arvo-core";
-import { ExecutionOpenTelemetryConfiguration } from "./types";
-/**
- * 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 {ExecutionOpenTelemetryConfiguration} opentelemetryConfig - Configuration for OpenTelemetry behavior
- */
-interface ICreateHandlerExecutionSpan {
-    spanName: string;
-    spanKinds: {
-        kind: SpanKind;
-        openInference: OpenInferenceSpanKind;
-        arvoExecution: ArvoExecutionSpanKind;
-    };
-    event: ArvoEvent;
-    opentelemetryConfig?: ExecutionOpenTelemetryConfiguration;
-}
-/**
- * Creates an OpenTelemetry span for tracking handler execution.
- *
- * This function creates a span either from an existing event or as a new span,
- * depending on the configuration. It includes attributes for both OpenInference
- * and Arvo execution span kinds.
- *
- * @param params - Parameters for creating the handler execution span
- * @param params.spanName - Name of the span to be created
- * @param params.spanKinds - Object containing different span kind classifications
- * @param params.event - The Arvo event associated with this span
- * @param params.opentelemetryConfig - OpenTelemetry configuration
- *
- * @returns A new OpenTelemetry span configured according to the parameters
- */
-export declare const createHandlerExecutionSpan: ({ spanName, spanKinds, event, opentelemetryConfig, }: ICreateHandlerExecutionSpan) => import("@opentelemetry/api").Span;
-export {};

package/dist/AbstractArvoEventHandler/utils.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHandlerExecutionSpan = void 0;
-var utils_1 = require("../OpenTelemetry/utils");
-var arvo_core_1 = require("arvo-core");
-var OpenTelemetry_1 = require("../OpenTelemetry");
-/**
- * Creates an OpenTelemetry span for tracking handler execution.
- *
- * This function creates a span either from an existing event or as a new span,
- * depending on the configuration. It includes attributes for both OpenInference
- * and Arvo execution span kinds.
- *
- * @param params - Parameters for creating the handler execution span
- * @param params.spanName - Name of the span to be created
- * @param params.spanKinds - Object containing different span kind classifications
- * @param params.event - The Arvo event associated with this span
- * @param params.opentelemetryConfig - OpenTelemetry configuration
- *
- * @returns A new OpenTelemetry span configured according to the parameters
- */
-var createHandlerExecutionSpan = function (_a) {
-    var _b;
-    var _c;
-    var spanName = _a.spanName, spanKinds = _a.spanKinds, event = _a.event, _d = _a.opentelemetryConfig, opentelemetryConfig = _d === void 0 ? {
-        inheritFrom: 'event',
-        tracer: null
-    } : _d;
-    var spanOptions = {
-        kind: spanKinds.kind,
-        attributes: (_b = {},
-            _b[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = spanKinds.openInference,
-            _b[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = spanKinds.arvoExecution,
-            _b),
-    };
-    var tracer = (_c = opentelemetryConfig.tracer) !== null && _c !== void 0 ? _c : (0, OpenTelemetry_1.fetchOpenTelemetryTracer)();
-    return opentelemetryConfig.inheritFrom === "event" ?
-        (0, utils_1.createSpanFromEvent)(spanName, event, spanKinds, tracer) :
-        tracer.startSpan(spanName, spanOptions);
-};
-exports.createHandlerExecutionSpan = createHandlerExecutionSpan;