|
| 1 | +import { Then } from '@cucumber/cucumber'; |
| 2 | +import { strict as assert } from 'assert'; |
| 3 | +import { Utils } from 'cli-testing'; |
| 4 | +import Zenko from 'world/Zenko'; |
| 5 | + |
| 6 | +const JAEGER_POLL_TIMEOUT = 30000; |
| 7 | +const JAEGER_POLL_INTERVAL = 2000; |
| 8 | + |
| 9 | +interface JaegerProcess { |
| 10 | + serviceName: string; |
| 11 | + tags: { key: string; value: string }[]; |
| 12 | +} |
| 13 | + |
| 14 | +interface JaegerSpan { |
| 15 | + traceID: string; |
| 16 | + spanID: string; |
| 17 | + operationName: string; |
| 18 | + processID: string; |
| 19 | + tags: { key: string; type: string; value: unknown }[]; |
| 20 | +} |
| 21 | + |
| 22 | +interface JaegerTrace { |
| 23 | + traceID: string; |
| 24 | + spans: JaegerSpan[]; |
| 25 | + processes: Record<string, JaegerProcess>; |
| 26 | +} |
| 27 | + |
| 28 | +interface JaegerSearchResponse { |
| 29 | + data: JaegerTrace[]; |
| 30 | +} |
| 31 | + |
| 32 | +async function pollJaegerForTraces( |
| 33 | + endpoint: string, |
| 34 | + service: string, |
| 35 | + bucketName: string, |
| 36 | + timeoutMs = JAEGER_POLL_TIMEOUT, |
| 37 | + intervalMs = JAEGER_POLL_INTERVAL, |
| 38 | +): Promise<JaegerTrace[]> { |
| 39 | + const deadline = Date.now() + timeoutMs; |
| 40 | + let lastError: Error | null = null; |
| 41 | + |
| 42 | + while (Date.now() < deadline) { |
| 43 | + try { |
| 44 | + const url = `${endpoint}/api/traces?service=${service}&lookback=1m&limit=100`; |
| 45 | + const response = await fetch(url, { |
| 46 | + signal: AbortSignal.timeout(5000), |
| 47 | + }); |
| 48 | + if (!response.ok) { |
| 49 | + throw new Error(`Jaeger query returned HTTP ${response.status}`); |
| 50 | + } |
| 51 | + const body = await response.json() as JaegerSearchResponse; |
| 52 | + const matching = (body.data || []).filter(trace => traceMatchesBucket(trace, bucketName)); |
| 53 | + if (matching.length > 0) { |
| 54 | + return matching; |
| 55 | + } |
| 56 | + } catch (err) { |
| 57 | + lastError = err as Error; |
| 58 | + } |
| 59 | + await Utils.sleep(intervalMs); |
| 60 | + } |
| 61 | + |
| 62 | + throw new Error( |
| 63 | + `pollJaegerForTraces timed out after ${timeoutMs}ms waiting for traces ` + |
| 64 | + `from service "${service}" referencing bucket "${bucketName}"` + |
| 65 | + `${lastError ? `: ${lastError.message}` : ''}`, |
| 66 | + ); |
| 67 | +} |
| 68 | + |
| 69 | +function traceMatchesBucket(trace: JaegerTrace, bucketName: string): boolean { |
| 70 | + return trace.spans.some(span => |
| 71 | + span.tags.some(tag => |
| 72 | + typeof tag.value === 'string' && tag.value.includes(bucketName), |
| 73 | + ), |
| 74 | + ); |
| 75 | +} |
| 76 | + |
| 77 | +function findPutObjectTrace(traces: JaegerTrace[]): JaegerTrace | undefined { |
| 78 | + return traces.find(trace => |
| 79 | + trace.spans.some(span => span.operationName === 'api.object_put'), |
| 80 | + ); |
| 81 | +} |
| 82 | + |
| 83 | +function traceHasServiceSpans(trace: JaegerTrace, serviceName: string): boolean { |
| 84 | + const processIds = Object.entries(trace.processes) |
| 85 | + .filter(([, proc]) => proc.serviceName === serviceName) |
| 86 | + .map(([id]) => id); |
| 87 | + |
| 88 | + return trace.spans.some(span => processIds.includes(span.processID)); |
| 89 | +} |
| 90 | + |
| 91 | +Then('a trace should exist in Jaeger for service {string}', |
| 92 | + { timeout: JAEGER_POLL_TIMEOUT + 10000 }, |
| 93 | + async function (this: Zenko, service: string) { |
| 94 | + const endpoint = this.parameters.JaegerQueryEndpoint; |
| 95 | + assert.ok(endpoint, 'JaegerQueryEndpoint is not configured in world parameters'); |
| 96 | + |
| 97 | + const bucketName = this.getSaved<string>('bucketName'); |
| 98 | + assert.ok(bucketName, 'No bucketName saved from a previous step'); |
| 99 | + |
| 100 | + const traces = await pollJaegerForTraces(endpoint, service, bucketName); |
| 101 | + const trace = findPutObjectTrace(traces); |
| 102 | + assert.ok(trace, |
| 103 | + `No trace with api.object_put operation found among ${traces.length} traces from ` + |
| 104 | + `service "${service}" referencing bucket "${bucketName}"`, |
| 105 | + ); |
| 106 | + |
| 107 | + this.addToSaved('jaegerTrace', trace); |
| 108 | + }, |
| 109 | +); |
| 110 | + |
| 111 | +Then('the trace should contain spans from service {string}', |
| 112 | + async function (this: Zenko, service: string) { |
| 113 | + const trace = this.getSaved<JaegerTrace>('jaegerTrace'); |
| 114 | + assert.ok(trace, 'No trace saved from the previous step'); |
| 115 | + |
| 116 | + assert.ok( |
| 117 | + traceHasServiceSpans(trace, service), |
| 118 | + `Trace ${trace.traceID} does not contain spans from service "${service}". ` + |
| 119 | + `Services in trace: ${[...new Set( |
| 120 | + Object.values(trace.processes).map(p => p.serviceName), |
| 121 | + )].join(', ')}`, |
| 122 | + ); |
| 123 | + }, |
| 124 | +); |
0 commit comments