From 0e0e49c6cbb46faec9964300cdc2e10c124a6374 Mon Sep 17 00:00:00 2001 From: Daniel Bruce Date: Mon, 2 Nov 2026 20:21:37 +0000 Subject: [PATCH 1/5] fix(spanner): ensure OpenTelemetry context manager on cached tracing path --- handwritten/spanner/src/instrument.ts | 3 +- handwritten/spanner/test/instrument.ts | 93 ++++++++++++++++++++++---- 2 files changed, 82 insertions(+), 14 deletions(-) diff --git a/handwritten/spanner/src/instrument.ts b/handwritten/spanner/src/instrument.ts index f483e3c890cf..3724a9ee1457 100644 --- a/handwritten/spanner/src/instrument.ts +++ b/handwritten/spanner/src/instrument.ts @@ -115,7 +115,7 @@ function getQueryTraceConfig(query?: string | QueryWithRequestOptions | null): { return {}; } -const SPAN_NAMESPACE_PREFIX = 'CloudSpanner'; // TODO: discuss & standardize this prefix. +const SPAN_NAMESPACE_PREFIX = 'CloudSpanner'; // TODO(https://github.com/googleapis/google-cloud-node/issues/9610): discuss & standardize this prefix. export { SPAN_NAMESPACE_PREFIX, traceConfig, @@ -169,6 +169,7 @@ const CACHE_TTL_MS = 10000; // 10 seconds TTL */ function isGlobalTracingEnabled(): boolean { if (globalTracingEnabled === true) { + ensureInitialContextManagerSet(); return true; } const now = Date.now(); diff --git a/handwritten/spanner/test/instrument.ts b/handwritten/spanner/test/instrument.ts index 697545f30626..d9bb78e1029a 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -18,6 +18,7 @@ import * as assert from 'assert'; import {context} from '@opentelemetry/api'; import {describe, it} from 'mocha'; import { + _resetTracingEnabledForTest, ensureInitialContextManagerSet, getActiveOrNoopSpan, getQueryTraceConfig, @@ -133,22 +134,88 @@ describe('instrument', () => { return trace.setSpan(ctx, span); } - let activeSpanAfterAwait: unknown; - await startTrace( - 'Test.asyncSpan', - {opts: {tracerProvider: fakeTracerProvider as any}}, - async span => { + try { + let activeSpanAfterAwait: unknown; + await startTrace( + 'Test.asyncSpan', + {opts: {tracerProvider: fakeTracerProvider as any}}, + async span => { + await Promise.resolve(); + activeSpanAfterAwait = getActiveOrNoopSpan(); + span.end(); + }, + ); + + assert.strictEqual( + (activeSpanAfterAwait as any)?.spanContext?.().spanId, + '2'.repeat(16), + ); + } finally { + ensureInitialContextManagerSet(); + } + }); + + it('should re-enable context manager on cached global tracing check after context.disable()', async () => { + const {trace} = require('@opentelemetry/api'); + const fakeTracerProvider = { + getTracer: () => ({ + startActiveSpan: ( + _name: string, + _opts: unknown, + fn: (span: unknown) => unknown, + ) => { + const fakeSpan = { + spanContext: () => ({ + traceId: '3'.repeat(32), + spanId: '4'.repeat(16), + traceFlags: 1, + }), + setAttribute: () => fakeSpan, + setAttributes: () => fakeSpan, + addEvent: () => fakeSpan, + setStatus: () => fakeSpan, + updateName: () => fakeSpan, + end: () => {}, + isRecording: () => true, + recordException: () => {}, + }; + return context.with(trace.setSpan(context.active(), fakeSpan), () => + fn(fakeSpan), + ); + }, + }), + }; + + const origGetTracerProvider = trace.getTracerProvider; + const origGetTracer = trace.getTracer; + _resetTracingEnabledForTest(); + trace.getTracerProvider = (() => fakeTracerProvider) as any; + trace.getTracer = (() => fakeTracerProvider.getTracer()) as any; + try { + // First trace primes globalTracingEnabled = true + await startTrace('Test.primedSpan', undefined, async span => { + span.end(); + }); + // Disable context manager while globalTracingEnabled remains cached as true + context.disable(); + + let activeSpanAfterAwait: unknown; + await startTrace('Test.cachedGlobalSpan', undefined, async span => { await Promise.resolve(); activeSpanAfterAwait = getActiveOrNoopSpan(); span.end(); - }, - ); - - assert.strictEqual( - (activeSpanAfterAwait as any)?.spanContext?.().spanId, - '2'.repeat(16), - ); - context.disable(); + }); + + assert.strictEqual( + (activeSpanAfterAwait as any)?.spanContext?.().spanId, + '4'.repeat(16), + ); + } finally { + trace.getTracerProvider = origGetTracerProvider; + trace.getTracer = origGetTracer; + _resetTracingEnabledForTest(); + ensureInitialContextManagerSet(); + } }); }); }); From a86787a8b4909397d91aead1d5527bd142850a1d Mon Sep 17 00:00:00 2001 From: danieljbruce Date: Tue, 3 Nov 2026 16:19:50 -0500 Subject: [PATCH 2/5] Update handwritten/spanner/test/instrument.ts Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com> --- handwritten/spanner/test/instrument.ts | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/handwritten/spanner/test/instrument.ts b/handwritten/spanner/test/instrument.ts index d9bb78e1029a..7de5fce80f3c 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -186,11 +186,8 @@ describe('instrument', () => { }), }; - const origGetTracerProvider = trace.getTracerProvider; - const origGetTracer = trace.getTracer; _resetTracingEnabledForTest(); - trace.getTracerProvider = (() => fakeTracerProvider) as any; - trace.getTracer = (() => fakeTracerProvider.getTracer()) as any; + trace.setGlobalTracerProvider(fakeTracerProvider as any); try { // First trace primes globalTracingEnabled = true await startTrace('Test.primedSpan', undefined, async span => { From ce9c35950c3f3a6a9b8aa84bb7f8a5e4d89d7527 Mon Sep 17 00:00:00 2001 From: danieljbruce Date: Tue, 3 Nov 2026 16:20:10 -0500 Subject: [PATCH 3/5] Update handwritten/spanner/test/instrument.ts Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com> --- handwritten/spanner/test/instrument.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/handwritten/spanner/test/instrument.ts b/handwritten/spanner/test/instrument.ts index 7de5fce80f3c..b29eb2842ce6 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -208,8 +208,7 @@ describe('instrument', () => { '4'.repeat(16), ); } finally { - trace.getTracerProvider = origGetTracerProvider; - trace.getTracer = origGetTracer; + trace.disable(); _resetTracingEnabledForTest(); ensureInitialContextManagerSet(); } From d7483de78e28829b2ab022015dd4a11cd30c2455 Mon Sep 17 00:00:00 2001 From: Daniel Bruce Date: Tue, 3 Nov 2026 22:56:01 +0000 Subject: [PATCH 4/5] [Address CI errors] stub trace.getTracerProvider in instrument test to avoid global provider collision --- handwritten/spanner/test/instrument.ts | 35 +++++++++++++++----------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/handwritten/spanner/test/instrument.ts b/handwritten/spanner/test/instrument.ts index b29eb2842ce6..edc400571aef 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -15,8 +15,9 @@ */ import * as assert from 'assert'; -import {context} from '@opentelemetry/api'; +import {Span, TracerProvider, context, trace} from '@opentelemetry/api'; import {describe, it} from 'mocha'; +import * as sinon from 'sinon'; import { _resetTracingEnabledForTest, ensureInitialContextManagerSet, @@ -116,29 +117,30 @@ describe('instrument', () => { setAttribute: () => fakeSpan, setAttributes: () => fakeSpan, addEvent: () => fakeSpan, + addLink: () => fakeSpan, + addLinks: () => fakeSpan, setStatus: () => fakeSpan, updateName: () => fakeSpan, end: () => {}, isRecording: () => true, recordException: () => {}, }; - return context.with(traceSetSpan(context.active(), fakeSpan), () => + return context.with(trace.setSpan(context.active(), fakeSpan), () => fn(fakeSpan), ); }, }), }; - const {trace} = require('@opentelemetry/api'); - function traceSetSpan(ctx: unknown, span: unknown) { - return trace.setSpan(ctx, span); - } - try { - let activeSpanAfterAwait: unknown; + let activeSpanAfterAwait: Span | undefined; await startTrace( 'Test.asyncSpan', - {opts: {tracerProvider: fakeTracerProvider as any}}, + { + opts: { + tracerProvider: fakeTracerProvider as unknown as TracerProvider, + }, + }, async span => { await Promise.resolve(); activeSpanAfterAwait = getActiveOrNoopSpan(); @@ -147,7 +149,7 @@ describe('instrument', () => { ); assert.strictEqual( - (activeSpanAfterAwait as any)?.spanContext?.().spanId, + activeSpanAfterAwait?.spanContext().spanId, '2'.repeat(16), ); } finally { @@ -156,7 +158,6 @@ describe('instrument', () => { }); it('should re-enable context manager on cached global tracing check after context.disable()', async () => { - const {trace} = require('@opentelemetry/api'); const fakeTracerProvider = { getTracer: () => ({ startActiveSpan: ( @@ -173,6 +174,8 @@ describe('instrument', () => { setAttribute: () => fakeSpan, setAttributes: () => fakeSpan, addEvent: () => fakeSpan, + addLink: () => fakeSpan, + addLinks: () => fakeSpan, setStatus: () => fakeSpan, updateName: () => fakeSpan, end: () => {}, @@ -187,7 +190,9 @@ describe('instrument', () => { }; _resetTracingEnabledForTest(); - trace.setGlobalTracerProvider(fakeTracerProvider as any); + const getTracerProviderStub = sinon + .stub(trace, 'getTracerProvider') + .returns(fakeTracerProvider as unknown as TracerProvider); try { // First trace primes globalTracingEnabled = true await startTrace('Test.primedSpan', undefined, async span => { @@ -196,7 +201,7 @@ describe('instrument', () => { // Disable context manager while globalTracingEnabled remains cached as true context.disable(); - let activeSpanAfterAwait: unknown; + let activeSpanAfterAwait: Span | undefined; await startTrace('Test.cachedGlobalSpan', undefined, async span => { await Promise.resolve(); activeSpanAfterAwait = getActiveOrNoopSpan(); @@ -204,11 +209,11 @@ describe('instrument', () => { }); assert.strictEqual( - (activeSpanAfterAwait as any)?.spanContext?.().spanId, + activeSpanAfterAwait?.spanContext().spanId, '4'.repeat(16), ); } finally { - trace.disable(); + getTracerProviderStub.restore(); _resetTracingEnabledForTest(); ensureInitialContextManagerSet(); } From a868341945eaf61fdef34def0f945107eb254ae9 Mon Sep 17 00:00:00 2001 From: Daniel Bruce Date: Wed, 4 Nov 2026 14:55:37 +0000 Subject: [PATCH 5/5] fix(spanner): skip setGlobalContextManager when context manager already set --- handwritten/spanner/src/instrument.ts | 9 ++++ handwritten/spanner/test/instrument.ts | 64 +++++++++++++++++++++++++- 2 files changed, 72 insertions(+), 1 deletion(-) diff --git a/handwritten/spanner/src/instrument.ts b/handwritten/spanner/src/instrument.ts index 3724a9ee1457..8f90e2484818 100644 --- a/handwritten/spanner/src/instrument.ts +++ b/handwritten/spanner/src/instrument.ts @@ -145,6 +145,15 @@ let defaultContextManager: ContextManager | undefined; * was called. */ function ensureInitialContextManagerSet() { + const currentContextManager = ( + context as unknown as {_getContextManager?: () => ContextManager} + )._getContextManager?.(); + if ( + currentContextManager && + currentContextManager.constructor?.name !== 'NoopContextManager' + ) { + return; + } if (!defaultContextManager) { const ContextManagerClass = AsyncLocalStorageContextManager || AsyncHooksContextManager; diff --git a/handwritten/spanner/test/instrument.ts b/handwritten/spanner/test/instrument.ts index edc400571aef..cc7138deb40f 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -15,7 +15,7 @@ */ import * as assert from 'assert'; -import {Span, TracerProvider, context, trace} from '@opentelemetry/api'; +import {Span, TracerProvider, context, diag, trace} from '@opentelemetry/api'; import {describe, it} from 'mocha'; import * as sinon from 'sinon'; import { @@ -218,5 +218,67 @@ describe('instrument', () => { ensureInitialContextManagerSet(); } }); + + it('should not call setGlobalContextManager or diag.error when a context manager is already registered', async () => { + const fakeTracerProvider = { + getTracer: () => ({ + startActiveSpan: ( + _name: string, + _opts: unknown, + fn: (span: unknown) => unknown, + ) => { + const fakeSpan = { + spanContext: () => ({ + traceId: '5'.repeat(32), + spanId: '6'.repeat(16), + traceFlags: 1, + }), + setAttribute: () => fakeSpan, + setAttributes: () => fakeSpan, + addEvent: () => fakeSpan, + addLink: () => fakeSpan, + addLinks: () => fakeSpan, + setStatus: () => fakeSpan, + updateName: () => fakeSpan, + end: () => {}, + isRecording: () => true, + recordException: () => {}, + }; + return context.with(trace.setSpan(context.active(), fakeSpan), () => + fn(fakeSpan), + ); + }, + }), + }; + + context.disable(); + ensureInitialContextManagerSet(); + _resetTracingEnabledForTest(); + + const sandbox = sinon.createSandbox(); + const setGlobalSpy = sandbox.spy(context, 'setGlobalContextManager'); + const diagErrorSpy = sandbox.spy(diag, 'error'); + sandbox + .stub(trace, 'getTracerProvider') + .returns(fakeTracerProvider as unknown as TracerProvider); + + try { + // First trace sets globalTracingEnabled = true; subsequent traces hit the cached fast path + await startTrace('Test.first', undefined, async span => { + span.end(); + }); + await startTrace('Test.second', undefined, async span => { + span.end(); + }); + ensureInitialContextManagerSet(); + + assert.strictEqual(setGlobalSpy.callCount, 0); + assert.strictEqual(diagErrorSpy.callCount, 0); + } finally { + sandbox.restore(); + _resetTracingEnabledForTest(); + ensureInitialContextManagerSet(); + } + }); }); });