@datadog/datadog-ci 0.17.8 → 0.17.9

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

@@ -0,0 +1,223 @@
+"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 });
+// tslint:disable: no-string-literal
+jest.mock('fs');
+jest.mock('aws-sdk');
+const aws_sdk_1 = require("aws-sdk");
+const chalk_1 = require("chalk");
+const fs = __importStar(require("fs"));
+const constants_1 = require("../constants");
+const uninstrument_1 = require("../uninstrument");
+const fixtures_1 = require("./fixtures");
+describe('uninstrument', () => {
+    describe('execute', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('prints dry run data for a valid uninstrumentation', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+            aws_sdk_1.Lambda.mockImplementation(() => 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',
+                    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 cli = fixtures_1.makeCli();
+            const context = fixtures_1.createMockContext();
+            const functionARN = 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument';
+            process.env.DATADOG_API_KEY = '1234';
+            const code = yield cli.run(['lambda', 'uninstrument', '-f', functionARN, '-r', 'us-east-1', '-d'], context);
+            const output = context.stdout.toString();
+            expect(code).toBe(0);
+            expect(output).toMatchInlineSnapshot(`
+        "${chalk_1.bold(chalk_1.cyan('[Dry Run] '))}Will apply the following updates:
+        UpdateFunctionConfiguration -> arn:aws:lambda:us-east-1:000000000000:function:uninstrument
+        {
+          \\"FunctionName\\": \\"arn:aws:lambda:us-east-1:000000000000:function:uninstrument\\",
+          \\"Handler\\": \\"lambda_function.lambda_handler\\",
+          \\"Environment\\": {
+            \\"Variables\\": {
+              \\"USER_VARIABLE\\": \\"shouldnt be deleted by uninstrumentation\\"
+            }
+          },
+          \\"Layers\\": []
+        }
+        "
+      `);
+        }));
+        test('runs function update command for valid uninstrumentation', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+            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',
+                    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',
+                },
+            });
+            aws_sdk_1.Lambda.mockImplementation(() => lambda);
+            const cli = fixtures_1.makeCli();
+            const context = fixtures_1.createMockContext();
+            const functionARN = 'arn:aws:lambda:us-east-1:000000000000:function:uninstrument';
+            process.env.DATADOG_API_KEY = '1234';
+            yield cli.run(['lambda', 'uninstrument', '-f', functionARN, '-r', 'us-east-1'], context);
+            expect(lambda.updateFunctionConfiguration).toHaveBeenCalled();
+        }));
+        test('aborts early when the aws-sdk throws an error', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+            aws_sdk_1.Lambda.mockImplementation(() => ({
+                getFunction: jest.fn().mockImplementation(() => ({ promise: () => Promise.reject('Lambda failed') })),
+            }));
+            process.env = {};
+            const command = fixtures_1.createCommand(uninstrument_1.UninstrumentCommand);
+            command['functions'] = ['my-func'];
+            command['region'] = 'us-east-1';
+            const code = yield command['execute']();
+            const output = command.context.stdout.toString();
+            expect(code).toBe(1);
+            expect(output).toMatch(`${chalk_1.red('[Error]')} Couldn't fetch lambda functions. Lambda failed\n`);
+        }));
+        test("aborts early when function regions can't be found", () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+            aws_sdk_1.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}));
+            const cli = fixtures_1.makeCli();
+            const context = fixtures_1.createMockContext();
+            const code = yield cli.run(['lambda', 'uninstrument', '--function', 'my-func'], context);
+            const output = context.stdout.toString();
+            expect(code).toBe(1);
+            expect(output).toMatch('No default region specified for ["my-func"]. Use -r, --region, or use a full functionARN');
+        }));
+        test('aborts early when no functions are specified', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+            aws_sdk_1.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}));
+            const cli = fixtures_1.makeCli();
+            const context = fixtures_1.createMockContext();
+            const code = yield cli.run(['lambda', 'uninstrument'], context);
+            const output = context.stdout.toString();
+            expect(code).toBe(1);
+            expect(output).toMatchInlineSnapshot(`
+        "No functions specified for un-instrumentation.
+        "
+      `);
+        }));
+        test('aborts early when no functions are specified while using config file', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            fs.readFile.mockImplementation((a, b, callback) => callback({}));
+            process.env = {};
+            const command = fixtures_1.createCommand(uninstrument_1.UninstrumentCommand);
+            command['config']['region'] = 'ap-southeast-1';
+            yield command['execute']();
+            const output = command.context.stdout.toString();
+            expect(output).toMatchInlineSnapshot(`
+        "No functions specified for un-instrumentation.
+        "
+      `);
+        }));
+    });
+    describe('printPlannedActions', () => {
+        test('prints no output when list is empty', () => {
+            process.env = {};
+            const command = fixtures_1.createCommand(uninstrument_1.UninstrumentCommand);
+            command['printPlannedActions']([]);
+            const output = command.context.stdout.toString();
+            expect(output).toMatchInlineSnapshot(`
+       "No updates will be applied
+       "
+      `);
+        });
+    });
+});

package/dist/commands/lambda/constants.d.ts

@@ -40,4 +40,5 @@ export declare const CI_SITE_ENV_VAR = "DATADOG_SITE";
 export declare const CI_API_KEY_ENV_VAR = "DATADOG_API_KEY";
 export declare const CI_KMS_API_KEY_ENV_VAR = "DATADOG_KMS_API_KEY";
 export declare const LIST_FUNCTIONS_MAX_RETRY_COUNT = 2;
+export declare const MAX_LAMBDA_STATE_CHECK_ATTEMPTS = 3;
 export declare const EXTRA_TAGS_REG_EXP: RegExp;

package/dist/commands/lambda/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXTRA_TAGS_REG_EXP = exports.LIST_FUNCTIONS_MAX_RETRY_COUNT = exports.CI_KMS_API_KEY_ENV_VAR = exports.CI_API_KEY_ENV_VAR = exports.CI_SITE_ENV_VAR = exports.EXTRA_TAGS_ENV_VAR = exports.ENVIRONMENT_ENV_VAR = exports.VERSION_ENV_VAR = exports.SERVICE_ENV_VAR = exports.LAMBDA_HANDLER_ENV_VAR = exports.LOG_LEVEL_ENV_VAR = exports.FLUSH_TO_LOG_ENV_VAR = exports.MERGE_XRAY_TRACES_ENV_VAR = exports.TRACE_ENABLED_ENV_VAR = exports.SITE_ENV_VAR = exports.KMS_API_KEY_ENV_VAR = exports.API_KEY_ENV_VAR = exports.DD_LAMBDA_EXTENSION_LAYER_NAME = exports.TAG_VERSION_NAME = exports.SUBSCRIPTION_FILTER_NAME = exports.GOVCLOUD_LAYER_AWS_ACCOUNT = exports.DEFAULT_LAYER_AWS_ACCOUNT = exports.HANDLER_LOCATION = exports.RUNTIME_LAYER_LOOKUP = void 0;
+exports.EXTRA_TAGS_REG_EXP = exports.MAX_LAMBDA_STATE_CHECK_ATTEMPTS = exports.LIST_FUNCTIONS_MAX_RETRY_COUNT = exports.CI_KMS_API_KEY_ENV_VAR = exports.CI_API_KEY_ENV_VAR = exports.CI_SITE_ENV_VAR = exports.EXTRA_TAGS_ENV_VAR = exports.ENVIRONMENT_ENV_VAR = exports.VERSION_ENV_VAR = exports.SERVICE_ENV_VAR = exports.LAMBDA_HANDLER_ENV_VAR = exports.LOG_LEVEL_ENV_VAR = exports.FLUSH_TO_LOG_ENV_VAR = exports.MERGE_XRAY_TRACES_ENV_VAR = exports.TRACE_ENABLED_ENV_VAR = exports.SITE_ENV_VAR = exports.KMS_API_KEY_ENV_VAR = exports.API_KEY_ENV_VAR = exports.DD_LAMBDA_EXTENSION_LAYER_NAME = exports.TAG_VERSION_NAME = exports.SUBSCRIPTION_FILTER_NAME = exports.GOVCLOUD_LAYER_AWS_ACCOUNT = exports.DEFAULT_LAYER_AWS_ACCOUNT = exports.HANDLER_LOCATION = exports.RUNTIME_LAYER_LOOKUP = void 0;
 exports.RUNTIME_LAYER_LOOKUP = {
     'nodejs10.x': 'Datadog-Node10-x',
     'nodejs12.x': 'Datadog-Node12-x',
@@ -46,6 +46,7 @@ exports.CI_SITE_ENV_VAR = 'DATADOG_SITE';
 exports.CI_API_KEY_ENV_VAR = 'DATADOG_API_KEY';
 exports.CI_KMS_API_KEY_ENV_VAR = 'DATADOG_KMS_API_KEY';
 exports.LIST_FUNCTIONS_MAX_RETRY_COUNT = 2;
+exports.MAX_LAMBDA_STATE_CHECK_ATTEMPTS = 3;
 // DD_TAGS Regular Expression
 // This RegExp ensures that the --extra-tags string
 // matches a list of <key>:<value> separated by commas

package/dist/commands/lambda/functions/commons.d.ts

@@ -0,0 +1,71 @@
+import { CloudWatchLogs, Lambda } from 'aws-sdk';
+import { FunctionConfiguration } from '../interfaces';
+/**
+ * Returns an array of merged layer ARNs if given a Full Layer ARN,
+ * if not, it justs returns the layer ARNs provided.
+ *
+ * @param fullLayerARN a complete layer ARN.
+ * @param partialLayerARN a partial layer ARN.
+ * @param layerARNs an array of layer ARNs.
+ * @returns an array of layer ARNs.
+ */
+export declare const addLayerARN: (fullLayerARN: string | undefined, partialLayerARN: string, layerARNs: string[]) => string[];
+/**
+ * Returns an arrayed grouped functions by its region, it
+ * throws an error if there are functions without a region.
+ *
+ * @param functions an array of strings comprised by
+ * Functions ARNs, Partial ARNs, or Function Names.
+ * @param defaultRegion a fallback region
+ * @returns an array of functions grouped by region
+ */
+export declare const collectFunctionsByRegion: (functions: string[], defaultRegion: string | undefined) => {
+    [key: string]: string[];
+};
+/**
+ * Given a Lambda instance and an array of Lambda names,
+ * return all the Lambda Function Configurations.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param functionARNs an array of strings comprised by
+ * Functions ARNs, Partial ARNs, or Function Names.
+ * @returns an array of Lambda FunctionConfiguration's.
+ */
+export declare const getLambdaFunctionConfigs: (lambda: Lambda, functionARNs: string[]) => Promise<Lambda.FunctionConfiguration[]>;
+/**
+ * Call the aws-sdk Lambda api to get a Function given
+ * an ARN and then return its Configuration.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param functionARN a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @returns the Lambda FunctionConfiguration of the given ARN.
+ */
+export declare const getLambdaFunctionConfig: (lambda: Lambda, functionARN: string) => Promise<Lambda.FunctionConfiguration>;
+/**
+ * Given a Function ARN, return its region by splitting the string,
+ * can return undefined if it is doesn't exist.
+ *
+ * @param functionARN a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @returns the region of an ARN.
+ */
+export declare const getRegion: (functionARN: string) => string | undefined;
+/**
+ * Returns whether a Lambda Function is active or throws an error if
+ * the FunctionConfiguration does not comply with `Successful` or `Active`.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param config a Lambda FunctionConfiguration.
+ * @param functionArn a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @param attempts the number of attemps that have passed since the last retry.
+ * @returns if a Lambda Function is active.
+ */
+export declare const isLambdaActive: (lambda: Lambda, config: Lambda.FunctionConfiguration, functionArn: string, attempts?: number) => Promise<boolean>;
+/**
+ * Returns whether the runtime given is supported by the Datadog CI Lambda.
+ *
+ * @param runtime a string representing a Lambda FunctionConfiguration Runtime.
+ * @returns if a runtime is supported.
+ */
+export declare const isSupportedRuntime: (runtime?: string | undefined) => runtime is "nodejs10.x" | "nodejs12.x" | "nodejs14.x" | "python2.7" | "python3.6" | "python3.7" | "python3.8" | "python3.9";
+export declare const sentenceMatchesRegEx: (sentence: string, regex: RegExp) => RegExpMatchArray | null;
+export declare const updateLambdaFunctionConfigs: (lambda: Lambda, cloudWatch: CloudWatchLogs, configs: FunctionConfiguration[]) => Promise<void>;

package/dist/commands/lambda/functions/commons.js

@@ -0,0 +1,170 @@
+"use strict";
+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 });
+exports.updateLambdaFunctionConfigs = exports.sentenceMatchesRegEx = exports.isSupportedRuntime = exports.isLambdaActive = exports.getRegion = exports.getLambdaFunctionConfig = exports.getLambdaFunctionConfigs = exports.collectFunctionsByRegion = exports.addLayerARN = void 0;
+const constants_1 = require("../constants");
+const loggroup_1 = require("../loggroup");
+const tags_1 = require("../tags");
+/**
+ * Returns an array of merged layer ARNs if given a Full Layer ARN,
+ * if not, it justs returns the layer ARNs provided.
+ *
+ * @param fullLayerARN a complete layer ARN.
+ * @param partialLayerARN a partial layer ARN.
+ * @param layerARNs an array of layer ARNs.
+ * @returns an array of layer ARNs.
+ */
+const addLayerARN = (fullLayerARN, partialLayerARN, layerARNs) => {
+    if (fullLayerARN) {
+        if (!layerARNs.includes(fullLayerARN)) {
+            // Remove any other versions of the layer
+            layerARNs = [...layerARNs.filter((l) => !l.startsWith(partialLayerARN)), fullLayerARN];
+        }
+    }
+    return layerARNs;
+};
+exports.addLayerARN = addLayerARN;
+/**
+ * Returns an arrayed grouped functions by its region, it
+ * throws an error if there are functions without a region.
+ *
+ * @param functions an array of strings comprised by
+ * Functions ARNs, Partial ARNs, or Function Names.
+ * @param defaultRegion a fallback region
+ * @returns an array of functions grouped by region
+ */
+const collectFunctionsByRegion = (functions, defaultRegion) => {
+    var _a;
+    const groups = {};
+    const regionless = [];
+    for (const func of functions) {
+        const region = (_a = exports.getRegion(func)) !== null && _a !== void 0 ? _a : defaultRegion;
+        if (region === undefined) {
+            regionless.push(func);
+            continue;
+        }
+        if (groups[region] === undefined) {
+            groups[region] = [];
+        }
+        const group = groups[region];
+        group.push(func);
+    }
+    if (regionless.length > 0) {
+        throw Error(`No default region specified for ${JSON.stringify(regionless)}. Use -r, --region, or use a full functionARN\n`);
+    }
+    return groups;
+};
+exports.collectFunctionsByRegion = collectFunctionsByRegion;
+/**
+ * Given a Lambda instance and an array of Lambda names,
+ * return all the Lambda Function Configurations.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param functionARNs an array of strings comprised by
+ * Functions ARNs, Partial ARNs, or Function Names.
+ * @returns an array of Lambda FunctionConfiguration's.
+ */
+const getLambdaFunctionConfigs = (lambda, functionARNs) => {
+    const promises = functionARNs.map((fn) => exports.getLambdaFunctionConfig(lambda, fn));
+    return Promise.all(promises);
+};
+exports.getLambdaFunctionConfigs = getLambdaFunctionConfigs;
+/**
+ * Call the aws-sdk Lambda api to get a Function given
+ * an ARN and then return its Configuration.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param functionARN a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @returns the Lambda FunctionConfiguration of the given ARN.
+ */
+const getLambdaFunctionConfig = (lambda, functionARN) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {
+        FunctionName: functionARN,
+    };
+    const result = yield lambda.getFunction(params).promise();
+    // AWS typescript API is slightly mistyped, adds undefineds where
+    // there shouldn't be.
+    const config = result.Configuration;
+    return config;
+});
+exports.getLambdaFunctionConfig = getLambdaFunctionConfig;
+/**
+ * Given a Function ARN, return its region by splitting the string,
+ * can return undefined if it is doesn't exist.
+ *
+ * @param functionARN a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @returns the region of an ARN.
+ */
+const getRegion = (functionARN) => {
+    const [, , , region] = functionARN.split(':');
+    return region === undefined || region === '*' ? undefined : region;
+};
+exports.getRegion = getRegion;
+/**
+ * Returns whether a Lambda Function is active or throws an error if
+ * the FunctionConfiguration does not comply with `Successful` or `Active`.
+ *
+ * @param lambda an instance of Lambda from aws-sdk.
+ * @param config a Lambda FunctionConfiguration.
+ * @param functionArn a string, can be Function ARN, Partial ARN, or a Function Name.
+ * @param attempts the number of attemps that have passed since the last retry.
+ * @returns if a Lambda Function is active.
+ */
+const isLambdaActive = (lambda, config, functionArn, attempts = 0) => __awaiter(void 0, void 0, void 0, function* () {
+    // TODO remove 1 Oct 2021 https://aws.amazon.com/blogs/compute/tracking-the-state-of-lambda-functions/
+    if (!config.State || !config.LastUpdateStatus) {
+        return true;
+    }
+    if (config.LastUpdateStatus === 'Successful' && config.State === 'Active') {
+        return true;
+    }
+    if (config.State === 'Pending' && attempts <= constants_1.MAX_LAMBDA_STATE_CHECK_ATTEMPTS) {
+        yield wait(Math.pow(2, attempts) * 1000);
+        const refetchedConfig = yield exports.getLambdaFunctionConfig(lambda, functionArn);
+        return exports.isLambdaActive(lambda, refetchedConfig, functionArn, (attempts += 1));
+    }
+    throw Error(`Can't instrument ${functionArn}, as current State is ${config.State} (must be "Active") and Last Update Status is ${config.LastUpdateStatus} (must be "Successful")`);
+});
+exports.isLambdaActive = isLambdaActive;
+/**
+ * Returns whether the runtime given is supported by the Datadog CI Lambda.
+ *
+ * @param runtime a string representing a Lambda FunctionConfiguration Runtime.
+ * @returns if a runtime is supported.
+ */
+const isSupportedRuntime = (runtime) => {
+    const lookup = constants_1.RUNTIME_LAYER_LOOKUP;
+    return runtime !== undefined && lookup[runtime] !== undefined;
+};
+exports.isSupportedRuntime = isSupportedRuntime;
+const sentenceMatchesRegEx = (sentence, regex) => sentence.match(regex);
+exports.sentenceMatchesRegEx = sentenceMatchesRegEx;
+const updateLambdaFunctionConfigs = (lambda, cloudWatch, configs) => __awaiter(void 0, void 0, void 0, function* () {
+    const results = configs.map((c) => __awaiter(void 0, void 0, void 0, function* () {
+        if (c.updateRequest !== undefined) {
+            yield lambda.updateFunctionConfiguration(c.updateRequest).promise();
+        }
+        if (c.logGroupConfiguration !== undefined) {
+            yield loggroup_1.applyLogGroupConfig(cloudWatch, c.logGroupConfiguration);
+        }
+        if (c.tagConfiguration !== undefined) {
+            yield tags_1.applyTagConfig(lambda, c.tagConfiguration);
+        }
+    }));
+    yield Promise.all(results);
+});
+exports.updateLambdaFunctionConfigs = updateLambdaFunctionConfigs;
+/**
+ * Waits for n ms
+ *
+ * @param ms
+ */
+const wait = (ms) => new Promise((res) => setTimeout(res, ms));

package/dist/commands/lambda/functions/instrument.d.ts

@@ -0,0 +1,16 @@
+import { CloudWatchLogs, Lambda } from 'aws-sdk';
+import { Runtime } from '../constants';
+import { FunctionConfiguration, InstrumentationSettings, LogGroupConfiguration, TagConfiguration } from '../interfaces';
+export declare const getFunctionConfigs: (lambda: Lambda, cloudWatch: CloudWatchLogs, region: string, functionARNs: string[], settings: InstrumentationSettings) => Promise<FunctionConfiguration[]>;
+export declare const getFunctionConfig: (lambda: Lambda, cloudWatch: CloudWatchLogs, config: Lambda.FunctionConfiguration, region: string, settings: InstrumentationSettings) => Promise<{
+    functionARN: string;
+    lambdaConfig: Lambda.FunctionConfiguration;
+    lambdaLibraryLayerArn: string;
+    logGroupConfiguration: LogGroupConfiguration | undefined;
+    tagConfiguration: TagConfiguration | undefined;
+    updateRequest: Lambda.UpdateFunctionConfigurationRequest | undefined;
+}>;
+export declare const getLambdaConfigsFromRegEx: (lambda: Lambda, cloudWatch: CloudWatchLogs, region: string, pattern: string, settings: InstrumentationSettings) => Promise<FunctionConfiguration[]>;
+export declare const getLayerArn: (runtime: Runtime, settings: InstrumentationSettings, region: string) => string;
+export declare const getExtensionArn: (settings: InstrumentationSettings, region: string) => string;
+export declare const calculateUpdateRequest: (config: Lambda.FunctionConfiguration, settings: InstrumentationSettings, lambdaLibraryLayerArn: string, lambdaExtensionLayerArn: string, runtime: Runtime) => Lambda.UpdateFunctionConfigurationRequest | undefined;