@dxos/client-services 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/packlets/invitations/invitation-host-extension.ts

@@ -8,7 +8,7 @@ import { randomBytes, verify } from '@dxos/crypto';
 import { InvariantViolation, invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { InvalidInvitationExtensionRoleError, trace } from '@dxos/protocols';
+import { InvalidInvitationExtensionRoleError } from '@dxos/protocols';
 import { schema } from '@dxos/protocols/proto';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -110,8 +110,7 @@ export class InvitationHostExtension
 
         introduce: async (request) => {
           const { profile, invitationId } = request;
-          const traceId = PublicKey.random().toHex();
-          log.trace('dxos.sdk.invitation-handler.host.introduce', trace.begin({ id: traceId }));
+          log('introducing host invitation');
 
           const invitation = this._requireActiveInvitation();
           this._assertInvitationState(Invitation.State.CONNECTED);
@@ -131,7 +130,7 @@ export class InvitationHostExtension
           this._challenge =
             invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY ? randomBytes(32) : undefined;
 
-          log.trace('dxos.sdk.invitation-handler.host.introduce', trace.end({ id: traceId }));
+          log('introduced host invitation');
           return {
             authMethod: invitation.authMethod,
             challenge: this._challenge,
@@ -139,8 +138,7 @@ export class InvitationHostExtension
         },
 
         authenticate: async ({ authCode: code, signedChallenge }) => {
-          const traceId = PublicKey.random().toHex();
-          log.trace('dxos.sdk.invitation-handler.host.authenticate', trace.begin({ id: traceId }));
+          log('authenticating host invitation');
 
           const invitation = this._requireActiveInvitation();
           log.verbose('received authentication request', { authCode: code });
@@ -201,13 +199,12 @@ export class InvitationHostExtension
             return { status };
           }
 
-          log.trace('dxos.sdk.invitation-handler.host.authenticate', trace.end({ id: traceId, data: { status } }));
+          log('authenticated host invitation', { status });
           return { status };
         },
 
         admit: async (request) => {
-          const traceId = PublicKey.random().toHex();
-          log.trace('dxos.sdk.invitation-handler.host.admit', trace.begin({ id: traceId }));
+          log('admitting guest');
           const invitation = this._requireActiveInvitation();
 
           try {
@@ -221,7 +218,7 @@ export class InvitationHostExtension
 
             const response = await this._callbacks.admit(request);
 
-            log.trace('dxos.sdk.invitation-handler.host.admit', trace.end({ id: traceId }));
+            log('admitted guest');
             return response;
           } catch (err: any) {
             this._callbacks.onError(err);
@@ -245,10 +242,12 @@ export class InvitationHostExtension
       await cancelWithContext(this._ctx, this._remoteOptionsTrigger.wait({ timeout: OPTIONS_TIMEOUT }));
       log.verbose('options received');
       if (this._remoteOptions?.role !== InvitationOptions.Role.GUEST) {
-        throw new InvalidInvitationExtensionRoleError(undefined, {
-          expected: InvitationOptions.Role.GUEST,
-          remoteOptions: this._remoteOptions,
-          remotePeerId: context.remotePeerId,
+        throw new InvalidInvitationExtensionRoleError({
+          context: {
+            expected: InvitationOptions.Role.GUEST,
+            remoteOptions: this._remoteOptions,
+            remotePeerId: context.remotePeerId,
+          },
         });
       }
       this._callbacks.onStateUpdate(Invitation.State.CONNECTED);

package/src/packlets/invitations/invitation-protocol.ts

@@ -2,8 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+import { type Context } from '@dxos/context';
 import { type PublicKey } from '@dxos/keys';
-import type { ApiError } from '@dxos/protocols';
 import type { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import type { DeviceProfileDocument, ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import type {
@@ -26,7 +26,7 @@ export interface InvitationProtocol {
   // Host
   //
 
-  checkCanInviteNewMembers(): ApiError | undefined;
+  checkCanInviteNewMembers(): Error | undefined;
 
   /**
    * Protocol-specific information to include in the invitation.
@@ -58,7 +58,7 @@ export interface InvitationProtocol {
    *
    * For example, the guest may already be a member of the space.
    */
-  checkInvitation(invitation: Partial<Invitation>): ApiError | undefined;
+  checkInvitation(invitation: Partial<Invitation>): Error | undefined;
 
   /**
    * Get profile information to send to the host to identify the guest.
@@ -72,6 +72,9 @@ export interface InvitationProtocol {
 
   /**
    * Redeem the admission credential.
+   * @param ctx - Caller context used for tracing and cancellation. Forwarded to downstream
+   *   internal methods (e.g. `DataSpaceManager.acceptSpace`) so their spans become children of
+   *   the invitation flow span.
    */
-  accept(response: AdmissionResponse, request: AdmissionRequest): Promise<Partial<Invitation>>;
+  accept(ctx: Context, response: AdmissionResponse, request: AdmissionRequest): Promise<Partial<Invitation>>;
 }

package/src/packlets/invitations/invitation-state.ts

@@ -31,12 +31,6 @@ export const createGuardedInvitationState = (
   invitation: Invitation,
   stream: PushStream<Invitation>,
 ): GuardedInvitationState => {
-  // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
-  // deadlocks seem very unlikely because hosts don't initiate multiple connections
-  // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
-  //  A has lock for flow with 1, B has lock for flow with 2
-  //  1 has lock for flow with B, 2 has lock for flow with A
-  // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
   const mutex = new Mutex();
   let lastActiveLockHolder: FlowLockHolder | null = null;
   let currentInvitation = { ...invitation };
@@ -44,9 +38,6 @@ export const createGuardedInvitationState = (
     if (ctx.disposed || (lockHolder !== null && mutex.isLocked() && !lockHolder.hasFlowLock())) {
       return false;
     }
-    // don't allow transitions from a terminal state unless a new extension acquired mutex
-    // handles a case when error occurs (e.g. connection is closed) after we completed the flow
-    // successfully or already reported another error
     return lockHolder == null || lastActiveLockHolder !== lockHolder || isNonTerminalState(currentInvitation.state);
   };
   return {
@@ -54,7 +45,6 @@ export const createGuardedInvitationState = (
     get current() {
       return currentInvitation;
     },
-    // disposing context prevents any further state updates
     complete: (newState: Partial<Invitation>) => {
       logStateUpdate(currentInvitation, undefined, invitation.state);
       currentInvitation = { ...currentInvitation, ...newState };
@@ -94,11 +84,7 @@ const logStateUpdate = (invitation: Invitation, actor: any, newState: Invitation
     error: error?.message,
     errorStack: error?.stack,
   };
-  if (isNonTerminalState(newState)) {
-    log.verbose('dxos.sdk.invitations-handler.state.update', logContext);
-  } else {
-    log.info('dxos.sdk.invitations-handler.state.update', logContext);
-  }
+  log.verbose('dxos.sdk.invitations-handler.state.update', logContext);
 };
 
 const isNonTerminalState = (currentState: Invitation.State): boolean => {

package/src/packlets/invitations/invitations-handler.test.ts

@@ -12,7 +12,6 @@ import { openAndClose } from '@dxos/test-utils';
 import { range } from '@dxos/util';
 
 import { TestBuilder, type TestPeer } from '../testing';
-
 import { type InvitationProtocol } from './invitation-protocol';
 import { InvitationsHandler } from './invitations-handler';
 import { SpaceInvitationProtocol } from './space-invitation-protocol';
@@ -95,7 +94,7 @@ describe.skipIf(process.env.CI && !process.env.RUN_FLAKY_TESTS)(
         await acceptInvitation(guest, invitation);
 
         await guest.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
-        await guest.peer.networkManager.close();
+        await guest.peer.networkManager.close(Context.default());
         await host.sink.waitFor(Invitation.State.CONNECTING);
 
         await sleep(10);
@@ -254,9 +253,9 @@ describe.skipIf(process.env.CI && !process.env.RUN_FLAKY_TESTS)(
       const peer = testBuilder.createPeer();
       await peer.createIdentity();
       await openAndClose(peer.echoHost, peer.dataSpaceManager);
-      await peer.echoHost.addReplicator(peer.meshEchoReplicator);
+      await peer.echoHost.addReplicator(Context.default(), peer.meshEchoReplicator);
       if (spaceKey == null) {
-        const space = await peer.dataSpaceManager.createSpace();
+        const space = await peer.dataSpaceManager.createSpace(new Context());
         spaceKey = space.key;
       }
       const invitationHandler = new InvitationsHandler(peer.networkManager, undefined, {
@@ -359,7 +358,7 @@ describe.skipIf(process.env.CI && !process.env.RUN_FLAKY_TESTS)(
     };
 
     const createInvitation = async (setup: PeerSetup, options?: Partial<Invitation>): Promise<Invitation> => {
-      const observable = await setup.peer.invitationsManager.createInvitation({
+      const observable = await setup.peer.invitationsManager.createInvitation(setup.ctx, {
         type: Invitation.Type.DELEGATED,
         kind: Invitation.Kind.SPACE,
         authMethod: Invitation.AuthMethod.SHARED_SECRET,

package/src/packlets/invitations/invitations-handler.ts

@@ -11,12 +11,12 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type SwarmConnection, type SwarmNetworkManager, createTeleportProtocolFactory } from '@dxos/network-manager';
-import { InvalidInvitationError, InvalidInvitationExtensionRoleError, trace } from '@dxos/protocols';
+import { InvalidInvitationError, InvalidInvitationExtensionRoleError } from '@dxos/protocols';
 import { type AdmissionKeypair, Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { AuthenticationResponse, type IntroductionResponse } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { InvitationOptions } from '@dxos/protocols/proto/dxos/halo/invitations';
-import { type ExtensionContext, type TeleportExtension, type TeleportParams } from '@dxos/teleport';
+import { type ExtensionContext, type TeleportExtension, type TeleportProps } from '@dxos/teleport';
 import { trace as _trace } from '@dxos/tracing';
 import { ComplexSet } from '@dxos/util';
 
@@ -31,8 +31,8 @@ const metrics = _trace.metrics;
 
 const MAX_DELEGATED_INVITATION_HOST_TRIES = 3;
 
-export type InvitationConnectionParams = {
-  teleport: Partial<TeleportParams>;
+export type InvitationConnectionProps = {
+  teleport: Partial<TeleportProps>;
   edgeInvitations?: EdgeInvitationConfig;
 };
 
@@ -64,6 +64,7 @@ export type InvitationConnectionParams = {
  *  TODO: the flow logic should either be contained in invitations-handler or in extensions, not be split across
  *  TODO: potentially re-evaluate host-side API to allow multiple concurrent connection, so that mutex can be removed
  */
+@_trace.resource()
 export class InvitationsHandler {
   /**
    * @internal
@@ -71,7 +72,7 @@ export class InvitationsHandler {
   constructor(
     private readonly _networkManager: SwarmNetworkManager,
     private readonly _edgeClient?: EdgeHttpClient,
-    private readonly _connectionParams?: InvitationConnectionParams,
+    private readonly _connectionProps?: InvitationConnectionProps,
   ) {}
 
   handleInvitationFlow(
@@ -87,6 +88,33 @@ export class InvitationsHandler {
       type: invitation.type,
     });
     metrics.increment('dxos.invitation.host');
+
+    const hostSpanId = `invitation-host-${invitation.invitationId}`;
+    // Reassign ctx to the child context so downstream `@trace.span` calls stay in the same trace.
+    // Link child -> parent disposal so `ctx.dispose()` inside this flow still completes the
+    // invitation stream (the caller's ctx owns `stream.complete()` via onDispose).
+    // Do NOT await `invitationCtx.dispose()` here: `derive()` registers a parent -> child
+    // dispose hook, so awaiting the parent dispose would re-enter the still-pending child
+    // dispose promise and deadlock.
+    const invitationCtx = ctx;
+    ctx =
+      _trace.spanStart({
+        id: hostSpanId,
+        instance: this,
+        methodName: 'handleInvitationFlow',
+        parentCtx: ctx,
+        op: 'invitation.host',
+        attributes: {
+          'ctx.dxos.invitation.id': invitation.invitationId,
+          'ctx.dxos.invitation.kind': Invitation.Kind[invitation.kind],
+        },
+      }) ?? ctx;
+    if (ctx !== invitationCtx) {
+      ctx.onDispose(() => {
+        void invitationCtx.dispose();
+      });
+    }
+    ctx.onDispose(() => _trace.spanEnd(hostSpanId));
     const guardedState = createGuardedInvitationState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
@@ -132,15 +160,14 @@ export class InvitationsHandler {
           });
 
           scheduleTask(connectionCtx, async () => {
-            const traceId = PublicKey.random().toHex();
             try {
-              log.trace('dxos.sdk.invitations-handler.host.onOpen', trace.begin({ id: traceId }));
+              log('opening host invitation handler');
               log.verbose('connected', { ...protocol.toJSON() });
               const deviceKey = await extension.completedTrigger.wait({ timeout: invitation.timeout });
               log.verbose('admitted guest', { guest: deviceKey, ...protocol.toJSON() });
               guardedState.set(extension, Invitation.State.SUCCESS);
               metrics.increment('dxos.invitation.success');
-              log.trace('dxos.sdk.invitations-handler.host.onOpen', trace.end({ id: traceId }));
+              log('host invitation handler opened');
               admitted = true;
 
               if (!invitation.multiUse) {
@@ -159,7 +186,6 @@ export class InvitationsHandler {
                   log.error('failed', err);
                 }
               }
-              log.trace('dxos.sdk.invitations-handler.host.onOpen', trace.error({ id: traceId, error: err }));
               // Close connection
               extensionsCtx.close(err);
             }
@@ -200,7 +226,7 @@ export class InvitationsHandler {
         ctx,
         async () => {
           // ensure the swarm is closed before changing state and closing the stream.
-          await swarmConnection.close();
+          await swarmConnection.close(ctx);
           guardedState.set(null, Invitation.State.EXPIRED);
           metrics.increment('dxos.invitation.expired');
           await ctx.dispose();
@@ -232,6 +258,34 @@ export class InvitationsHandler {
     });
     const { timeout = INVITATION_TIMEOUT } = invitation;
 
+    const guestSpanId = `invitation-guest-${invitation.invitationId}`;
+    // Reassign ctx to the child context returned by spanStart so downstream calls
+    // (`edgeInvitationHandler.handle`, `_joinSwarm`, etc.) inherit this span as their
+    // parent rather than starting a new root trace.
+    // Link child -> parent disposal so `ctx.dispose()` inside this flow still completes the
+    // invitation stream. See note in `handleInvitationFlow`: must not await the parent
+    // dispose here (`derive()` registers a parent -> child dispose hook, so awaiting would
+    // re-enter the still-pending child dispose promise and deadlock).
+    const invitationCtx = ctx;
+    ctx =
+      _trace.spanStart({
+        id: guestSpanId,
+        instance: this,
+        methodName: 'acceptInvitation',
+        parentCtx: ctx,
+        op: 'invitation.guest',
+        attributes: {
+          'ctx.dxos.invitation.id': invitation.invitationId,
+          'ctx.dxos.invitation.kind': Invitation.Kind[invitation.kind],
+        },
+      }) ?? ctx;
+    if (ctx !== invitationCtx) {
+      ctx.onDispose(() => {
+        void invitationCtx.dispose();
+      });
+    }
+    ctx.onDispose(() => _trace.spanEnd(guestSpanId));
+
     if (deviceProfile) {
       invariant(invitation.kind === Invitation.Kind.DEVICE, 'deviceProfile provided for non-device invitation');
     }
@@ -279,9 +333,8 @@ export class InvitationsHandler {
           });
 
           scheduleTask(connectionCtx, async () => {
-            const traceId = PublicKey.random().toHex();
             try {
-              log.trace('dxos.sdk.invitations-handler.guest.onOpen', trace.begin({ id: traceId }));
+              log('opening guest invitation handler');
 
               scheduleTask(
                 connectionCtx,
@@ -345,7 +398,7 @@ export class InvitationsHandler {
               admitted = true;
 
               // 4. Record credential in our HALO.
-              const result = await protocol.accept(admissionResponse, admissionRequest);
+              const result = await protocol.accept(ctx, admissionResponse, admissionRequest);
 
               // 5. Success.
               log.verbose('dxos.sdk.invitations-handler.guest.admitted-by-host', {
@@ -357,7 +410,7 @@ export class InvitationsHandler {
                 ...result,
                 state: Invitation.State.SUCCESS,
               });
-              log.trace('dxos.sdk.invitations-handler.guest.onOpen', trace.end({ id: traceId }));
+              log('guest invitation handler opened');
             } catch (err: any) {
               if (err instanceof TimeoutError) {
                 log.verbose('timeout', { ...protocol.toJSON() });
@@ -367,7 +420,6 @@ export class InvitationsHandler {
                 guardedState.error(extension, err);
               }
               extensionCtx.close(err);
-              log.trace('dxos.sdk.invitations-handler.guest.onOpen', trace.error({ id: traceId, error: err }));
             }
           });
         },
@@ -388,9 +440,9 @@ export class InvitationsHandler {
       return extension;
     };
 
-    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
-      onInvitationSuccess: async (admissionResponse, admissionRequest) => {
-        const result = await protocol.accept(admissionResponse, admissionRequest);
+    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionProps?.edgeInvitations, this._edgeClient, {
+      onInvitationSuccess: async (edgeCtx, admissionResponse, admissionRequest) => {
+        const result = await protocol.accept(edgeCtx, admissionResponse, admissionRequest);
         log.info('admitted by edge', { ...protocol.toJSON() });
         guardedState.complete({ ...guardedState.current, ...result, state: Invitation.State.SUCCESS });
       },
@@ -436,15 +488,15 @@ export class InvitationsHandler {
     } else {
       label = `invitation host for space ${invitation.spaceKey?.truncate()}`;
     }
-    const swarmConnection = await this._networkManager.joinSwarm({
+    const swarmConnection = await this._networkManager.joinSwarm(ctx, {
       topic: invitation.swarmKey,
       protocolProvider: createTeleportProtocolFactory(async (teleport) => {
         teleport.addExtension('dxos.halo.invitations', extensionFactory());
-      }, this._connectionParams?.teleport),
+      }, this._connectionProps?.teleport),
       topology: new InvitationTopology(role),
       label,
     });
-    ctx.onDispose(() => swarmConnection.close());
+    ctx.onDispose(() => swarmConnection.close(ctx));
     return swarmConnection;
   }
 
@@ -503,7 +555,7 @@ export class InvitationsHandler {
 const checkInvitation = (protocol: InvitationProtocol, invitation: Partial<Invitation>) => {
   const expiresOn = getExpirationTime(invitation);
   if (expiresOn && expiresOn.getTime() < Date.now()) {
-    return new InvalidInvitationError('Invitation already expired.');
+    return new InvalidInvitationError({ message: 'Invitation already expired.' });
   }
   return protocol.checkInvitation(invitation);
 };

package/src/packlets/invitations/invitations-manager.ts

@@ -21,6 +21,7 @@ import {
   Invitation,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { trace } from '@dxos/tracing';
 
 import type { InvitationProtocol } from './invitation-protocol';
 import { type InvitationsHandler, createAdmissionKeypair } from './invitations-handler';
@@ -29,6 +30,7 @@ import { type InvitationsHandler, createAdmissionKeypair } from './invitations-h
  * Entry point for creating and accepting invitations, keeps track of existing invitation set and
  * emits events when the set changes.
  */
+@trace.resource()
 export class InvitationsManager {
   private readonly _createInvitations = new Map<string, CancellableInvitation>();
   private readonly _acceptInvitations = new Map<string, AuthenticatingInvitation>();
@@ -48,7 +50,11 @@ export class InvitationsManager {
     private readonly _metadataStore: MetadataStore,
   ) {}
 
-  async createInvitation(options: Partial<Invitation> & Pick<Invitation, 'kind'>): Promise<CancellableInvitation> {
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
+  async createInvitation(
+    ctx: Context,
+    options: Partial<Invitation> & Pick<Invitation, 'kind'>,
+  ): Promise<CancellableInvitation> {
     if (options.invitationId) {
       const existingInvitation = this._createInvitations.get(options.invitationId);
       if (existingInvitation) {
@@ -63,7 +69,11 @@ export class InvitationsManager {
     }
     const invitation = this._createInvitation(handler, options);
 
-    const { ctx, stream, observableInvitation } = this._createObservableInvitation(handler, invitation);
+    const {
+      ctx: invitationCtx,
+      stream,
+      observableInvitation,
+    } = this._createObservableInvitation(ctx, handler, invitation);
 
     this._createInvitations.set(invitation.invitationId, observableInvitation);
     this.invitationCreated.emit(invitation);
@@ -84,12 +94,12 @@ export class InvitationsManager {
       return observableInvitation;
     }
 
-    this._invitationsHandler.handleInvitationFlow(ctx, stream, handler, observableInvitation.get());
+    this._invitationsHandler.handleInvitationFlow(invitationCtx, stream, handler, observableInvitation.get());
 
     return observableInvitation;
   }
 
-  async loadPersistentInvitations(): Promise<{ invitations: Invitation[] }> {
+  async loadPersistentInvitations(ctx: Context): Promise<{ invitations: Invitation[] }> {
     if (this._persistentInvitationsLoaded) {
       const invitations = this.getCreatedInvitations().filter((i) => i.persistent);
       return { invitations };
@@ -101,7 +111,7 @@ export class InvitationsManager {
 
       const loadTasks = freshInvitations.map((persistentInvitation) => {
         invariant(!this._createInvitations.get(persistentInvitation.invitationId), 'invitation already exists');
-        return this.createInvitation({ ...persistentInvitation, persistent: false });
+        return this.createInvitation(ctx, { ...persistentInvitation, persistent: false });
       });
       const cInvitations = await Promise.all(loadTasks);
 
@@ -115,7 +125,7 @@ export class InvitationsManager {
     }
   }
 
-  acceptInvitation(request: AcceptInvitationRequest): AuthenticatingInvitation {
+  acceptInvitation(ctx: Context, request: AcceptInvitationRequest): AuthenticatingInvitation {
     const options = request.invitation;
     const existingInvitation = this._acceptInvitations.get(options.invitationId);
     if (existingInvitation) {
@@ -123,8 +133,20 @@ export class InvitationsManager {
     }
 
     const handler = this._getHandler(options);
-    const { ctx, invitation, stream, otpEnteredTrigger } = this._createObservableAcceptingInvitation(handler, options);
-    this._invitationsHandler.acceptInvitation(ctx, stream, handler, options, otpEnteredTrigger, request.deviceProfile);
+    const {
+      ctx: invitationCtx,
+      invitation,
+      stream,
+      otpEnteredTrigger,
+    } = this._createObservableAcceptingInvitation(ctx, handler, options);
+    this._invitationsHandler.acceptInvitation(
+      invitationCtx,
+      stream,
+      handler,
+      options,
+      otpEnteredTrigger,
+      request.deviceProfile,
+    );
     this._acceptInvitations.set(invitation.get().invitationId, invitation);
     this.invitationAccepted.emit(invitation.get());
 
@@ -198,7 +220,7 @@ export class InvitationsManager {
       state = Invitation.State.INIT,
       timeout = INVITATION_TIMEOUT,
       swarmKey = PublicKey.random(),
-      persistent = _options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY, // default no not storing keypairs
+      persistent = _options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
       created = new Date(),
       guestKeypair = undefined,
       role = SpaceMember.Role.ADMIN,
@@ -232,17 +254,18 @@ export class InvitationsManager {
   }
 
   private _createObservableInvitation(
+    ctx: Context,
     handler: InvitationProtocol,
     invitation: Invitation,
   ): { ctx: Context; stream: PushStream<Invitation>; observableInvitation: CancellableInvitation } {
     const stream = new PushStream<Invitation>();
-    const ctx = new Context({
+    const invitationCtx = ctx.derive({
       onError: (err) => {
         stream.error(err);
-        void ctx.dispose();
+        void invitationCtx.dispose();
       },
     });
-    ctx.onDispose(() => {
+    invitationCtx.onDispose(() => {
       log('complete', { ...handler.toJSON() });
       stream.complete();
     });
@@ -251,13 +274,14 @@ export class InvitationsManager {
       subscriber: stream.observable,
       onCancel: async () => {
         stream.next({ ...invitation, state: Invitation.State.CANCELLED });
-        await ctx.dispose();
+        await invitationCtx.dispose();
       },
     });
-    return { ctx, stream, observableInvitation };
+    return { ctx: invitationCtx, stream, observableInvitation };
   }
 
   private _createObservableAcceptingInvitation(
+    parentCtx: Context,
     handler: InvitationProtocol,
     initialState: Invitation,
   ): {
@@ -268,7 +292,8 @@ export class InvitationsManager {
   } {
     const otpEnteredTrigger = new Trigger<string>();
     const stream = new PushStream<Invitation>();
-    const ctx = new Context({
+    // Derive from caller ctx so `TRACE_SPAN_ATTRIBUTE` propagates via the parent chain.
+    const ctx = parentCtx.derive({
       onError: (err) => {
         if (err instanceof TimeoutError) {
           log('timeout', { ...handler.toJSON() });

package/src/packlets/invitations/invitations-service.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Stream } from '@dxos/codec-protobuf/stream';
+import { type RequestOptions, Stream } from '@dxos/codec-protobuf';
 import {
   type AcceptInvitationRequest,
   type AuthenticationRequest,
@@ -27,23 +27,23 @@ export class InvitationsServiceImpl implements InvitationsService {
     };
   }
 
-  createInvitation(options: Invitation): Stream<Invitation> {
-    return new Stream<Invitation>(({ next, close }) => {
+  createInvitation(request: Invitation, options?: RequestOptions): Stream<Invitation> {
+    return new Stream<Invitation>(({ ctx, next, close }) => {
       void this._invitationsManager
-        .createInvitation(options)
+        .createInvitation(ctx, request)
         .then((invitation) => {
           trace.metrics.increment('dxos.invitation.created');
           invitation.subscribe(next, close, close);
         })
         .catch(close);
-    });
+    }, options?.ctx);
   }
 
-  acceptInvitation(request: AcceptInvitationRequest): Stream<Invitation> {
-    const invitation = this._invitationsManager.acceptInvitation(request);
-    return new Stream<Invitation>(({ next, close }) => {
+  acceptInvitation(request: AcceptInvitationRequest, options?: RequestOptions): Stream<Invitation> {
+    return new Stream<Invitation>(({ ctx, next, close }) => {
+      const invitation = this._invitationsManager.acceptInvitation(ctx, request);
       invitation.subscribe(next, close, close);
-    });
+    }, options?.ctx);
   }
 
   async authenticate(request: AuthenticationRequest): Promise<void> {