@datadog/datadog-ci 0.17.9 → 0.17.13

package/dist/commands/lambda/instrument.js

@@ -19,74 +19,116 @@ const upload_1 = require("../git-metadata/upload");
 const constants_1 = require("./constants");
 const commons_1 = require("./functions/commons");
 const instrument_1 = require("./functions/instrument");
+const prompt_1 = require("./prompt");
 class InstrumentCommand extends clipanion_1.Command {
     constructor() {
         super(...arguments);
         this.config = {
             functions: [],
-            region: process.env.AWS_DEFAULT_REGION,
+            region: process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR],
             tracing: 'true',
         };
         this.dryRun = false;
         this.functions = [];
+        this.interactive = false;
         this.sourceCodeIntegration = false;
     }
     execute() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const lambdaConfig = { lambda: this.config };
             this.config = (yield utils_1.parseConfigFile(lambdaConfig, this.configPath)).lambda;
+            let hasSpecifiedFunctions = this.functions.length !== 0 || this.config.functions.length !== 0;
+            if (this.interactive) {
+                try {
+                    if (commons_1.isMissingAWSCredentials()) {
+                        this.context.stdout.write(`${chalk_1.bold(chalk_1.yellow('[!]'))} No existing AWS credentials found, let's set them up!\n`);
+                        yield prompt_1.requestAWSCredentials();
+                    }
+                    if (commons_1.isMissingDatadogEnvVars()) {
+                        this.context.stdout.write(`${chalk_1.bold(chalk_1.yellow('[!]'))} Configure Datadog settings.\n`);
+                        yield prompt_1.requestDatadogEnvVars();
+                    }
+                }
+                catch (e) {
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} ${e}\n`);
+                    return 1;
+                }
+                const region = (_b = (_a = this.region) !== null && _a !== void 0 ? _a : this.config.region) !== null && _b !== void 0 ? _b : process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR];
+                this.region = region;
+                // If user doesn't specify functions, allow them
+                // to select from all of the functions from the
+                // requested region.
+                if (!hasSpecifiedFunctions) {
+                    try {
+                        const lambda = new aws_sdk_1.Lambda({ region });
+                        this.context.stdout.write('Fetching Lambda functions, this might take a while.\n');
+                        const functionNames = (_c = (yield commons_1.getAllLambdaFunctionConfigs(lambda)).map((config) => config.FunctionName).sort()) !== null && _c !== void 0 ? _c : [];
+                        if (functionNames.length === 0) {
+                            this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't find any Lambda functions in the specified region.\n`);
+                            return 1;
+                        }
+                        const functions = yield prompt_1.requestFunctionSelection(functionNames);
+                        this.functions = functions;
+                    }
+                    catch (err) {
+                        this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
+                        return 1;
+                    }
+                }
+            }
             const settings = this.getSettings();
             if (settings === undefined) {
                 return 1;
             }
-            const hasSpecifiedFuntions = this.functions.length !== 0 || this.config.functions.length !== 0;
-            const hasSpecifiedRegExPattern = this.regExPattern !== undefined;
-            if (!hasSpecifiedFuntions && !hasSpecifiedRegExPattern) {
-                this.context.stdout.write('No functions specified for instrumentation.\n');
+            hasSpecifiedFunctions = this.functions.length !== 0 || this.config.functions.length !== 0;
+            const hasSpecifiedRegExPattern = this.regExPattern !== undefined && this.regExPattern !== '';
+            if (!hasSpecifiedFunctions && !hasSpecifiedRegExPattern) {
+                this.context.stdout.write(`${chalk_1.red('[Error]')} No functions specified for instrumentation.\n`);
                 return 1;
             }
             if (settings.extensionVersion && settings.forwarderARN) {
-                this.context.stdout.write('"extensionVersion" and "forwarder" should not be used at the same time.\n');
+                this.context.stdout.write(`${chalk_1.red('[Error]')} "extensionVersion" and "forwarder" should not be used at the same time.\n`);
                 return 1;
             }
             if (this.sourceCodeIntegration) {
                 if (!process.env.DATADOG_API_KEY) {
-                    this.context.stdout.write('Missing DATADOG_API_KEY in your environment\n');
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Missing DATADOG_API_KEY in your environment\n`);
                     return 1;
                 }
                 try {
                     yield this.getGitDataAndUpload(settings);
                 }
                 catch (err) {
-                    this.context.stdout.write(`${err}\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} ${err}\n`);
                     return 1;
                 }
             }
             const configGroups = [];
             if (hasSpecifiedRegExPattern) {
-                if (hasSpecifiedFuntions) {
+                if (hasSpecifiedFunctions) {
                     const usedCommand = this.functions.length !== 0 ? '"--functions"' : 'Functions in config file';
-                    this.context.stdout.write(`${usedCommand} and "--functions-regex" should not be used at the same time.\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} ${usedCommand} and "--functions-regex" should not be used at the same time.\n`);
                     return 1;
                 }
                 if (this.regExPattern.match(':')) {
-                    this.context.stdout.write(`"--functions-regex" isn't meant to be used with ARNs.\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} "--functions-regex" isn't meant to be used with ARNs.\n`);
                     return 1;
                 }
                 const region = this.region || this.config.region;
                 if (!region) {
-                    this.context.stdout.write('No default region specified. Use -r,--region,');
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} No default region specified. Use \`-r\`, \`--region\`.\n`);
                     return 1;
                 }
                 try {
                     const cloudWatchLogs = new aws_sdk_1.CloudWatchLogs({ region });
                     const lambda = new aws_sdk_1.Lambda({ region });
-                    this.context.stdout.write('Fetching lambda functions, this might take a while.\n');
-                    const configs = yield instrument_1.getLambdaConfigsFromRegEx(lambda, cloudWatchLogs, region, this.regExPattern, settings);
+                    this.context.stdout.write('Fetching Lambda functions, this might take a while.\n');
+                    const configs = yield instrument_1.getInstrumentedFunctionConfigsFromRegEx(lambda, cloudWatchLogs, region, this.regExPattern, settings);
                     configGroups.push({ configs, lambda, cloudWatchLogs, region: region });
                 }
                 catch (err) {
-                    this.context.stdout.write(`Couldn't fetch lambda functions. ${err}\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
                     return 1;
                 }
             }
@@ -96,18 +138,18 @@ class InstrumentCommand extends clipanion_1.Command {
                     functionGroups = commons_1.collectFunctionsByRegion(this.functions.length !== 0 ? this.functions : this.config.functions, this.region || this.config.region);
                 }
                 catch (err) {
-                    this.context.stdout.write(`Couldn't group functions. ${err}`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't group functions. ${err}`);
                     return 1;
                 }
                 for (const [region, functionList] of Object.entries(functionGroups)) {
                     const lambda = new aws_sdk_1.Lambda({ region });
                     const cloudWatchLogs = new aws_sdk_1.CloudWatchLogs({ region });
                     try {
-                        const configs = yield instrument_1.getFunctionConfigs(lambda, cloudWatchLogs, region, functionList, settings);
+                        const configs = yield instrument_1.getInstrumentedFunctionConfigs(lambda, cloudWatchLogs, region, functionList, settings);
                         configGroups.push({ configs, lambda, cloudWatchLogs, region });
                     }
                     catch (err) {
-                        this.context.stdout.write(`Couldn't fetch lambda functions. ${err}\n`);
+                        this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
                         return 1;
                     }
                 }
@@ -117,20 +159,26 @@ class InstrumentCommand extends clipanion_1.Command {
             if (this.dryRun || configList.length === 0) {
                 return 0;
             }
+            const willUpdate = commons_1.willUpdateFunctionConfigs(configList);
+            if (this.interactive && willUpdate) {
+                this.context.stdout.write(`${chalk_1.yellow('[!]')} Confirmation needed.\n`);
+                const isConfirmed = yield prompt_1.requestChangesConfirmation('Do you want to apply the changes?');
+                if (!isConfirmed) {
+                    return 0;
+                }
+                this.context.stdout.write(`${chalk_1.yellow('[!]')} Instrumenting functions.\n`);
+            }
             const promises = Object.values(configGroups).map((group) => commons_1.updateLambdaFunctionConfigs(group.lambda, group.cloudWatchLogs, group.configs));
             try {
                 yield Promise.all(promises);
             }
             catch (err) {
-                this.context.stdout.write(`Failure during update. ${err}\n`);
+                this.context.stdout.write(`${chalk_1.red('[Error]')} Failure during update. ${err}\n`);
                 return 1;
             }
             return 0;
         });
     }
-    convertStringBooleanToBoolean(fallback, value, configValue) {
-        return value ? value.toLowerCase() === 'true' : configValue ? configValue.toLowerCase() === 'true' : fallback;
-    }
     getCurrentGitStatus() {
         return __awaiter(this, void 0, void 0, function* () {
             const simpleGit = yield git_1.newSimpleGit();
@@ -173,7 +221,7 @@ class InstrumentCommand extends clipanion_1.Command {
         });
     }
     getSettings() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         const layerVersionStr = (_a = this.layerVersion) !== null && _a !== void 0 ? _a : this.config.layerVersion;
         const extensionVersionStr = (_b = this.extensionVersion) !== null && _b !== void 0 ? _b : this.config.extensionVersion;
         const layerAWSAccount = (_c = this.layerAWSAccount) !== null && _c !== void 0 ? _c : this.config.layerAWSAccount;
@@ -195,23 +243,26 @@ class InstrumentCommand extends clipanion_1.Command {
             return;
         }
         const stringBooleansMap = {
-            flushMetricsToLogs: (_f = (_e = this.flushMetricsToLogs) === null || _e === void 0 ? void 0 : _e.toLowerCase()) !== null && _f !== void 0 ? _f : (_g = this.config.flushMetricsToLogs) === null || _g === void 0 ? void 0 : _g.toLowerCase(),
-            mergeXrayTraces: (_j = (_h = this.mergeXrayTraces) === null || _h === void 0 ? void 0 : _h.toLowerCase()) !== null && _j !== void 0 ? _j : (_k = this.config.mergeXrayTraces) === null || _k === void 0 ? void 0 : _k.toLowerCase(),
-            tracing: (_m = (_l = this.tracing) === null || _l === void 0 ? void 0 : _l.toLowerCase()) !== null && _m !== void 0 ? _m : (_o = this.config.tracing) === null || _o === void 0 ? void 0 : _o.toLowerCase(),
+            captureLambdaPayload: (_e = this.captureLambdaPayload) !== null && _e !== void 0 ? _e : this.config.captureLambdaPayload,
+            flushMetricsToLogs: (_f = this.flushMetricsToLogs) !== null && _f !== void 0 ? _f : this.config.flushMetricsToLogs,
+            mergeXrayTraces: (_g = this.mergeXrayTraces) !== null && _g !== void 0 ? _g : this.config.mergeXrayTraces,
+            tracing: (_h = this.tracing) !== null && _h !== void 0 ? _h : this.config.tracing,
         };
         for (const [stringBoolean, value] of Object.entries(stringBooleansMap)) {
-            if (!['true', 'false', undefined].includes(value)) {
+            if (!['true', 'false', undefined].includes(value === null || value === void 0 ? void 0 : value.toString().toLowerCase())) {
                 this.context.stdout.write(`Invalid boolean specified for ${stringBoolean}.\n`);
                 return;
             }
         }
-        const flushMetricsToLogs = this.convertStringBooleanToBoolean(true, this.flushMetricsToLogs, this.config.flushMetricsToLogs);
-        const mergeXrayTraces = this.convertStringBooleanToBoolean(false, this.mergeXrayTraces, this.config.mergeXrayTraces);
-        const tracingEnabled = this.convertStringBooleanToBoolean(true, this.tracing, this.config.tracing);
-        const logLevel = (_p = this.logLevel) !== null && _p !== void 0 ? _p : this.config.logLevel;
-        const service = (_q = this.service) !== null && _q !== void 0 ? _q : this.config.service;
-        const environment = (_r = this.environment) !== null && _r !== void 0 ? _r : this.config.environment;
-        const version = (_s = this.version) !== null && _s !== void 0 ? _s : this.config.version;
+        const captureLambdaPayload = commons_1.coerceBoolean(false, this.captureLambdaPayload, this.config.captureLambdaPayload);
+        const flushMetricsToLogs = commons_1.coerceBoolean(true, this.flushMetricsToLogs, this.config.flushMetricsToLogs);
+        const mergeXrayTraces = commons_1.coerceBoolean(false, this.mergeXrayTraces, this.config.mergeXrayTraces);
+        const tracingEnabled = commons_1.coerceBoolean(true, this.tracing, this.config.tracing);
+        const interactive = commons_1.coerceBoolean(false, this.interactive, this.config.interactive);
+        const logLevel = (_j = this.logLevel) !== null && _j !== void 0 ? _j : this.config.logLevel;
+        const service = (_k = this.service) !== null && _k !== void 0 ? _k : this.config.service;
+        const environment = (_l = this.environment) !== null && _l !== void 0 ? _l : this.config.environment;
+        const version = (_m = this.version) !== null && _m !== void 0 ? _m : this.config.version;
         const tagsMap = {
             environment,
             service,
@@ -228,17 +279,19 @@ class InstrumentCommand extends clipanion_1.Command {
             const plural = tagsMissing.length > 1;
             this.context.stdout.write(`${chalk_1.bold(chalk_1.yellow('[Warning]'))} The ${tags} tag${plural ? 's have' : ' has'} not been configured. Learn more about Datadog unified service tagging: ${chalk_1.underline(chalk_1.blueBright('https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/#serverless-environment.'))}\n`);
         }
-        const extraTags = (_u = (_t = this.extraTags) === null || _t === void 0 ? void 0 : _t.toLowerCase()) !== null && _u !== void 0 ? _u : (_v = this.config.extraTags) === null || _v === void 0 ? void 0 : _v.toLowerCase();
+        const extraTags = (_p = (_o = this.extraTags) === null || _o === void 0 ? void 0 : _o.toLowerCase()) !== null && _p !== void 0 ? _p : (_q = this.config.extraTags) === null || _q === void 0 ? void 0 : _q.toLowerCase();
         if (extraTags && !commons_1.sentenceMatchesRegEx(extraTags, constants_1.EXTRA_TAGS_REG_EXP)) {
             this.context.stdout.write('Extra tags do not comply with the <key>:<value> array.\n');
             return;
         }
         return {
+            captureLambdaPayload,
             environment,
             extensionVersion,
             extraTags,
             flushMetricsToLogs,
             forwarderARN,
+            interactive,
             layerAWSAccount,
             layerVersion,
             logLevel,
@@ -249,25 +302,24 @@ class InstrumentCommand extends clipanion_1.Command {
         };
     }
     printPlannedActions(configs) {
-        var _a, _b, _c;
         const prefix = this.dryRun ? chalk_1.bold(chalk_1.cyan('[Dry Run] ')) : '';
-        let anyUpdates = false;
-        for (const config of configs) {
-            if (config.updateRequest !== undefined ||
-                ((_a = config.logGroupConfiguration) === null || _a === void 0 ? void 0 : _a.createLogGroupRequest) !== undefined ||
-                ((_b = config.logGroupConfiguration) === null || _b === void 0 ? void 0 : _b.deleteSubscriptionFilterRequest) !== undefined ||
-                ((_c = config.logGroupConfiguration) === null || _c === void 0 ? void 0 : _c.subscriptionFilterRequest) !== undefined ||
-                (config === null || config === void 0 ? void 0 : config.tagConfiguration) !== undefined) {
-                anyUpdates = true;
-                break;
-            }
-        }
-        if (!anyUpdates) {
+        const willUpdate = commons_1.willUpdateFunctionConfigs(configs);
+        if (!willUpdate) {
             this.context.stdout.write(`\n${prefix}No updates will be applied\n`);
             return;
         }
         this.context.stdout.write(`${chalk_1.bold(chalk_1.yellow('[Warning]'))} Instrument your ${chalk_1.hex('#FF9900').bold('Lambda')} functions in a dev or staging environment first. Should the instrumentation result be unsatisfactory, run \`${chalk_1.bold('uninstrument')}\` with the same arguments to revert the changes.\n`);
-        this.context.stdout.write(`${prefix}Will apply the following updates:\n`);
+        this.context.stdout.write(`\n${chalk_1.bold(chalk_1.yellow('[!]'))} Functions to be updated:\n`);
+        for (const config of configs) {
+            this.context.stdout.write(`\t- ${chalk_1.bold(config.functionARN)}\n`);
+            // Later, we should inform which layer is the latest.
+            if (this.interactive) {
+                if (!this.extensionVersion || !this.extensionVersion) {
+                    this.context.stdout.write(`\t${chalk_1.bold(chalk_1.yellow('[Warning]'))} At least one latest layer version is being used. Ensure to lock in versions for production applications using \`--layerVersion\` and \`--extensionVersion\`.\n`);
+                }
+            }
+        }
+        this.context.stdout.write(`\n${prefix}Will apply the following updates:\n`);
         for (const config of configs) {
             if (config.updateRequest) {
                 this.context.stdout.write(`UpdateFunctionConfiguration -> ${config.functionARN}\n${JSON.stringify(config.updateRequest, undefined, 2)}\n`);
@@ -301,20 +353,22 @@ class InstrumentCommand extends clipanion_1.Command {
 exports.InstrumentCommand = InstrumentCommand;
 InstrumentCommand.addPath('lambda', 'instrument');
 InstrumentCommand.addOption('functions', clipanion_1.Command.Array('-f,--function'));
-InstrumentCommand.addOption('regExPattern', clipanion_1.Command.String('--functions-regex'));
+InstrumentCommand.addOption('regExPattern', clipanion_1.Command.String('--functions-regex,--functionsRegex'));
 InstrumentCommand.addOption('region', clipanion_1.Command.String('-r,--region'));
-InstrumentCommand.addOption('extensionVersion', clipanion_1.Command.String('-e,--extensionVersion'));
-InstrumentCommand.addOption('layerVersion', clipanion_1.Command.String('-v,--layerVersion'));
-InstrumentCommand.addOption('layerAWSAccount', clipanion_1.Command.String('-a,--layerAccount', { hidden: true }));
+InstrumentCommand.addOption('extensionVersion', clipanion_1.Command.String('-e,--extension-version,--extensionVersion'));
+InstrumentCommand.addOption('layerVersion', clipanion_1.Command.String('-v,--layer-version,--layerVersion'));
+InstrumentCommand.addOption('layerAWSAccount', clipanion_1.Command.String('-a,--layer-account,--layerAccount', { hidden: true }));
 InstrumentCommand.addOption('tracing', clipanion_1.Command.String('--tracing'));
-InstrumentCommand.addOption('mergeXrayTraces', clipanion_1.Command.String('--mergeXrayTraces'));
-InstrumentCommand.addOption('flushMetricsToLogs', clipanion_1.Command.String('--flushMetricsToLogs'));
+InstrumentCommand.addOption('mergeXrayTraces', clipanion_1.Command.String('--merge-xray-traces,--mergeXrayTraces'));
+InstrumentCommand.addOption('flushMetricsToLogs', clipanion_1.Command.String('--flush-metrics-to-logs,--flushMetricsToLogs'));
 InstrumentCommand.addOption('dryRun', clipanion_1.Command.Boolean('-d,--dry'));
 InstrumentCommand.addOption('configPath', clipanion_1.Command.String('--config'));
 InstrumentCommand.addOption('forwarder', clipanion_1.Command.String('--forwarder'));
-InstrumentCommand.addOption('logLevel', clipanion_1.Command.String('--logLevel'));
+InstrumentCommand.addOption('logLevel', clipanion_1.Command.String('--log-level,--logLevel'));
 InstrumentCommand.addOption('service', clipanion_1.Command.String('--service'));
 InstrumentCommand.addOption('environment', clipanion_1.Command.String('--env'));
 InstrumentCommand.addOption('version', clipanion_1.Command.String('--version'));
-InstrumentCommand.addOption('extraTags', clipanion_1.Command.String('--extra-tags'));
-InstrumentCommand.addOption('sourceCodeIntegration', clipanion_1.Command.Boolean('-s,--source-code-integration'));
+InstrumentCommand.addOption('extraTags', clipanion_1.Command.String('--extra-tags,--extraTags'));
+InstrumentCommand.addOption('sourceCodeIntegration', clipanion_1.Command.Boolean('-s,--source-code-integration,--sourceCodeIntegration'));
+InstrumentCommand.addOption('interactive', clipanion_1.Command.Boolean('-i,--interactive'));
+InstrumentCommand.addOption('captureLambdaPayload', clipanion_1.Command.String('--capture-lambda-payload,--captureLambdaPayload'));

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

@@ -4,12 +4,14 @@ import { CloudWatchLogs, Lambda } from 'aws-sdk';
  * the CLI in order to instrument properly.
  */
 export interface LambdaConfigOptions {
+    captureLambdaPayload?: string;
     environment?: string;
     extensionVersion?: string;
     extraTags?: string;
     flushMetricsToLogs?: string;
     forwarder?: string;
     functions: string[];
+    interactive?: boolean;
     layerAWSAccount?: string;
     layerVersion?: string;
     logLevel?: string;
@@ -27,7 +29,6 @@ export interface LambdaConfigOptions {
 export interface FunctionConfiguration {
     functionARN: string;
     lambdaConfig: Lambda.FunctionConfiguration;
-    lambdaLibraryLayerArn?: string;
     logGroupConfiguration?: LogGroupConfiguration;
     tagConfiguration?: TagConfiguration;
     updateRequest?: Lambda.UpdateFunctionConfigurationRequest;
@@ -37,9 +38,11 @@ export interface FunctionConfiguration {
  * lambda to be instrumented.
  */
 export interface InstrumentationSettings extends InstrumentationTags {
+    captureLambdaPayload?: boolean;
     extensionVersion?: number;
     flushMetricsToLogs: boolean;
     forwarderARN?: string;
+    interactive?: boolean;
     layerAWSAccount?: string;
     layerVersion?: number;
     logLevel?: string;

package/dist/commands/lambda/loggroup.js

@@ -26,7 +26,9 @@ const applyLogGroupConfig = (logs, config) => __awaiter(void 0, void 0, void 0,
     if (deleteSubscriptionFilterRequest !== undefined) {
         yield logs.deleteSubscriptionFilter(deleteSubscriptionFilterRequest).promise();
     }
-    yield logs.putSubscriptionFilter(subscriptionFilterRequest).promise();
+    if (subscriptionFilterRequest !== undefined) {
+        yield logs.putSubscriptionFilter(subscriptionFilterRequest).promise();
+    }
 });
 exports.applyLogGroupConfig = applyLogGroupConfig;
 const calculateLogGroupUpdateRequest = (logs, logGroupName, forwarderARN) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -0,0 +1,9 @@
+import { CheckboxQuestion, ConfirmQuestion, InputQuestion, ListQuestion } from 'inquirer';
+export declare const datadogApiKeyTypeQuestion: (datadogSite: string) => ListQuestion;
+export declare const datadogEnvVarsQuestions: (datadogApiKeyType: Record<string, any>) => InputQuestion;
+export declare const confirmationQuestion: (message: string) => ConfirmQuestion;
+export declare const functionSelectionQuestion: (functionNames: string[]) => CheckboxQuestion;
+export declare const requestAWSCredentials: () => Promise<void>;
+export declare const requestDatadogEnvVars: () => Promise<void>;
+export declare const requestChangesConfirmation: (message: string) => Promise<any>;
+export declare const requestFunctionSelection: (functionNames: string[]) => Promise<any>;

package/dist/commands/lambda/prompt.js

@@ -0,0 +1,187 @@
+"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.requestFunctionSelection = exports.requestChangesConfirmation = exports.requestDatadogEnvVars = exports.requestAWSCredentials = exports.functionSelectionQuestion = exports.confirmationQuestion = exports.datadogEnvVarsQuestions = exports.datadogApiKeyTypeQuestion = void 0;
+const chalk_1 = require("chalk");
+const inquirer_1 = require("inquirer");
+const constants_1 = require("./constants");
+const commons_1 = require("./functions/commons");
+const awsCredentialsQuestions = [
+    {
+        // AWS_ACCESS_KEY_ID question
+        message: 'Enter AWS Access Key ID:',
+        name: constants_1.AWS_ACCESS_KEY_ID_ENV_VAR,
+        type: 'input',
+        validate: (value) => {
+            if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.AWS_ACCESS_KEY_ID_REG_EXP)) {
+                return 'Enter a valid AWS Access Key ID.';
+            }
+            return true;
+        },
+    },
+    {
+        // AWS_SECRET_ACCESS_KEY_ENV_VAR question
+        mask: true,
+        message: 'Enter AWS Secret Access Key:',
+        name: constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR,
+        type: 'password',
+        validate: (value) => {
+            if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.AWS_SECRET_ACCESS_KEY_REG_EXP)) {
+                return 'Enter a valid AWS Secret Access Key.';
+            }
+            return true;
+        },
+    },
+    {
+        // AWS_SESSION_TOKEN
+        mask: true,
+        message: 'Enter AWS Session Token (optional):',
+        name: constants_1.AWS_SESSION_TOKEN_ENV_VAR,
+        type: 'password',
+    },
+    {
+        // AWS_DEFAULT_REGION
+        choices: constants_1.AWS_REGIONS,
+        default: 0,
+        message: 'Select an AWS region:',
+        name: constants_1.AWS_DEFAULT_REGION_ENV_VAR,
+        type: 'list',
+    },
+];
+const datadogApiKeyTypeQuestion = (datadogSite) => ({
+    choices: [
+        {
+            name: `Plain text ${chalk_1.bold('API Key')} (Recommended for trial users) `,
+            value: {
+                envVar: constants_1.CI_API_KEY_ENV_VAR,
+                message: 'API Key:',
+            },
+        },
+        new inquirer_1.Separator(),
+        {
+            name: `API key encrypted with AWS Key Management Service ${chalk_1.bold('(KMS) API Key')}`,
+            value: {
+                envVar: constants_1.CI_KMS_API_KEY_ENV_VAR,
+                message: 'KMS Encrypted API Key:',
+            },
+        },
+        {
+            name: `AWS Secrets Manager ${chalk_1.bold('API Key Secret ARN')}`,
+            value: {
+                envVar: constants_1.CI_API_KEY_SECRET_ARN_ENV_VAR,
+                message: 'API Key Secret ARN:',
+            },
+        },
+    ],
+    message: `Which type of Datadog API Key you want to set? \nLearn more at ${chalk_1.blueBright(`https://app.${datadogSite}/organization-settings/api-keys`)}`,
+    name: 'type',
+    type: 'list',
+});
+exports.datadogApiKeyTypeQuestion = datadogApiKeyTypeQuestion;
+const datadogSiteQuestion = {
+    // DATADOG SITE
+    choices: constants_1.SITES,
+    message: `Select the Datadog site to send data. \nLearn more at ${chalk_1.blueBright('https://docs.datadoghq.com/getting_started/site/')}`,
+    name: constants_1.CI_SITE_ENV_VAR,
+    type: 'list',
+};
+const datadogEnvVarsQuestions = (datadogApiKeyType) => ({
+    // DATADOG API KEY given type
+    default: process.env[datadogApiKeyType.envVar],
+    message: datadogApiKeyType.message,
+    name: datadogApiKeyType.envVar,
+    type: 'input',
+    validate: (value) => {
+        if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.DATADOG_API_KEY_REG_EXP)) {
+            return 'Enter a valid Datadog API Key.';
+        }
+        return true;
+    },
+});
+exports.datadogEnvVarsQuestions = datadogEnvVarsQuestions;
+const confirmationQuestion = (message) => ({
+    message,
+    name: 'confirmation',
+    type: 'confirm',
+});
+exports.confirmationQuestion = confirmationQuestion;
+const functionSelectionQuestion = (functionNames) => ({
+    choices: functionNames,
+    message: 'Select the functions to modify',
+    name: 'functions',
+    type: 'checkbox',
+    validate: (selectedFunctions) => {
+        if (selectedFunctions.length < 1) {
+            return 'You must choose at least one function.';
+        }
+        return true;
+    },
+});
+exports.functionSelectionQuestion = functionSelectionQuestion;
+const requestAWSCredentials = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const awsCredentialsAnswers = yield inquirer_1.prompt(awsCredentialsQuestions);
+        process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR];
+        process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR];
+        process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_DEFAULT_REGION_ENV_VAR];
+        if (awsCredentialsAnswers[constants_1.AWS_SESSION_TOKEN_ENV_VAR] !== undefined) {
+            process.env[constants_1.AWS_SESSION_TOKEN_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_SESSION_TOKEN_ENV_VAR];
+        }
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't set AWS Credentials. ${e.message}`);
+        }
+    }
+});
+exports.requestAWSCredentials = requestAWSCredentials;
+const requestDatadogEnvVars = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const datadogSiteAnswer = yield inquirer_1.prompt(datadogSiteQuestion);
+        const selectedDatadogSite = datadogSiteAnswer[constants_1.CI_SITE_ENV_VAR];
+        process.env[constants_1.CI_SITE_ENV_VAR] = selectedDatadogSite;
+        const datadogApiKeyTypeAnswer = yield inquirer_1.prompt(exports.datadogApiKeyTypeQuestion(selectedDatadogSite));
+        const datadogApiKeyType = datadogApiKeyTypeAnswer.type;
+        const datadogEnvVars = yield inquirer_1.prompt(exports.datadogEnvVarsQuestions(datadogApiKeyType));
+        const selectedDatadogApiKeyEnvVar = datadogApiKeyType.envVar;
+        process.env[selectedDatadogApiKeyEnvVar] = datadogEnvVars[selectedDatadogApiKeyEnvVar];
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't set Datadog Environment Variables. ${e.message}`);
+        }
+    }
+});
+exports.requestDatadogEnvVars = requestDatadogEnvVars;
+const requestChangesConfirmation = (message) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const confirmationAnswer = yield inquirer_1.prompt(exports.confirmationQuestion(message));
+        return confirmationAnswer.confirmation;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't receive confirmation. ${e.message}`);
+        }
+    }
+});
+exports.requestChangesConfirmation = requestChangesConfirmation;
+const requestFunctionSelection = (functionNames) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const selectedFunctionsAnswer = yield inquirer_1.prompt(exports.functionSelectionQuestion(functionNames));
+        return selectedFunctionsAnswer.functions;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't receive selected functions. ${e.message}`);
+        }
+    }
+});
+exports.requestFunctionSelection = requestFunctionSelection;

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

@@ -5,6 +5,8 @@ export declare class UninstrumentCommand extends Command {
     private dryRun;
     private forwarder?;
     private functions;
+    private interactive;
+    private regExPattern?;
     private region?;
     execute(): Promise<1 | 0>;
     private printPlannedActions;