Spaces:
Running
Running
| import { context, trace, ROOT_CONTEXT } from '@opentelemetry/api'; | |
| import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks'; | |
| import { BasicTracerProvider, SimpleSpanProcessor, InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'; | |
| import { LoggerProvider, SimpleLogRecordProcessor, InMemoryLogRecordExporter } from '@opentelemetry/sdk-logs'; | |
| import { MeterProvider } from '@opentelemetry/sdk-metrics'; | |
| import { OpenTelemetryRuntimeTelemetry } from '../src/telemetry/opentelemetry'; | |
| import { AbstractSQLTeaQLClient, EntitySchema } from '../src/sql/core'; | |
| import { SQLiteDriver } from '../src/sql/sqlite'; | |
| import { SelectQuery } from '../src/core/ast'; | |
| import { UserContext } from '../src/core/context'; | |
| test('a broken optional SQL-diagnostic capability cannot change a real query result or expose its error', async () => { | |
| const warning = jest.spyOn(console, 'warn').mockImplementation(() => {}); | |
| const diagnostic = jest.fn(); | |
| class Client extends AbstractSQLTeaQLClient { | |
| constructor() {super(new SQLiteDriver(':memory:'), {School: {table:'school_data',columns:{ | |
| id:{columnName:'id',logicalType:'integer',decode:'string'},version:{columnName:'version',logicalType:'integer',decode:'number'}, | |
| }}});} | |
| } | |
| const client = new Client().setDiagnosticSQLLogSink(undefined).setRuntimeTelemetry({ | |
| start: () => ({success() {},failure() {}}), recordDiagnostic: diagnostic, | |
| recordsSQLDiagnostics: () => {throw new Error('PRIVATE-CUSTOM-CAPABILITY');}, | |
| }); | |
| try { | |
| await new UserContext().insertResource('dataService',client).ensureSchema(); | |
| const rows = await client.executeQuery(new SelectQuery('School').limit(1) | |
| .comment('inspect empty fixture').purpose('verify fail-open capability')); | |
| expect(rows).toEqual([]);expect(diagnostic).not.toHaveBeenCalled(); | |
| expect(JSON.stringify(warning.mock.calls)).not.toContain('PRIVATE-CUSTOM-CAPABILITY'); | |
| } finally {await client.close();warning.mockRestore();} | |
| }); | |
| test('out-of-order SQL completion retains its own span and does not replace global SDK context', async () => { | |
| const beforeProvider = trace.getTracerProvider(); | |
| const beforeContext = context.active(); | |
| const manager = new AsyncLocalStorageContextManager().enable(); | |
| const spanExporter = new InMemorySpanExporter(); | |
| const logExporter = new InMemoryLogRecordExporter(); | |
| const tracerProvider = new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(spanExporter)] }); | |
| const loggerProvider = new LoggerProvider({ processors: [new SimpleLogRecordProcessor({ exporter: logExporter })] }); | |
| const meterProvider = new MeterProvider(); | |
| const telemetry = new OpenTelemetryRuntimeTelemetry(tracerProvider.getTracer('io.teaql.runtime'), | |
| meterProvider.getMeter('io.teaql.runtime'), {}, loggerProvider.getLogger('io.teaql.runtime'), { | |
| active: () => manager.active() === ROOT_CONTEXT ? context.active() : manager.active(), | |
| with: (active, work) => manager.with(active, work), | |
| }); | |
| const schemas: Record<string, EntitySchema> = { School: { table: 'school_data', columns: { | |
| id: { columnName: 'id', logicalType: 'integer', decode: 'string' }, | |
| version: { columnName: 'version', logicalType: 'integer', decode: 'number' }, | |
| } } }; | |
| class Driver extends SQLiteDriver { | |
| concurrent = false; | |
| private calls = 0; | |
| private releaseFirst!: () => void; | |
| private readonly secondFinished = new Promise<void>(resolve => { this.releaseFirst = resolve; }); | |
| async query(sql: string, values: any[]) { | |
| if (!this.concurrent) return super.query(sql, values); | |
| const call = ++this.calls; | |
| if (call === 1) await this.secondFinished; | |
| const result = await super.query(sql, values); | |
| if (call === 2) this.releaseFirst(); | |
| return result; | |
| } | |
| } | |
| const driver = new Driver(':memory:'); | |
| class Client extends AbstractSQLTeaQLClient { | |
| constructor() { super(driver, schemas); } | |
| } | |
| const client = new Client().setRuntimeTelemetry(telemetry).setDiagnosticSQLLogSink(undefined); | |
| try { | |
| await new UserContext().insertResource('dataService', client).ensureSchema(); | |
| driver.concurrent = true; | |
| await Promise.all([1, 2].map(limit => client.executeQuery(new SelectQuery('School').limit(limit) | |
| .comment(`concurrent ${limit}`).purpose('verify isolated SQL identity')))); | |
| await Promise.all([tracerProvider.forceFlush(), loggerProvider.forceFlush()]); | |
| const logs = logExporter.getFinishedLogRecords().filter(log => log.body === 'TeaQL SQL execution'); | |
| const spans = spanExporter.getFinishedSpans(); | |
| expect(logs).toHaveLength(2); | |
| expect(logs.map(log => log.attributes['teaql.intent.comment'])).toEqual(['concurrent 2', 'concurrent 1']); | |
| for (const log of logs) { | |
| const provider = spans.find(span => span.spanContext().spanId === log.spanContext?.spanId); | |
| expect(provider?.attributes['teaql.operation.family']).toBe('provider'); | |
| const query = spans.find(span => span.spanContext().spanId === provider?.parentSpanContext?.spanId); | |
| expect(query?.attributes['teaql.operation.family']).toBe('query'); | |
| expect(provider?.spanContext().traceId).toBe(log.spanContext?.traceId); | |
| } | |
| expect(new Set(logs.map(log => log.spanContext?.traceId)).size).toBe(2); | |
| expect(trace.getTracerProvider()).toBe(beforeProvider); | |
| expect(context.active()).toBe(beforeContext); | |
| } finally { | |
| await client.close(); | |
| await Promise.all([tracerProvider.shutdown(), loggerProvider.shutdown(), meterProvider.shutdown()]); | |
| manager.disable(); | |
| } | |
| }); | |
| test('an existing customer SDK stays installed and receives no TeaQL-owned exports', async () => { | |
| const externalManager = new AsyncLocalStorageContextManager().enable(); | |
| context.setGlobalContextManager(externalManager); | |
| const externalExporter = new InMemorySpanExporter(); | |
| const externalProvider = new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(externalExporter)] }); | |
| trace.setGlobalTracerProvider(externalProvider); | |
| const originalGlobalProvider = trace.getTracerProvider(); | |
| const manager = new AsyncLocalStorageContextManager().enable(); | |
| const ownExporter = new InMemorySpanExporter(); | |
| const ownProvider = new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(ownExporter)] }); | |
| const meterProvider = new MeterProvider(); | |
| const telemetry = new OpenTelemetryRuntimeTelemetry(ownProvider.getTracer('io.teaql.runtime'), | |
| meterProvider.getMeter('io.teaql.runtime'), {}, undefined, { | |
| active: () => manager.active() === ROOT_CONTEXT ? context.active() : manager.active(), | |
| with: (active, work) => manager.with(active, work), | |
| }); | |
| const externalSpan = externalProvider.getTracer('customer').startSpan('HTTP request'); | |
| try { | |
| await context.with(trace.setSpan(context.active(), externalSpan), async () => { | |
| const scope = telemetry.start({ family: 'query', name: 'Order.list' }); | |
| await scope.run!(async () => {}); scope.success(); | |
| expect(trace.getTracerProvider()).toBe(originalGlobalProvider); | |
| expect(trace.getSpan(context.active())).toBe(externalSpan); | |
| }); | |
| await ownProvider.forceFlush(); | |
| expect(ownExporter.getFinishedSpans()).toHaveLength(1); | |
| expect(ownExporter.getFinishedSpans()[0].parentSpanContext?.spanId).toBe(externalSpan.spanContext().spanId); | |
| expect(externalExporter.getFinishedSpans()).toHaveLength(0); | |
| await ownProvider.shutdown(); manager.disable(); | |
| externalSpan.end(); await externalProvider.forceFlush(); | |
| expect(externalExporter.getFinishedSpans()).toHaveLength(1); | |
| expect(trace.getTracerProvider()).toBe(originalGlobalProvider); | |
| } finally { | |
| externalSpan.end(); | |
| await ownProvider.shutdown(); manager.disable(); | |
| await externalProvider.shutdown(); await meterProvider.shutdown(); | |
| context.disable(); trace.disable(); externalManager.disable(); | |
| } | |
| }); | |