@cratis/chronicle 6.42.1 → 6.43.0

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;
+            }
+        }
+    });
+});

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

@@ -0,0 +1,47 @@
+// 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 } from 'vitest';
+import type { ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
+import { eventSequence, Recorded } from '../given/an_event_sequence.fixture.js';
+import { WellKnownTelemetryNames as names } from '../../../WellKnownTelemetryNames.js';
+
+chai.should();
+const telemetry = telemetrySession();
+describe('when recording metrics from thrown single and batch append failures', () => {
+    let scopes: ScopeMetrics[];
+    let scope: ScopeMetrics;
+    let outcomes: PromiseSettledResult<unknown>[];
+    const failure = new Error('Sensitive transport failure');
+    beforeAll(async () => {
+        const { sequence, services } = eventSequence();
+        services.append.mockRejectedValue(failure);
+        services.appendManyForEventSources.mockRejectedValue(failure);
+        outcomes = await Promise.allSettled([
+            sequence.append('private-source', new Recorded()),
+            sequence.appendMany('private-source', [new Recorded(), new Recorded()])
+        ]);
+        scopes = (await telemetry.reader.collect()).resourceMetrics.scopeMetrics;
+        scope = scopes[0];
+    });
+    it('should preserve both thrown failures', () => {
+        outcomes.should.deep.equal([
+            { status: 'rejected', reason: failure }, { status: 'rejected', reason: failure }
+        ]);
+    });
+    it('should emit only the canonical error counter and no completed-append durations', () => {
+        scopes.should.have.lengthOf(1);
+        scope.scope.name.should.equal(names.scope);
+        scope.metrics.map(metric => metric.descriptor.name).should.deep.equal([names.metrics.appendErrors]);
+    });
+    it('should count each failed operation once with only sequence dimensions', () => {
+        const metric = scope.metrics[0];
+        metric.dataPoints.should.have.lengthOf(1);
+        metric.dataPoints[0].attributes.should.deep.equal({
+            'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace',
+            'cratis.event_sequence.id': 'event-log'
+        });
+        metric.dataPoints[0].value.should.equal(2);
+    });
+});

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

@@ -0,0 +1,99 @@
+// 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 } from 'vitest';
+import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
+import { ChronicleMetrics, ChronicleConventionMetrics } from '../../../Metrics.js';
+import { WellKnownTelemetryNames as names } from '../../../WellKnownTelemetryNames.js';
+import { clientVersion } from '../../../connection/clientVersion.js';
+import type { ScopeMetrics } from '@opentelemetry/sdk-metrics';
+
+chai.should();
+const telemetry = telemetrySession();
+describe('when recording through the deprecated millisecond compatibility bridge', () => {
+    let scope: ScopeMetrics;
+    const attributes = Object.freeze({ 'chronicle.event_store': 'store', 'chronicle.namespace': 'namespace',
+        'chronicle.event_sequence_id': 'event-log', 'chronicle.event_type_id': 'recorded',
+        'chronicle.events_count': 237, 'chronicle.event_source_id': 'private-source',
+        'cratis.correlation_id': 'private-correlation', tenant: 'custom-dimension' });
+    beforeAll(async () => {
+        // Metrics was imported before provider installation: recording must still reach the SDK.
+        for (const instrument of ['eventsAppended', 'batchAppendsPerformed', 'eventStoreRetrievals', 'constraintViolations', 'appendErrors'] as const) {
+            ChronicleMetrics[instrument].add(3, attributes);
+        }
+        for (const instrument of ['appendDuration', 'appendManyDuration'] as const) {
+            ChronicleMetrics[instrument].record(250, attributes);
+            // Canonical keys take precedence over historical input keys; direct seconds are not converted.
+            ChronicleConventionMetrics[instrument].record(0.5, { 'cratis.event_store.name': 'direct' });
+            ChronicleMetrics[instrument].record(1250, { 'chronicle.event_store': 'ignored', 'cratis.event_store.name': 'canonical-input' });
+        }
+        scope = (await telemetry.reader.collect()).resourceMetrics.scopeMetrics[0];
+    });
+    it('should use the shared scope and installed version for both families', () => {
+        scope.scope.should.include({ name: 'Cratis.Chronicle.Client', version: clientVersion });
+    });
+    it('should retain dual recording for every compatibility instrument', () => {
+        scope.metrics.map(metric => metric.descriptor.name).should.have.members([
+            ...Object.values(names.metrics), ...Object.values(names.legacyMetrics)
+        ]);
+    });
+    for (const instrument of ['appendDuration', 'appendManyDuration'] as const) {
+        it(`should retain ${instrument} milliseconds and record seconds exactly once`, () => {
+            const legacy = scope.metrics.find(metric => metric.descriptor.name === names.legacyMetrics[instrument])!;
+            legacy.descriptor.unit.should.equal('ms');
+            legacy.dataPoints.should.have.lengthOf(2);
+            legacy.dataPoints.find(point => point.attributes['chronicle.event_store'] === 'store')!.value.should.include({
+                min: 250, max: 250, sum: 250, count: 1
+            });
+            legacy.dataPoints.find(point => point.attributes['chronicle.event_store'] === 'ignored')!.value.should.include({
+                min: 1250, max: 1250, sum: 1250, count: 1
+            });
+            const canonical = scope.metrics.find(metric => metric.descriptor.name === names.metrics[instrument])!;
+            canonical.descriptor.unit.should.equal('s');
+            canonical.dataPoints.should.have.lengthOf(3);
+            canonical.dataPoints.find(point => point.attributes['cratis.event_store.name'] === 'store')!.value.should.include({
+                min: 0.25, max: 0.25, sum: 0.25, count: 1
+            });
+            canonical.dataPoints.find(point => point.attributes['cratis.event_store.name'] === 'canonical-input')!.value.should.include({
+                min: 1.25, max: 1.25, sum: 1.25, count: 1
+            });
+        });
+        it(`should leave direct ${instrument} seconds unchanged without emitting a legacy measurement`, () => {
+            const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics[instrument])!;
+            metric.dataPoints.find(point => point.attributes['cratis.event_store.name'] === 'direct')!.value.should.include({
+                min: 0.5, max: 0.5, sum: 0.5, count: 1
+            });
+            const legacy = scope.metrics.find(metric => metric.descriptor.name === names.legacyMetrics[instrument])!;
+            legacy.dataPoints.filter(point => point.attributes['cratis.event_store.name'] === 'direct').should.be.empty;
+        });
+        it(`should retain millisecond and second bucket boundaries for ${instrument}`, () => {
+            const milliseconds = [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000];
+            for (const [name, boundaries] of [
+                [names.legacyMetrics[instrument], milliseconds],
+                [names.metrics[instrument], milliseconds.map(value => value / 1000)]
+            ] as const) {
+                const metric = scope.metrics.find(metric => metric.descriptor.name === name)!;
+                metric.dataPoints[0].value.should.have.nested.property('buckets.boundaries').deep.equal(boundaries);
+            }
+        });
+    }
+    it('should preserve counter values in both families without scaling or duplication', () => {
+        for (const metric of scope.metrics.filter(metric => !metric.descriptor.name.endsWith('_duration'))) {
+            metric.dataPoints.should.have.lengthOf(1);
+            metric.dataPoints[0].value.should.equal(3);
+        }
+    });
+    it('should preserve every caller attribute on the legacy measurements', () => {
+        for (const metric of scope.metrics.filter(metric => metric.descriptor.name.startsWith('chronicle.'))) {
+            metric.dataPoints.find(point => point.attributes['chronicle.event_store'] === 'store')!.attributes.should.deep.equal(attributes);
+        }
+    });
+    it('should keep canonical dimensions bounded without forwarding custom or sensitive dimensions', () => {
+        for (const metric of scope.metrics.filter(metric => metric.descriptor.name.startsWith('cratis.'))) {
+            metric.dataPoints.find(point => point.attributes['cratis.event_store.name'] === 'store')!.attributes.should.deep.equal({
+                'cratis.event_store.name': 'store', 'cratis.event_store.namespace': 'namespace',
+                'cratis.event_sequence.id': 'event-log', 'cratis.event_type.id': 'recorded'
+            });
+        }
+    });
+});

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

@@ -0,0 +1,88 @@
+// 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 { ConstraintType } from '@cratis/chronicle.contracts';
+import type { ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
+import { eventSequence, Recorded } from '../given/an_event_sequence.fixture.js';
+import { WellKnownTelemetryNames as names } from '../../../WellKnownTelemetryNames.js';
+
+chai.should();
+const telemetry = telemetrySession();
+describe('when recording metrics from rejected single and batch appends', () => {
+    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 { sequence, services } = eventSequence();
+        const rejection = {
+            ConstraintViolations: [{
+                EventTypeId: 'telemetry-recorded', SequenceNumber: 0n, ConstraintType: ConstraintType.Unique,
+                ConstraintName: 'unique', Message: 'Value must be unique', Details: {}
+            }],
+            Errors: ['Append rejected']
+        };
+        let milliseconds = 1000;
+        const clock = vi.spyOn(performance, 'now').mockImplementation(() => milliseconds);
+        services.append.mockImplementation(async () => {
+            milliseconds += 500;
+            return { Response: { SequenceNumber: 0n, ...rejection } };
+        });
+        services.appendManyForEventSources.mockImplementation(async () => {
+            milliseconds += 2500;
+            return { Response: { SequenceNumbers: [], ...rejection } };
+        });
+        try {
+            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();
+        }
+    });
+
+    it('should emit only canonical append instruments', () => {
+        scopes.should.have.lengthOf(1);
+        scope.scope.name.should.equal(names.scope);
+        scope.metrics.map(metric => metric.descriptor.name).should.have.members([
+            names.metrics.eventsAppended, names.metrics.batchAppendsPerformed, names.metrics.appendDuration,
+            names.metrics.appendManyDuration, names.metrics.constraintViolations, names.metrics.appendErrors
+        ]);
+    });
+    it('should record completed rejection durations in seconds without scaling twice', () => {
+        for (const [instrument, seconds, attributes] of [
+            ['appendDuration', 0.5, eventAttributes], ['appendManyDuration', 2.5, sequenceAttributes]
+        ] as const) {
+            const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics[instrument])!;
+            metric.descriptor.unit.should.equal('s');
+            metric.dataPoints.should.have.lengthOf(1);
+            metric.dataPoints[0].attributes.should.deep.equal(attributes);
+            metric.dataPoints[0].value.should.include({ min: seconds, max: seconds, sum: seconds, count: 1 });
+        }
+    });
+    it('should retain per-result violation and error counts with only sequence dimensions', () => {
+        for (const instrument of ['constraintViolations', 'appendErrors'] as const) {
+            const metric = scope.metrics.find(metric => metric.descriptor.name === names.metrics[instrument])!;
+            metric.dataPoints.should.have.lengthOf(1);
+            metric.dataPoints[0].attributes.should.deep.equal(sequenceAttributes);
+            metric.dataPoints[0].value.should.equal(3);
+        }
+    });
+    it('should retain completed-append counter semantics for returned rejections', () => {
+        const appended = scope.metrics.find(metric => metric.descriptor.name === names.metrics.eventsAppended)!;
+        appended.dataPoints.map(point => ({ attributes: point.attributes, value: point.value })).should.have.deep.members([
+            { attributes: eventAttributes, value: 1 }, { attributes: sequenceAttributes, value: 2 }
+        ]);
+        const batches = scope.metrics.find(metric => metric.descriptor.name === names.metrics.batchAppendsPerformed)!;
+        batches.dataPoints.should.have.lengthOf(1);
+        batches.dataPoints[0].attributes.should.deep.equal(sequenceAttributes);
+        batches.dataPoints[0].value.should.equal(1);
+    });
+});

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

@@ -0,0 +1,51 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import type { Attributes } from '@opentelemetry/api';
+import type { ChronicleClient } from '../../../ChronicleClient.js';
+import { client } from '../given/a_client.fixture.js';
+import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
+
+chai.should();
+const telemetry = telemetrySession();
+
+for (const hasEvents of [true, false]) {
+    describe(`when recording event presence ${hasEvents}`, () => {
+        let instance: ChronicleClient;
+        let attributes: Attributes;
+        beforeEach(async () => {
+            instance = client();
+            const store = await instance.getEventStore('store');
+            telemetry.spans.reset();
+            await store.eventLog.hasEventsFor(hasEvents ? 'source' : 'empty');
+            attributes = telemetry.spans.getFinishedSpans()[0].attributes;
+        });
+        afterEach(() => instance.dispose());
+        it('should record the boolean under only the product name', () => {
+            attributes.should.have.property('cratis.chronicle.event_sequence.has_events', hasEvents);
+            attributes.should.not.have.property('chronicle.has_events');
+        });
+    });
+}
+
+describe('when completing a stream', () => {
+    let instance: ChronicleClient;
+    let attributes: Attributes;
+    beforeEach(async () => {
+        instance = client();
+        const store = await instance.getEventStore('store');
+        telemetry.spans.reset();
+        await store.eventLog.completeStream('orders', 'stream-1');
+        attributes = telemetry.spans.getFinishedSpans()[0].attributes;
+    });
+    afterEach(() => instance.dispose());
+    it('should record the stream type under only the product name', () => {
+        attributes.should.have.property('cratis.chronicle.event_stream.type', 'orders');
+        attributes.should.not.have.property('chronicle.event_stream_type');
+    });
+    it('should record the stream identifier under only the product name', () => {
+        attributes.should.have.property('cratis.chronicle.event_stream.id', 'stream-1');
+        attributes.should.not.have.property('chronicle.event_stream_id');
+    });
+});

package/telemetry/for_ChronicleTelemetry/when_recording_sequence_numbers/with_integer_precision.spec.ts

@@ -14,7 +14,7 @@ for (const [number, expected] of [[42n, 42], [9007199254740991n, Number.MAX_SAFE
             services.tailSequenceNumber.mockResolvedValue({ IsAuthorized: true, Data: { SequenceNumber: number } });
             await sequence.getTailSequenceNumber();
         });
-        it('should keep the legacy string and emit only exactly representable shared integers', () => {
+        it('should emit only safe canonical integers and preserve every exact compatibility string', () => {
             const attributes = telemetry.spans.getFinishedSpans()[0].attributes;
             should.equal(attributes['cratis.event_sequence.number'], expected);
             should.equal(attributes['chronicle.sequence_number'], number.toString());

package/telemetry/observeOperation.ts

@@ -6,17 +6,14 @@ import { ChronicleTracer } from '../Tracing.js';
 import { correlationIdManager } from '../correlation/index.js';
 import { CorrelationId } from '../correlation/CorrelationId.js';
 import { WellKnownTelemetryNames } from '../WellKnownTelemetryNames.js';
-import type { ChronicleTelemetryOptions } from './ChronicleTelemetryOptions.js';
 
 /** Opens one client span, scoping the resolved business correlation without generating a new one. */
 export function observeOperation<T>(
     operation: keyof typeof WellKnownTelemetryNames.conventionSpans,
-    telemetry: ChronicleTelemetryOptions | undefined,
     action: (span: Span) => Promise<T>,
     correlationId?: { toString(): string }
 ): Promise<T> {
-    const names = telemetry?.spanNames === 'convention' ? WellKnownTelemetryNames.conventionSpans : WellKnownTelemetryNames.spans;
-    const name = names[operation];
+    const name = WellKnownTelemetryNames.conventionSpans[operation];
     const resolved = correlationId ? new CorrelationId(correlationId.toString()) : correlationIdManager.scoped;
     const run = () => {
         const active = context.active();

package/telemetry/spanAttributes.ts

@@ -6,22 +6,19 @@ import { SpanStatusCode, type Span, type AttributeValue } from '@opentelemetry/a
 import { WellKnownTelemetryNames as names } from '../WellKnownTelemetryNames.js';
 import type { ChronicleTelemetryOptions } from './ChronicleTelemetryOptions.js';
 
-/** Records a shared attribute and its legacy alias on the same span. */
-export function setTelemetryAttribute(span: Span, name: keyof typeof names.legacyAttributes, value: AttributeValue): void {
-    span.setAttribute(names.legacyAttributes[name], value);
-    if (name in names.attributes) {
-        span.setAttribute(names.attributes[name as keyof typeof names.attributes], value);
-    }
+/** Records a canonical shared or product-specific attribute. */
+export function setTelemetryAttribute(span: Span, name: keyof typeof names.attributes, value: AttributeValue): void {
+    span.setAttribute(names.attributes[name], value);
 }
 
-/** Preserves the legacy string; records the shared integer only when exactly representable. */
+/** Preserves the exact compatibility string; records the canonical integer only when exactly representable. */
 export function setSequenceNumber(span: Span, value: bigint): void {
     span.setAttribute(names.legacyAttributes.sequenceNumber, value.toString());
     const number = Number(value);
     if (Number.isSafeInteger(number)) span.setAttribute(names.attributes.sequenceNumber, number);
 }
 
-/** Applies the same privacy policy to both event source identifier names. */
+/** Records an event source identifier only under the client's explicit privacy policy. */
 export function setEventSourceId(span: Span, value: string | undefined, options?: ChronicleTelemetryOptions): void {
     try {
         const policy = options?.eventSourceId;

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

@@ -1,44 +0,0 @@
-// 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, it } from 'vitest';
-import { WellKnownTelemetryNames as names } from '../../../WellKnownTelemetryNames.js';
-import { legacySpans, conventionSpans } from '../given/a_span_name_registry.fixture.js';
-
-chai.should();
-describe('when exposing names during the migration overlap', () => {
-    it('should preserve every legacy span constant', () => {
-        names.spans.should.deep.equal(legacySpans);
-    });
-    it('should expose a matching convention span for every operation', () => {
-        names.conventionSpans.should.deep.equal(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');
-    });
-    it('should preserve every legacy attribute constant', () => {
-        names.legacyAttributes.should.deep.equal({
-            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'
-        });
-    });
-    it('should preserve every legacy metric constant', () => {
-        names.legacyMetrics.should.deep.equal({
-            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'
-        });
-    });
-    it('should expose 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_recording_metrics/with_legacy_overlap.spec.ts

@@ -1,40 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import { beforeEach, chai, describe, it } from 'vitest';
-import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
-import { ChronicleMetrics } from '../../../Metrics.js';
-import { clientVersion } from '../../../connection/clientVersion.js';
-import type { ScopeMetrics } from '@opentelemetry/sdk-metrics';
-
-chai.should();
-const telemetry = telemetrySession();
-describe('when recording metrics after installing the SDK', () => {
-    let scope: ScopeMetrics;
-    beforeEach(async () => {
-        // Metrics was imported before provider installation: recording must still reach the SDK.
-        const attributes = { 'chronicle.event_store': 'store', 'chronicle.namespace': 'namespace',
-            'chronicle.event_sequence_id': 'event-log', 'chronicle.events_count': 237 };
-        ChronicleMetrics.batchAppendsPerformed.add(1, attributes);
-        ChronicleMetrics.appendManyDuration.record(250, attributes);
-        scope = (await telemetry.reader.collect()).resourceMetrics.scopeMetrics[0];
-    });
-    it('should use the shared scope and installed version', () => {
-        scope.scope.should.include({ name: 'Cratis.Chronicle.Client', version: clientVersion });
-    });
-    it('should retain legacy milliseconds while emitting seconds', () => {
-        const legacy = scope.metrics.find(metric => metric.descriptor.name === 'chronicle.events.append_many_duration')!;
-        const shared = scope.metrics.find(metric => metric.descriptor.name === 'cratis.chronicle.event_sequence.append_many_duration')!;
-        legacy.descriptor.unit.should.equal('ms');
-        shared.descriptor.unit.should.equal('s');
-        legacy.dataPoints[0].value.should.include({ min: 250, max: 250 });
-        shared.dataPoints[0].value.should.include({ min: 0.25, max: 0.25 });
-    });
-    it('should exclude batch size from only the new metric dimensions', () => {
-        const legacy = scope.metrics.find(metric => metric.descriptor.name === 'chronicle.events.batch_appends')!;
-        const shared = scope.metrics.find(metric => metric.descriptor.name === 'cratis.chronicle.event_sequence.batch_appends')!;
-        legacy.dataPoints[0].attributes.should.have.property('chronicle.events_count', 237);
-        shared.dataPoints[0].attributes.should.deep.equal({ 'cratis.event_store.name': 'store',
-            'cratis.event_store.namespace': 'namespace', 'cratis.event_sequence.id': 'event-log' });
-    });
-});

package/telemetry/for_ChronicleTelemetry/when_recording_product_attributes/with_both_naming_modes.spec.ts

@@ -1,52 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import { afterEach, beforeEach, chai, describe, it } from 'vitest';
-import type { Attributes } from '@opentelemetry/api';
-import type { ChronicleClient } from '../../../ChronicleClient.js';
-import { client } from '../given/a_client.fixture.js';
-import { telemetrySession } from '../given/a_telemetry_session.fixture.js';
-
-chai.should();
-const telemetry = telemetrySession();
-
-for (const spanNames of ['legacy', 'convention'] as const) {
-    for (const hasEvents of [true, false]) {
-        describe(`when recording event presence ${hasEvents} with ${spanNames} span names`, () => {
-            let instance: ChronicleClient;
-            let attributes: Attributes;
-            beforeEach(async () => {
-                instance = client({ spanNames });
-                const store = await instance.getEventStore('store');
-                telemetry.spans.reset();
-                await store.eventLog.hasEventsFor(hasEvents ? 'source' : 'empty');
-                attributes = telemetry.spans.getFinishedSpans()[0].attributes;
-            });
-            afterEach(() => instance.dispose());
-            it('should record the boolean under both the legacy and product-only names', () => {
-                attributes.should.include({
-                    'chronicle.has_events': hasEvents,
-                    'cratis.chronicle.event_sequence.has_events': hasEvents
-                });
-            });
-        });
-    }
-    describe(`when completing a stream with ${spanNames} span names`, () => {
-        let instance: ChronicleClient;
-        let attributes: Attributes;
-        beforeEach(async () => {
-            instance = client({ spanNames });
-            const store = await instance.getEventStore('store');
-            telemetry.spans.reset();
-            await store.eventLog.completeStream('orders', 'stream-1');
-            attributes = telemetry.spans.getFinishedSpans()[0].attributes;
-        });
-        afterEach(() => instance.dispose());
-        it('should record the stream type under both names', () => {
-            attributes.should.include({ 'chronicle.event_stream_type': 'orders', 'cratis.chronicle.event_stream.type': 'orders' });
-        });
-        it('should record the stream identifier under both names', () => {
-            attributes.should.include({ 'chronicle.event_stream_id': 'stream-1', 'cratis.chronicle.event_stream.id': 'stream-1' });
-        });
-    });
-}