@cratis/chronicle 6.33.0 → 6.35.0

package/WellKnownTelemetryNames.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** Public telemetry names. Legacy names remain available during the minor-release overlap. */
+export const WellKnownTelemetryNames = {
+    scope: 'Cratis.Chronicle.Client',
+    legacyScope: '@cratis/chronicle',
+    attributes: {
+        correlationId: 'cratis.correlation_id',
+        eventStore: 'cratis.event_store.name',
+        namespace: 'cratis.event_store.namespace',
+        eventSequenceId: 'cratis.event_sequence.id',
+        sequenceNumber: 'cratis.event_sequence.number',
+        eventTypeId: 'cratis.event_type.id',
+        eventTypeGeneration: 'cratis.event_type.generation',
+        eventSourceType: 'cratis.event_source.type',
+        eventSourceId: 'cratis.event_source.id',
+        eventCount: 'cratis.event.count',
+        errorType: 'error.type',
+        exceptionType: 'exception.type'
+    },
+    legacyAttributes: {
+        eventStore: 'chronicle.event_store',
+        namespace: 'chronicle.namespace',
+        eventSequenceId: 'chronicle.event_sequence_id',
+        sequenceNumber: 'chronicle.sequence_number',
+        eventTypeId: 'chronicle.event_type_id',
+        eventTypeGeneration: 'chronicle.event_type_generation',
+        eventSourceId: 'chronicle.event_source_id',
+        eventCount: 'chronicle.events_count',
+        hasEvents: 'chronicle.has_events',
+        eventStreamType: 'chronicle.event_stream_type',
+        eventStreamId: 'chronicle.event_stream_id'
+    },
+    spans: {
+        append: 'chronicle.event_sequences.append',
+        appendMany: 'chronicle.event_sequences.append_many',
+        getTailSequenceNumber: 'chronicle.event_sequences.get_tail_sequence_number',
+        hasEventsFor: 'chronicle.event_sequences.has_events_for',
+        getForEventSourceIdAndEventTypes: 'chronicle.event_sequences.get_for_event_source_id_and_event_types',
+        getFromSequenceNumber: 'chronicle.event_sequences.get_from_sequence_number',
+        redact: 'chronicle.event_sequences.redact',
+        redactForEventSource: 'chronicle.event_sequences.redact_for_event_source',
+        completeStream: 'chronicle.event_sequences.complete_stream',
+        getEventStore: 'chronicle.client.get_event_store',
+        getEventStores: 'chronicle.client.get_event_stores',
+        getNamespaces: 'chronicle.event_store.get_namespaces'
+    },
+    metrics: {
+        eventsAppended: 'cratis.chronicle.event_sequence.appended',
+        batchAppendsPerformed: 'cratis.chronicle.event_sequence.batch_appends',
+        eventStoreRetrievals: 'cratis.chronicle.event_store.retrievals',
+        appendDuration: 'cratis.chronicle.event_sequence.append_duration',
+        appendManyDuration: 'cratis.chronicle.event_sequence.append_many_duration',
+        constraintViolations: 'cratis.chronicle.event_sequence.constraint_violations',
+        appendErrors: 'cratis.chronicle.event_sequence.append_errors'
+    },
+    legacyMetrics: {
+        eventsAppended: 'chronicle.events.appended',
+        batchAppendsPerformed: 'chronicle.events.batch_appends',
+        eventStoreRetrievals: 'chronicle.client.event_store_retrievals',
+        appendDuration: 'chronicle.events.append_duration',
+        appendManyDuration: 'chronicle.events.append_many_duration',
+        constraintViolations: 'chronicle.events.constraint_violations',
+        appendErrors: 'chronicle.events.append_errors'
+    }
+} as const;

package/artifacts/validateArtifactSchemas.spec.ts

@@ -35,7 +35,7 @@ describe('artifact schema preflight', () => {
     it('blocks every Kernel registration when preflight fails', async () => {
         const register = vi.fn();
         const connection = new Proxy({}, {
-            get: () => new Proxy({}, { get: () => register })
+            get: (_target, property) => property === 'logger' ? undefined : new Proxy({}, { get: () => register })
         }) as ChronicleConnection;
         const lifecycle = { onDisconnected: vi.fn(), onConnected: vi.fn() } as unknown as ConnectionLifecycle;
         const store = new EventStore(new EventStoreName('Test'), EventStoreNamespaceName.default, connection, lifecycle, 'sink');

package/artifacts/withActivatedArtifact.ts

@@ -1,7 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { diag } from '@opentelemetry/api';
+import { createLogger } from '../logging/createLogger.js';
+import type { IChronicleLogger } from '../logging/IChronicleLogger.js';
 import type { Constructor } from '@cratis/fundamentals';
 import type { ActivatedArtifact } from './ActivatedArtifact.js';
 import type { ArtifactActivationContext } from './ArtifactActivationContext.js';
@@ -9,12 +10,11 @@ import type { ArtifactInvocationContext } from './ArtifactInvocationContext.js';
 import { ArtifactCompletionFailed } from './ArtifactCompletionFailed.js';
 import type { ClientArtifactsActivator } from './ClientArtifactsActivator.js';
 
-const logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/artifacts' });
-
 /** Activates once per delivery and always releases the lease before acknowledgement. */
 export async function withActivatedArtifact<T, R>(
     type: Constructor<T>, context: ArtifactActivationContext, activator: ClientArtifactsActivator,
-    callback: (artifact: ActivatedArtifact<T>) => Promise<R>
+    callback: (artifact: ActivatedArtifact<T>) => Promise<R>,
+    logger?: IChronicleLogger
 ): Promise<R> {
     const artifact = await activator(type, context);
     try {
@@ -38,7 +38,9 @@ export async function withActivatedArtifact<T, R>(
         try {
             await artifact.dispose?.();
         } catch (error) {
-            logger.error('Error disposing activated artifact', { kind: context.kind, artifactId: context.artifactId, error: String(error) });
+            createLogger('@cratis/chronicle/artifacts', logger).error('Error disposing activated artifact', {
+                kind: context.kind, artifactId: context.artifactId, error
+            });
         }
     }
 }

package/connection/ChronicleConnection.ts

@@ -2,7 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { status, type Channel, type ChannelCredentials, type ChannelOptions } from '@grpc/grpc-js';
-import { diag } from '@opentelemetry/api';
+import { createLogger } from '../logging/createLogger.js';
+import type { IChronicleLogger } from '../logging/IChronicleLogger.js';
+import { traceContextMiddleware } from './TraceContextMiddleware.js';
+import { runInBackgroundContext } from '../telemetry/runInBackgroundContext.js';
 import {
     ConnectionServiceDefinition,
     ConstraintsDefinition,
@@ -46,6 +49,9 @@ import { ITokenProvider, NoOpTokenProvider, OAuthTokenProvider } from './TokenPr
  * Configuration options for Chronicle connection.
  */
 export interface ChronicleConnectionOptions {
+    /** Optional client-owned diagnostic sink; absent preserves the diag adapter. */
+    logger?: IChronicleLogger;
+
     /**
      * The connection string used to connect to Chronicle.
      */
@@ -120,7 +126,7 @@ export class ChronicleConnection implements ChronicleServices {
         this._addressResolver = new ChronicleServerAddressResolver();
         this._loadBalancerStrategy = createLoadBalancerStrategy(this._connectionString.loadBalancer, this._connectionString.skipTlsValidation);
 
-        this._clientsReady = this.createClients();
+        this._clientsReady = runInBackgroundContext(() => this.createClients());
         // Building the initial channel is async (address resolution + load balancer
         // selection), so the constructor cannot await it. Real failures still surface to
         // callers that await connect()/resetChannel(); this only prevents an unhandled
@@ -128,6 +134,11 @@ export class ChronicleConnection implements ChronicleServices {
         this._clientsReady.catch(() => {});
     }
 
+    /** The diagnostic sink shared by services owned by this connection. */
+    get logger(): IChronicleLogger | undefined {
+        return this._options.logger;
+    }
+
     get connectionString(): ChronicleConnectionString {
         return this._connectionString;
     }
@@ -243,7 +254,7 @@ export class ChronicleConnection implements ChronicleServices {
         }
 
         this._isConnected = false;
-        this._clientsReady = this.createClients();
+        this._clientsReady = runInBackgroundContext(() => this.createClients());
         await this._clientsReady;
     }
 
@@ -283,7 +294,8 @@ export class ChronicleConnection implements ChronicleServices {
 
         this._channel = createChannel(serverAddress, credentials, channelOptions);
 
-        const factory = createClientFactory().use(this.createAuthMiddleware(tokenProvider));
+        // nice-grpc invokes the last middleware first: auth retries re-enter propagation.
+        const factory = createClientFactory().use(traceContextMiddleware).use(this.createAuthMiddleware(tokenProvider));
         this._connections = factory.create(ConnectionServiceDefinition, this._channel);
         this._compatibility = new CompatibilityPreflight(this._connections, this._options.connectTimeout ?? 10_000);
         const eventSequenceFactory = factory.use(this._compatibility.middleware());
@@ -360,7 +372,7 @@ export class ChronicleConnection implements ChronicleServices {
 
     private createAuthMiddleware(tokenProvider: ITokenProvider): ClientMiddleware {
         const connectionString = this._connectionString;
-        const logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/ChronicleConnection' });
+        const logger = createLogger('@cratis/chronicle/ChronicleConnection', this.logger);
         const loggedFailures = new WeakSet<Error>();
 
         return async function* authMiddleware(call, options) {
@@ -373,7 +385,7 @@ export class ChronicleConnection implements ChronicleServices {
                 tokenFailure = error instanceof Error ? error : new Error(String(error));
                 if (!loggedFailures.has(tokenFailure)) {
                     loggedFailures.add(tokenFailure);
-                    logger.warn('Failed to obtain OAuth2 token; sending RPC without authorization', { error: tokenFailure.message });
+                    logger.warn('Failed to obtain OAuth2 token; sending RPC without authorization', { error: tokenFailure });
                 }
             }
             if (!token) tokenFailure ??= tokenProvider.lastTokenFailure;

package/connection/CompatibilityPreflight.ts

@@ -6,6 +6,7 @@ import { chronicleDescriptorSet, type ConnectionServiceClient } from '@cratis/ch
 import { ClientError, Status, type ClientMiddleware } from 'nice-grpc-common';
 import { IncompatibleChronicleServer } from './IncompatibleChronicleServer.js';
 import { clientVersion } from './clientVersion.js';
+import { runInBackgroundContext } from '../telemetry/runInBackgroundContext.js';
 
 const require = createRequire(import.meta.url);
 const protocolVersion = (require('@cratis/chronicle.contracts/package.json') as { version: string }).version;
@@ -19,7 +20,7 @@ export class CompatibilityPreflight {
     /** Shares in-flight checks and caches verdicts for this channel; transient failures can be retried. */
     verify(): Promise<void> {
         if (!this._verification) {
-            const verification = this.check().catch(error => {
+            const verification = runInBackgroundContext(() => this.check()).catch(error => {
                 if (!(error instanceof IncompatibleChronicleServer) && this._verification === verification) {
                     this._verification = undefined;
                 }

package/connection/KernelKeepAlive.ts

@@ -1,7 +1,9 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { diag } from '@opentelemetry/api';
+import { createLogger } from '../logging/createLogger.js';
+import { runInBackgroundContext } from '../telemetry/runInBackgroundContext.js';
+import type { IChronicleLogger } from '../logging/IChronicleLogger.js';
 import type { ConnectRequest } from '@cratis/chronicle.contracts';
 
 /**
@@ -49,9 +51,7 @@ export class KernelKeepAlive {
     /** How long a single answer may take before the connection is considered dead. */
     static readonly defaultAnswerTimeoutMs = 5000;
 
-    private readonly _logger = diag.createComponentLogger({
-        namespace: '@cratis/chronicle/KernelKeepAlive'
-    });
+    private readonly _logger: ReturnType<typeof createLogger>;
 
     private readonly _idleTimeoutMs: number;
     private readonly _answerTimeoutMs: number;
@@ -65,8 +65,10 @@ export class KernelKeepAlive {
     constructor(
         private readonly connections: IKeepAliveConnections,
         private readonly onConnectionLost: (reason: string, error: unknown) => void,
-        timeouts: KeepAliveTimeouts = {}
+        timeouts: KeepAliveTimeouts = {},
+        logger?: IChronicleLogger
     ) {
+        this._logger = createLogger('@cratis/chronicle/KernelKeepAlive', logger);
         this._idleTimeoutMs = timeouts.idleTimeoutMs ?? KernelKeepAlive.defaultIdleTimeoutMs;
         this._answerTimeoutMs = timeouts.answerTimeoutMs ?? KernelKeepAlive.defaultAnswerTimeoutMs;
     }
@@ -79,7 +81,11 @@ export class KernelKeepAlive {
      * @param request - The connect request identifying this client.
      * @param signal - Aborted to stop the keep-alive entirely.
      */
-    async start(request: ConnectRequest, signal: AbortSignal): Promise<void> {
+    start(request: ConnectRequest, signal: AbortSignal): Promise<void> {
+        return runInBackgroundContext(() => this.openStream(request, signal));
+    }
+
+    private async openStream(request: ConnectRequest, signal: AbortSignal): Promise<void> {
         const stream = this.connections.connect(request, { signal });
         const iterator = stream[Symbol.asyncIterator]();
 
@@ -136,7 +142,7 @@ export class KernelKeepAlive {
     private connectionLost(reason: string, error: unknown): void {
         this._logger.warn('Kernel keep-alive lost the connection', {
             reason,
-            error: error instanceof Error ? error.message : String(error)
+            error
         });
         this.onConnectionLost(reason, error);
     }

package/connection/TokenProvider.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { fetchOAuthAccessToken, OAuthTokenHttpError, type OAuthTokenResponse } from './fetchOAuthAccessToken.js';
+import { runInBackgroundContext } from '../telemetry/runInBackgroundContext.js';
 
 // Refresh once the token has less than this long left before it expires.
 const TOKEN_REFRESH_MARGIN_MS = 60_000;
@@ -99,7 +100,8 @@ export class OAuthTokenProvider implements ITokenProvider {
             return undefined;
         }
 
-        this._refreshPromise = this.fetchAndCacheAccessToken();
+        // Acquisition is shared client-owned work, not part of the caller's business trace.
+        this._refreshPromise = runInBackgroundContext(() => this.fetchAndCacheAccessToken());
         try {
             return await this._refreshPromise;
         } finally {

package/connection/TraceContextMiddleware.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { context, propagation } from '@opentelemetry/api';
+import { Metadata, type ClientMiddleware, type ClientMiddlewareCall, type CallOptions } from 'nice-grpc-common';
+import { correlationIdManager } from '../correlation/index.js';
+import { WellKnownTelemetryNames } from '../WellKnownTelemetryNames.js';
+
+/** Injects host-configured propagation for every RPC without mutating caller metadata or baggage. */
+export const traceContextMiddleware: ClientMiddleware = async function* <Request, Response>(call: ClientMiddlewareCall<Request, Response>, options: CallOptions) {
+    const metadata = options.metadata ? Metadata(options.metadata) : Metadata();
+    // These headers belong to the active context, never to a stale caller-supplied carrier.
+    for (const field of new Set(['traceparent', 'tracestate', 'baggage', ...propagation.fields()])) metadata.delete(field);
+    const active = context.active();
+    const key = WellKnownTelemetryNames.attributes.correlationId;
+    const correlation = correlationIdManager.scoped?.toString() ?? propagation.getBaggage(active)?.getEntry(key)?.value;
+    const filtered = propagation.setBaggage(active, propagation.createBaggage(correlation ? { [key]: { value: correlation } } : {}));
+    propagation.inject(filtered, metadata, { set: (carrier, name, value) => carrier.set(name, value) });
+    const iterator: AsyncGenerator<Response, Response | void, undefined> = context.with(filtered, () => call.next(call.request, { ...options, metadata }));
+    // Async generators execute on each advance, not at creation. Bind all advances,
+    // including cancellation/error cleanup, so gRPC instrumentation cannot restore
+    // the caller's forbidden baggage. context.with restores the consumer's scope.
+    const downstream: AsyncIterableIterator<Response, Response | void, undefined> = {
+        [Symbol.asyncIterator]() { return this; },
+        next: value => context.with(filtered, () => iterator.next(value)),
+        return: value => context.with(filtered, () => iterator.return(value)),
+        throw: error => context.with(filtered, () => iterator.throw(error))
+    };
+    return yield* downstream;
+};

package/connection/for_ChronicleConnection/when_creating_clients/with_correlated_multi_host_callers.spec.ts

@@ -0,0 +1,73 @@
+// 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, vi } from 'vitest';
+import { context, propagation, trace, type Context } from '@opentelemetry/api';
+import { createServer, type ServiceImplementation } from 'nice-grpc';
+import { ConnectionServiceDefinition } from '@cratis/chronicle.contracts';
+import { ChronicleConnection } from '../../ChronicleConnection.js';
+import { CorrelationId, correlationIdManager } from '../../../correlation/index.js';
+import { telemetrySession } from '../../../telemetry/for_ChronicleTelemetry/given/a_telemetry_session.fixture.js';
+
+const should = chai.should();
+const telemetry = telemetrySession();
+let server: ReturnType<typeof createServer>;
+let connection: ChronicleConnection;
+let probes: { url: string; method: string; active: Context; correlation: CorrelationId | undefined; headers: Record<string, string> }[];
+
+beforeEach(async () => {
+    probes = [];
+    server = createServer();
+    const unused = async () => { throw new Error('Unexpected RPC'); };
+    server.add(ConnectionServiceDefinition, {
+        ...Object.fromEntries(Object.keys(ConnectionServiceDefinition.methods).map(name => [name, unused])),
+        checkCompatibility: async () => ({ IsCompatible: true, Incompatibilities: [], ServerVersion: 'test' })
+    } as ServiceImplementation<typeof ConnectionServiceDefinition>);
+    const port = await server.listen('127.0.0.1:0');
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (input, options) => {
+        await Promise.resolve();
+        const active = context.active();
+        const headers: Record<string, string> = {};
+        propagation.inject(active, headers);
+        const url = String(input);
+        probes.push({ url, method: options?.method ?? 'GET', active, correlation: correlationIdManager.scoped, headers });
+        return new Response(url.includes(`:${port}/`) ? '0' : '1');
+    });
+    const correlation = new CorrelationId('constructing-business');
+    const span = telemetry.traces.getTracer('host').startSpan('constructing-caller');
+    const active = propagation.setBaggage(trace.setSpan(context.active(), span), propagation.createBaggage({
+        'cratis.correlation_id': { value: correlation.toString() }, email: { value: 'private@example.com' }
+    }));
+    try {
+        await context.with(active, () => correlationIdManager.run(correlation, async () => {
+            connection = new ChronicleConnection({
+                connectionString: `chronicle://127.0.0.1:${port},127.0.0.1:1?disableTls=true&apiKey=test`
+            });
+            await connection.connect();
+            await connection.resetChannel();
+            context.active().should.equal(active);
+            correlationIdManager.scoped!.should.equal(correlation);
+        }));
+    } finally { span.end(); }
+});
+
+afterEach(async () => {
+    connection?.dispose();
+    await server?.shutdown();
+    vi.restoreAllMocks();
+});
+
+describe('when constructing and resetting a multi-host connection inside a business context', () => {
+    it('should detach both count probes and reservation on every client creation', () => {
+        probes.should.have.lengthOf(6);
+        probes.map(probe => probe.method).should.deep.equal(['GET', 'GET', 'POST', 'GET', 'GET', 'POST']);
+        probes.filter(probe => probe.url.endsWith('/connections/count')).should.have.lengthOf(4);
+        probes.filter(probe => probe.url.endsWith('/connections/reserve')).should.have.lengthOf(2);
+        for (const probe of probes) {
+            should.equal(trace.getSpanContext(probe.active), undefined);
+            should.equal(propagation.getBaggage(probe.active), undefined);
+            should.equal(probe.correlation, undefined);
+            probe.headers.should.deep.equal({});
+        }
+    });
+});

package/connection/for_OAuthTokenProvider/when_acquiring_tokens/with_http_instrumentation.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 { afterAll, beforeAll, beforeEach, chai, describe, it } from 'vitest';
+import { context, propagation, trace } from '@opentelemetry/api';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import type { IncomingHttpHeaders, Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { createRequire, syncBuiltinESMExports } from 'node:module';
+import type { OAuthTokenProvider } from '../../TokenProvider.js';
+import { CorrelationId, correlationIdManager } from '../../../correlation/index.js';
+import { telemetrySession } from '../../../telemetry/for_ChronicleTelemetry/given/a_telemetry_session.fixture.js';
+
+const should = chai.should();
+const telemetry = telemetrySession();
+const correlations: Array<CorrelationId | undefined> = [];
+const instrumentation = new HttpInstrumentation({
+    enabled: false,
+    disableIncomingRequestInstrumentation: true,
+    requestHook: () => { correlations.push(correlationIdManager.scoped); }
+});
+let server: Server;
+let Provider: typeof OAuthTokenProvider;
+let endpoint: string;
+let lifetime: number;
+let requests: number;
+let received: IncomingHttpHeaders[];
+
+beforeAll(async () => {
+    instrumentation.setTracerProvider(telemetry.traces);
+    instrumentation.enable();
+    // Vitest does not install the host's ESM loader hooks. Trigger the real require hook
+    // and synchronize the patched built-in exports before loading the provider's transport.
+    const { createServer } = createRequire(import.meta.url)('node:http') as typeof import('node:http');
+    syncBuiltinESMExports();
+    Provider = (await import('../../TokenProvider.js')).OAuthTokenProvider;
+    server = createServer((request, response) => {
+        received.push(request.headers);
+        request.resume();
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ access_token: `token-${++requests}`, expires_in: lifetime }));
+    });
+    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+    endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}/connect/token`;
+});
+
+afterAll(async () => {
+    instrumentation.disable();
+    syncBuiltinESMExports();
+    if (server) await new Promise<void>((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+});
+
+for (const acquisition of ['initial', 'expiring', 'forced'] as const) {
+    describe(`when ${acquisition} token acquisition is shared by correlated callers`, () => {
+        let callerTraceIds: string[];
+        let tokens: Array<string | undefined>;
+        beforeEach(async () => {
+            received = [];
+            requests = 0;
+            lifetime = acquisition === 'expiring' ? 30 : 3600;
+            const provider = new Provider(endpoint, 'client', 'secret');
+            if (acquisition !== 'initial') await provider.getAccessToken();
+            received.length = 0;
+            correlations.length = 0;
+            telemetry.spans.reset();
+            callerTraceIds = [];
+            const pending = ['first', 'second'].map((caller, index) => {
+                const correlation = new CorrelationId(`${caller}-business`);
+                const span = telemetry.traces.getTracer('host').startSpan(caller);
+                callerTraceIds.push(span.spanContext().traceId);
+                const active = propagation.setBaggage(trace.setSpan(context.active(), span), propagation.createBaggage({
+                    'cratis.correlation_id': { value: correlation.toString() },
+                    email: { value: 'private@example.com' },
+                    'cratis.tenant.id': { value: 'private-tenant' }
+                }));
+                return context.with(active, () => correlationIdManager.run(correlation, async () => {
+                    try {
+                        const token = await (index === 0 && acquisition === 'forced' ? provider.refresh() : provider.getAccessToken());
+                        context.active().should.equal(active);
+                        correlationIdManager.scoped!.should.equal(correlation);
+                        return token;
+                    } finally { span.end(); }
+                }));
+            });
+            tokens = await Promise.all(pending);
+        });
+        it('should send one shared request without caller trace or baggage', () => {
+            received.should.have.lengthOf(1);
+            should.equal(received[0].baggage, undefined);
+            for (const traceId of callerTraceIds) String(received[0].traceparent).should.not.contain(traceId);
+            const token = acquisition === 'initial' ? 'token-1' : 'token-2';
+            tokens.should.deep.equal([token, token]);
+        });
+        it('should let enabled HTTP instrumentation create a detached root span', () => {
+            const spans = telemetry.spans.getFinishedSpans().filter(span => span.instrumentationScope.name === '@opentelemetry/instrumentation-http');
+            spans.should.have.lengthOf(1);
+            should.equal(spans[0].parentSpanContext, undefined);
+            String(received[0].traceparent).should.contain(spans[0].spanContext().traceId);
+            correlations.should.deep.equal([undefined]);
+        });
+    });
+}