diff --git a/handwritten/spanner/src/instrument.ts b/handwritten/spanner/src/instrument.ts index f483e3c890cf..8f90e2484818 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, @@ -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; @@ -169,6 +178,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..cc7138deb40f 100644 --- a/handwritten/spanner/test/instrument.ts +++ b/handwritten/spanner/test/instrument.ts @@ -15,9 +15,11 @@ */ import * as assert from 'assert'; -import {context} from '@opentelemetry/api'; +import {Span, TracerProvider, context, diag, trace} from '@opentelemetry/api'; import {describe, it} from 'mocha'; +import * as sinon from 'sinon'; import { + _resetTracingEnabledForTest, ensureInitialContextManagerSet, getActiveOrNoopSpan, getQueryTraceConfig, @@ -115,40 +117,168 @@ 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: Span | undefined; + await startTrace( + 'Test.asyncSpan', + { + opts: { + tracerProvider: fakeTracerProvider as unknown as TracerProvider, + }, + }, + async span => { + await Promise.resolve(); + activeSpanAfterAwait = getActiveOrNoopSpan(); + span.end(); + }, + ); + + assert.strictEqual( + activeSpanAfterAwait?.spanContext().spanId, + '2'.repeat(16), + ); + } finally { + ensureInitialContextManagerSet(); } + }); - let activeSpanAfterAwait: unknown; - await startTrace( - 'Test.asyncSpan', - {opts: {tracerProvider: fakeTracerProvider as any}}, - async span => { + it('should re-enable context manager on cached global tracing check after context.disable()', async () => { + 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, + addLink: () => fakeSpan, + addLinks: () => fakeSpan, + setStatus: () => fakeSpan, + updateName: () => fakeSpan, + end: () => {}, + isRecording: () => true, + recordException: () => {}, + }; + return context.with(trace.setSpan(context.active(), fakeSpan), () => + fn(fakeSpan), + ); + }, + }), + }; + + _resetTracingEnabledForTest(); + 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 => { + span.end(); + }); + // Disable context manager while globalTracingEnabled remains cached as true + context.disable(); + + let activeSpanAfterAwait: Span | undefined; + await startTrace('Test.cachedGlobalSpan', undefined, async span => { await Promise.resolve(); activeSpanAfterAwait = getActiveOrNoopSpan(); span.end(); - }, - ); + }); + + assert.strictEqual( + activeSpanAfterAwait?.spanContext().spanId, + '4'.repeat(16), + ); + } finally { + getTracerProviderStub.restore(); + _resetTracingEnabledForTest(); + 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), + ); + }, + }), + }; - assert.strictEqual( - (activeSpanAfterAwait as any)?.spanContext?.().spanId, - '2'.repeat(16), - ); 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(); + } }); }); });