diff --git a/package-lock.json b/package-lock.json index 1cc4b28d..bb4d0e46 100644 --- a/package-lock.json +++ b/package-lock.json @@ -16829,9 +16829,9 @@ "integrity": "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==" }, "node_modules/semver": { - "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "version": "6.3.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.2.tgz", + "integrity": "sha512-GYrCADwpu6yV5OAvchkQ27Z5wwMxWAEMg5NNWjyHh/5DboFFqbdbvYNIvZouQpxXyeMPoTOh0vdPYKlf0ZswdQ==", "dev": true, "bin": { "semver": "bin/semver.js" @@ -19268,7 +19268,7 @@ "semver": "^7.5.3" }, "devDependencies": { - "@aws/lambda-invoke-store": "^0.2.0" + "@aws/lambda-invoke-store": "^0.2.2" }, "engines": { "node": ">= 14.x" @@ -19280,9 +19280,9 @@ "integrity": "sha512-4Dx3eRTrUHLxhFdLJL8zdNGzVsJfAxtxPYYGmIddUkO2Gj3WA1TGjdfG4XN/ClI6e1XonCHafQX3UYO/mgnH3g==" }, "packages/core/node_modules/@aws/lambda-invoke-store": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.0.tgz", - "integrity": "sha512-D1jAmAZQYMoPiacfgNf7AWhg3DFN3Wq/vQv3WINt9znwjzHp2x+WzdJFxxj7xZL7V1U79As6G8f7PorMYWBKsQ==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.2.tgz", + "integrity": "sha512-C0NBLsIqzDIae8HFw9YIrIBsbc0xTiOtt7fAukGPnqQ/+zZNaq+4jhuccltK0QuWHBnNm/a6kLIRA6GFiM10eg==", "dev": true, "license": "Apache-2.0", "engines": { @@ -23761,7 +23761,7 @@ "version": "file:packages/core", "requires": { "@aws-sdk/types": "^3.4.1", - "@aws/lambda-invoke-store": "^0.2.0", + "@aws/lambda-invoke-store": "^0.2.2", "@smithy/service-error-classification": "^2.0.4", "@types/cls-hooked": "^4.3.3", "atomic-batcher": "^1.0.2", @@ -23775,9 +23775,9 @@ "integrity": "sha512-4Dx3eRTrUHLxhFdLJL8zdNGzVsJfAxtxPYYGmIddUkO2Gj3WA1TGjdfG4XN/ClI6e1XonCHafQX3UYO/mgnH3g==" }, "@aws/lambda-invoke-store": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.0.tgz", - "integrity": "sha512-D1jAmAZQYMoPiacfgNf7AWhg3DFN3Wq/vQv3WINt9znwjzHp2x+WzdJFxxj7xZL7V1U79As6G8f7PorMYWBKsQ==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.2.tgz", + "integrity": "sha512-C0NBLsIqzDIae8HFw9YIrIBsbc0xTiOtt7fAukGPnqQ/+zZNaq+4jhuccltK0QuWHBnNm/a6kLIRA6GFiM10eg==", "dev": true }, "semver": { @@ -28142,7 +28142,7 @@ "version": "file:packages/core", "requires": { "@aws-sdk/types": "^3.4.1", - "@aws/lambda-invoke-store": "^0.2.0", + "@aws/lambda-invoke-store": "^0.2.2", "@smithy/service-error-classification": "^2.0.4", "@types/cls-hooked": "^4.3.3", "atomic-batcher": "^1.0.2", @@ -28156,9 +28156,9 @@ "integrity": "sha512-4Dx3eRTrUHLxhFdLJL8zdNGzVsJfAxtxPYYGmIddUkO2Gj3WA1TGjdfG4XN/ClI6e1XonCHafQX3UYO/mgnH3g==" }, "@aws/lambda-invoke-store": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.0.tgz", - "integrity": "sha512-D1jAmAZQYMoPiacfgNf7AWhg3DFN3Wq/vQv3WINt9znwjzHp2x+WzdJFxxj7xZL7V1U79As6G8f7PorMYWBKsQ==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.2.tgz", + "integrity": "sha512-C0NBLsIqzDIae8HFw9YIrIBsbc0xTiOtt7fAukGPnqQ/+zZNaq+4jhuccltK0QuWHBnNm/a6kLIRA6GFiM10eg==", "dev": true }, "semver": { @@ -37157,9 +37157,9 @@ "integrity": "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==" }, "semver": { - "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "version": "6.3.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.2.tgz", + "integrity": "sha512-GYrCADwpu6yV5OAvchkQ27Z5wwMxWAEMg5NNWjyHh/5DboFFqbdbvYNIvZouQpxXyeMPoTOh0vdPYKlf0ZswdQ==", "dev": true }, "send": { @@ -47844,9 +47844,9 @@ "integrity": "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==" }, "semver": { - "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "version": "6.3.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.2.tgz", + "integrity": "sha512-GYrCADwpu6yV5OAvchkQ27Z5wwMxWAEMg5NNWjyHh/5DboFFqbdbvYNIvZouQpxXyeMPoTOh0vdPYKlf0ZswdQ==", "dev": true }, "send": { diff --git a/packages/core/lib/context_utils.js b/packages/core/lib/context_utils.js index fe20f440..5792fc01 100644 --- a/packages/core/lib/context_utils.js +++ b/packages/core/lib/context_utils.js @@ -11,9 +11,19 @@ var Subsegment = require('./segments/attributes/subsegment'); var cls_mode = true; var NAMESPACE ='AWSXRay'; var SEGMENT = 'segment'; +var isLambda = !!process.env.LAMBDA_TASK_ROOT; +var lambdaEnv; var contextOverride = false; +function getLambdaInvocationContext() { + // The Lambda module also imports contextUtils, so load it on first use. + if (!lambdaEnv) { + lambdaEnv = require('./env/aws_lambda'); + } + return lambdaEnv.getInvocationContext(); +} + var contextUtils = { CONTEXT_MISSING_STRATEGY: { RUNTIME_ERROR: { @@ -95,11 +105,13 @@ var contextUtils = { getSegment: function getSegment() { if (cls_mode) { - var segment = contextUtils.getNamespace(NAMESPACE).get(SEGMENT); + var namespace = contextUtils.getNamespace(NAMESPACE); + var invocation = isLambda && getLambdaInvocationContext(); + var segment = invocation ? invocation.getSegment(namespace.active) : namespace.get(SEGMENT); if (!segment) { contextUtils.contextMissingStrategy.contextMissing('Failed to get the current sub/segment from the context.'); - } else if (segment instanceof Segment && process.env.LAMBDA_TASK_ROOT && segment.facade == true) { + } else if (segment instanceof Segment && isLambda && segment.facade == true) { segment.resolveLambdaTraceData(); } @@ -118,7 +130,10 @@ var contextUtils = { setSegment: function setSegment(segment) { if (cls_mode) { - if (!contextUtils.getNamespace(NAMESPACE).set(SEGMENT, segment)) { + var namespace = contextUtils.getNamespace(NAMESPACE); + var invocation = isLambda && getLambdaInvocationContext(); + var segmentSet = invocation ? invocation.setSegment(namespace.active, segment) : namespace.set(SEGMENT, segment); + if (!segmentSet) { logger.getLogger().warn('Failed to set the current sub/segment on the context.'); } } else { diff --git a/packages/core/lib/env/aws_lambda.js b/packages/core/lib/env/aws_lambda.js index 65e6d466..f22e479a 100644 --- a/packages/core/lib/env/aws_lambda.js +++ b/packages/core/lib/env/aws_lambda.js @@ -11,7 +11,44 @@ const TraceID = require('../segments/attributes/trace_id'); * @namespace * @ignore */ -var xAmznTraceIdPrev = null; +// Weak keys let completed invocations (and their tracing state) be collected. +var invocationContexts = new WeakMap(); + +module.exports.getInvocationContext = function getInvocationContext() { + var invokeStore = globalThis.awslambda?.InvokeStore; + var invocation = invokeStore?.getContext?.(); + if (!invocation) { + return; + } + + var context = invocationContexts.get(invocation); + if (!context) { + var segment = facadeSegment(invokeStore.getXRayTraceId() ?? process.env._X_AMZN_TRACE_ID); + var segments = new WeakMap(); + context = { + getSegment: function(active) { + // CLS child contexts inherit their parent's segment. Keep those slots + // inside the invocation, including the shared Lambda bootstrap context. + while (active) { + if (segments.has(active)) { + return segments.get(active); + } + active = Object.getPrototypeOf(active); + } + return segment; + }, + setSegment: function(active, current) { + if (!active) { + return false; + } + segments.set(active, current); + return true; + } + }; + invocationContexts.set(invocation, context); + } + return context; +}; /** * Used to initialize segments on AWS Lambda with extra data from the context. @@ -35,14 +72,16 @@ module.exports.init = function init() { var namespace = contextUtils.getNamespace(); namespace.enter(namespace.createContext()); - contextUtils.setSegment(facadeSegment()); + // Initialize only the legacy slot, even if the SDK is loaded in a handler. + // Invocation state is created lazily from InvokeStore by get/setSegment. + namespace.set('segment', facadeSegment(process.env._X_AMZN_TRACE_ID)); }; -var facadeSegment = function facadeSegment() { +var facadeSegment = function facadeSegment(xAmznTraceId) { var segment = new Segment('facade'); var whitelistFcn = ['addNewSubsegment', 'addSubsegment', 'removeSubsegment', 'toString', 'addSubsegmentWithoutSampling', 'addNewSubsegmentWithoutSampling']; var silentFcn = ['incrementCounter', 'decrementCounter', 'isClosed', 'close', 'format', 'flush']; - var xAmznTraceId = process.env._X_AMZN_TRACE_ID; + var xAmznTraceIdPrev = null; for (var key in segment) { if (typeof segment[key] === 'function' && whitelistFcn.indexOf(key) === -1) { diff --git a/packages/core/package.json b/packages/core/package.json index e56cdb07..9b70ccc2 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -31,7 +31,7 @@ "semver": "^7.5.3" }, "devDependencies": { - "@aws/lambda-invoke-store": "^0.2.0" + "@aws/lambda-invoke-store": "^0.2.2" }, "scripts": { "prepare": "npm run compile", @@ -40,12 +40,13 @@ "copy-test": "find test -name '*.json' | xargs -I % ../../scripts/cp-with-structure.sh % dist", "lint": "eslint .", "lint:fix": "eslint . --fix", - "test": "npm run compile && mocha --recursive ./dist/test/ -R spec && tsd && mocha --recursive ./dist/test_async/ -R spec", + "test": "npm run compile && mocha --recursive ./dist/test/ -R spec && tsd && npm run test-async:run", "test-d": "tsd", - "test-async": "npm run compile && mocha --recursive ./dist/test_async/ -R spec", + "test-async": "npm run compile && npm run test-async:run", "clean": "rm -rf dist && rm -rf node_modules", "testcov": "nyc npm run test", - "reportcov": "nyc report --reporter=text-lcov > coverage.lcov" + "reportcov": "nyc report --reporter=text-lcov > coverage.lcov", + "test-async:run": "mocha --recursive ./dist/test_async/ --exclude dist/test_async/lambda_invocation_isolation.test.js -R spec && mocha ./dist/test_async/lambda_invocation_isolation.test.js -R spec" }, "keywords": [ "amazon", diff --git a/packages/core/test/unit/env/aws_lambda.test.js b/packages/core/test/unit/env/aws_lambda.test.js index 4cbf19ff..3a3889b7 100644 --- a/packages/core/test/unit/env/aws_lambda.test.js +++ b/packages/core/test/unit/env/aws_lambda.test.js @@ -44,7 +44,8 @@ describe('AWSLambda', function () { sandbox = sinon.createSandbox(); sandbox.stub(contextUtils, 'getNamespace').returns({ enter: function () { }, - createContext: function () { } + createContext: function () { }, + set: function () { } }); }); @@ -61,7 +62,7 @@ describe('AWSLambda', function () { disableCentralizedSamplingStub = sandbox.stub(mwUtils, 'disableCentralizedSampling'); validateStub = sandbox.stub(LambdaUtils, 'validTraceData').returns(true); populateStub = sandbox.stub(LambdaUtils, 'populateTraceData').returns(true); - setSegmentStub = sandbox.stub(contextUtils, 'setSegment'); + setSegmentStub = sandbox.stub(contextUtils.getNamespace(), 'set'); }); afterEach(function () { @@ -86,9 +87,9 @@ describe('AWSLambda', function () { it('should set a facade segment on the context', function () { Lambda.init(); setSegmentStub.should.have.been.calledOnce; - setSegmentStub.should.have.been.calledWith(sinon.match.instanceOf(Segment)); + setSegmentStub.should.have.been.calledWith('segment', sinon.match.instanceOf(Segment)); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; assert.equal(facade.name, 'facade'); assert.equal(facade.trace_id, TraceID.Invalid().toString()); }); @@ -130,7 +131,7 @@ describe('AWSLambda', function () { sandbox.stub(LambdaUtils, 'validTraceData').returns(true); populateStub = sandbox.stub(LambdaUtils, 'populateTraceData').returns(true); - setSegmentStub = sandbox.stub(contextUtils, 'setSegment'); + setSegmentStub = sandbox.stub(contextUtils.getNamespace(), 'set'); }); afterEach(function () { @@ -141,7 +142,7 @@ describe('AWSLambda', function () { it('should check reset the facade', function () { Lambda.init(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.trace_id = 'traceIdHere'; facade.id = 'parentIdHere'; facade.subsegments = [{ subsegment: 'here' }]; @@ -172,7 +173,7 @@ describe('AWSLambda', function () { Lambda.init(); populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; assert.throws(facade.resolveLambdaTraceData); populateStub.should.have.not.been.called; }); @@ -182,7 +183,7 @@ describe('AWSLambda', function () { Lambda.init(); process.env._X_AMZN_TRACE_ID = 'xAmznTraceId2'; populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); populateStub.should.have.been.calledOnce; @@ -192,7 +193,7 @@ describe('AWSLambda', function () { process.env._X_AMZN_TRACE_ID = traceId; Lambda.init(); process.env._X_AMZN_TRACE_ID = 'xAmznTraceId2'; - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; var resetStub = sandbox.stub(facade, 'reset'); facade.resolveLambdaTraceData(); @@ -204,7 +205,7 @@ describe('AWSLambda', function () { Lambda.init(); populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); populateStub.should.have.not.been.called; }); @@ -220,7 +221,7 @@ describe('AWSLambda', function () { populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); getXRayTraceIdStub.should.have.been.calledOnce; @@ -237,7 +238,7 @@ describe('AWSLambda', function () { populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); getXRayTraceIdStub.should.have.been.calledOnce; @@ -257,7 +258,7 @@ describe('AWSLambda', function () { populateStub.reset(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); getXRayTraceIdStub.should.have.been.calledOnce; @@ -274,7 +275,7 @@ describe('AWSLambda', function () { sandbox.stub(SegmentEmitter, 'disableReusableSocket'); sandbox.stub(LambdaUtils, 'validTraceData').returns(true); - setSegmentStub = sandbox.stub(contextUtils, 'setSegment'); + setSegmentStub = sandbox.stub(contextUtils.getNamespace(), 'set'); }); afterEach(function () { @@ -288,7 +289,7 @@ describe('AWSLambda', function () { Lambda.init(); await setupInvokeStore(); - var facade = setSegmentStub.args[0][0]; + var facade = setSegmentStub.args[0][1]; facade.resolveLambdaTraceData(); var additionalTraceData = facade.additionalTraceData; assert.equal(additionalTraceData['Lineage'], '1234abcd:4|3456abcd:6'); diff --git a/packages/core/test/unit/segments/segment.test.js b/packages/core/test/unit/segments/segment.test.js index fcf2e36a..f41e9c3f 100644 --- a/packages/core/test/unit/segments/segment.test.js +++ b/packages/core/test/unit/segments/segment.test.js @@ -269,7 +269,7 @@ describe('Segment', function() { beforeEach(function() { sandbox = sinon.createSandbox(); - setSegmentStub = sandbox.stub(Context, 'setSegment'); + setSegmentStub = sandbox.stub(Context.getNamespace(), 'set'); }); afterEach(function() { @@ -283,7 +283,7 @@ describe('Segment', function() { setSegmentStub.should.have.been.calledOnce; - let facade = setSegmentStub.args[0][0]; + let facade = setSegmentStub.args[0][1]; let unsampledSegment = facade.addNewSubsegmentWithoutSampling('unsampled-subsegment'); assert.equal(unsampledSegment.notTraced, true); }); @@ -294,7 +294,7 @@ describe('Segment', function() { setSegmentStub.should.have.been.calledOnce; - let facade = setSegmentStub.args[0][0]; + let facade = setSegmentStub.args[0][1]; let sampledSubsegment = facade.addNewSubsegment('sampled-subsegment'); assert.equal(sampledSubsegment.notTraced, undefined); }); diff --git a/packages/core/test_async/lambda_invocation_isolation.test.js b/packages/core/test_async/lambda_invocation_isolation.test.js new file mode 100644 index 00000000..302392ea --- /dev/null +++ b/packages/core/test_async/lambda_invocation_isolation.test.js @@ -0,0 +1,435 @@ +var assert = require('chai').assert; +var sinon = require('sinon'); + +var ROOT_A = '1-5f0000aa-0000000000000000000000aa'; +var ROOT_B = '1-5f0000bb-0000000000000000000000bb'; +var TRACE_A = 'Root=' + ROOT_A + ';Parent=00000000000000aa;Sampled=1;Lineage=aaaaaaaa:1'; +var TRACE_B = 'Root=' + ROOT_B + ';Parent=00000000000000bb;Sampled=1'; +var TRACE_B_UNSAMPLED = 'Root=' + ROOT_B + ';Parent=00000000000000bb;Sampled=0'; + +// Every participant must arrive before any resumes. No timer controls the overlap. +function barrier(count) { + var release; + var ready = new Promise(function(resolve) { + release = resolve; + }); + return function() { + if (--count === 0) { + release(); + } + return ready; + }; +} + +function nextTurn() { + return new Promise(function(resolve) { + setImmediate(resolve); + }); +} + +describe('Lambda invocation isolation', function() { + var AWSXRay, contextUtils, Lambda, SegmentUtils; + var sandbox, storeModule, invokeStore, protectedKeys, namespace, lambdaContext, legacyFacade; + var documents, previousGlobal, previousManualMode, previousThreshold; + var previousEnv = {}; + var envNames = ['LAMBDA_TASK_ROOT', '_X_AMZN_TRACE_ID', 'AWS_LAMBDA_BENCHMARK_MODE', 'AWS_LAMBDA_MAX_CONCURRENCY']; + + before(async function() { + envNames.forEach(function(name) { + previousEnv[name] = process.env[name]; + }); + previousGlobal = globalThis.awslambda; + process.env.LAMBDA_TASK_ROOT = '/var/task'; + process.env.AWS_LAMBDA_BENCHMARK_MODE = '1'; + process.env.AWS_LAMBDA_MAX_CONCURRENCY = '2'; + delete process.env._X_AMZN_TRACE_ID; + + contextUtils = require('../lib/context_utils'); + Lambda = require('../lib/env/aws_lambda'); + var mwUtils = require('../lib/middleware/mw_utils'); + var SegmentEmitter = require('../lib/segment_emitter'); + SegmentUtils = require('../lib/segments/segment_utils'); + previousManualMode = contextUtils.enableManualMode; + previousThreshold = SegmentUtils.getStreamingThreshold(); + + storeModule = await import('@aws/lambda-invoke-store'); + storeModule.InvokeStore._testing.reset(); + invokeStore = await storeModule.InvokeStore.getInstanceAsync(); + protectedKeys = storeModule.InvokeStoreBase.PROTECTED_KEYS; + + sandbox = sinon.createSandbox(); + sandbox.stub(SegmentEmitter, 'disableReusableSocket'); + sandbox.stub(mwUtils, 'disableCentralizedSampling'); + sandbox.stub(SegmentEmitter, 'send').callsFake(function(segment) { + documents.push(JSON.parse(segment.format())); + }); + // Load the SDK only after setting up the Lambda environment so its startup initializes CLS. + AWSXRay = require('../lib'); + AWSXRay.enableAutomaticMode(); + namespace = AWSXRay.getNamespace(); + lambdaContext = namespace.active; + legacyFacade = namespace.get('segment'); + }); + + beforeEach(function() { + documents = []; + }); + + after(function() { + sandbox.restore(); + namespace.exit(lambdaContext); + contextUtils.enableManualMode = previousManualMode; + SegmentUtils.setStreamingThreshold(previousThreshold); + globalThis.awslambda = previousGlobal; + envNames.forEach(function(name) { + if (previousEnv[name] === undefined) { + delete process.env[name]; + } else { + process.env[name] = previousEnv[name]; + } + }); + }); + + function invocation(traceHeader, fn) { + return invokeStore.run({ [protectedKeys.X_RAY_TRACE_ID]: traceHeader }, fn); + } + + it('isolates manual active segments, annotations, metadata and emitted parents across native awaits and callbacks', async function() { + var overlap = barrier(2); + // The promise and continuation exist before either invocation first uses X-Ray. + var ready = Promise.resolve(); + async function handler(name, root, parent) { + await ready; + var facade = AWSXRay.getSegment(); + var subsegment = facade.addNewSubsegment(name); + AWSXRay.setSegment(subsegment); + await overlap(); + assert.strictEqual(AWSXRay.getSegment(), subsegment); + await new Promise(function(resolve, reject) { + setImmediate(function() { + try { + assert.strictEqual(AWSXRay.getSegment(), subsegment); + AWSXRay.getSegment().addAnnotation('invocation', name); + AWSXRay.getSegment().addMetadata('owner', { name: name }); + resolve(); + } catch (err) { + reject(err); + } + }); + }); + assert.strictEqual(subsegment.parent, facade); + assert.equal(facade.trace_id, root); + assert.equal(facade.id, parent); + subsegment.close(); + AWSXRay.setSegment(facade); + assert.strictEqual(AWSXRay.getSegment(), facade); + return facade; + } + var facades = await Promise.all([ + invocation(TRACE_A, function() { + return handler('A', ROOT_A, '00000000000000aa'); + }), + invocation(TRACE_B, function() { + return handler('B', ROOT_B, '00000000000000bb'); + }) + ]); + assert.notStrictEqual(facades[0], facades[1]); + assert.lengthOf(documents, 2); + documents.forEach(function(document) { + assert.equal(document.annotations.invocation, document.name); + assert.deepEqual(document.metadata.default.owner, { name: document.name }); + assert.equal(document.trace_id, document.name === 'A' ? ROOT_A : ROOT_B); + assert.equal(document.parent_id, document.name === 'A' ? '00000000000000aa' : '00000000000000bb'); + }); + }); + + it('preserves parallel and nested capture scopes and restores their caller independently in each invocation', async function() { + var overlap = barrier(2); + async function handler(name) { + var facade = AWSXRay.getSegment(); + await AWSXRay.captureAsyncFunc(name, async function(outer) { + await overlap(); + assert.strictEqual(AWSXRay.getSegment(), outer); + outer.addAnnotation('owner', name); + var siblings = barrier(2); + await Promise.all(['left', 'right'].map(function(childName) { + return AWSXRay.captureAsyncFunc(name + '-' + childName, async function(child) { + assert.strictEqual(child.parent, outer); + await siblings(); + await nextTurn(); + assert.strictEqual(AWSXRay.getSegment(), child); + child.addAnnotation('owner', name); + AWSXRay.captureFunc('nested', function(nested) { + assert.strictEqual(nested.parent, child); + assert.strictEqual(AWSXRay.getSegment(), nested); + nested.addAnnotation('owner', name); + }); + assert.strictEqual(AWSXRay.getSegment(), child); + child.close(); + }); + })); + assert.strictEqual(AWSXRay.getSegment(), outer); + outer.close(); + }); + assert.strictEqual(AWSXRay.getSegment(), facade); + } + await Promise.all([ + invocation(TRACE_A, function() { + return handler('A'); + }), + invocation(TRACE_B, function() { + return handler('B'); + }) + ]); + assert.lengthOf(documents, 10); + documents.forEach(function(document) { + assert.equal(document.trace_id, document.annotations.owner === 'A' ? ROOT_A : ROOT_B); + }); + }); + + it('does not lose sampled work or inherit errors when an unsampled invocation interleaves before flushing', async function() { + var opened = barrier(2); + var error = new Error('only invocation A failed'); + await Promise.all([ + invocation(TRACE_A, async function() { + var facade = AWSXRay.getSegment(); + var work = facade.addNewSubsegment('sampled'); + await opened(); + await nextTurn(); + work.close(error); + assert.equal(facade.exception.ex, error); + }), + invocation(TRACE_B_UNSAMPLED, async function() { + var facade = AWSXRay.getSegment(); + var work = facade.addNewSubsegment('unsampled'); + await opened(); + await nextTurn(); + work.close(); + assert.isUndefined(facade.exception); + assert.deepEqual(facade.additionalTraceData, {}); + }) + ]); + assert.lengthOf(documents, 1); + assert.equal(documents[0].name, 'sampled'); + assert.equal(documents[0].trace_id, ROOT_A); + assert.equal(documents[0].parent_id, '00000000000000aa'); + assert.isTrue(documents[0].fault); + assert.equal(documents[0].cause.exceptions[0].message, error.message); + }); + + it('uses invocation identity even when separate invocations have identical trace headers', async function() { + var overlap = barrier(2); + var facades = await Promise.all([1, 2].map(function(index) { + return invocation(TRACE_A, async function() { + var facade = AWSXRay.getSegment(); + var work = facade.addNewSubsegment('work-' + index); + AWSXRay.setSegment(work); + await overlap(); + assert.strictEqual(AWSXRay.getSegment(), work); + work.close(); + AWSXRay.setSegment(facade); + return facade; + }); + })); + assert.notStrictEqual(facades[0], facades[1]); + assert.equal(facades[0].trace_id, ROOT_A); + assert.equal(facades[1].trace_id, ROOT_A); + assert.lengthOf(documents, 2); + }); + + it('starts the next invocation with a fresh facade even if the previous handler left its active segment set', async function() { + var oldFacade; + await invocation(TRACE_A, async function() { + oldFacade = AWSXRay.getSegment(); + AWSXRay.setSegment(oldFacade.addNewSubsegment('unfinished')); + await nextTurn(); + }); + await invocation(TRACE_B, async function() { + var facade = AWSXRay.getSegment(); + assert.isTrue(facade.facade); + assert.notStrictEqual(facade, oldFacade); + assert.equal(facade.trace_id, ROOT_B); + assert.isUndefined(facade.subsegments); + assert.isUndefined(facade.exception); + assert.deepEqual(facade.additionalTraceData, {}); + await nextTurn(); + assert.strictEqual(AWSXRay.getSegment(), facade); + }); + assert.isUndefined(invokeStore.getContext()); + }); + + it('starts a fresh facade for each classic Lambda invocation even when the store retains the previous context', async function() { + var previousConcurrency = process.env.AWS_LAMBDA_MAX_CONCURRENCY; + delete process.env.AWS_LAMBDA_MAX_CONCURRENCY; + storeModule.InvokeStore._testing.reset(); + try { + var singleStore = await storeModule.InvokeStore.getInstanceAsync(); + var firstContext = { [protectedKeys.X_RAY_TRACE_ID]: TRACE_A }; + var firstFacade; + await singleStore.run(firstContext, async function() { + firstFacade = AWSXRay.getSegment(); + assert.equal(firstFacade.trace_id, ROOT_A); + var unfinished = firstFacade.addNewSubsegment('unfinished-classic'); + AWSXRay.setSegment(unfinished); + await nextTurn(); + assert.strictEqual(AWSXRay.getSegment(), unfinished); + }); + assert.strictEqual(singleStore.getContext(), firstContext); + + var nextContext = { [protectedKeys.X_RAY_TRACE_ID]: TRACE_B }; + await singleStore.run(nextContext, async function() { + var facade = AWSXRay.getSegment(); + assert.isTrue(facade.facade); + assert.notStrictEqual(facade, firstFacade); + assert.equal(facade.trace_id, ROOT_B); + assert.equal(facade.id, '00000000000000bb'); + assert.isUndefined(facade.subsegments); + assert.deepEqual(facade.additionalTraceData, {}); + + await nextTurn(); + assert.strictEqual(AWSXRay.getSegment(), facade); + AWSXRay.captureFunc('classic-second', function(work) { + assert.strictEqual(work.parent, facade); + assert.strictEqual(AWSXRay.getSegment(), work); + }); + assert.strictEqual(AWSXRay.getSegment(), facade); + }); + assert.strictEqual(singleStore.getContext(), nextContext); + assert.equal(firstFacade.trace_id, ROOT_A); + assert.lengthOf(documents, 1); + assert.equal(documents[0].trace_id, ROOT_B); + assert.equal(documents[0].parent_id, '00000000000000bb'); + } finally { + process.env.AWS_LAMBDA_MAX_CONCURRENCY = previousConcurrency; + storeModule.InvokeStore._testing.reset(); + invokeStore = await storeModule.InvokeStore.getInstanceAsync(); + } + }); + + it('restores capture context after a thrown exception without leaking it into a peer invocation', async function() { + var overlap = barrier(2); + await Promise.all([TRACE_A, TRACE_B].map(function(trace) { + return invocation(trace, async function() { + var facade = AWSXRay.getSegment(); + await overlap(); + assert.throws(function() { + AWSXRay.captureFunc('throws', function(current) { + assert.strictEqual(AWSXRay.getSegment(), current); + throw new Error(trace); + }); + }, trace); + assert.strictEqual(AWSXRay.getSegment(), facade); + }); + })); + assert.lengthOf(documents, 2); + documents.forEach(function(document) { + assert.isTrue(document.fault); + }); + }); + + it('keeps captured callbacks on their invocation after a peer has resolved its facade', async function() { + var overlap = barrier(2); + await Promise.all([TRACE_A, TRACE_B].map(function(trace) { + return invocation(trace, async function() { + var facade = AWSXRay.getSegment(); + var callback = AWSXRay.captureCallbackFunc('callback', function(value, current) { + assert.equal(value, trace); + assert.strictEqual(current.parent, facade); + assert.strictEqual(AWSXRay.getSegment(), current); + current.addAnnotation('owner', trace); + }); + await overlap(); + await new Promise(function(resolve, reject) { + setImmediate(function() { + try { + callback(trace); + assert.strictEqual(AWSXRay.getSegment(), facade); + resolve(); + } catch (err) { + reject(err); + } + }); + }); + }); + })); + assert.lengthOf(documents, 2); + documents.forEach(function(document) { + assert.equal(document.trace_id, document.annotations.owner === TRACE_A ? ROOT_A : ROOT_B); + }); + }); + + it('warns and preserves the invocation facade when setting a segment without an active CLS context', function() { + var active = namespace.active; + var warn = sandbox.stub(AWSXRay.getLogger(), 'warn'); + namespace.active = null; + try { + invocation(TRACE_A, function() { + var facade = AWSXRay.getSegment(); + var work = facade.addNewSubsegment('without-cls'); + AWSXRay.setSegment(work); + assert.strictEqual(AWSXRay.getSegment(), facade); + + AWSXRay.captureFunc('captured', function(current) { + assert.strictEqual(current.parent, facade); + assert.strictEqual(AWSXRay.getSegment(), current); + }); + assert.strictEqual(AWSXRay.getSegment(), facade); + sinon.assert.calledOnceWithExactly(warn, 'Failed to set the current sub/segment on the context.'); + work.close(); + }); + } finally { + namespace.active = active; + warn.restore(); + } + }); + + it('initializes Lambda inside an invocation without copying startup trace metadata into its facade', function() { + process.env._X_AMZN_TRACE_ID = TRACE_A; + try { + invocation(TRACE_B, function() { + var active = namespace.active; + Lambda.init(); + try { + var facade = AWSXRay.getSegment(); + assert.equal(facade.trace_id, ROOT_B); + assert.equal(facade.id, '00000000000000bb'); + assert.deepEqual(facade.additionalTraceData, {}); + assert.isUndefined(facade.noOp); + } finally { + namespace.exit(namespace.active); + assert.strictEqual(namespace.active, active); + } + }); + } finally { + delete process.env._X_AMZN_TRACE_ID; + } + }); + + it('retains the ordinary Lambda CLS lifecycle when InvokeStore is absent', function() { + return namespace.runAndReturn(async function() { + var runtime = globalThis.awslambda; + delete globalThis.awslambda; + process.env._X_AMZN_TRACE_ID = TRACE_A; + try { + AWSXRay.setSegment(legacyFacade); + var facade = AWSXRay.getSegment(); + assert.isTrue(facade.facade); + assert.equal(facade.trace_id, ROOT_A); + var work = facade.addNewSubsegment('legacy'); + AWSXRay.setSegment(work); + await nextTurn(); + assert.strictEqual(AWSXRay.getSegment(), work); + work.close(); + AWSXRay.setSegment(facade); + process.env._X_AMZN_TRACE_ID = TRACE_B; + assert.strictEqual(AWSXRay.getSegment(), facade); + assert.equal(facade.trace_id, ROOT_B); + assert.lengthOf(documents, 1); + assert.equal(documents[0].trace_id, ROOT_A); + } finally { + globalThis.awslambda = runtime; + delete process.env._X_AMZN_TRACE_ID; + } + }); + }); +});