@datadog/datadog-ci 0.17.8 → 0.17.12

package/dist/commands/lambda/__tests__/functions/uninstrument.test.js

@@ -0,0 +1,371 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../../loggroup');
+const constants_1 = require("../../constants");
+const commons_1 = require("../../functions/commons");
+const uninstrument_1 = require("../../functions/uninstrument");
+const fixtures_1 = require("../fixtures");
+const loggroup = __importStar(require("../../loggroup"));
+describe('uninstrument', () => {
+    describe('calculateUpdateRequest', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('calculates an update request removing all variables set by the CI', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.API_KEY_SECRET_ARN_ENV_VAR]: 'some-secret:arn:from:aws',
+                            [constants_1.ENVIRONMENT_ENV_VAR]: 'staging',
+                            [constants_1.FLUSH_TO_LOG_ENV_VAR]: 'true',
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'lambda_function.lambda_handler',
+                            [constants_1.LOG_LEVEL_ENV_VAR]: 'debug',
+                            [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                            [constants_1.SERVICE_ENV_VAR]: 'middletier',
+                            [constants_1.SITE_ENV_VAR]: 'datadoghq.com',
+                            [constants_1.TRACE_ENABLED_ENV_VAR]: 'true',
+                            [constants_1.VERSION_ENV_VAR]: '0.2',
+                            USER_VARIABLE: 'shouldnt be deleted by uninstrumentation',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'datadog_lambda.handler.handler',
+                    Runtime: 'python3.8',
+                },
+            });
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            const updateRequest = yield uninstrument_1.calculateUpdateRequest(config, config.Runtime);
+            expect(updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {
+              "USER_VARIABLE": "shouldnt be deleted by uninstrumentation",
+            },
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:uninstrument",
+          "Handler": "lambda_function.lambda_handler",
+        }
+      `);
+        }));
+        test('calculates an update request setting the previous handler', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'lambda_function.lambda_handler',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'datadog_lambda.handler.handler',
+                    Runtime: 'python3.8',
+                },
+            });
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            const updateRequest = yield uninstrument_1.calculateUpdateRequest(config, config.Runtime);
+            expect(updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {},
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:uninstrument",
+          "Handler": "lambda_function.lambda_handler",
+        }
+      `);
+        }));
+        test('calculates an update request removing lambda layers set by the CI', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'lambda_function.lambda_handler',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'datadog_lambda.handler.handler',
+                    Layers: [
+                        {
+                            Arn: 'arn:aws:lambda:sa-east-1:000000000000:layer:Datadog-Extension:11',
+                            CodeSize: 0,
+                            SigningJobArn: 'some-signing-job-arn',
+                            SigningProfileVersionArn: 'some-signing-profile',
+                        },
+                        {
+                            Arn: 'arn:aws:lambda:sa-east-1:000000000000:layer:Datadog-Python38:49',
+                            CodeSize: 0,
+                            SigningJobArn: 'some-signing-job-arn',
+                            SigningProfileVersionArn: 'some-signing-profile',
+                        },
+                    ],
+                    Runtime: 'python3.8',
+                },
+            });
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            const updateRequest = yield uninstrument_1.calculateUpdateRequest(config, config.Runtime);
+            expect(updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {},
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:uninstrument",
+          "Handler": "lambda_function.lambda_handler",
+          "Layers": Array [],
+        }
+      `);
+        }));
+    });
+    describe('getUninstrumentedFunctionConfigs', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('returns the update request for each function', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.ENVIRONMENT_ENV_VAR]: 'staging',
+                            [constants_1.FLUSH_TO_LOG_ENV_VAR]: 'true',
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'lambda_function.lambda_handler',
+                            [constants_1.LOG_LEVEL_ENV_VAR]: 'debug',
+                            [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                            [constants_1.SERVICE_ENV_VAR]: 'middletier',
+                            [constants_1.SITE_ENV_VAR]: 'datadoghq.com',
+                            [constants_1.TRACE_ENABLED_ENV_VAR]: 'true',
+                            [constants_1.VERSION_ENV_VAR]: '0.2',
+                            USER_VARIABLE: 'shouldnt be deleted by uninstrumentation',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'datadog_lambda.handler.handler',
+                    Runtime: 'python3.8',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const result = yield uninstrument_1.getUninstrumentedFunctionConfigs(lambda, cloudWatch, ['arn:aws:lambda:us-east-1:000000000000:function:uninstrument'], undefined);
+            expect(result.length).toEqual(1);
+            expect(result[0].updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {
+              "USER_VARIABLE": "shouldnt be deleted by uninstrumentation",
+            },
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:uninstrument",
+          "Handler": "lambda_function.lambda_handler",
+        }
+      `);
+        }));
+        test('returns results for multiple functions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:another-func': {
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:another-func',
+                    Runtime: 'nodejs12.x',
+                },
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.FLUSH_TO_LOG_ENV_VAR]: 'false',
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                            [constants_1.LOG_LEVEL_ENV_VAR]: 'debug',
+                            [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                            [constants_1.SITE_ENV_VAR]: 'datadoghq.com',
+                            [constants_1.TRACE_ENABLED_ENV_VAR]: 'false',
+                            [constants_1.SERVICE_ENV_VAR]: 'middletier',
+                            [constants_1.ENVIRONMENT_ENV_VAR]: 'staging',
+                            [constants_1.VERSION_ENV_VAR]: '0.2',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                    Runtime: 'nodejs12.x',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const result = yield uninstrument_1.getUninstrumentedFunctionConfigs(lambda, cloudWatch, [
+                'arn:aws:lambda:us-east-1:000000000000:function:another-func',
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+            ], undefined);
+            expect(result.length).toEqual(2);
+            expect(result[0].updateRequest).toBeUndefined();
+            expect(result[1].updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {},
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:uninstrument",
+          "Handler": "index.handler",
+        }
+      `);
+        }));
+    });
+    describe('getUninstrumentedFunctionConfig', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('throws an error when it encounters an unsupported runtime', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Runtime: 'go',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            yield expect(uninstrument_1.getUninstrumentedFunctionConfig(lambda, cloudWatch, config, undefined)).rejects.toThrow();
+        }));
+        test('returns configurations without updateRequest when no changes need to be made', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    Environment: {
+                        Variables: {},
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'index.handler',
+                    Runtime: 'nodejs12.x',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            expect((yield uninstrument_1.getUninstrumentedFunctionConfig(lambda, cloudWatch, config, undefined)).updateRequest).toBeUndefined();
+        }));
+        test('returns log group configuration subscription delete request when forwarderARN is set', () => __awaiter(void 0, void 0, void 0, function* () {
+            const logGroupName = '/aws/lambda/group';
+            loggroup.calculateLogGroupRemoveRequest.mockImplementation(() => ({
+                filterName: constants_1.SUBSCRIPTION_FILTER_NAME,
+                logGroupName,
+            }));
+            const lambda = fixtures_1.makeMockLambda({
+                'arn:aws:lambda:us-east-1:000000000000:function:uninstrument': {
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument',
+                    Handler: 'index.handler',
+                    Runtime: 'nodejs12.x',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const config = yield commons_1.getLambdaFunctionConfig(lambda, 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument');
+            const result = yield uninstrument_1.getUninstrumentedFunctionConfig(lambda, cloudWatch, config, 'valid-forwarder-arn');
+            expect(result).toBeDefined();
+            expect(result.logGroupConfiguration).toMatchInlineSnapshot(`
+        Object {
+          "filterName": "${constants_1.SUBSCRIPTION_FILTER_NAME}",
+          "logGroupName": "${logGroupName}",
+        }
+      `);
+        }));
+    });
+    describe('getUninstrumentedFunctionConfigsFromRegEx', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('returns the update request for each function that matches the pattern', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({
+                'autoinstrument-scooby': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.ENVIRONMENT_ENV_VAR]: 'staging',
+                            [constants_1.FLUSH_TO_LOG_ENV_VAR]: 'true',
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                            [constants_1.LOG_LEVEL_ENV_VAR]: 'debug',
+                            [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                            [constants_1.SERVICE_ENV_VAR]: 'middletier',
+                            [constants_1.SITE_ENV_VAR]: 'datadoghq.com',
+                            [constants_1.TRACE_ENABLED_ENV_VAR]: 'true',
+                            [constants_1.VERSION_ENV_VAR]: '0.2',
+                            USER_VARIABLE: 'shouldnt be deleted by uninstrumentation',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument-scooby',
+                    FunctionName: 'autoinstrument-scooby',
+                    Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                    Runtime: 'nodejs12.x',
+                },
+                'autoinstrument-scrapy': {
+                    Environment: {
+                        Variables: {
+                            [constants_1.API_KEY_ENV_VAR]: '1234',
+                            [constants_1.ENVIRONMENT_ENV_VAR]: 'staging',
+                            [constants_1.FLUSH_TO_LOG_ENV_VAR]: 'true',
+                            [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                            [constants_1.LOG_LEVEL_ENV_VAR]: 'debug',
+                            [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                        },
+                    },
+                    FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument-scrapy',
+                    FunctionName: 'autoinstrument-scrapy',
+                    Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                    Runtime: 'nodejs12.x',
+                },
+            });
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            const result = yield uninstrument_1.getUninstrumentedFunctionConfigsFromRegEx(lambda, cloudWatch, 'autoinstrument-scr.', undefined);
+            expect(result.length).toEqual(1);
+            expect(result[0].updateRequest).toMatchInlineSnapshot(`
+        Object {
+          "Environment": Object {
+            "Variables": Object {},
+          },
+          "FunctionName": "arn:aws:lambda:us-east-1:000000000000:function:autoinstrument-scrapy",
+          "Handler": "index.handler",
+        }
+      `);
+        }));
+        test('fails when retry count is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
+            const makeMockLambdaListFunctionsError = () => ({
+                listFunctions: jest.fn().mockImplementation((args) => ({
+                    promise: () => Promise.reject(),
+                })),
+            });
+            const lambda = makeMockLambdaListFunctionsError();
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            yield expect(uninstrument_1.getUninstrumentedFunctionConfigsFromRegEx(lambda, cloudWatch, 'fake-pattern', undefined)).rejects.toStrictEqual(new Error('Max retry count exceeded.'));
+        }));
+    });
+});