@datadog/datadog-ci 0.17.8 → 0.17.12

package/LICENSE-3rdparty.csv

@@ -7,6 +7,7 @@ Component,Origin,Licence,Copyright
 @types/tiny-async-pool,dev,MIT,Copyright (c) Microsoft Corporation
 @types/deep-extend,dev,MIT,Copyright Microsoft Corporation
 @types/glob,dev,MIT,Copyright Microsoft Corporation
+@types/inquirer,dev,MIT,Copyright Microsoft Corporation
 @types/jest,dev,MIT,Copyright Microsoft Corporation
 @types/node,dev,MIT,Copyright Microsoft Corporation
 @types/ssh2,dev,MIT,Copyright Microsoft Corporation
@@ -25,6 +26,7 @@ deep-extend,import,MIT,Copyright (c) 2013-2018, Viacheslav Lotsmanov
 fast-xml-parser,import,MIT,Copyright (c) 2017 Amit Kumar Gupta
 form-data,import,MIT,Copyright (c) 2012 Felix Geisendörfer (felix@debuggable.com) and contributors
 glob,import,ISC,Copyright (c) Isaac Z. Schlueter and Contributors
+inquirer,import,MIT,Copyright (c) 2012 Simon Boudrias
 jest,dev,MIT,Copyright (c) Facebook, Inc. and its affiliates.
 jest-environment-node,dev,MIT,Copyright (c) Facebook, Inc. and its affiliates.
 jest-matcher-specific-error,dev,MIT,Copyright (c) 2020 Daniel Hreben

package/README.md

@@ -33,12 +33,13 @@ yarn global add @datadog/datadog-ci
 ```bash
 Usage: datadog-ci <command> <subcommand> [options]
 
-Available command:
+Available commands:
   - dependencies
   - lambda
   - sourcemaps
   - synthetics
   - dsyms
+  - git-metadata
 ```
 
 Each command allows interacting with a product of the Datadog platform. The commands are defined in the [src/commands](/src/commands) folder.
@@ -50,6 +51,7 @@ Further documentation for each command can be found in its folder, ie:
 - [Sourcemaps](src/commands/sourcemaps/)
 - [Synthetics CI/CD Testing](src/commands/synthetics/)
 - [iOS dSYM Files](src/commands/dsyms/)
+- [Git metadata](src/commands/git-metadata)
 
 ## Contributing
 

package/dist/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const clipanion_1 = require("clipanion");
+const onError = (err) => {
+    console.log(err);
+    process.exitCode = 1;
+};
+process.on('uncaughtException', onError);
+process.on('unhandledRejection', onError);
+const cli = new clipanion_1.Cli({
+    binaryLabel: 'Datadog CI',
+    binaryName: 'datadog-ci',
+    binaryVersion: require('../package.json').version,
+});
+const commandsPath = `${__dirname}/commands`;
+for (const commandFolder of fs_1.default.readdirSync(commandsPath)) {
+    const commandPath = `${commandsPath}/${commandFolder}`;
+    if (fs_1.default.statSync(commandPath).isDirectory()) {
+        // tslint:disable-next-line: no-var-requires
+        require(`${commandPath}/cli`).forEach((command) => cli.register(command));
+    }
+}
+if (require.main === module) {
+    cli.runExit(process.argv.slice(2), {
+        stderr: process.stderr,
+        stdin: process.stdin,
+        stdout: process.stdout,
+    });
+}

package/dist/commands/dependencies/upload.d.ts

@@ -1,7 +1,7 @@
 import { Command } from 'clipanion';
 export declare class UploadCommand extends Command {
     static SUPPORTED_SOURCES: string[];
-    static usage: import("clipanion/lib/advanced").Usage;
+    static usage: import("clipanion").Usage;
     private static INVALID_INPUT_EXIT_CODE;
     private static MISSING_FILE_EXIT_CODE;
     private static UPLOAD_ERROR_EXIT_CODE;

package/dist/commands/dsyms/upload.d.ts

@@ -1,6 +1,6 @@
 import { Command } from 'clipanion';
 export declare class UploadCommand extends Command {
-    static usage: import("clipanion/lib/advanced").Usage;
+    static usage: import("clipanion").Usage;
     private basePath;
     private config;
     private dryRun;

package/dist/commands/git-metadata/upload.d.ts

@@ -1,6 +1,6 @@
 import { Command } from 'clipanion';
 export declare class UploadCommand extends Command {
-    static usage: import("clipanion/lib/advanced").Usage;
+    static usage: import("clipanion").Usage;
     repositoryURL?: string;
     private cliVersion;
     private config;

package/dist/commands/git-metadata/upload.js

@@ -51,7 +51,7 @@ class UploadCommand extends clipanion_1.Command {
             });
             const payload = yield git_1.getCommitInfo(yield git_1.newSimpleGit(), this.context.stdout, this.repositoryURL);
             if (payload === undefined) {
-                return 0;
+                return 1;
             }
             this.context.stdout.write(renderer_1.renderCommandInfo(payload));
             try {
@@ -106,6 +106,11 @@ class UploadCommand extends clipanion_1.Command {
         return utils_1.getRequestBuilder({
             apiKey: this.config.apiKey,
             baseUrl: api_1.getBaseIntakeUrl(),
+            headers: new Map([
+                ['DD-EVP-ORIGIN', 'datadog-ci git-metadata'],
+                ['DD-EVP-ORIGIN-VERSION', this.cliVersion],
+            ]),
+            overrideUrl: 'api/v2/srcmap',
         });
     }
     uploadRepository(requestBuilder) {

package/dist/commands/junit/upload.d.ts

@@ -1,6 +1,6 @@
 import { Command } from 'clipanion';
 export declare class UploadJUnitXMLCommand extends Command {
-    static usage: import("clipanion/lib/advanced").Usage;
+    static usage: import("clipanion").Usage;
     private basePaths?;
     private config;
     private dryRun;

package/dist/commands/lambda/__tests__/fixtures.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="jest" />
+import { CloudWatchLogs, Lambda } from 'aws-sdk';
+import { Cli, Command } from 'clipanion/lib/advanced';
+export declare const createMockContext: () => {
+    stdout: {
+        toString: () => string;
+        write: (input: string) => void;
+    };
+};
+export declare const makeCli: () => Cli<import("clipanion/lib/advanced").BaseContext>;
+/**
+ * Allow for constructors with any amount of parameters.
+ * Mainly used for testing when we are creating commands.
+ */
+export declare type ConstructorOf<T> = new (...args: any[]) => T;
+/**
+ * Allows to create an instance of any command that
+ * extends the Command clss.
+ *
+ * @param commandClass any class that extends the Command class.
+ * @param parameters parameters to use while creating the commandClass
+ * @returns the instance of the given command with a mock context attatched.
+ */
+export declare const createCommand: <T extends Command<import("clipanion/lib/advanced").BaseContext>>(commandClass: ConstructorOf<T>, ...parameters: any[]) => T;
+export declare const makeMockLambda: (functionConfigs: Record<string, Lambda.FunctionConfiguration>) => {
+    getFunction: jest.Mock<any, any>;
+    listFunctions: jest.Mock<any, any>;
+    listTags: jest.Mock<any, any>;
+    tagResource: jest.Mock<any, any>;
+    updateFunctionConfiguration: jest.Mock<any, any>;
+};
+export declare const makeMockCloudWatchLogs: (logGroups: Record<string, {
+    config: CloudWatchLogs.DescribeLogGroupsResponse;
+    filters?: CloudWatchLogs.DescribeSubscriptionFiltersResponse;
+}>) => {
+    createLogGroup: jest.Mock<any, any>;
+    deleteSubscriptionFilter: jest.Mock<any, any>;
+    describeLogGroups: jest.Mock<any, any>;
+    describeSubscriptionFilters: jest.Mock<any, any>;
+    putSubscriptionFilter: jest.Mock<any, any>;
+};
+export declare const mockAwsAccount = "123456789012";

package/dist/commands/lambda/__tests__/fixtures.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockAwsAccount = exports.makeMockCloudWatchLogs = exports.makeMockLambda = exports.createCommand = exports.makeCli = exports.createMockContext = void 0;
+const advanced_1 = require("clipanion/lib/advanced");
+const instrument_1 = require("../instrument");
+const uninstrument_1 = require("../uninstrument");
+const createMockContext = () => {
+    let data = '';
+    return {
+        stdout: {
+            toString: () => data,
+            write: (input) => {
+                data += input;
+            },
+        },
+    };
+};
+exports.createMockContext = createMockContext;
+const makeCli = () => {
+    const cli = new advanced_1.Cli();
+    cli.register(instrument_1.InstrumentCommand);
+    cli.register(uninstrument_1.UninstrumentCommand);
+    return cli;
+};
+exports.makeCli = makeCli;
+/**
+ * Allows to create an instance of any command that
+ * extends the Command clss.
+ *
+ * @param commandClass any class that extends the Command class.
+ * @param parameters parameters to use while creating the commandClass
+ * @returns the instance of the given command with a mock context attatched.
+ */
+const createCommand = (commandClass, ...parameters) => {
+    // Create a new instance of commandClass and pass in the parameters
+    const command = new commandClass(...parameters);
+    command.context = exports.createMockContext();
+    return command;
+};
+exports.createCommand = createCommand;
+const makeMockLambda = (functionConfigs) => ({
+    getFunction: jest.fn().mockImplementation(({ FunctionName }) => ({
+        promise: () => Promise.resolve({ Configuration: functionConfigs[FunctionName] }),
+    })),
+    listFunctions: jest.fn().mockImplementation(() => ({
+        promise: () => Promise.resolve({ Functions: Object.values(functionConfigs) }),
+    })),
+    listTags: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve({ Tags: {} }) })),
+    tagResource: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    updateFunctionConfiguration: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+});
+exports.makeMockLambda = makeMockLambda;
+const makeMockCloudWatchLogs = (logGroups) => ({
+    createLogGroup: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    deleteSubscriptionFilter: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    describeLogGroups: jest.fn().mockImplementation(({ logGroupNamePrefix }) => {
+        var _a, _b;
+        const groups = (_b = (_a = logGroups[logGroupNamePrefix]) === null || _a === void 0 ? void 0 : _a.config) !== null && _b !== void 0 ? _b : { logGroups: [] };
+        return {
+            promise: () => Promise.resolve(groups),
+        };
+    }),
+    describeSubscriptionFilters: jest.fn().mockImplementation(({ logGroupName }) => {
+        var _a, _b;
+        const groups = (_b = (_a = logGroups[logGroupName]) === null || _a === void 0 ? void 0 : _a.filters) !== null && _b !== void 0 ? _b : { subscriptionFilters: [] };
+        return {
+            promise: () => Promise.resolve(groups),
+        };
+    }),
+    putSubscriptionFilter: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+});
+exports.makeMockCloudWatchLogs = makeMockCloudWatchLogs;
+exports.mockAwsAccount = '123456789012';

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

@@ -0,0 +1,350 @@
+"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 });
+/* tslint:disable:no-string-literal */
+const constants_1 = require("../../constants");
+const commons_1 = require("../../functions/commons");
+const instrument_1 = require("../../instrument");
+const fixtures_1 = require("../fixtures");
+describe('commons', () => {
+    describe('addLayerArn', () => {
+        test('adds layers and removes previous versions', () => {
+            const runtime = 'python3.9';
+            const config = {
+                Runtime: runtime,
+            };
+            let layerARNs = [
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:48',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:10',
+            ];
+            const region = 'sa-east-1';
+            const lambdaLibraryLayerName = constants_1.RUNTIME_LAYER_LOOKUP[runtime];
+            const fullLambdaLibraryLayerArn = commons_1.getLayerArn(config, config.Runtime, region) + ':49';
+            const fullExtensionLayerArn = commons_1.getLayerArn(config, constants_1.EXTENSION_LAYER_KEY, region) + ':11';
+            layerARNs = commons_1.addLayerArn(fullLambdaLibraryLayerArn, lambdaLibraryLayerName, layerARNs);
+            layerARNs = commons_1.addLayerArn(fullExtensionLayerArn, constants_1.DD_LAMBDA_EXTENSION_LAYER_NAME, layerARNs);
+            expect(layerARNs).toEqual([
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:11',
+            ]);
+        });
+        test('swaps layers if architecture is arm64', () => {
+            const runtime = 'python3.9';
+            const config = {
+                Architectures: ['arm64'],
+                Runtime: runtime,
+            };
+            let layerARNs = [
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:11',
+            ];
+            const region = 'sa-east-1';
+            const lambdaLibraryLayerName = constants_1.RUNTIME_LAYER_LOOKUP[runtime];
+            const fullLambdaLibraryLayerArn = commons_1.getLayerArn(config, config.Runtime, region) + ':49';
+            const fullExtensionLayerArn = commons_1.getLayerArn(config, constants_1.EXTENSION_LAYER_KEY, region) + ':11';
+            layerARNs = commons_1.addLayerArn(fullLambdaLibraryLayerArn, lambdaLibraryLayerName, layerARNs);
+            layerARNs = commons_1.addLayerArn(fullExtensionLayerArn, constants_1.DD_LAMBDA_EXTENSION_LAYER_NAME, layerARNs);
+            expect(layerARNs).toEqual([
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39-ARM:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension-ARM:11',
+            ]);
+        });
+    });
+    describe('coerceBoolean', () => {
+        test('return fallback when none of the values provided can be parsed to boolean', () => {
+            expect(commons_1.coerceBoolean(true, 'NotBoolean', 123, [], {})).toBe(true);
+            expect(commons_1.coerceBoolean(false, 'NotBooleanEither', 456, ['An array'], { booleanInObject: true })).toBe(false);
+        });
+        test('return the first boolean when one of the values provided can be parsed to boolean', () => {
+            expect(commons_1.coerceBoolean(true, 'false', 'true')).toBe(false);
+            expect(commons_1.coerceBoolean(false, 'true', 'False')).toBe(true);
+        });
+        test('return the first boolean when one of the values provided is boolean', () => {
+            expect(commons_1.coerceBoolean(true, false, 'truE', true)).toBe(false);
+            expect(commons_1.coerceBoolean(false, true, 'False', false)).toBe(true);
+        });
+    });
+    describe('collectFunctionsByRegion', () => {
+        test('groups functions with region read from arn', () => {
+            process.env = {};
+            const command = fixtures_1.createCommand(instrument_1.InstrumentCommand);
+            const region = 'us-east-1';
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:us-east-1:123456789012:function:another',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            expect(commons_1.collectFunctionsByRegion(command['functions'], region)).toEqual({
+                'us-east-1': [
+                    'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                    'arn:aws:lambda:us-east-1:123456789012:function:another',
+                ],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('groups functions in the config object', () => {
+            process.env = {};
+            const command = fixtures_1.createCommand(instrument_1.InstrumentCommand);
+            const region = 'us-east-1';
+            command['config']['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:us-east-1:123456789012:function:another',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            expect(commons_1.collectFunctionsByRegion(command['config']['functions'], region)).toEqual({
+                'us-east-1': [
+                    'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                    'arn:aws:lambda:us-east-1:123456789012:function:another',
+                ],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('uses default region for functions not in arn format', () => {
+            process.env = {};
+            const command = fixtures_1.createCommand(instrument_1.InstrumentCommand);
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:*:123456789012:function:func-with-wildcard',
+                'func-without-region',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            command['region'] = 'ap-south-1';
+            expect(commons_1.collectFunctionsByRegion(command['functions'], command['region'])).toEqual({
+                'ap-south-1': ['arn:aws:lambda:*:123456789012:function:func-with-wildcard', 'func-without-region'],
+                'us-east-1': ['arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world'],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('fails to collect when there are regionless functions and no default region is set', () => {
+            process.env = {};
+            const command = fixtures_1.createCommand(instrument_1.InstrumentCommand);
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:*:123456789012:function:func-with-wildcard',
+                'func-without-region',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            command['region'] = undefined;
+            command['config']['region'] = undefined;
+            let functionsGroup;
+            try {
+                functionsGroup = commons_1.collectFunctionsByRegion(command['functions'], command['region']);
+            }
+            catch (err) {
+                // Do nothing
+            }
+            expect(functionsGroup).toBeUndefined();
+        });
+    });
+    describe('getLayerArn', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('gets sa-east-1 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = commons_1.getLayerArn({}, constants_1.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_1.mockAwsAccount}:layer:Datadog-Extension`);
+        }));
+        test('gets sa-east-1 arm64 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = {
+                Architectures: ['arm64'],
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = commons_1.getLayerArn(config, constants_1.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_1.mockAwsAccount}:layer:Datadog-Extension-ARM`);
+        }));
+        test('gets us-gov-1 gov cloud Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = commons_1.getLayerArn({}, constants_1.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_1.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Extension`);
+        }));
+        test('gets us-gov-1 gov cloud arm64 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = {
+                Architectures: ['arm64'],
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = commons_1.getLayerArn(config, constants_1.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_1.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Extension-ARM`);
+        }));
+        test('gets sa-east-1 Node12 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = 'nodejs12.x';
+            const config = {
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = commons_1.getLayerArn(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_1.mockAwsAccount}:layer:Datadog-Node12-x`);
+        }));
+        test('gets sa-east-1 Python3.9 arm64 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = 'python3.9';
+            const config = {
+                Architectures: ['arm64'],
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = commons_1.getLayerArn(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_1.mockAwsAccount}:layer:Datadog-Python39-ARM`);
+        }));
+        test('gets us-gov-1 Python37 gov cloud Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = 'python3.7';
+            const config = {
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = commons_1.getLayerArn(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_1.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Python37`);
+        }));
+        test('gets us-gov-1 Python39 gov cloud arm64 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = 'python3.9';
+            const config = {
+                Architectures: ['arm64'],
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_1.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = commons_1.getLayerArn(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_1.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Python39-ARM`);
+        }));
+    });
+    describe('getRegion', () => {
+        test('should return the expected region', () => {
+            const functionARN = 'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world';
+            const expectedRegion = 'us-east-1';
+            const region = commons_1.getRegion(functionARN);
+            expect(region).toBe(expectedRegion);
+        });
+        test('should return undefined if Function ARN does not contain the region', () => {
+            const functionName = 'lambda-hello-world';
+            const region = commons_1.getRegion(functionName);
+            expect(region).toBe(undefined);
+        });
+    });
+    describe('sentenceMatchesRegEx', () => {
+        const tags = [
+            ['not-complying:regex-should-fail', false],
+            ['1first-char-is-number:should-fail', false],
+            ['_also-not-complying:should-fail', false],
+            ['complying_tag:accepted/with/slashes.and.dots,but-empty-tag', false],
+            ['also_complying:success,1but_is_illegal:should-fail', false],
+            ['this:complies,also_this_one:yes,numb3r_in_name:should-succeed,dots:al.lo.wed', true],
+            ['complying_ip_address_4:192.342.3134.231', true],
+            ['complying:alone', true],
+            ['one_divided_by_two:1/2,one_divided_by_four:0.25,three_minus_one_half:3-1/2', true],
+            ['this_is_a_valid_t4g:yes/it.is-42', true],
+        ];
+        test.each(tags)('check if the tags match the expected result from the regex', (tag, expectedResult) => {
+            const result = !!commons_1.sentenceMatchesRegEx(tag, constants_1.EXTRA_TAGS_REG_EXP);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('updateLambdaConfigs', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('updates every lambda', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({});
+            const configs = [
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                        Handler: 'index.handler',
+                        Runtime: 'nodejs12.x',
+                    },
+                    lambdaLibraryLayerArn: 'arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node12-x',
+                    updateRequest: {
+                        Environment: {
+                            Variables: {
+                                [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                                [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                                [constants_1.TRACE_ENABLED_ENV_VAR]: 'false',
+                            },
+                        },
+                        FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                        Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                        Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node12-x:22'],
+                    },
+                },
+            ];
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            yield commons_1.updateLambdaFunctionConfigs(lambda, cloudWatch, configs);
+            expect(lambda.updateFunctionConfiguration).toHaveBeenCalledWith({
+                Environment: {
+                    Variables: {
+                        [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                        [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                        [constants_1.TRACE_ENABLED_ENV_VAR]: 'false',
+                    },
+                },
+                FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node12-x:22'],
+            });
+        }));
+    });
+});