@cratis/chronicle 6.42.2 → 6.44.0

package/projections/modelBound/childrenAndNestedBuilder.ts

@@ -234,8 +234,13 @@ function discoverIdentifiedBy(childType: Function | undefined, eventKey: string
  * `@childrenFrom`/`@nested` properties the child/nested type itself declares.
  * @param definition - The children definition being populated.
  * @param childType - The resolved child/nested type, when available.
+ * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
  */
-function populateFromType(definition: ChildrenDefinitionLike, childType: Function | undefined): void {
+function populateFromType(
+    definition: ChildrenDefinitionLike,
+    childType: Function | undefined,
+    collectSharedMapping?: (prototype: object, property: string) => void
+): void {
     if (!childType) {
         return;
     }
@@ -275,7 +280,10 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
     }
 
     const prototype = childType.prototype;
-    for (const property of TypeIntrospector.getTrackedProperties(childType)) {
+    const properties = TypeIntrospector.getTrackedProperties(childType);
+    // Like .NET, collect this type's members before descending into its children.
+    for (const property of properties) collectSharedMapping?.(prototype, property);
+    for (const property of properties) {
         applyPropertyMappings(prototype, property, fromByEventType);
 
         // A clear on the member carrying @nested removes that nested object; a clear on
@@ -299,11 +307,11 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
 
         const childrenFromList = getChildrenFromMetadata(prototype, property);
         if (childrenFromList.length > 0) {
-            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList);
+            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList, collectSharedMapping);
         }
 
         if (isNested(prototype, property)) {
-            definition.Nested[property] = buildNestedEntry(childType, property);
+            definition.Nested[property] = buildNestedEntry(childType, property, collectSharedMapping);
         }
     }
 
@@ -317,9 +325,15 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
  * @param type - The class declaring the property.
  * @param property - The property name.
  * @param metadataList - The `@childrenFrom` metadata entries declared on the property (one per creating event type).
+ * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
  * @returns The wire-shaped children definition.
  */
-export function buildChildrenEntry(type: Function, property: string, metadataList: ChildrenFromMetadata[]): ChildrenDefinitionLike {
+export function buildChildrenEntry(
+    type: Function,
+    property: string,
+    metadataList: ChildrenFromMetadata[],
+    collectSharedMapping?: (prototype: object, property: string) => void
+): ChildrenDefinitionLike {
     const childType = resolveChildElementType(type, property);
     const definition = createEmptyChildrenDefinition(type, childType);
 
@@ -338,7 +352,7 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
         });
     }
 
-    populateFromType(definition, childType);
+    populateFromType(definition, childType, collectSharedMapping);
 
     // For non-aggregate-only creating events, populate an unmapped child identifier from
     // the creating event's key. IdentifiedBy selects the child property; it is not itself
@@ -381,9 +395,14 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
  * Builds the `ChildrenDefinition` for a `@nested` single-object property.
  * @param type - The class declaring the property.
  * @param property - The property name.
+ * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
  * @returns The wire-shaped nested definition.
  */
-export function buildNestedEntry(type: Function, property: string): ChildrenDefinitionLike {
+export function buildNestedEntry(
+    type: Function,
+    property: string,
+    collectSharedMapping?: (prototype: object, property: string) => void
+): ChildrenDefinitionLike {
     const nestedType = resolveNestedType(type, property);
     const definition = createEmptyChildrenDefinition(type, nestedType);
     definition.IdentifiedBy = notSetPropertyPath;
@@ -395,6 +414,6 @@ export function buildNestedEntry(type: Function, property: string): ChildrenDefi
         definition.RemovedWith.push({ Key: eventType, Value: { Key: '$eventSourceId', ParentKey: '' } });
     }
 
-    populateFromType(definition, nestedType);
+    populateFromType(definition, nestedType, collectSharedMapping);
     return definition;
 }

package/projections/modelBound/fromAll.ts

@@ -5,6 +5,7 @@ import 'reflect-metadata';
 import { TypeIntrospector } from '../../types/index.js';
 import { decorateModelBoundProperty } from '../../types/modelBoundProperty.js';
 import { ChroniclePropertyDecorator, getPropertyMetadata } from '../../types/propertyDecoratorMetadata.js';
+import { getFromAllEventsMetadata } from './fromAllEvents.js';
 
 /** Metadata stored by the fromAll property decorator. */
 export interface FromAllMetadata {
@@ -21,7 +22,9 @@ const METADATA_KEY = 'chronicle:projection:fromAll';
  * event type the projection is built from - the convention-based counterpart to declaring the same
  * mapping on every individual `fromEvent`. Equivalent to {@link fromEvery} for model-bound
  * projections.
- * @deprecated In the next major, @fromAll subscribes to every event type like fluent fromAll() and .NET [FromAll]; use @fromEvery to keep the current behavior.
+ * @deprecated @fromAll remains a supported, deprecated alias for restricted mappings; prefer @fromEvery.
+ * Contrary to the earlier 'next major' announcement, its behavior will not change;
+ * use @fromAllEvents to opt into all-event subscriptions.
  * @param property - Optional event property name. If not specified, uses the model property name.
  * @param contextProperty - Optional event context property name.
  * @returns A property decorator.
@@ -35,11 +38,13 @@ export function fromAll(property?: string, contextProperty?: string): ChronicleP
 }
 
 /**
- * Retrieves fromAll metadata stored on the given property.
+ * Retrieves fromAll metadata stored on the given property, falling back to fromAllEvents metadata
+ * for compatibility with existing model discovery. This reader does not imply an all-event subscription.
  * @param target - The class prototype.
  * @param propertyKey - The property name.
  * @returns The fromAll metadata, or undefined if not decorated.
  */
 export function getFromAllMetadata(target: object, propertyKey: string): FromAllMetadata | undefined {
-    return getPropertyMetadata<FromAllMetadata>(METADATA_KEY, target, propertyKey);
+    return getPropertyMetadata<FromAllMetadata>(METADATA_KEY, target, propertyKey)
+        ?? getFromAllEventsMetadata(target, propertyKey);
 }

package/projections/modelBound/fromAllEvents.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types/index.js';
+import { decorateModelBoundProperty } from '../../types/modelBoundProperty.js';
+import { ChroniclePropertyDecorator, getPropertyMetadata } from '../../types/propertyDecoratorMetadata.js';
+import type { FromAllEventsMetadata } from './FromAllEventsMetadata.js';
+
+const METADATA_KEY = 'chronicle:projection:fromAllEvents';
+
+/**
+ * On a root property, subscribes the projection to every event type, including events not declared
+ * with `fromEvent`. The model has one shared All block: opting in makes every root
+ * `@fromEvery`/`@fromAll` mapping (including inherited ones) an all-event mapping that also applies
+ * to children. Restricted and all-event shared mappings cannot be mixed in one model.
+ * `@fromEvery`/`@fromAll` mappings on child or nested types are not collected, unlike .NET,
+ * which also collects child [FromEvery] mappings.
+ * On a child or nested member, contributes its bare property name to the root All block and sets
+ * IncludeChildren for the shared block, including the root's restricted shared mappings, without
+ * widening the root subscription. With kernel 19.26.2, when the child's creating event is explicitly
+ * subscribed at the root, it updates the root's shared mappings and creates the child without
+ * populating its shared mapped values. Opt into `@fromAllEvents` at the root to populate child values
+ * in this case. Takes precedence over `fromEvery` and the deprecated `fromAll` alias on the same property.
+ * Opting in changes the definition and may trigger replay; unrelated events can create rows or clear
+ * mapped properties. Use `fromEvery` without `fromAllEvents` on the model or its children to keep
+ * shared mappings restricted to already-subscribed events and the root.
+ * @param property - Optional event property name. If not specified, uses the model property name.
+ * @param contextProperty - Optional event context property name.
+ * @returns A property decorator.
+ */
+export function fromAllEvents(property?: string, contextProperty?: string): ChroniclePropertyDecorator {
+    return decorateModelBoundProperty((target: object, propertyKey: string | symbol) => {
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, propertyKey.toString());
+        const metadata: FromAllEventsMetadata = { property, contextProperty };
+        Reflect.defineMetadata(METADATA_KEY, metadata, target, propertyKey.toString());
+    });
+}
+
+/**
+ * Retrieves the explicit all-event subscription metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns The fromAllEvents metadata, or undefined if not decorated.
+ */
+export function getFromAllEventsMetadata(target: object, propertyKey: string): FromAllEventsMetadata | undefined {
+    return getPropertyMetadata<FromAllEventsMetadata>(METADATA_KEY, target, propertyKey);
+}

package/projections/modelBound/index.ts

@@ -37,6 +37,8 @@ export { fromEvery, getFromEveryMetadata } from './fromEvery.js';
 export type { FromEveryMetadata } from './fromEvery.js';
 export { fromAll, getFromAllMetadata } from './fromAll.js';
 export type { FromAllMetadata } from './fromAll.js';
+export { fromAllEvents, getFromAllEventsMetadata } from './fromAllEvents.js';
+export type { FromAllEventsMetadata } from './FromAllEventsMetadata.js';
 export { noAutoMap, isNoAutoMap, isPropertyNoAutoMap } from './noAutoMap.js';
 export { eventSequence, eventLog, getEventSequenceMetadata } from './eventSequence.js';
 export { variantOf, getVariantOfMetadata } from './variantOf.js';

package/telemetry/ChronicleTelemetryOptions.ts

@@ -1,12 +1,13 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-/** Per-client naming and privacy settings; instrumentation itself is always available. */
+/** Per-client privacy and compatibility settings; instrumentation itself is always available. */
 export interface ChronicleTelemetryOptions {
     /**
-     * Span naming convention. Defaults to legacy; both modes use the same scope and attribute families.
-     * Replacing the earlier "next major" plan, built-in legacy span emission ends in an upcoming
-     * minor after ADR 0001's one-minor overlap. Both values will remain accepted as no-ops, without a removal deadline.
+     * Retained naming selector. Both 'legacy' and 'convention' are accepted as no-ops;
+     * built-in instrumentation always uses conventionSpans, including when this option is absent.
+     * @deprecated No longer needed; built-in spans always use convention names. This option has no removal deadline.
+     * The minor-release naming cutoff replaces the earlier "next major" plan after ADR 0001's one-minor overlap.
      * See https://github.com/Cratis/Chronicle.TypeScript/issues/171.
      */
     spanNames?: 'legacy' | 'convention';

package/telemetry/for_ChronicleTelemetry/given/a_span_name_registry.fixture.ts

@@ -15,7 +15,7 @@ export const legacySpans = {
     getEventStore: 'chronicle.client.get_event_store',
     getEventStores: 'chronicle.client.get_event_stores',
     getNamespaces: 'chronicle.event_store.get_namespaces'
-};
+} as const;
 
 export const conventionSpans = {
     append: 'cratis.chronicle.client.event_sequence.append',
@@ -30,4 +30,4 @@ export const conventionSpans = {
     getEventStore: 'cratis.chronicle.client.event_store.get',
     getEventStores: 'cratis.chronicle.client.event_store.list',
     getNamespaces: 'cratis.chronicle.client.event_store.get_namespaces'
-};
+} as const;

package/telemetry/for_ChronicleTelemetry/when_appending/{with_shared_and_legacy_attributes.spec.ts → with_canonical_attributes.spec.ts}

@@ -26,24 +26,23 @@ describe('when appending with a business correlation override', () => {
         await correlationIdManager.run(new CorrelationId('outer'), () => sequence.append('sensitive-id', new Recorded(), { correlationId: correlation }));
         span = telemetry.spans.getFinishedSpans()[0];
     });
-    it('should produce one client span with the unchanged operation name', () => {
+    it('should produce one client span with the convention operation name', () => {
         telemetry.spans.getFinishedSpans().should.have.lengthOf(1);
         span.kind.should.equal(SpanKind.CLIENT);
-        span.name.should.equal('chronicle.event_sequences.append');
+        span.name.should.equal('cratis.chronicle.client.event_sequence.append');
     });
     it('should use the versioned shared instrumentation scope', () => {
         span.instrumentationScope.name.should.equal('Cratis.Chronicle.Client');
         should.equal(span.instrumentationScope.version, clientVersion);
     });
-    it('should emit both registries on the same span', () => {
+    it('should emit canonical attributes with the exact-string sequence number exception', () => {
         span.attributes.should.include({
-            'cratis.event_store.name': 'store', 'chronicle.event_store': 'store',
-            'cratis.event_store.namespace': 'namespace', 'chronicle.namespace': 'namespace',
-            'cratis.event_sequence.id': 'event-log', 'chronicle.event_sequence_id': 'event-log',
-            'cratis.event_type.id': 'telemetry-recorded', 'chronicle.event_type_id': 'telemetry-recorded',
-            'cratis.event_type.generation': 1, 'chronicle.event_type_generation': 1,
-            'cratis.event_sequence.number': 42, 'chronicle.sequence_number': '42'
+            'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace',
+            'cratis.event_sequence.id': 'event-log', 'cratis.event_type.id': 'telemetry-recorded',
+            'cratis.event_type.generation': 1, 'cratis.event_sequence.number': 42
         });
+        Object.keys(span.attributes).filter(key => key.startsWith('chronicle.')).should.deep.equal(['chronicle.sequence_number']);
+        span.attributes.should.have.property('chronicle.sequence_number', '42');
     });
     it('should scope the resolved correlation consistently for propagation', () => {
         should.equal(span.attributes['cratis.correlation_id'], correlation);

package/telemetry/for_ChronicleTelemetry/when_exposing_names/with_convention_names.spec.ts

@@ -0,0 +1,65 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, expectTypeOf, it } from 'vitest';
+import { ChronicleOptions, ChronicleMetrics, ChronicleConventionMetrics, WellKnownTelemetryNames as names } from '../../../index.js';
+import type { ChronicleTelemetryOptions } from '../../../index.js';
+import { legacySpans, conventionSpans } from '../given/a_span_name_registry.fixture.js';
+
+const legacyAttributes = {
+    eventStore: 'chronicle.event_store', namespace: 'chronicle.namespace',
+    eventSequenceId: 'chronicle.event_sequence_id', sequenceNumber: 'chronicle.sequence_number',
+    eventTypeId: 'chronicle.event_type_id', eventTypeGeneration: 'chronicle.event_type_generation',
+    eventSourceId: 'chronicle.event_source_id', eventCount: 'chronicle.events_count',
+    hasEvents: 'chronicle.has_events', eventStreamType: 'chronicle.event_stream_type', eventStreamId: 'chronicle.event_stream_id'
+} as const;
+const legacyMetrics = {
+    eventsAppended: 'chronicle.events.appended', batchAppendsPerformed: 'chronicle.events.batch_appends',
+    eventStoreRetrievals: 'chronicle.client.event_store_retrievals', appendDuration: 'chronicle.events.append_duration',
+    appendManyDuration: 'chronicle.events.append_many_duration', constraintViolations: 'chronicle.events.constraint_violations',
+    appendErrors: 'chronicle.events.append_errors'
+} as const;
+
+chai.should();
+describe('when exposing canonical names alongside retained compatibility APIs', () => {
+    it('should preserve every legacy span value and literal type', () => {
+        names.spans.should.deep.equal(legacySpans);
+        expectTypeOf(names.spans).toEqualTypeOf<typeof legacySpans>();
+    });
+    it('should expose a matching canonical span for every operation', () => {
+        names.conventionSpans.should.deep.equal(conventionSpans);
+        expectTypeOf(names.conventionSpans).toEqualTypeOf<typeof conventionSpans>();
+        Object.keys(names.conventionSpans).should.deep.equal(Object.keys(names.spans));
+    });
+    it('should preserve the current and historical scopes', () => {
+        names.scope.should.equal('Cratis.Chronicle.Client');
+        names.legacyScope.should.equal('@cratis/chronicle');
+        expectTypeOf(names.legacyScope).toEqualTypeOf<'@cratis/chronicle'>();
+    });
+    it('should preserve every legacy attribute value and literal type', () => {
+        names.legacyAttributes.should.deep.equal(legacyAttributes);
+        expectTypeOf(names.legacyAttributes).toEqualTypeOf<typeof legacyAttributes>();
+    });
+    it('should preserve every legacy metric value and literal type', () => {
+        names.legacyMetrics.should.deep.equal(legacyMetrics);
+        expectTypeOf(names.legacyMetrics).toEqualTypeOf<typeof legacyMetrics>();
+    });
+    it('should retain both typed selector values through the public factories', () => {
+        expectTypeOf<ChronicleTelemetryOptions['spanNames']>().toEqualTypeOf<'legacy' | 'convention' | undefined>();
+        for (const spanNames of ['legacy', 'convention'] as const) {
+            ChronicleOptions.development({ telemetry: { spanNames } }).telemetry!.spanNames!.should.equal(spanNames);
+            ChronicleOptions.fromConnectionString('chronicle://localhost:35000', { telemetry: { spanNames } })
+                .telemetry!.spanNames!.should.equal(spanNames);
+        }
+    });
+    it('should retain the public metric recording signatures', () => {
+        expectTypeOf(ChronicleMetrics).toEqualTypeOf<typeof ChronicleConventionMetrics>();
+        Object.keys(ChronicleMetrics).should.have.members(Object.keys(names.legacyMetrics));
+    });
+    it('should retain the product-only attributes alongside the shared registry', () => {
+        names.attributes.should.include({
+            hasEvents: 'cratis.chronicle.event_sequence.has_events',
+            eventStreamType: 'cratis.chronicle.event_stream.type', eventStreamId: 'cratis.chronicle.event_stream.id'
+        });
+    });
+});

package/telemetry/for_ChronicleTelemetry/when_naming_spans/{with_per_client_modes.spec.ts → with_convention_names.spec.ts}

@@ -6,6 +6,7 @@ import { SpanKind } from '@opentelemetry/api';
 import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import type { ChronicleClient } from '../../../ChronicleClient.js';
 import type { IEventSequence } from '../../../eventSequences/IEventSequence.js';
+import type { ChronicleTelemetryOptions } from '../../ChronicleTelemetryOptions.js';
 import { EventSequenceId } from '../../../eventSequences/EventSequenceId.js';
 import { EventSequenceNumber } from '../../../eventSequences/EventSequenceNumber.js';
 import { clientVersion } from '../../../connection/clientVersion.js';
@@ -30,14 +31,14 @@ const operations = {
 };
 
 for (const spanNames of [undefined, 'legacy', 'convention'] as const) {
-    const expected = spanNames === 'convention' ? conventionSpans : legacySpans;
+    const options: ChronicleTelemetryOptions | undefined = spanNames === undefined ? undefined : { spanNames };
     for (const sequenceId of [EventSequenceId.eventLog, new EventSequenceId('dynamic')]) {
         for (const operation of Object.keys(operations) as (keyof typeof operations)[]) {
-            describe(`when naming ${operation} on ${sequenceId.value} with ${spanNames ?? 'default'} names`, () => {
+            describe(`when naming ${operation} on ${sequenceId.value} with ${spanNames ?? 'default'} configuration`, () => {
                 let instance: ChronicleClient;
                 let span: ReadableSpan;
                 beforeEach(async () => {
-                    instance = client(spanNames === undefined ? undefined : { spanNames });
+                    instance = client(options);
                     const store = await instance.getEventStore('store', 'namespace');
                     const sequence = sequenceId === EventSequenceId.eventLog ? store.eventLog : store.getEventSequence(sequenceId);
                     telemetry.spans.reset();
@@ -45,32 +46,35 @@ for (const spanNames of [undefined, 'legacy', 'convention'] as const) {
                     span = telemetry.spans.getFinishedSpans()[0];
                 });
                 afterEach(() => instance.dispose());
-                it('should emit exactly one client span with the selected name', () => {
+                it('should emit exactly one convention client span and no legacy span', () => {
                     telemetry.spans.getFinishedSpans().should.have.lengthOf(1);
-                    span.name.should.equal(expected[operation]);
+                    span.name.should.equal(conventionSpans[operation]).and.not.equal(legacySpans[operation]);
                     span.kind.should.equal(SpanKind.CLIENT);
                 });
                 it('should retain the versioned shared instrumentation scope', () => {
                     span.instrumentationScope.name.should.equal('Cratis.Chronicle.Client');
                     should.equal(span.instrumentationScope.version, clientVersion);
                 });
-                it('should retain both attribute families', () => {
+                it('should emit canonical attributes with only the exact-string sequence number exception', () => {
                     span.attributes.should.include({
-                        'chronicle.event_store': 'store', 'cratis.event_store.name': 'store',
-                        'chronicle.namespace': 'namespace', 'cratis.event_store.namespace': 'namespace',
-                        'chronicle.event_sequence_id': sequenceId.value, 'cratis.event_sequence.id': sequenceId.value
+                        'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace',
+                        'cratis.event_sequence.id': sequenceId.value
                     });
+                    const hasSequenceNumber = ['append', 'getTailSequenceNumber', 'getFromSequenceNumber', 'redact'].includes(operation);
+                    Object.keys(span.attributes).filter(key => key.startsWith('chronicle.')).should.deep.equal(
+                        hasSequenceNumber ? ['chronicle.sequence_number'] : []);
+                    if (hasSequenceNumber) span.attributes.should.have.property('chronicle.sequence_number', '42');
                 });
             });
         }
     }
 
     for (const operation of ['getEventStore', 'getEventStores', 'getNamespaces'] as const) {
-        describe(`when naming ${operation} with ${spanNames ?? 'default'} names`, () => {
+        describe(`when naming ${operation} with ${spanNames ?? 'default'} configuration`, () => {
             let instance: ChronicleClient;
             let span: ReadableSpan;
             beforeEach(async () => {
-                instance = client(spanNames === undefined ? undefined : { spanNames });
+                instance = client(options);
                 if (operation === 'getNamespaces') {
                     const store = await instance.getEventStore('store', 'namespace');
                     telemetry.spans.reset();
@@ -83,56 +87,57 @@ for (const spanNames of [undefined, 'legacy', 'convention'] as const) {
                 span = telemetry.spans.getFinishedSpans()[0];
             });
             afterEach(() => instance.dispose());
-            it('should emit exactly one client span with the selected name and shared scope', () => {
+            it('should emit exactly one convention client span and no legacy span', () => {
                 telemetry.spans.getFinishedSpans().should.have.lengthOf(1);
-                span.name.should.equal(expected[operation]);
+                span.name.should.equal(conventionSpans[operation]).and.not.equal(legacySpans[operation]);
                 span.kind.should.equal(SpanKind.CLIENT);
                 span.instrumentationScope.name.should.equal('Cratis.Chronicle.Client');
                 should.equal(span.instrumentationScope.version, clientVersion);
             });
+            it('should not emit legacy attributes', () => {
+                Object.keys(span.attributes).filter(key => key.startsWith('chronicle.')).should.be.empty;
+            });
             if (operation !== 'getEventStores') {
-                it('should retain both event store attributes', () => {
-                    span.attributes.should.include({ 'chronicle.event_store': 'store', 'cratis.event_store.name': 'store' });
+                it('should retain the canonical event store attribute', () => {
+                    span.attributes.should.include({ 'cratis.event_store.name': 'store' });
                 });
             }
         });
     }
 }
 
-describe('when interleaving two clients with different span naming modes', () => {
+describe('when legacy and convention configurations coexist in one process', () => {
     let legacy: ChronicleClient;
     let convention: ChronicleClient;
-    let spans: ReadableSpan[];
     beforeEach(async () => {
-        legacy = client({ spanNames: 'legacy' });
+        legacy = client({ spanNames: 'legacy', eventSourceId: { mode: 'raw' } });
         convention = client({ spanNames: 'convention' });
         const [legacyStore, conventionStore] = await Promise.all([
-            legacy.getEventStore('legacy-store'), convention.getEventStore('convention-store')
+            legacy.getEventStore('legacy-client'), convention.getEventStore('convention-client')
+        ]);
+        telemetry.spans.reset();
+        await Promise.all([
+            legacyStore.eventLog.append('legacy-source', new Recorded()),
+            conventionStore.eventLog.append('convention-source', new Recorded())
         ]);
-        await Promise.all([convention.getEventStores(), legacy.getEventStores()]);
-        await Promise.all([legacyStore.getNamespaces(), conventionStore.getNamespaces()]);
-        await conventionStore.eventLog.append('source', new Recorded());
-        await legacyStore.eventLog.append('source', new Recorded());
-        const id = new EventSequenceId('dynamic');
-        await legacyStore.getEventSequence(id).append('source', new Recorded());
-        await conventionStore.getEventSequence(id).append('source', new Recorded());
-        await legacy.getEventStore('legacy-store');
-        await convention.getEventStore('convention-store');
-        spans = telemetry.spans.getFinishedSpans();
     });
     afterEach(() => { legacy.dispose(); convention.dispose(); });
-    it('should keep each client and its cached stores in its own mode', () => {
-        spans.should.have.lengthOf(12);
-        spans.filter(span => span.attributes['cratis.event_store.name'] === 'legacy-store').map(span => span.name).should.deep.equal([
-            legacySpans.getEventStore, legacySpans.getNamespaces, legacySpans.append, legacySpans.append, legacySpans.getEventStore
+    it('should emit one canonical span per operation regardless of the retained selector', () => {
+        telemetry.spans.getFinishedSpans().map(span => span.name).should.deep.equal([
+            conventionSpans.append, conventionSpans.append
         ]);
-        spans.filter(span => span.attributes['cratis.event_store.name'] === 'convention-store').map(span => span.name).should.deep.equal([
-            conventionSpans.getEventStore, conventionSpans.getNamespaces, conventionSpans.append, conventionSpans.append, conventionSpans.getEventStore
-        ]);
-        spans.map(span => span.name).should.include(legacySpans.getEventStores).and.include(conventionSpans.getEventStores);
     });
-    it('should use the same tracer scope in both modes', () => {
-        new Set(spans.map(span => `${span.instrumentationScope.name}/${span.instrumentationScope.version}`)).should.deep.equal(
-            new Set([`Cratis.Chronicle.Client/${clientVersion}`]));
+    it('should keep privacy local to each client', () => {
+        const spans = telemetry.spans.getFinishedSpans();
+        spans.find(span => span.attributes['cratis.event_store.name'] === 'legacy-client')!
+            .attributes.should.have.property('cratis.event_source.id', 'legacy-source');
+        spans.find(span => span.attributes['cratis.event_store.name'] === 'convention-client')!
+            .attributes.should.not.have.property('cratis.event_source.id');
+    });
+    it('should not restore legacy metric instruments for either client', async () => {
+        const scopes = (await telemetry.reader.collect()).resourceMetrics.scopeMetrics;
+        scopes.should.have.lengthOf(1);
+        scopes[0].metrics.should.not.be.empty;
+        scopes[0].metrics.filter(metric => metric.descriptor.name.startsWith('chronicle.')).should.be.empty;
     });
 });

package/telemetry/for_ChronicleTelemetry/when_recording_identifiers/with_per_client_privacy.spec.ts

@@ -32,11 +32,11 @@ for (const [label, policy, expected] of [
             await sequence.redactForEventSource(source, 'private reason');
             services.append.mock.calls[0][0].EventSourceId.should.equal(source);
         });
-        it('should apply the policy equally to both names on every operation', () => {
+        it('should apply the policy only to the canonical name on every operation', () => {
             telemetry.spans.getFinishedSpans().should.have.lengthOf(8);
             for (const span of telemetry.spans.getFinishedSpans()) {
                 should.equal(span.attributes['cratis.event_source.id'], expected);
-                should.equal(span.attributes['chronicle.event_source_id'], expected);
+                should.equal(span.attributes['chronicle.event_source_id'], undefined);
             }
         });
     });
@@ -71,7 +71,8 @@ describe('when appending a batch with multiple event sources', () => {
     });
     it('should record the count without an identifier array', () => {
         const attributes = telemetry.spans.getFinishedSpans()[0].attributes;
-        attributes.should.include({ 'cratis.event.count': 2, 'chronicle.events_count': 2 });
+        attributes.should.have.property('cratis.event.count', 2);
+        attributes.should.not.have.property('chronicle.events_count');
         should.equal(attributes['cratis.event_source.id'], undefined);
         should.equal(attributes['chronicle.event_source_id'], undefined);
     });

package/telemetry/for_ChronicleTelemetry/when_recording_metrics/with_client_operations.spec.ts

@@ -0,0 +1,102 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeAll, chai, describe, it, vi } from 'vitest';
+import type { ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
+import { client } from '../given/a_client.fixture.js';
+import { eventSequence, Recorded } from '../given/an_event_sequence.fixture.js';
+import { WellKnownTelemetryNames as names } from '../../../WellKnownTelemetryNames.js';
+import { clientVersion } from '../../../connection/clientVersion.js';
+
+chai.should();
+const telemetry = telemetrySession();
+describe('when recording metrics from successful client operations', () => {
+    let scopes: ScopeMetrics[];
+    let scope: ScopeMetrics;
+    const sequenceAttributes = {
+        'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace',
+        'cratis.event_sequence.id': 'event-log'
+    };
+    const eventAttributes = { ...sequenceAttributes, 'cratis.event_type.id': 'telemetry-recorded' };
+
+    beforeAll(async () => {
+        const instance = client();
+        const { sequence, services } = eventSequence();
+        let milliseconds = 1000;
+        const clock = vi.spyOn(performance, 'now').mockImplementation(() => milliseconds);
+        services.append.mockImplementation(async () => {
+            milliseconds += 250;
+            return { Response: { SequenceNumber: 42n } };
+        });
+        services.appendManyForEventSources.mockImplementation(async () => {
+            milliseconds += 1250;
+            return { Response: { SequenceNumbers: [43n, 44n] } };
+        });
+        try {
+            await instance.getEventStore('store', 'namespace');
+            await sequence.append('private-source', new Recorded());
+            await sequence.appendMany('private-source', [new Recorded(), new Recorded()]);
+            scopes = (await telemetry.reader.collect()).resourceMetrics.scopeMetrics;
+            scope = scopes[0];
+        } finally {
+            clock.mockRestore();
+            instance.dispose();
+        }
+    });
+
+    it('should use the canonical scope and installed client version', () => {
+        scopes.should.have.lengthOf(1);
+        scope.scope.should.include({ name: 'Cratis.Chronicle.Client', version: clientVersion });
+    });
+    it('should emit only the expected canonical instruments with no legacy names', () => {
+        scope.metrics.map(metric => metric.descriptor.name).should.have.members([
+            names.metrics.eventsAppended, names.metrics.batchAppendsPerformed, names.metrics.eventStoreRetrievals,
+            names.metrics.appendDuration, names.metrics.appendManyDuration
+        ]);
+        scope.metrics.filter(metric => metric.descriptor.name.startsWith('chronicle.')).should.be.empty;
+    });
+    it('should record the single append duration in seconds exactly once', () => {
+        const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics.appendDuration)!;
+        metric.descriptor.unit.should.equal('s');
+        metric.dataPoints.should.have.lengthOf(1);
+        metric.dataPoints[0].attributes.should.deep.equal(eventAttributes);
+        metric.dataPoints[0].value.should.include({ min: 0.25, max: 0.25, sum: 0.25, count: 1 });
+    });
+    it('should record the batch append duration in seconds exactly once', () => {
+        const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics.appendManyDuration)!;
+        metric.descriptor.unit.should.equal('s');
+        metric.dataPoints.should.have.lengthOf(1);
+        metric.dataPoints[0].attributes.should.deep.equal(sequenceAttributes);
+        metric.dataPoints[0].value.should.include({ min: 1.25, max: 1.25, sum: 1.25, count: 1 });
+    });
+    it('should count individual events with the dimensions known to each append path', () => {
+        const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics.eventsAppended)!;
+        metric.dataPoints.map(point => ({ attributes: point.attributes, value: point.value })).should.have.deep.members([
+            { attributes: eventAttributes, value: 1 }, { attributes: sequenceAttributes, value: 2 }
+        ]);
+    });
+    it('should count the batch without a batch-size dimension', () => {
+        const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics.batchAppendsPerformed)!;
+        metric.dataPoints.should.have.lengthOf(1);
+        metric.dataPoints[0].attributes.should.deep.equal(sequenceAttributes);
+        metric.dataPoints[0].value.should.equal(1);
+    });
+    it('should count the event-store retrieval with only store and namespace dimensions', () => {
+        const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics.eventStoreRetrievals)!;
+        metric.dataPoints.should.have.lengthOf(1);
+        metric.dataPoints[0].attributes.should.deep.equal({
+            'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace'
+        });
+        metric.dataPoints[0].value.should.equal(1);
+    });
+    it('should exclude legacy, batch-size and sensitive dimensions from every measurement', () => {
+        for (const metric of scope.metrics) {
+            for (const point of metric.dataPoints) {
+                Object.keys(point.attributes).filter(key => ![
+                    'cratis.event_store.name', 'cratis.event_store.namespace', 'cratis.event_sequence.id', 'cratis.event_type.id'
+                ].includes(key)).should.be.empty;
+            }
+        }
+    });
+});