@event-driven-io/emmett 0.43.0-beta.19 → 0.43.0-beta.20

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_plugins = require('./plugins-DB9xe8AV.cjs');
+const require_plugins = require('./plugins-iXublZYn.cjs');
 let uuid = require("uuid");
 let async_retry = require("async-retry");
 async_retry = require_plugins.__toESM(async_retry, 1);
@@ -978,6 +978,356 @@ const getInMemoryDatabase = () => {
 	} };
 };
 
+//#endregion
+//#region src/observability/attributes.ts
+const EmmettAttributes = {
+	scope: { type: "emmett.scope.type" },
+	command: {
+		type: "emmett.command.type",
+		status: "emmett.command.status",
+		eventCount: "emmett.command.event_count",
+		eventTypes: "emmett.command.event_types"
+	},
+	stream: {
+		name: "emmett.stream.name",
+		versionBefore: "emmett.stream.version.before",
+		versionAfter: "emmett.stream.version.after"
+	},
+	eventStore: {
+		operation: "emmett.eventstore.operation",
+		read: {
+			eventCount: "emmett.eventstore.read.event_count",
+			eventTypes: "emmett.eventstore.read.event_types",
+			status: "emmett.eventstore.read.status"
+		},
+		append: {
+			batchSize: "emmett.eventstore.append.batch_size",
+			status: "emmett.eventstore.append.status"
+		}
+	},
+	event: { type: "emmett.event.type" },
+	processor: {
+		id: "emmett.processor.id",
+		type: "emmett.processor.type",
+		status: "emmett.processor.status",
+		batchSize: "emmett.processor.batch_size",
+		eventTypes: "emmett.processor.event_types",
+		checkpointBefore: "emmett.processor.checkpoint.before",
+		checkpointAfter: "emmett.processor.checkpoint.after",
+		lagEvents: "emmett.processor.lag_events"
+	},
+	workflow: {
+		id: "emmett.workflow.id",
+		type: "emmett.workflow.type",
+		inputType: "emmett.workflow.input.type",
+		outputs: "emmett.workflow.outputs",
+		outputsCount: "emmett.workflow.outputs.count",
+		streamPosition: "emmett.workflow.stream_position",
+		stateRebuildEventCount: "emmett.workflow.state_rebuild.event_count"
+	},
+	consumer: {
+		batchSize: "emmett.consumer.batch_size",
+		processorCount: "emmett.consumer.processor_count",
+		delivery: { processorId: "emmett.consumer.delivery.processor_id" }
+	}
+};
+const EmmettMetrics = {
+	command: { handlingDuration: "emmett.command.handling.duration" },
+	event: {
+		appendingCount: "emmett.event.appending.count",
+		readingCount: "emmett.event.reading.count"
+	},
+	stream: {
+		readingDuration: "emmett.stream.reading.duration",
+		readingSize: "emmett.stream.reading.size",
+		appendingDuration: "emmett.stream.appending.duration",
+		appendingSize: "emmett.stream.appending.size"
+	},
+	processor: {
+		processingDuration: "emmett.processor.processing.duration",
+		lagEvents: "emmett.processor.lag_events"
+	},
+	workflow: { processingDuration: "emmett.workflow.processing.duration" },
+	consumer: {
+		pollDuration: "emmett.consumer.poll.duration",
+		deliveryDuration: "emmett.consumer.delivery.duration"
+	}
+};
+const ScopeTypes = {
+	command: "command",
+	processor: "processor",
+	reactor: "reactor",
+	projector: "projector",
+	workflow: "workflow",
+	consumer: "consumer"
+};
+const MessagingSystemName = "emmett";
+
+//#endregion
+//#region src/observability/options.ts
+const resolveConsumerObservability = (options, parent) => ({
+	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? (0, _event_driven_io_almanac.noopTracer)(),
+	meter: options?.observability?.meter ?? parent?.observability?.meter ?? (0, _event_driven_io_almanac.noopMeter)(),
+	pollTracing: options?.observability?.pollTracing ?? parent?.observability?.pollTracing ?? "off",
+	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both"
+});
+const resolveWorkflowObservability = (options, parent) => ({
+	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? (0, _event_driven_io_almanac.noopTracer)(),
+	meter: options?.observability?.meter ?? parent?.observability?.meter ?? (0, _event_driven_io_almanac.noopMeter)(),
+	propagation: options?.observability?.propagation ?? parent?.observability?.propagation ?? "links",
+	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both",
+	includeMessagePayloads: options?.observability?.includeMessagePayloads ?? parent?.observability?.includeMessagePayloads ?? false
+});
+
+//#endregion
+//#region src/observability/tracer.ts
+const tracer = () => {};
+const LogLevel = {
+	DISABLED: "DISABLED",
+	INFO: "INFO",
+	LOG: "LOG",
+	WARN: "WARN",
+	ERROR: "ERROR"
+};
+const LogStyle = {
+	RAW: "RAW",
+	PRETTY: "PRETTY"
+};
+const getEnvVariable = (name) => {
+	try {
+		if (typeof process !== "undefined" && process.env) return process.env[name];
+		return;
+	} catch {
+		return;
+	}
+};
+const shouldLog = (logLevel) => {
+	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
+	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
+	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.LOG && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG
+	].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.INFO && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG,
+		LogLevel.INFO
+	].includes(logLevel)) return true;
+	return false;
+};
+const nulloTraceEventRecorder = () => {};
+const getTraceEventFormatter = (logStyle, serializer) => (event) => {
+	serializer = serializer ?? JSONSerializer.from();
+	switch (logStyle) {
+		case "RAW": return serializer.serialize(event);
+		case "PRETTY": return serializer.serialize(event);
+	}
+};
+const getTraceEventRecorder = (logLevel, logStyle) => {
+	const format = getTraceEventFormatter(logStyle);
+	switch (logLevel) {
+		case "DISABLED": return nulloTraceEventRecorder;
+		case "INFO": return (event) => console.info(format(event));
+		case "LOG": return (event) => console.log(format(event));
+		case "WARN": return (event) => console.warn(format(event));
+		case "ERROR": return (event) => console.error(format(event));
+	}
+};
+const recordTraceEvent = (logLevel, eventName, attributes) => {
+	if (!shouldLog(LogLevel.LOG)) return;
+	const event = {
+		name: eventName,
+		timestamp: (/* @__PURE__ */ new Date()).getTime(),
+		...attributes
+	};
+	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
+};
+tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
+tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
+tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
+tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
+
+//#endregion
+//#region src/eventStore/observability/eventStoreCollector.ts
+const resolveEventStoreObservability = (options, parent) => ({
+	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? (0, _event_driven_io_almanac.noopTracer)(),
+	meter: options?.observability?.meter ?? parent?.observability?.meter ?? (0, _event_driven_io_almanac.noopMeter)(),
+	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both"
+});
+const eventStoreCollector = (observability) => {
+	const A = EmmettAttributes;
+	const M = _event_driven_io_almanac.MessagingAttributes;
+	const streamReadingDuration = observability.meter.histogram(EmmettMetrics.stream.readingDuration);
+	const streamReadingSize = observability.meter.histogram(EmmettMetrics.stream.readingSize);
+	const eventReadingCount = observability.meter.counter(EmmettMetrics.event.readingCount);
+	const streamAppendingDuration = observability.meter.histogram(EmmettMetrics.stream.appendingDuration);
+	const streamAppendingSize = observability.meter.histogram(EmmettMetrics.stream.appendingSize);
+	const eventAppendingCount = observability.meter.counter(EmmettMetrics.event.appendingCount);
+	return {
+		instrumentRead: (streamName, fn) => {
+			const start = Date.now();
+			return observability.tracer.startSpan("eventStore.readStream", async (span) => {
+				span.setAttributes({
+					[A.eventStore.operation]: "readStream",
+					[A.stream.name]: streamName,
+					[M.operation.type]: "receive",
+					[M.destination.name]: streamName,
+					[M.system]: MessagingSystemName
+				});
+				let status = "success";
+				try {
+					const result = await fn();
+					const events = result.events;
+					span.setAttributes({
+						[A.eventStore.read.status]: status,
+						[A.eventStore.read.eventCount]: events.length,
+						[A.eventStore.read.eventTypes]: [...new Set(events.map((e) => e.type))]
+					});
+					streamReadingSize.record(events.length, { [A.eventStore.read.status]: status });
+					for (const event of events) eventReadingCount.add(1, { [A.event.type]: event.type });
+					return result;
+				} catch (err) {
+					status = "failure";
+					span.setAttributes({ [A.eventStore.read.status]: status });
+					throw err;
+				} finally {
+					streamReadingDuration.record(Date.now() - start, { [A.eventStore.read.status]: status });
+				}
+			});
+		},
+		instrumentAppend: (streamName, events, fn) => {
+			const start = Date.now();
+			return observability.tracer.startSpan("eventStore.appendToStream", async (span) => {
+				span.setAttributes({
+					[A.eventStore.operation]: "appendToStream",
+					[A.stream.name]: streamName,
+					[A.eventStore.append.batchSize]: events.length,
+					[M.operation.type]: "send",
+					[M.batch.messageCount]: events.length,
+					[M.destination.name]: streamName,
+					[M.system]: MessagingSystemName
+				});
+				let status = "success";
+				try {
+					const result = await fn();
+					span.setAttributes({
+						[A.eventStore.append.status]: status,
+						[A.stream.versionAfter]: Number(result.nextExpectedStreamVersion)
+					});
+					streamAppendingSize.record(events.length, { [A.eventStore.append.status]: status });
+					for (const event of events) eventAppendingCount.add(1, { [A.event.type]: event.type });
+					return result;
+				} catch (err) {
+					status = "failure";
+					span.setAttributes({ [A.eventStore.append.status]: status });
+					throw err;
+				} finally {
+					streamAppendingDuration.record(Date.now() - start, { [A.eventStore.append.status]: status });
+				}
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/observability/collectors/consumerCollector.ts
+const consumerCollector = (observability) => {
+	const { startScope } = (0, _event_driven_io_almanac.ObservabilityScope)({
+		...observability,
+		attributePrefix: "emmett"
+	});
+	const A = EmmettAttributes;
+	const M = _event_driven_io_almanac.MessagingAttributes;
+	const pollDuration = observability.meter.histogram(EmmettMetrics.consumer.pollDuration);
+	const deliveryDuration = observability.meter.histogram(EmmettMetrics.consumer.deliveryDuration);
+	return {
+		tracePoll: (context, fn) => {
+			if (observability.pollTracing === "off" || observability.pollTracing === "active" && context.batchSize === 0) return fn(_event_driven_io_almanac.noopScope);
+			return startScope("consumer.poll", async (scope) => {
+				scope.setAttributes({
+					[A.scope.type]: ScopeTypes.consumer,
+					[A.consumer.batchSize]: context.batchSize,
+					[A.consumer.processorCount]: context.processorCount,
+					[M.system]: MessagingSystemName,
+					[M.operation.type]: "receive",
+					...context.empty ? { "emmett.consumer.poll.empty": true } : {},
+					...context.waitMs != null ? { "emmett.consumer.poll.wait_ms": context.waitMs } : {}
+				});
+				return fn(scope);
+			});
+		},
+		recordPollMetrics: (durationMs, attrs) => {
+			pollDuration.record(durationMs, attrs);
+		},
+		traceDelivery: (scope, processorId, fn) => {
+			const start = Date.now();
+			return scope.scope(`consumer.deliver.${processorId}`, async (child) => {
+				try {
+					return await fn();
+				} catch (error) {
+					if (error instanceof Error) child.recordException(error);
+					throw error;
+				} finally {
+					deliveryDuration.record(Date.now() - start, { [A.consumer.delivery.processorId]: processorId });
+				}
+			}, { attributes: { [A.consumer.delivery.processorId]: processorId } });
+		}
+	};
+};
+
+//#endregion
+//#region src/observability/collectors/workflowCollector.ts
+const workflowCollector = (observability) => {
+	const { startScope } = (0, _event_driven_io_almanac.ObservabilityScope)({
+		...observability,
+		attributePrefix: "emmett"
+	});
+	const A = EmmettAttributes;
+	const M = _event_driven_io_almanac.MessagingAttributes;
+	const processingDuration = observability.meter.histogram(EmmettMetrics.workflow.processingDuration);
+	return {
+		startScope: (context, fn) => {
+			const start = Date.now();
+			return startScope("workflow.handle", async (scope) => {
+				scope.setAttributes({
+					[A.scope.type]: ScopeTypes.workflow,
+					[A.workflow.id]: context.workflowId,
+					[A.workflow.type]: context.workflowType,
+					[A.workflow.inputType]: context.inputType,
+					[M.system]: MessagingSystemName
+				});
+				let status = "success";
+				try {
+					return await fn(scope);
+				} catch (err) {
+					status = "failure";
+					throw err;
+				} finally {
+					processingDuration.record(Date.now() - start, {
+						[A.workflow.type]: context.workflowType,
+						status
+					});
+				}
+			}, { attributes: {
+				[A.scope.type]: ScopeTypes.workflow,
+				[A.workflow.type]: context.workflowType
+			} });
+		},
+		recordOutputs: (scope, outputs) => {
+			scope.setAttributes({
+				[A.workflow.outputs]: outputs.map((o) => o.type),
+				[A.workflow.outputsCount]: outputs.length
+			});
+		},
+		recordStateRebuild: (scope, eventCount) => {
+			scope.setAttributes({ [A.workflow.stateRebuildEventCount]: eventCount });
+		}
+	};
+};
+
 //#endregion
 //#region src/processors/checkpoints.ts
 const ProcessorCheckpoint = (checkpoint) => checkpoint;
@@ -987,6 +1337,88 @@ const getCheckpoint = (message) => {
 	return message.metadata.checkpoint;
 };
 
+//#endregion
+//#region src/processors/observability/processorCollector.ts
+const resolveProcessorObservability = (options, parent) => ({
+	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? (0, _event_driven_io_almanac.noopTracer)(),
+	meter: options?.observability?.meter ?? parent?.observability?.meter ?? (0, _event_driven_io_almanac.noopMeter)(),
+	propagation: options?.observability?.propagation ?? parent?.observability?.propagation ?? "links",
+	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both",
+	includeMessagePayloads: options?.observability?.includeMessagePayloads ?? parent?.observability?.includeMessagePayloads ?? false
+});
+const processorCollector = (observability) => {
+	const { startScope } = (0, _event_driven_io_almanac.ObservabilityScope)({
+		...observability,
+		attributePrefix: "emmett"
+	});
+	const A = EmmettAttributes;
+	const M = _event_driven_io_almanac.MessagingAttributes;
+	const processingDuration = observability.meter.histogram(EmmettMetrics.processor.processingDuration);
+	const lagEvents = observability.meter.gauge(EmmettMetrics.processor.lagEvents);
+	return {
+		startScope: (context, messages, fn) => {
+			const sourceLinks = messages.filter((m) => m.metadata?.traceId && m.metadata?.spanId).reduce((acc, m) => {
+				const meta = m.metadata;
+				const link = {
+					traceId: meta.traceId,
+					spanId: meta.spanId
+				};
+				return acc.some((l) => l.traceId === link.traceId && l.spanId === link.spanId) ? acc : [...acc, link];
+			}, []);
+			const start = Date.now();
+			return startScope("processor.handle", async (scope) => {
+				scope.setAttributes({
+					[A.scope.type]: ScopeTypes.processor,
+					[A.processor.id]: context.processorId,
+					[A.processor.type]: context.type,
+					[A.processor.batchSize]: messages.length,
+					[A.processor.eventTypes]: [...new Set(messages.map((m) => m.type))],
+					[M.system]: MessagingSystemName,
+					[M.batch.messageCount]: messages.length,
+					...context.checkpoint ? { [A.processor.checkpointBefore]: context.checkpoint } : {}
+				});
+				let status = "success";
+				try {
+					return await fn(scope);
+				} catch (err) {
+					status = "failure";
+					throw err;
+				} finally {
+					processingDuration.record(Date.now() - start, {
+						[A.processor.id]: context.processorId,
+						[A.processor.type]: context.type,
+						[A.processor.status]: status
+					});
+				}
+			}, { links: sourceLinks });
+		},
+		startMessageScope: (context, message, batchCtx, fn) => {
+			const meta = message.metadata;
+			const parent = meta?.traceId && meta?.spanId ? {
+				traceId: meta.traceId,
+				spanId: meta.spanId
+			} : void 0;
+			const links = batchCtx.traceId ? [batchCtx] : [];
+			return startScope(`processor.message.${message.type}`, async (scope) => {
+				scope.setAttributes({
+					[A.scope.type]: context.archetypeType,
+					[A.processor.id]: context.processorId,
+					[A.processor.type]: context.type,
+					[M.operation.type]: "process",
+					...meta?.messageId ? { [M.message.id]: meta.messageId } : {}
+				});
+				return fn(scope);
+			}, {
+				parent,
+				links
+			});
+		},
+		recordLag: (processorId, lag) => {
+			lagEvents.record(lag, { [A.processor.id]: processorId });
+		}
+	};
+};
+
 //#endregion
 //#region src/processors/processors.ts
 const wasMessageHandled = (message, checkpoint) => {
@@ -1007,19 +1439,32 @@ const MessageProcessor = { result: {
 		...options ?? {}
 	})
 } };
-const defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+const defaultProcessingMessageProcessingScope = (handler, partialContext) => handler({
+	...partialContext,
+	observabilityScope: partialContext.observabilityScope ?? _event_driven_io_almanac.noopScope
+});
 const defaultProcessorVersion = 1;
 const defaultProcessorPartition = defaultTag;
 const getProcessorInstanceId = (processorId) => `${processorId}:${(0, uuid.v7)()}`;
 const getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
 const reactor = (options) => {
 	const { checkpoints, processorId, processorInstanceId: instanceId = getProcessorInstanceId(processorId), type = MessageProcessorType.REACTOR, version = 1, partition = defaultProcessorPartition, hooks = {}, processingScope = defaultProcessingMessageProcessingScope, startFrom, canHandle, stopAfter } = options;
+	const collector = processorCollector(resolveProcessorObservability(options));
 	const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
 	const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
+		const batchCtx = context.observabilityScope.spanContext();
 		let result = void 0;
 		for (let i = 0; i < messages.length; i++) {
 			const message = messages[i];
-			const messageProcessingResult = await options.eachMessage(message, context);
+			const messageProcessingResult = await collector.startMessageScope({
+				processorId,
+				type,
+				checkpoint: lastCheckpoint,
+				archetypeType: type
+			}, message, batchCtx, (messageScope) => Promise.resolve(options.eachMessage(message, {
+				...context,
+				observabilityScope: messageScope
+			})));
 			if (messageProcessingResult && messageProcessingResult.type === "STOP") {
 				result = {
 					...messageProcessingResult,
@@ -1073,8 +1518,19 @@ const reactor = (options) => {
 		instanceId,
 		type,
 		canHandle,
-		init,
-		start: async (startOptions) => {
+		init: async (partialOptions) => {
+			partialOptions ??= {};
+			await init({
+				...partialOptions,
+				observabilityScope: ("observabilityScope" in partialOptions ? partialOptions.observabilityScope ?? _event_driven_io_almanac.noopScope : _event_driven_io_almanac.noopScope) ?? _event_driven_io_almanac.noopScope
+			});
+		},
+		start: async (partialOptions) => {
+			partialOptions ??= {};
+			const startOptions = {
+				...partialOptions,
+				observabilityScope: ("observabilityScope" in partialOptions ? partialOptions.observabilityScope ?? _event_driven_io_almanac.noopScope : _event_driven_io_almanac.noopScope) ?? _event_driven_io_almanac.noopScope
+			};
 			if (isActive) {
 				console.log(`Processor ${processorId} with instance id ${instanceId} is already active. Start request ignored.`);
 				return;
@@ -1111,50 +1567,69 @@ const reactor = (options) => {
 				return { lastCheckpoint };
 			}, startOptions);
 		},
-		close,
+		close: async (partialOptions) => {
+			partialOptions ??= {};
+			await close({
+				...partialOptions,
+				observabilityScope: ("observabilityScope" in partialOptions ? partialOptions.observabilityScope ?? _event_driven_io_almanac.noopScope : _event_driven_io_almanac.noopScope) ?? _event_driven_io_almanac.noopScope
+			});
+		},
 		get isActive() {
 			return isActive;
 		},
 		handle: async (messages, partialContext) => {
 			if (!isActive) return Promise.resolve();
-			try {
-				return await processingScope(async (context) => {
-					const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
-					const upcastedMessages = messagesAboveCheckpoint.map((message) => upcastRecordedMessage(message, options.messageOptions?.schema?.versioning)).filter((upcasted) => !canHandle || canHandle.includes(upcasted.type));
-					const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
-					const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
-					const batchResult = await eachBatch(unhandledMessages, context);
-					const messageProcessingResult = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+			return collector.startScope({
+				processorId,
+				type,
+				checkpoint: lastCheckpoint
+			}, messages, async (scope) => {
+				try {
+					return await processingScope(async (context) => {
+						const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
+						const upcastedMessages = messagesAboveCheckpoint.map((message) => upcastRecordedMessage(message, options.messageOptions?.schema?.versioning)).filter((upcasted) => !canHandle || canHandle.includes(upcasted.type));
+						const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
+						const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
+						const batchResult = await eachBatch(unhandledMessages, {
+							...context,
+							observabilityScope: scope
+						});
+						const messageProcessingResult = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+							type: "STOP",
+							reason: "Stop condition reached",
+							lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+						} : batchResult;
+						const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
+						const checkpointMessage = messageProcessingResult?.type === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
+						if (checkpointMessage && checkpoints) {
+							const storeCheckpointResult = await checkpoints.store({
+								processorId,
+								version,
+								message: checkpointMessage,
+								lastCheckpoint,
+								partition
+							}, context);
+							if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
+						}
+						scope.setAttributes({ [EmmettAttributes.processor.status]: messageProcessingResult?.type ?? "ack" });
+						if (isStop) {
+							isActive = false;
+							return messageProcessingResult;
+						}
+					}, {
+						...partialContext,
+						observabilityScope: scope
+					});
+				} catch (error) {
+					console.log(`Error during message processing for processor ${processorId} with instance id ${instanceId}. Stopping the processor.`, error);
+					isActive = false;
+					return {
 						type: "STOP",
-						reason: "Stop condition reached",
-						lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
-					} : batchResult;
-					const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
-					const checkpointMessage = messageProcessingResult?.type === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
-					if (checkpointMessage && checkpoints) {
-						const storeCheckpointResult = await checkpoints.store({
-							processorId,
-							version,
-							message: checkpointMessage,
-							lastCheckpoint,
-							partition
-						}, context);
-						if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
-					}
-					if (isStop) {
-						isActive = false;
-						return messageProcessingResult;
-					}
-				}, partialContext);
-			} catch (error) {
-				console.log(`Error during message processing for processor ${processorId} with instance id ${instanceId}. Stopping the processor.`, error);
-				isActive = false;
-				return {
-					type: "STOP",
-					error,
-					reason: "Error during message processing"
-				};
-			}
+						error,
+						reason: "Error during message processing"
+					};
+				}
+			});
 		}
 	};
 };
@@ -1174,7 +1649,7 @@ const projector = (options) => {
 			} : void 0,
 			onClose: options.hooks?.onClose
 		},
-		eachBatch: async (events, context) => projection.handle(events, context)
+		eachBatch: (events, context) => projection.handle(events, context)
 	});
 };
 
@@ -1266,13 +1741,15 @@ const DATABASE_REQUIRED_ERROR_MESSAGE = "Database is required in context for InM
 * Similar to the PostgreSQL implementation, this processes events through projections
 */
 const handleInMemoryProjections = async (options) => {
-	const { projections, events, database, eventStore } = options;
+	const { projections, events, database, eventStore, observability } = options;
 	const eventTypes = events.map((e) => e.type);
 	const relevantProjections = projections.filter((p) => p.canHandle.some((type) => eventTypes.includes(type)));
-	for (const projection of relevantProjections) await projection.handle(events, {
+	const { startScope } = (0, _event_driven_io_almanac.ObservabilityScope)(observability);
+	for (const projection of relevantProjections) await startScope("eventStore.inlineProjection", async (observabilityScope) => projection.handle(events, {
 		eventStore,
-		database
-	});
+		database,
+		observabilityScope
+	}));
 };
 /**
 * Creates an InMemory projection
@@ -1704,7 +2181,8 @@ const InMemoryProjectionSpec = { for: (options) => {
 						streamExists: async () => {
 							return Promise.resolve(false);
 						}
-					}
+					},
+					observability: resolveEventStoreObservability(void 0)
 				});
 			};
 			return {
@@ -1819,6 +2297,8 @@ const getInMemoryEventStore = (eventStoreOptions) => {
 	};
 	const database = eventStoreOptions?.database || getInMemoryDatabase();
 	const inlineProjections = (eventStoreOptions?.projections ?? []).filter(({ type }) => type === "inline").map(({ projection }) => projection);
+	const observability = resolveEventStoreObservability(eventStoreOptions);
+	const collector = eventStoreCollector(observability);
 	const eventStore = {
 		database,
 		async aggregateStream(streamName, options) {
@@ -1832,55 +2312,62 @@ const getInMemoryEventStore = (eventStoreOptions) => {
 				streamExists: result.streamExists
 			};
 		},
-		readStream: (streamName, readOptions) => {
+		readStream: (streamName, readOptions) => collector.instrumentRead(streamName, () => {
 			const events = streams.get(streamName);
 			const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
 			assertExpectedVersionMatchesCurrent(currentStreamVersion, readOptions?.expectedStreamVersion, InMemoryEventStoreDefaultStreamVersion);
 			const from = Number(readOptions?.from ?? 0);
 			const to = Number(readOptions?.to ?? (readOptions?.maxCount ? (readOptions.from ?? 0n) + readOptions.maxCount : events?.length ?? 1));
-			const result = {
+			const resultEvents = events !== void 0 && events.length > 0 ? upcastRecordedMessages(events.slice(from, to), readOptions?.schema?.versioning) : [];
+			return Promise.resolve({
 				currentStreamVersion,
-				events: events !== void 0 && events.length > 0 ? upcastRecordedMessages(events.slice(from, to), readOptions?.schema?.versioning) : [],
+				events: resultEvents,
 				streamExists: events !== void 0 && events.length > 0
-			};
-			return Promise.resolve(result);
-		},
-		appendToStream: async (streamName, events, options) => {
+			});
+		}),
+		appendToStream: (streamName, events, options) => {
 			const currentEvents = streams.get(streamName) ?? [];
 			const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
-			assertExpectedVersionMatchesCurrent(currentStreamVersion, options?.expectedStreamVersion, InMemoryEventStoreDefaultStreamVersion);
-			const newEvents = events.map((event, index) => {
-				const globalPosition = BigInt(getAllEventsCount() + index + 1);
-				const metadata = {
-					streamName,
-					messageId: (0, uuid.v4)(),
-					streamPosition: BigInt(currentEvents.length + index + 1),
-					globalPosition: bigIntProcessorCheckpoint(globalPosition),
-					checkpoint: bigIntProcessorCheckpoint(globalPosition)
-				};
-				return {
-					...event,
-					kind: event.kind ?? "Event",
-					metadata: {
-						..."metadata" in event ? event.metadata ?? {} : {},
-						...metadata
-					}
+			return collector.instrumentAppend(streamName, events, async () => {
+				assertExpectedVersionMatchesCurrent(currentStreamVersion, options?.expectedStreamVersion, InMemoryEventStoreDefaultStreamVersion);
+				const newEvents = events.map((event, index) => {
+					const globalPosition = BigInt(getAllEventsCount() + index + 1);
+					const metadata = {
+						streamName,
+						messageId: (0, uuid.v4)(),
+						streamPosition: BigInt(currentEvents.length + index + 1),
+						globalPosition: bigIntProcessorCheckpoint(globalPosition),
+						checkpoint: bigIntProcessorCheckpoint(globalPosition),
+						...options?.correlationId ? { correlationId: options.correlationId } : {},
+						...options?.causationId ? { causationId: options.causationId } : {},
+						...options?.traceId ? { traceId: options.traceId } : {},
+						...options?.spanId ? { spanId: options.spanId } : {}
+					};
+					return {
+						...event,
+						kind: event.kind ?? "Event",
+						metadata: {
+							..."metadata" in event ? event.metadata ?? {} : {},
+							...metadata
+						}
+					};
+				});
+				const positionOfLastEventInTheStream = BigInt(newEvents.slice(-1)[0].metadata.streamPosition);
+				streams.set(streamName, [...currentEvents, ...downcastRecordedMessages(newEvents, options?.schema?.versioning)]);
+				if (inlineProjections.length > 0) await handleInMemoryProjections({
+					projections: inlineProjections,
+					events: newEvents,
+					database: eventStore.database,
+					eventStore,
+					observability
+				});
+				const result = {
+					nextExpectedStreamVersion: positionOfLastEventInTheStream,
+					createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
 				};
+				await tryPublishMessagesAfterCommit(newEvents, eventStoreOptions?.hooks);
+				return result;
 			});
-			const positionOfLastEventInTheStream = BigInt(newEvents.slice(-1)[0].metadata.streamPosition);
-			streams.set(streamName, [...currentEvents, ...downcastRecordedMessages(newEvents, options?.schema?.versioning)]);
-			if (inlineProjections.length > 0) await handleInMemoryProjections({
-				projections: inlineProjections,
-				events: newEvents,
-				database: eventStore.database,
-				eventStore
-			});
-			const result = {
-				nextExpectedStreamVersion: positionOfLastEventInTheStream,
-				createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
-			};
-			await tryPublishMessagesAfterCommit(newEvents, eventStoreOptions?.hooks);
-			return result;
 		},
 		streamExists: (streamName) => {
 			const events = streams.get(streamName);
@@ -1891,168 +2378,13 @@ const getInMemoryEventStore = (eventStoreOptions) => {
 };
 
 //#endregion
-//#region src/observability/attributes.ts
-const EmmettAttributes = {
-	scope: { type: "emmett.scope.type" },
-	command: {
-		type: "emmett.command.type",
-		status: "emmett.command.status",
-		eventCount: "emmett.command.event_count",
-		eventTypes: "emmett.command.event_types"
-	},
-	stream: {
-		name: "emmett.stream.name",
-		versionBefore: "emmett.stream.version.before",
-		versionAfter: "emmett.stream.version.after"
-	},
-	eventStore: {
-		operation: "emmett.eventstore.operation",
-		read: {
-			eventCount: "emmett.eventstore.read.event_count",
-			eventTypes: "emmett.eventstore.read.event_types",
-			status: "emmett.eventstore.read.status"
-		},
-		append: {
-			batchSize: "emmett.eventstore.append.batch_size",
-			status: "emmett.eventstore.append.status"
-		}
-	},
-	event: { type: "emmett.event.type" },
-	processor: {
-		id: "emmett.processor.id",
-		type: "emmett.processor.type",
-		status: "emmett.processor.status",
-		batchSize: "emmett.processor.batch_size",
-		eventTypes: "emmett.processor.event_types",
-		checkpointBefore: "emmett.processor.checkpoint.before",
-		checkpointAfter: "emmett.processor.checkpoint.after",
-		lagEvents: "emmett.processor.lag_events"
-	},
-	workflow: {
-		id: "emmett.workflow.id",
-		type: "emmett.workflow.type",
-		inputType: "emmett.workflow.input.type",
-		outputs: "emmett.workflow.outputs",
-		outputsCount: "emmett.workflow.outputs.count",
-		streamPosition: "emmett.workflow.stream_position",
-		stateRebuildEventCount: "emmett.workflow.state_rebuild.event_count"
-	},
-	consumer: {
-		batchSize: "emmett.consumer.batch_size",
-		processorCount: "emmett.consumer.processor_count",
-		delivery: { processorId: "emmett.consumer.delivery.processor_id" }
-	}
-};
-const EmmettMetrics = {
-	command: { handlingDuration: "emmett.command.handling.duration" },
-	event: {
-		appendingCount: "emmett.event.appending.count",
-		readingCount: "emmett.event.reading.count"
-	},
-	stream: {
-		readingDuration: "emmett.stream.reading.duration",
-		readingSize: "emmett.stream.reading.size",
-		appendingDuration: "emmett.stream.appending.duration",
-		appendingSize: "emmett.stream.appending.size"
-	},
-	processor: {
-		processingDuration: "emmett.processor.processing.duration",
-		lagEvents: "emmett.processor.lag_events"
-	},
-	workflow: { processingDuration: "emmett.workflow.processing.duration" },
-	consumer: {
-		pollDuration: "emmett.consumer.poll.duration",
-		deliveryDuration: "emmett.consumer.delivery.duration"
-	}
-};
-const ScopeTypes = {
-	command: "command",
-	processor: "processor",
-	reactor: "reactor",
-	projector: "projector",
-	workflow: "workflow",
-	consumer: "consumer"
-};
-const MessagingSystemName = "emmett";
-
-//#endregion
-//#region src/observability/options.ts
+//#region src/commandHandling/observability/commandHandlerCollector.ts
 const resolveCommandObservability = (options, parent) => ({
 	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? (0, _event_driven_io_almanac.noopTracer)(),
 	meter: options?.observability?.meter ?? parent?.observability?.meter ?? (0, _event_driven_io_almanac.noopMeter)(),
 	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both",
 	includeMessagePayloads: options?.observability?.includeMessagePayloads ?? parent?.observability?.includeMessagePayloads ?? false
 });
-
-//#endregion
-//#region src/observability/tracer.ts
-const tracer = () => {};
-const LogLevel = {
-	DISABLED: "DISABLED",
-	INFO: "INFO",
-	LOG: "LOG",
-	WARN: "WARN",
-	ERROR: "ERROR"
-};
-const getEnvVariable = (name) => {
-	try {
-		if (typeof process !== "undefined" && process.env) return process.env[name];
-		return;
-	} catch {
-		return;
-	}
-};
-const shouldLog = (logLevel) => {
-	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
-	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
-	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.LOG && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG
-	].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.INFO && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG,
-		LogLevel.INFO
-	].includes(logLevel)) return true;
-	return false;
-};
-const nulloTraceEventRecorder = () => {};
-const getTraceEventFormatter = (logStyle, serializer) => (event) => {
-	serializer = serializer ?? JSONSerializer.from();
-	switch (logStyle) {
-		case "RAW": return serializer.serialize(event);
-		case "PRETTY": return serializer.serialize(event);
-	}
-};
-const getTraceEventRecorder = (logLevel, logStyle) => {
-	const format = getTraceEventFormatter(logStyle);
-	switch (logLevel) {
-		case "DISABLED": return nulloTraceEventRecorder;
-		case "INFO": return (event) => console.info(format(event));
-		case "LOG": return (event) => console.log(format(event));
-		case "WARN": return (event) => console.warn(format(event));
-		case "ERROR": return (event) => console.error(format(event));
-	}
-};
-const recordTraceEvent = (logLevel, eventName, attributes) => {
-	if (!shouldLog(LogLevel.LOG)) return;
-	const event = {
-		name: eventName,
-		timestamp: (/* @__PURE__ */ new Date()).getTime(),
-		...attributes
-	};
-	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
-};
-tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
-tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
-tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
-tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
-
-//#endregion
-//#region src/commandHandling/observability/commandHandlerCollector.ts
 const commandHandlerCollector = (observability) => {
 	const { startScope } = (0, _event_driven_io_almanac.ObservabilityScope)({
 		...observability,
@@ -2373,82 +2705,95 @@ const createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcess
 	};
 };
 const workflowStreamName = ({ workflowName, workflowId }) => `emt:workflow:${workflowName}:${workflowId}`;
-const WorkflowHandler = (options) => async (store, message, handleOptions) => asyncRetry(async () => {
-	return await withSession(store, async ({ eventStore }) => {
-		const { workflow: { evolve, initialState, decide, name: workflowName }, getWorkflowId } = options;
-		const inputMessageId = ("metadata" in message && message.metadata?.messageId ? message.metadata.messageId : void 0) ?? (0, uuid.v7)();
-		const messageWithMetadata = {
-			...message,
-			metadata: {
-				messageId: inputMessageId,
-				...message.metadata
+const WorkflowHandler = (options) => async (store, message, handleOptions) => {
+	const collector = workflowCollector(resolveWorkflowObservability(options));
+	const workflowType = options.workflow.name;
+	const inputType = message.type;
+	const workflowId = options.getWorkflowId(message) ?? "";
+	return asyncRetry(() => collector.startScope({
+		workflowId,
+		workflowType,
+		inputType
+	}, async (scope) => {
+		return await withSession(store, async ({ eventStore }) => {
+			const { workflow: { evolve, initialState, decide, name: workflowName }, getWorkflowId } = options;
+			const inputMessageId = ("metadata" in message && message.metadata?.messageId ? message.metadata.messageId : void 0) ?? (0, uuid.v7)();
+			const messageWithMetadata = {
+				...message,
+				metadata: {
+					messageId: inputMessageId,
+					...message.metadata
+				}
+			};
+			const workflowId = getWorkflowId(messageWithMetadata);
+			if (!workflowId) return emptyHandlerResult();
+			const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
+				workflowName,
+				workflowId
+			});
+			const messageType = messageWithMetadata.type;
+			const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
+			if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
+				const inputMetadata = createInputMetadata(inputMessageId, "InitiatedBy");
+				const inputToStore = {
+					type: `${workflowName}:${messageWithMetadata.type}`,
+					data: messageWithMetadata.data,
+					kind: messageWithMetadata.kind,
+					metadata: inputMetadata
+				};
+				return {
+					...await eventStore.appendToStream(streamName, [inputToStore], {
+						...handleOptions,
+						expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+					}),
+					newMessages: []
+				};
 			}
-		};
-		const workflowId = getWorkflowId(messageWithMetadata);
-		if (!workflowId) return emptyHandlerResult();
-		const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
-			workflowName,
-			workflowId
-		});
-		const messageType = messageWithMetadata.type;
-		const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
-		if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
-			const inputMetadata = createInputMetadata(inputMessageId, "InitiatedBy");
+			const wrappedInitialState = createWrappedInitialState(initialState);
+			const wrappedEvolve = createWrappedEvolve(evolve, workflowName, options.separateInputInboxFromProcessing ?? false);
+			const aggregationResult = await eventStore.aggregateStream(streamName, {
+				evolve: wrappedEvolve,
+				initialState: wrappedInitialState,
+				read: {
+					...handleOptions,
+					expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+				}
+			});
+			const { currentStreamVersion } = aggregationResult;
+			collector.recordStateRebuild(scope, Number(currentStreamVersion));
+			const { userState: state, processedInputIds } = aggregationResult.state;
+			if (processedInputIds.has(inputMessageId)) return emptyHandlerResult(currentStreamVersion);
+			const result = decide(hasWorkflowPrefix ? {
+				...messageWithMetadata,
+				type: messageType.replace(`${workflowName}:`, "")
+			} : messageWithMetadata, state);
+			const inputMetadata = createInputMetadata(inputMessageId, aggregationResult.streamExists ? "Received" : "InitiatedBy");
 			const inputToStore = {
 				type: `${workflowName}:${messageWithMetadata.type}`,
 				data: messageWithMetadata.data,
 				kind: messageWithMetadata.kind,
 				metadata: inputMetadata
 			};
+			const outputMessages = (Array.isArray(result) ? result : [result]).filter((msg) => msg !== void 0 && msg !== null);
+			const outputCommandTypes = options.outputs?.commands ?? [];
+			const taggedOutputMessages = outputMessages.map((msg) => {
+				return tagOutputMessage(msg, outputCommandTypes.includes(msg.type) ? "Sent" : "Published");
+			});
+			const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
+			if (messagesToAppend.length === 0) return emptyHandlerResult(currentStreamVersion);
+			const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
+			const appendResult = await eventStore.appendToStream(streamName, messagesToAppend, {
+				...handleOptions,
+				expectedStreamVersion
+			});
+			collector.recordOutputs(scope, outputMessages);
 			return {
-				...await eventStore.appendToStream(streamName, [inputToStore], {
-					...handleOptions,
-					expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
-				}),
-				newMessages: []
+				...appendResult,
+				newMessages: outputMessages
 			};
-		}
-		const wrappedInitialState = createWrappedInitialState(initialState);
-		const wrappedEvolve = createWrappedEvolve(evolve, workflowName, options.separateInputInboxFromProcessing ?? false);
-		const aggregationResult = await eventStore.aggregateStream(streamName, {
-			evolve: wrappedEvolve,
-			initialState: wrappedInitialState,
-			read: {
-				...handleOptions,
-				expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
-			}
-		});
-		const { currentStreamVersion } = aggregationResult;
-		const { userState: state, processedInputIds } = aggregationResult.state;
-		if (processedInputIds.has(inputMessageId)) return emptyHandlerResult(currentStreamVersion);
-		const result = decide(hasWorkflowPrefix ? {
-			...messageWithMetadata,
-			type: messageType.replace(`${workflowName}:`, "")
-		} : messageWithMetadata, state);
-		const inputMetadata = createInputMetadata(inputMessageId, aggregationResult.streamExists ? "Received" : "InitiatedBy");
-		const inputToStore = {
-			type: `${workflowName}:${messageWithMetadata.type}`,
-			data: messageWithMetadata.data,
-			kind: messageWithMetadata.kind,
-			metadata: inputMetadata
-		};
-		const outputMessages = (Array.isArray(result) ? result : [result]).filter((msg) => msg !== void 0 && msg !== null);
-		const outputCommandTypes = options.outputs?.commands ?? [];
-		const taggedOutputMessages = outputMessages.map((msg) => {
-			return tagOutputMessage(msg, outputCommandTypes.includes(msg.type) ? "Sent" : "Published");
 		});
-		const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
-		if (messagesToAppend.length === 0) return emptyHandlerResult(currentStreamVersion);
-		const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
-		return {
-			...await eventStore.appendToStream(streamName, messagesToAppend, {
-				...handleOptions,
-				expectedStreamVersion
-			}),
-			newMessages: outputMessages
-		};
-	});
-}, fromWorkflowHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
+	}), fromWorkflowHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
+};
 const withSession = (eventStore, callback) => {
 	return (canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore)).withSession(callback);
 };
@@ -2521,6 +2866,174 @@ const workflowProcessor = (options) => {
 	});
 };
 
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ require_plugins.__exportAll({
+	AssertionError: () => AssertionError,
+	CommandHandler: () => CommandHandler,
+	CommandHandlerStreamVersionConflictRetryOptions: () => CommandHandlerStreamVersionConflictRetryOptions,
+	ConcurrencyError: () => require_plugins.ConcurrencyError,
+	ConcurrencyInMemoryDatabaseError: () => require_plugins.ConcurrencyInMemoryDatabaseError,
+	DATABASE_REQUIRED_ERROR_MESSAGE: () => DATABASE_REQUIRED_ERROR_MESSAGE,
+	DeciderCommandHandler: () => DeciderCommandHandler,
+	DeciderSpecification: () => DeciderSpecification,
+	EmmettAttributes: () => EmmettAttributes,
+	EmmettError: () => require_plugins.EmmettError,
+	EmmettMetrics: () => EmmettMetrics,
+	ExpectedVersionConflictError: () => ExpectedVersionConflictError,
+	GlobalStreamCaughtUpType: () => GlobalStreamCaughtUpType,
+	IllegalStateError: () => require_plugins.IllegalStateError,
+	InMemoryEventStoreDefaultStreamVersion: () => InMemoryEventStoreDefaultStreamVersion,
+	InMemoryProjectionSpec: () => InMemoryProjectionSpec,
+	InProcessLock: () => InProcessLock,
+	JSONCodec: () => JSONCodec,
+	JSONReplacer: () => JSONReplacer,
+	JSONReplacers: () => JSONReplacers,
+	JSONReviver: () => JSONReviver,
+	JSONRevivers: () => JSONRevivers,
+	JSONSerializer: () => JSONSerializer,
+	LogLevel: () => LogLevel,
+	LogStyle: () => LogStyle,
+	MessageProcessor: () => MessageProcessor,
+	MessageProcessorType: () => MessageProcessorType,
+	MessagingSystemName: () => MessagingSystemName,
+	NO_CONCURRENCY_CHECK: () => NO_CONCURRENCY_CHECK,
+	NoRetries: () => NoRetries,
+	NotFoundError: () => require_plugins.NotFoundError,
+	ProcessorCheckpoint: () => ProcessorCheckpoint,
+	STREAM_DOES_NOT_EXIST: () => STREAM_DOES_NOT_EXIST,
+	STREAM_EXISTS: () => STREAM_EXISTS,
+	ScopeTypes: () => ScopeTypes,
+	TaskProcessor: () => TaskProcessor,
+	ValidationError: () => require_plugins.ValidationError,
+	ValidationErrors: () => require_plugins.ValidationErrors,
+	Workflow: () => Workflow,
+	WorkflowHandler: () => WorkflowHandler,
+	WorkflowHandlerStreamVersionConflictRetryOptions: () => WorkflowHandlerStreamVersionConflictRetryOptions,
+	WorkflowSpecification: () => WorkflowSpecification,
+	WrapEventStore: () => WrapEventStore,
+	argMatches: () => argMatches,
+	argValue: () => argValue,
+	arrayUtils: () => arrayUtils,
+	assertDeepEqual: () => assertDeepEqual,
+	assertDefined: () => assertDefined,
+	assertDoesNotThrow: () => assertDoesNotThrow,
+	assertEqual: () => assertEqual,
+	assertExpectedVersionMatchesCurrent: () => assertExpectedVersionMatchesCurrent,
+	assertFails: () => assertFails,
+	assertFalse: () => assertFalse,
+	assertIsNotNull: () => assertIsNotNull,
+	assertIsNull: () => assertIsNull,
+	assertMatches: () => assertMatches,
+	assertNotDeepEqual: () => assertNotDeepEqual,
+	assertNotEmptyString: () => require_plugins.assertNotEmptyString,
+	assertNotEqual: () => assertNotEqual,
+	assertOk: () => assertOk,
+	assertPositiveNumber: () => require_plugins.assertPositiveNumber,
+	assertRejects: () => assertRejects,
+	assertThat: () => assertThat,
+	assertThatArray: () => assertThatArray,
+	assertThrows: () => assertThrows,
+	assertThrowsAsync: () => assertThrowsAsync,
+	assertTrue: () => assertTrue,
+	assertUndefined: () => assertUndefined,
+	assertUnsignedBigInt: () => require_plugins.assertUnsignedBigInt,
+	asyncAwaiter: () => asyncAwaiter,
+	asyncProjections: () => asyncProjections,
+	asyncRetry: () => asyncRetry,
+	bigInt: () => bigInt,
+	bigIntProcessorCheckpoint: () => bigIntProcessorCheckpoint,
+	canCreateEventStoreSession: () => canCreateEventStoreSession,
+	caughtUpEventFrom: () => caughtUpEventFrom,
+	command: () => command,
+	composeJSONReplacers: () => composeJSONReplacers,
+	composeJSONRevivers: () => composeJSONRevivers,
+	consumerCollector: () => consumerCollector,
+	deepEquals: () => deepEquals,
+	defaultProcessingMessageProcessingScope: () => defaultProcessingMessageProcessingScope,
+	defaultProcessorPartition: () => defaultProcessorPartition,
+	defaultProcessorVersion: () => 1,
+	defaultTag: () => defaultTag,
+	delay: () => delay,
+	documentExists: () => documentExists,
+	downcastRecordedMessage: () => downcastRecordedMessage,
+	downcastRecordedMessages: () => downcastRecordedMessages,
+	emmettPrefix: () => "emt",
+	event: () => event,
+	eventInStream: () => eventInStream,
+	eventStoreCollector: () => eventStoreCollector,
+	eventsInStream: () => eventsInStream,
+	expectInMemoryDocuments: () => expectInMemoryDocuments,
+	filterProjections: () => filterProjections,
+	formatDateToUtcYYYYMMDD: () => require_plugins.formatDateToUtcYYYYMMDD,
+	forwardToMessageBus: () => forwardToMessageBus,
+	getCheckpoint: () => getCheckpoint,
+	getInMemoryDatabase: () => getInMemoryDatabase,
+	getInMemoryEventStore: () => getInMemoryEventStore,
+	getInMemoryMessageBus: () => getInMemoryMessageBus,
+	getProcessorInstanceId: () => getProcessorInstanceId,
+	getProjectorId: () => getProjectorId,
+	getWorkflowId: () => getWorkflowId,
+	globalStreamCaughtUp: () => globalStreamCaughtUp,
+	globalTag: () => globalTag,
+	guardBoundedAccess: () => guardBoundedAccess,
+	guardExclusiveAccess: () => guardExclusiveAccess,
+	guardInitializedOnce: () => guardInitializedOnce,
+	handleInMemoryProjections: () => handleInMemoryProjections,
+	hashText: () => hashText,
+	inMemoryCheckpointer: () => inMemoryCheckpointer,
+	inMemoryMultiStreamProjection: () => inMemoryMultiStreamProjection,
+	inMemoryProjection: () => inMemoryProjection,
+	inMemoryProjector: () => inMemoryProjector,
+	inMemoryReactor: () => inMemoryReactor,
+	inMemorySingleStreamProjection: () => inMemorySingleStreamProjection,
+	inlineProjections: () => inlineProjections,
+	isBigint: () => require_plugins.isBigint,
+	isEquatable: () => isEquatable,
+	isErrorConstructor: () => require_plugins.isErrorConstructor,
+	isExpectedVersionConflictError: () => isExpectedVersionConflictError,
+	isGlobalStreamCaughtUp: () => isGlobalStreamCaughtUp,
+	isNotInternalEvent: () => isNotInternalEvent,
+	isNumber: () => require_plugins.isNumber,
+	isPluginConfig: () => require_plugins.isPluginConfig,
+	isString: () => require_plugins.isString,
+	isSubscriptionEvent: () => isSubscriptionEvent,
+	isSubset: () => isSubset,
+	isValidYYYYMMDD: () => require_plugins.isValidYYYYMMDD,
+	jsonSerializer: () => jsonSerializer,
+	matchesExpectedVersion: () => matchesExpectedVersion,
+	merge: () => merge,
+	message: () => message,
+	newEventsInStream: () => newEventsInStream,
+	nulloSessionFactory: () => nulloSessionFactory,
+	onShutdown: () => onShutdown,
+	parseBigIntProcessorCheckpoint: () => parseBigIntProcessorCheckpoint,
+	parseDateFromUtcYYYYMMDD: () => require_plugins.parseDateFromUtcYYYYMMDD,
+	processorCollector: () => processorCollector,
+	projection: () => projection,
+	projections: () => projections,
+	projector: () => projector,
+	reactor: () => reactor,
+	reduceAsync: () => reduceAsync,
+	resolveConsumerObservability: () => resolveConsumerObservability,
+	resolveEventStoreObservability: () => resolveEventStoreObservability,
+	resolveProcessorObservability: () => resolveProcessorObservability,
+	resolveWorkflowObservability: () => resolveWorkflowObservability,
+	sum: () => sum,
+	toNormalizedString: () => toNormalizedString,
+	tracer: () => tracer,
+	tryPublishMessagesAfterCommit: () => tryPublishMessagesAfterCommit,
+	unknownTag: () => unknownTag,
+	upcastRecordedMessage: () => upcastRecordedMessage,
+	upcastRecordedMessages: () => upcastRecordedMessages,
+	verifyThat: () => verifyThat,
+	wasMessageHandled: () => wasMessageHandled,
+	workflowCollector: () => workflowCollector,
+	workflowOutputHandler: () => workflowOutputHandler,
+	workflowProcessor: () => workflowProcessor,
+	workflowStreamName: () => workflowStreamName
+});
+
 //#endregion
 exports.AssertionError = AssertionError;
 exports.CommandHandler = CommandHandler;
@@ -2530,7 +3043,9 @@ exports.ConcurrencyInMemoryDatabaseError = require_plugins.ConcurrencyInMemoryDa
 exports.DATABASE_REQUIRED_ERROR_MESSAGE = DATABASE_REQUIRED_ERROR_MESSAGE;
 exports.DeciderCommandHandler = DeciderCommandHandler;
 exports.DeciderSpecification = DeciderSpecification;
+exports.EmmettAttributes = EmmettAttributes;
 exports.EmmettError = require_plugins.EmmettError;
+exports.EmmettMetrics = EmmettMetrics;
 exports.ExpectedVersionConflictError = ExpectedVersionConflictError;
 exports.GlobalStreamCaughtUpType = GlobalStreamCaughtUpType;
 exports.IllegalStateError = require_plugins.IllegalStateError;
@@ -2543,14 +3058,18 @@ exports.JSONReplacers = JSONReplacers;
 exports.JSONReviver = JSONReviver;
 exports.JSONRevivers = JSONRevivers;
 exports.JSONSerializer = JSONSerializer;
+exports.LogLevel = LogLevel;
+exports.LogStyle = LogStyle;
 exports.MessageProcessor = MessageProcessor;
 exports.MessageProcessorType = MessageProcessorType;
+exports.MessagingSystemName = MessagingSystemName;
 exports.NO_CONCURRENCY_CHECK = NO_CONCURRENCY_CHECK;
 exports.NoRetries = NoRetries;
 exports.NotFoundError = require_plugins.NotFoundError;
 exports.ProcessorCheckpoint = ProcessorCheckpoint;
 exports.STREAM_DOES_NOT_EXIST = STREAM_DOES_NOT_EXIST;
 exports.STREAM_EXISTS = STREAM_EXISTS;
+exports.ScopeTypes = ScopeTypes;
 exports.TaskProcessor = TaskProcessor;
 exports.ValidationError = require_plugins.ValidationError;
 exports.ValidationErrors = require_plugins.ValidationErrors;
@@ -2595,6 +3114,7 @@ exports.caughtUpEventFrom = caughtUpEventFrom;
 exports.command = command;
 exports.composeJSONReplacers = composeJSONReplacers;
 exports.composeJSONRevivers = composeJSONRevivers;
+exports.consumerCollector = consumerCollector;
 exports.deepEquals = deepEquals;
 exports.defaultProcessingMessageProcessingScope = defaultProcessingMessageProcessingScope;
 exports.defaultProcessorPartition = defaultProcessorPartition;
@@ -2607,6 +3127,7 @@ exports.downcastRecordedMessages = downcastRecordedMessages;
 exports.emmettPrefix = emmettPrefix;
 exports.event = event;
 exports.eventInStream = eventInStream;
+exports.eventStoreCollector = eventStoreCollector;
 exports.eventsInStream = eventsInStream;
 exports.expectInMemoryDocuments = expectInMemoryDocuments;
 exports.filterProjections = filterProjections;
@@ -2654,20 +3175,34 @@ exports.nulloSessionFactory = nulloSessionFactory;
 exports.onShutdown = onShutdown;
 exports.parseBigIntProcessorCheckpoint = parseBigIntProcessorCheckpoint;
 exports.parseDateFromUtcYYYYMMDD = require_plugins.parseDateFromUtcYYYYMMDD;
+exports.processorCollector = processorCollector;
 exports.projection = projection;
 exports.projections = projections;
 exports.projector = projector;
 exports.reactor = reactor;
 exports.reduceAsync = reduceAsync;
+exports.resolveConsumerObservability = resolveConsumerObservability;
+exports.resolveEventStoreObservability = resolveEventStoreObservability;
+exports.resolveProcessorObservability = resolveProcessorObservability;
+exports.resolveWorkflowObservability = resolveWorkflowObservability;
 exports.sum = sum;
 exports.toNormalizedString = toNormalizedString;
+exports.tracer = tracer;
 exports.tryPublishMessagesAfterCommit = tryPublishMessagesAfterCommit;
 exports.unknownTag = unknownTag;
 exports.upcastRecordedMessage = upcastRecordedMessage;
 exports.upcastRecordedMessages = upcastRecordedMessages;
 exports.verifyThat = verifyThat;
 exports.wasMessageHandled = wasMessageHandled;
+exports.workflowCollector = workflowCollector;
 exports.workflowOutputHandler = workflowOutputHandler;
 exports.workflowProcessor = workflowProcessor;
 exports.workflowStreamName = workflowStreamName;
+Object.keys(_event_driven_io_almanac).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _event_driven_io_almanac[k]; }
+  });
+});
+
 //# sourceMappingURL=index.cjs.map