@cratis/chronicle 6.32.1 → 6.34.0

package/readModels/for_ReadModels/when_releasing_a_document/with_a_default_subject.spec.ts

@@ -0,0 +1,39 @@
+// 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 { JsonSchemaGenerator } from '../../../schemas/index.js';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document with a default subject', () => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: '{"id":"account","name":"released name"}' });
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', __subject: 'owner'
+        });
+    });
+
+    it('should release all present properties together', () => context.release.mock.calls.should.have.lengthOf(1));
+    it('should use the stored subject rather than the id', () => context.requestFor('owner').Subject.should.equal('owner'));
+    it('should use the current event store and namespace', () => {
+        const { EventStore, Namespace } = context.requestFor('owner');
+        ({ EventStore, Namespace }).should.deep.equal({ EventStore: 'store', Namespace: 'tenant' });
+    });
+    it('should send only data properties', () => JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ id: 'account', name: 'encrypted name' }));
+    it('should preserve compliance metadata in the relevant schema', () => {
+        const schema = JsonSchemaGenerator.generate(AccountDocument);
+        JSON.parse(context.requestFor('owner').Schema).should.deep.equal({
+            ...schema,
+            properties: { id: schema.properties!.id, name: schema.properties!.name },
+            required: ['id', 'name']
+        });
+    });
+    it('should return the released values', () => result.should.deep.equal({ id: 'account', name: 'released name' }));
+    it('should return a plain document rather than a model instance', () => Object.getPrototypeOf(result).should.equal(Object.prototype));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_a_frozen_document.spec.ts

@@ -0,0 +1,28 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a frozen document', () => {
+    let document: Readonly<Record<string, unknown>>;
+    let result: Record<string, unknown>;
+    let original: string;
+
+    beforeEach(async () => {
+        const context = new a_stored_read_model();
+        document = Object.freeze({
+            name: 'encrypted name', contact: Object.freeze({ phone: 'unchanged phone' }),
+            __subjects: Object.freeze({ name: 'owner' })
+        });
+        original = JSON.stringify(document);
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: '{"name":"released name"}' });
+        result = await context.readModels.releaseDocument(AccountDocument, document);
+    });
+
+    it('should not mutate the document or its metadata', () => JSON.stringify(document).should.equal(original));
+    it('should release into a separate document', () => result.should.deep.equal({ name: 'released name', contact: { phone: 'unchanged phone' } }));
+    it('should copy even the subtrees that are not released', () => result.contact!.should.not.equal(document.contact));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_a_malformed_response.spec.ts

@@ -0,0 +1,24 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+const should = chai.should();
+
+describe.each(['private@example.test', '', 'null', '[]', '"private@example.test"', '42'])('when releasing a document with malformed response %s', payload => {
+    let result: Record<string, unknown> | undefined;
+    let error: Error;
+
+    beforeEach(async () => {
+        const context = new a_stored_read_model();
+        result = undefined;
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: payload });
+        await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', __subject: 'owner' }).then(
+            released => { result = released; }, caught => { error = caught as Error; }
+        );
+    });
+
+    it('should reject without returning data', () => should.not.exist(result));
+    it('should sanitize parsing failures', () => error.message.should.equal('Failed to release PII in stored read model document.'));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_a_reported_failure.spec.ts

@@ -0,0 +1,38 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+const should = chai.should();
+
+describe.each(['kernel', 'transport'])('when releasing a document and a later subject reports a %s failure', failure => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown> | undefined;
+    let error: Error;
+    let document: Record<string, unknown>;
+    let original: string;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = undefined;
+        document = { name: 'encrypted name', email: 'encrypted email', __subjects: { name: 'owner', email: 'other-owner' } };
+        original = JSON.stringify(document);
+        context.release.mockResolvedValueOnce({ HasError: false, Error: '', Payload: '{"name":"released name"}' });
+        if (failure === 'kernel') {
+            context.release.mockResolvedValueOnce({ HasError: true, Error: 'PII private@example.test', Payload: '{"email":"private@example.test"}' });
+        } else {
+            context.release.mockRejectedValueOnce(new Error('Transport details: private@example.test'));
+        }
+        await context.readModels.releaseDocument(AccountDocument, document).then(
+            released => { result = released; }, caught => { error = caught as Error; }
+        );
+    });
+
+    it('should have attempted both subjects', () => context.release.mock.calls.should.have.lengthOf(2));
+    it('should reject the whole operation', () => error.should.be.instanceOf(Error));
+    it('should never expose the earlier released group', () => should.not.exist(result));
+    it('should leave the input unchanged even after a partial release', () => JSON.stringify(document).should.equal(original));
+    it('should not expose PII from errors or payloads', () => error.message.should.equal('Failed to release PII in stored read model document.'));
+    it('should not attach an unsafe cause', () => should.not.exist(error.cause));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_an_empty_released_value.spec.ts

@@ -0,0 +1,19 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document and the kernel reports success with an empty value', () => {
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        const context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: '{"name":""}' });
+        result = await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', __subject: 'owner' });
+    });
+
+    it('should accept the reported success without guessing whether decryption failed', () => result.should.deep.equal({ name: '' }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_an_unknown_subject_property.spec.ts

@@ -0,0 +1,42 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each(['unknown', 'contact.phone', '__subject', '__subjects', 'toString'])('when releasing a document with unknown subject property %s', property => {
+    let context: a_stored_read_model;
+    let error: Error;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', contact: { phone: 'encrypted phone' }, unknown: 'not declared',
+            'contact.phone': 'not declared', toString: 'not declared',
+            __subject: 'owner', __subjects: { [property]: 'other-owner' }
+        }).catch(caught => { error = caught as Error; });
+    });
+
+    it('should reject undeclared, nested, reserved and inherited property names', () => error.message.should.equal('Stored read model document has an unknown subject property.'));
+    it('should validate the entire subject map before attempting any releases', () => context.release.mock.calls.should.have.lengthOf(0));
+});
+
+describe.each(['email', 'removedProperty', 'contact.phone', 'toString'])('when releasing a document with a stale subject property %s', property => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', __subject: 'owner', __subjects: { [property]: 'other-owner' }
+        });
+    });
+
+    it('should ignore mappings without a corresponding document property', () => result.should.deep.equal({ name: 'encrypted name' }));
+    it('should release only the existing properties under their subject', () => {
+        context.release.mock.calls.should.have.lengthOf(1);
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name' });
+    });
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_bookkeeping_fields.spec.ts

@@ -0,0 +1,27 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([undefined, 'owner'])('when releasing a document with bookkeeping and default subject %s', defaultSubject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'stored name', _id: 'storage-id', __generation: 1,
+            __subject: defaultSubject, __subjects: {}
+        });
+    });
+
+    it('should strip storage-only and subject metadata', () => result.should.deep.equal({ id: 'account', name: 'stored name' }));
+    it('should never send bookkeeping for release', () => {
+        context.release.mock.calls.forEach(([request]) => {
+            JSON.parse(request.Payload).should.deep.equal({ id: 'account', name: 'stored name' });
+        });
+    });
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_conflicting_or_missing_properties.spec.ts

@@ -0,0 +1,32 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+const should = chai.should();
+
+describe.each([
+    '{}',
+    '{"name":"wrong group"}',
+    '{"email":"released email","name":"overwrite released group"}',
+    '{"email":"released email","id":"overwrite unreleased property"}',
+    '{"email":"released email","__proto__":{"polluted":true}}'
+])('when releasing a document with missing or conflicting response properties %s', payload => {
+    let result: Record<string, unknown> | undefined;
+    let error: Error;
+
+    beforeEach(async () => {
+        const context = new a_stored_read_model();
+        result = undefined;
+        context.release.mockResolvedValueOnce({ HasError: false, Error: '', Payload: '{"name":"released name"}' });
+        context.release.mockResolvedValueOnce({ HasError: false, Error: '', Payload: payload });
+        await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            __subjects: { name: 'owner', email: 'other-owner' }
+        }).then(released => { result = released; }, caught => { error = caught as Error; });
+    });
+
+    it('should reject the whole operation', () => error.message.should.equal('Failed to release stored read model document: missing or conflicting properties.'));
+    it('should not expose a partial result', () => should.not.exist(result));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_empty_subject_metadata.spec.ts

@@ -0,0 +1,56 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: null }, { __subject: '' },
+    { __subjects: { name: null } }, { __subjects: { name: '' } },
+    { __subjects: null }, { __subjects: [] }, { __subjects: 'owner' }, { __subjects: 42 }
+])('when releasing a document without usable subject metadata %j', metadata => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, { name: 'stored name', ...metadata });
+    });
+
+    it('should copy properties without a subject unchanged', () => result.should.deep.equal({ name: 'stored name' }));
+    it('should not attempt release', () => context.release.mock.calls.should.have.lengthOf(0));
+});
+
+describe.each([null, ''])('when releasing a document with an empty property subject %j and a default subject', subject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', __subject: 'owner', __subjects: { name: subject }
+        });
+    });
+
+    it('should fall back to the default subject', () => context.requestFor('owner').Subject.should.equal('owner'));
+    it('should release the property', () => result.should.deep.equal({ name: 'released name' }));
+});
+
+describe.each([null, ''])('when releasing a document with an empty default subject %j and a property subject', subject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', __subject: subject, __subjects: { name: 'owner' }
+        });
+    });
+
+    it('should release only the property with a subject', () => JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name' }));
+    it('should retain properties without a subject', () => result.should.deep.equal({ id: 'account', name: 'released name' }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_invalid_subject_metadata.spec.ts

@@ -0,0 +1,27 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: 42 }, { __subject: false }, { __subject: [] }, { __subject: {} },
+    { __subjects: { name: 42 } }, { __subjects: { name: false } },
+    { __subjects: { name: [] } }, { __subjects: { name: { subject: 'private@example.test' } } },
+    { __subjects: { email: 42 } }, { __subjects: { removedProperty: 42 } }
+])('when releasing a document with invalid subject metadata %j', metadata => {
+    let context: a_stored_read_model;
+    let error: Error;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', ...metadata })
+            .catch(caught => { error = caught as Error; });
+    });
+
+    it('should reject the document', () => error.should.be.instanceOf(Error));
+    it('should not expose metadata values in the error', () => error.message.should.not.contain('private@example.test'));
+    it('should not attempt release with invalid metadata', () => context.release.mock.calls.should.have.lengthOf(0));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_mixed_subjects.spec.ts

@@ -0,0 +1,38 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document with mixed default and property subjects', () => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockImplementation(async request => ({
+            HasError: false, Error: '', Payload: JSON.stringify(request.Subject === 'owner'
+                ? { id: 'account', name: 'released name' } : { email: 'released email' })
+        }));
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            __subject: 'owner', __subjects: { name: 'owner', email: 'joined-owner' }
+        });
+    });
+
+    it('should reuse the default subject group for matching property subjects', () => context.release.mock.calls.should.have.lengthOf(2));
+    it('should apply the default to unmapped properties', () => {
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ id: 'account', name: 'encrypted name' });
+    });
+    it('should override the default for mapped properties', () => {
+        JSON.parse(context.requestFor('joined-owner').Payload).should.deep.equal({ email: 'encrypted email' });
+    });
+    it('should send a schema limited to the overridden property', () => {
+        Object.keys(JSON.parse(context.requestFor('joined-owner').Schema).properties).should.deep.equal(['email']);
+    });
+    it('should merge the released properties without bookkeeping', () => result.should.deep.equal({
+        id: 'account', name: 'released name', email: 'released email'
+    }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_property_subjects.spec.ts

@@ -0,0 +1,52 @@
+// 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 { JsonSchemaGenerator } from '../../../schemas/index.js';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document with property subjects', () => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockImplementation(async request => ({
+            HasError: false, Error: '', Payload: JSON.stringify(request.Subject === 'owner'
+                ? { name: 'released name', email: 'released email' }
+                : { contact: { phone: 'released phone' }, contacts: [{ phone: 'released list phone' }] })
+        }));
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            contact: { phone: 'encrypted phone' }, contacts: [{ phone: 'encrypted list phone' }],
+            __subjects: { name: 'owner', email: 'owner', contact: 'contact-owner', contacts: 'contact-owner' }
+        });
+    });
+
+    it('should batch properties by distinct subject', () => context.release.mock.calls.should.have.lengthOf(2));
+    it('should send only the owner properties to that subject', () => {
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name', email: 'encrypted email' });
+    });
+    it('should release each nested subtree and array under its top-level subject', () => {
+        JSON.parse(context.requestFor('contact-owner').Payload).should.deep.equal({
+            contact: { phone: 'encrypted phone' }, contacts: [{ phone: 'encrypted list phone' }]
+        });
+    });
+    it('should retain nested compliance schemas', () => {
+        const properties = JsonSchemaGenerator.generate(AccountDocument).properties!;
+        JSON.parse(context.requestFor('contact-owner').Schema).properties.should.deep.equal({
+            contact: properties.contact, contacts: properties.contacts
+        });
+    });
+    it('should include the array item phone PII metadata in the subject-specific schema', () => {
+        JSON.parse(context.requestFor('contact-owner').Schema).properties.contacts.items.properties.phone.should.deep.equal({
+            type: 'string', compliance: [{ metadataType: 'PII', details: '' }]
+        });
+    });
+    it('should combine the released groups and retain properties without a subject', () => result.should.deep.equal({
+        id: 'account', name: 'released name', email: 'released email',
+        contact: { phone: 'released phone' }, contacts: [{ phone: 'released list phone' }]
+    }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_whitespace_subjects.spec.ts

@@ -0,0 +1,24 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: '  \t' },
+    { __subject: 'owner', __subjects: { name: '  \t' } }
+])('when releasing a document with a whitespace-only subject %j', metadata => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', ...metadata });
+    });
+
+    it('should preserve the exact subject in the release request', () => context.requestFor('  \t').Subject.should.equal('  \t'));
+    it('should release the property', () => result.should.deep.equal({ name: 'released name' }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/without_subjects.spec.ts

@@ -0,0 +1,24 @@
+// 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 { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document without subjects', () => {
+    let context: a_stored_read_model;
+    let document: Record<string, unknown>;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        document = { id: 'account', name: 'unchanged', contact: { phone: 'unchanged phone' } };
+        result = await context.readModels.releaseDocument(AccountDocument, document);
+    });
+
+    it('should leave data values unchanged', () => result.should.deep.equal(document));
+    it('should not infer a subject from id or subject decorators', () => context.release.mock.calls.should.have.lengthOf(0));
+    it('should return a copy', () => result.should.not.equal(document));
+    it('should not share unreleased subtrees with the input', () => result.contact!.should.not.equal(document.contact));
+});

package/reducers/Reducers.ts

@@ -2,7 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import 'reflect-metadata';
-import { diag } from '@opentelemetry/api';
+import { createLogger } from '../logging/createLogger.js';
+import { runInBackgroundContext } from '../telemetry/runInBackgroundContext.js';
 import { Constructor } from '@cratis/fundamentals';
 import { ObservationState, ReadModelObserverType, ReducerMessage, ReplayState } from '@cratis/chronicle.contracts';
 import { IClientArtifactsProvider } from '../artifacts/index.js';
@@ -102,7 +103,7 @@ export class Reducers implements IReducers {
     /** How long to wait before re-establishing an observation whose stream ended. */
     private static readonly _reobserveDelayMs = 2000;
 
-    private readonly _logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/reducers' });
+    private readonly _logger: ReturnType<typeof createLogger>;
     private readonly _lifecycle: ConnectionLifecycle;
     private readonly _reducers = new Map<string, Constructor>();
     private readonly _queues = new Map<string, AsyncQueue<ReducerMessage>>();
@@ -133,6 +134,7 @@ export class Reducers implements IReducers {
         private readonly _artifactActivator?: ClientArtifactsActivator,
         private readonly _readModelNamingPolicy?: ReadModelNamingPolicy
     ) {
+        this._logger = createLogger('@cratis/chronicle/reducers', _connection.logger);
         this._lifecycle = lifecycle;
         lifecycle.onDisconnected(async () => {
             this._logger.info('Disconnected — stopping all reducer observations');
@@ -235,21 +237,23 @@ export class Reducers implements IReducers {
     }
 
     private startObservation(id: string, reducerType: Constructor): void {
-        if (this._disposed) return;
-        const metadata = getReducerMetadata(reducerType)!;
-        const eventSequenceId = metadata.eventSequenceId ?? EventSequenceId.eventLog.value;
-        const dispatcher = new ReducerEventDispatcher(reducerType, this._clientArtifacts.eventTypes);
-        const readModelName = this.getReducerReadModelIdentifier(reducerType);
-
-        this._logger.info('Starting reducer observation', {
-            reducerId: id,
-            eventSequenceId,
-            readModel: readModelName,
-            handlerCount: dispatcher.handlers.length,
-            handlers: dispatcher.handlers.map(e => e.methodName)
-        });
+        runInBackgroundContext(() => {
+            if (this._disposed) return;
+            const metadata = getReducerMetadata(reducerType)!;
+            const eventSequenceId = metadata.eventSequenceId ?? EventSequenceId.eventLog.value;
+            const dispatcher = new ReducerEventDispatcher(reducerType, this._clientArtifacts.eventTypes);
+            const readModelName = this.getReducerReadModelIdentifier(reducerType);
 
-        void this.runObservation(id, reducerType, eventSequenceId, readModelName, dispatcher);
+            this._logger.info('Starting reducer observation', {
+                reducerId: id,
+                eventSequenceId,
+                readModel: readModelName,
+                handlerCount: dispatcher.handlers.length,
+                handlers: dispatcher.handlers.map(e => e.methodName)
+            });
+
+            void this.runObservation(id, reducerType, eventSequenceId, readModelName, dispatcher);
+        });
     }
 
     private async runObservation(
@@ -262,7 +266,7 @@ export class Reducers implements IReducers {
         try {
             await this.observeReducer(id, reducerType, eventSequenceId, readModelName, dispatcher);
         } catch (error) {
-            this._logger.error('Reducer observation loop exited with error', { reducerId: id, error: String(error) });
+            this._logger.error('Reducer observation loop exited with error', { reducerId: id, error });
         }
 
         this.scheduleReobserve(id, reducerType);
@@ -285,14 +289,14 @@ export class Reducers implements IReducers {
             return;
         }
 
-        const handle = setTimeout(() => {
+        const handle = runInBackgroundContext(() => setTimeout(() => {
             if (!this._registered || this._disposed) {
                 return;
             }
 
             this._logger.info('Re-establishing reducer observation', { reducerId: id });
             this.startObservation(id, reducerType);
-        }, Reducers._reobserveDelayMs);
+        }, Reducers._reobserveDelayMs));
 
         handle.unref?.();
     }
@@ -359,7 +363,6 @@ export class Reducers implements IReducers {
 
                 this._logger.debug('Received reduce operation', {
                     reducerId: id,
-                    partition: operation.Partition,
                     count: operation.Events.length,
                     hasInitialState: operation.InitialState !== '',
                     replayState: operation.ReplayState
@@ -375,12 +378,12 @@ export class Reducers implements IReducers {
                             replayState: operation.ReplayState
                         }, this._artifactActivator, artifact => runActivated(artifact, () =>
                             notifyReplayLifecycle(artifact.instance, operation.ReplayState, operation.Partition),
-                            { delivery: ArtifactDelivery.ReplayNotification, replayState: operation.ReplayState }));
+                            { delivery: ArtifactDelivery.ReplayNotification, replayState: operation.ReplayState }), this._connection.logger);
                     } else if (reducerInstance) {
                         await notifyReplayLifecycle(reducerInstance, operation.ReplayState, operation.Partition);
                     }
                 } catch (err) {
-                    this._logger.error('Error notifying reducer of replay lifecycle transition', { reducerId: id, error: String(err) });
+                    this._logger.error('Error notifying reducer of replay lifecycle transition', { reducerId: id, error: err });
                     if (err instanceof ArtifactCompletionFailed && err.processingError !== undefined) {
                         exceptionMessages.push(String(err.processingError));
                     }
@@ -424,7 +427,7 @@ export class Reducers implements IReducers {
                                 { delivery: ArtifactDelivery.Events, eventContext: context, methodName: entry.methodName });
                             lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
                         } catch (err) {
-                            this._logger.error('Error handling event in reducer', { reducerId: id, error: String(err) });
+                            this._logger.error('Error handling event in reducer', { reducerId: id, error: err });
                             exceptionMessages.push(String(err));
                             exceptionStackTrace = err instanceof Error ? (err.stack ?? '') : '';
                             state = ObservationState.Failed;
@@ -445,9 +448,9 @@ export class Reducers implements IReducers {
                             readModels: this._eventStore.readModels, eventSequenceId, partition: operation.Partition,
                             signal: controller.signal, delivery: ArtifactDelivery.Events,
                             eventContext: toClientEventContext(firstInvocableEvent.Context!)
-                        }, this._artifactActivator, processEvents);
+                        }, this._artifactActivator, processEvents, this._connection.logger);
                     } catch (err) {
-                        this._logger.error('Error activating reducer', { reducerId: id, error: String(err) });
+                        this._logger.error('Error activating reducer', { reducerId: id, error: err });
                         exceptionMessages.push(String(err));
                         const completionStack = err instanceof Error ? (err.stack ?? '') : '';
                         exceptionStackTrace = err instanceof ArtifactCompletionFailed && exceptionStackTrace
@@ -483,7 +486,7 @@ export class Reducers implements IReducers {
             if (!this._queues.has(id)) {
                 this._logger.debug('Reducer observation stream closed cleanly', { reducerId: id });
             } else {
-                this._logger.error('Reducer observation stream ended unexpectedly', { reducerId: id, error: String(err) });
+                this._logger.error('Reducer observation stream ended unexpectedly', { reducerId: id, error: err });
             }
         } finally {
             // Only retire our own queue: a reconnect can already have replaced it,