@datadog/datadog-ci 2.16.0 → 2.17.0

package/dist/commands/lambda/flare.js

@@ -0,0 +1,656 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToDatadog = exports.getEndpointUrl = exports.zipContents = exports.sleep = exports.convertToCSV = exports.writeFile = exports.getTags = exports.getAllLogs = exports.getLogEvents = exports.getLogStreamNames = exports.createDirectories = exports.deleteFolder = exports.maskConfig = exports.validateStartEndFlags = exports.LambdaFlareCommand = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = __importDefault(require("util"));
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const axios_1 = __importDefault(require("axios"));
+const clipanion_1 = require("clipanion");
+const form_data_1 = __importDefault(require("form-data"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const jszip_1 = __importDefault(require("jszip"));
+const constants_1 = require("../../constants");
+const validation_1 = require("../../helpers/validation");
+const constants_2 = require("./constants");
+const commons_1 = require("./functions/commons");
+const prompt_1 = require("./prompt");
+const commonRenderer = __importStar(require("./renderers/common-renderer"));
+const flareRenderer = __importStar(require("./renderers/flare-renderer"));
+const { version } = require('../../../package.json');
+const ENDPOINT_PATH = '/api/ui/support/serverless/flare';
+const FLARE_OUTPUT_DIRECTORY = '.datadog-ci';
+const LOGS_DIRECTORY = 'logs';
+const FUNCTION_CONFIG_FILE_NAME = 'function_config.json';
+const TAGS_FILE_NAME = 'tags.json';
+const ZIP_FILE_NAME = 'lambda-flare-output.zip';
+const MAX_LOG_STREAMS = 50;
+const DEFAULT_LOG_STREAMS = 3;
+const MAX_LOG_EVENTS_PER_STREAM = 1000;
+class LambdaFlareCommand extends clipanion_1.Command {
+    constructor() {
+        super(...arguments);
+        this.isDryRun = false;
+        this.withLogs = false;
+    }
+    /**
+     * Entry point for the `lambda flare` command.
+     * Gathers lambda function configuration and sends it to Datadog.
+     * @returns 0 if the command ran successfully, 1 otherwise.
+     */
+    execute() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.context.stdout.write(flareRenderer.renderLambdaFlareHeader(this.isDryRun));
+            // Validate function name
+            if (this.functionName === undefined) {
+                this.context.stderr.write(commonRenderer.renderError('No function name specified. [-f,--function]'));
+                return 1;
+            }
+            const errorMessages = [];
+            // Validate region
+            const region = (_b = (_a = commons_1.getRegion(this.functionName)) !== null && _a !== void 0 ? _a : this.region) !== null && _b !== void 0 ? _b : process.env[constants_2.AWS_DEFAULT_REGION_ENV_VAR];
+            if (region === undefined) {
+                errorMessages.push(commonRenderer.renderNoDefaultRegionSpecifiedError());
+            }
+            // Validate Datadog API key
+            this.apiKey = (_c = process.env[constants_2.CI_API_KEY_ENV_VAR]) !== null && _c !== void 0 ? _c : process.env[constants_2.API_KEY_ENV_VAR];
+            if (this.apiKey === undefined) {
+                errorMessages.push(commonRenderer.renderError('No Datadog API key specified. Set an API key with the DATADOG_API_KEY environment variable.'));
+            }
+            if (!this.isDryRun) {
+                // Validate case ID
+                if (this.caseId === undefined) {
+                    errorMessages.push(commonRenderer.renderError('No case ID specified. [-c,--case-id]'));
+                }
+                // Validate email
+                if (this.email === undefined) {
+                    errorMessages.push(commonRenderer.renderError('No email specified. [-e,--email]'));
+                }
+            }
+            // Validate start/end flags if both are specified
+            let startMillis;
+            let endMillis;
+            try {
+                ;
+                [startMillis, endMillis] = exports.validateStartEndFlags(this.start, this.end);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    errorMessages.push(commonRenderer.renderError(err.message));
+                }
+            }
+            if (errorMessages.length > 0) {
+                for (const message of errorMessages) {
+                    this.context.stderr.write(message);
+                }
+                return 1;
+            }
+            // Get AWS credentials
+            this.context.stdout.write('\n🔑 Getting AWS credentials...\n');
+            try {
+                this.credentials = yield commons_1.getAWSCredentials();
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    this.context.stderr.write(commonRenderer.renderError(err.message));
+                }
+                return 1;
+            }
+            if (this.credentials === undefined) {
+                this.context.stdout.write('\n' + commonRenderer.renderNoAWSCredentialsFound());
+                try {
+                    yield prompt_1.requestAWSCredentials();
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        this.context.stderr.write(commonRenderer.renderError(err.message));
+                    }
+                    return 1;
+                }
+            }
+            // Get and print Lambda function configuration
+            this.context.stdout.write('\n🔍 Fetching Lambda function configuration...\n');
+            const lambdaClientConfig = {
+                region,
+                credentials: this.credentials,
+            };
+            const lambdaClient = new client_lambda_1.LambdaClient(lambdaClientConfig);
+            let config;
+            try {
+                config = yield commons_1.getLambdaFunctionConfig(lambdaClient, this.functionName);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    this.context.stderr.write(commonRenderer.renderError(`Unable to get Lambda function configuration: ${err.message}`));
+                }
+                return 1;
+            }
+            config = exports.maskConfig(config);
+            const configStr = util_1.default.inspect(config, false, undefined, true);
+            this.context.stdout.write(`\n${configStr}\n`);
+            // Get tags
+            this.context.stdout.write('\n🏷 Getting Resource Tags...\n');
+            let tags;
+            try {
+                tags = yield exports.getTags(lambdaClient, region, config.FunctionArn);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    this.context.stderr.write(commonRenderer.renderError(err.message));
+                }
+                return 1;
+            }
+            const tagsLength = Object.keys(tags).length;
+            if (tagsLength === 0) {
+                this.context.stdout.write(commonRenderer.renderSoftWarning(`No resource tags were found.`));
+            }
+            else {
+                this.context.stdout.write(`✅ Found ${tagsLength} resource tags.\n`);
+            }
+            // Get CloudWatch logs
+            let logs = new Map();
+            if (this.withLogs) {
+                this.context.stdout.write('\n☁️ Getting CloudWatch logs...\n');
+                try {
+                    logs = yield exports.getAllLogs(region, this.functionName, startMillis, endMillis);
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        this.context.stderr.write(commonRenderer.renderError(err.message));
+                    }
+                    return 1;
+                }
+            }
+            try {
+                // CloudWatch messages
+                if (this.withLogs) {
+                    let message = '\n✅ Found log streams:\n';
+                    if (logs.size === 0) {
+                        message = commonRenderer.renderSoftWarning('No CloudWatch log streams were found. Logs will not be retrieved or sent.');
+                    }
+                    this.context.stdout.write(message);
+                    for (const [logStreamName, logEvents] of logs) {
+                        let warningMessage = '\n';
+                        if (logEvents.length === 0) {
+                            warningMessage = ' - ' + commonRenderer.renderSoftWarning('No log events found in this stream');
+                        }
+                        this.context.stdout.write(`• ${logStreamName}${warningMessage}`);
+                    }
+                }
+                // Create folders
+                this.context.stdout.write('\n💾 Saving files...\n');
+                const rootFolderPath = path.join(process.cwd(), FLARE_OUTPUT_DIRECTORY);
+                const logsFolderPath = path.join(rootFolderPath, LOGS_DIRECTORY);
+                if (fs.existsSync(rootFolderPath)) {
+                    exports.deleteFolder(rootFolderPath);
+                }
+                exports.createDirectories(rootFolderPath, logsFolderPath, logs);
+                // Write files
+                const configFilePath = path.join(rootFolderPath, FUNCTION_CONFIG_FILE_NAME);
+                exports.writeFile(configFilePath, JSON.stringify(config, undefined, 2));
+                this.context.stdout.write(`• Saved function config to ${configFilePath}\n`);
+                if (tagsLength > 0) {
+                    const tagsFilePath = path.join(rootFolderPath, TAGS_FILE_NAME);
+                    exports.writeFile(tagsFilePath, JSON.stringify(tags, undefined, 2));
+                    this.context.stdout.write(`• Saved tags to ${tagsFilePath}\n`);
+                }
+                for (const [logStreamName, logEvents] of logs) {
+                    if (logEvents.length === 0) {
+                        continue;
+                    }
+                    const logFilePath = path.join(logsFolderPath, `${logStreamName.split('/').join('-')}.csv`);
+                    const data = exports.convertToCSV(logEvents);
+                    exports.writeFile(logFilePath, data);
+                    this.context.stdout.write(`• Saved logs to ${logFilePath}\n`);
+                    // Sleep for 1 millisecond so creation times are different
+                    // This allows the logs to be sorted by creation time by the support team
+                    yield exports.sleep(1);
+                }
+                // Exit if dry run
+                const outputMsg = `\nℹ️ Your output files are located at: ${rootFolderPath}\n\n`;
+                if (this.isDryRun) {
+                    this.context.stdout.write('\n🚫 The flare files were not sent as it was executed in dry run mode.');
+                    this.context.stdout.write(outputMsg);
+                    return 0;
+                }
+                // Confirm before sending
+                this.context.stdout.write('\n');
+                const answer = yield inquirer_1.default.prompt(prompt_1.confirmationQuestion('Are you sure you want to send the flare file to Datadog Support?'));
+                if (!answer.confirmation) {
+                    this.context.stdout.write('\n🚫 The flare files were not sent based on your selection.');
+                    this.context.stdout.write(outputMsg);
+                    return 0;
+                }
+                // Zip folder
+                const zipPath = path.join(rootFolderPath, ZIP_FILE_NAME);
+                yield exports.zipContents(rootFolderPath, zipPath);
+                // Send to Datadog
+                this.context.stdout.write('\n🚀 Sending to Datadog Support...\n');
+                yield exports.sendToDatadog(zipPath, this.caseId, this.email, this.apiKey, rootFolderPath);
+                this.context.stdout.write('\n✅ Successfully sent flare file to Datadog Support!\n');
+                // Delete contents
+                exports.deleteFolder(rootFolderPath);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    this.context.stderr.write(commonRenderer.renderError(err.message));
+                }
+                return 1;
+            }
+            return 0;
+        });
+    }
+}
+exports.LambdaFlareCommand = LambdaFlareCommand;
+/**
+ * Validate the start and end flags and adds error messages if found
+ * @param start start time as a string
+ * @param end end time as a string
+ * @throws error if start or end are not valid numbers
+ * @returns [startMillis, endMillis] as numbers or [undefined, undefined] if both are undefined
+ */
+const validateStartEndFlags = (start, end) => {
+    if (!start && !end) {
+        return [undefined, undefined];
+    }
+    if (!start) {
+        throw Error('Start time is required when end time is specified. [--start]');
+    }
+    if (!end) {
+        throw Error('End time is required when start time is specified. [--end]');
+    }
+    const startMillis = Number(start);
+    let endMillis = Number(end);
+    if (isNaN(startMillis)) {
+        throw Error(`Start time must be a time in milliseconds since Unix Epoch. '${start}' is not a number.`);
+    }
+    if (isNaN(endMillis)) {
+        throw Error(`End time must be a time in milliseconds since Unix Epoch. '${end}' is not a number.`);
+    }
+    // Required for AWS SDK to work correctly
+    endMillis = Math.min(endMillis, Date.now());
+    if (startMillis >= endMillis) {
+        throw Error('Start time must be before end time.');
+    }
+    return [startMillis, endMillis];
+};
+exports.validateStartEndFlags = validateStartEndFlags;
+/**
+ * Mask the environment variables in a Lambda function configuration
+ * @param config
+ */
+const maskConfig = (config) => {
+    var _a;
+    const environmentVariables = (_a = config.Environment) === null || _a === void 0 ? void 0 : _a.Variables;
+    if (!environmentVariables) {
+        return config;
+    }
+    const replacer = commons_1.maskStringifiedEnvVar(environmentVariables);
+    const stringifiedConfig = JSON.stringify(config, replacer);
+    return JSON.parse(stringifiedConfig);
+};
+exports.maskConfig = maskConfig;
+/**
+ * Delete a folder and all its contents
+ * @param folderPath the folder to delete
+ * @throws Error if the deletion fails
+ */
+const deleteFolder = (folderPath) => {
+    try {
+        fs.rmSync(folderPath, { recursive: true, force: true });
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw Error(`Failed to delete files located at ${folderPath}: ${err.message}`);
+        }
+    }
+};
+exports.deleteFolder = deleteFolder;
+/**
+ * Creates the root folder and the logs sub-folder
+ * @param rootFolderPath path to the root folder
+ * @param logsFolderPath path to the logs folder
+ * @param logs array of logs
+ * @throws Error if the root folder cannot be deleted or folders cannot be created
+ */
+const createDirectories = (rootFolderPath, logsFolderPath, logs) => {
+    try {
+        fs.mkdirSync(rootFolderPath);
+        if (logs.size > 0) {
+            fs.mkdirSync(logsFolderPath);
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw Error(`Unable to create directories: ${err.message}`);
+        }
+    }
+};
+exports.createDirectories = createDirectories;
+/**
+ * Gets the LOG_STREAM_COUNT latest log stream names, sorted by last event time
+ * @param cwlClient CloudWatch Logs client
+ * @param logGroupName name of the log group
+ * @param startMillis start time in milliseconds or undefined if no start time is specified
+ * @param endMillis end time in milliseconds or undefined if no end time is specified
+ * @returns an array of the last LOG_STREAM_COUNT log stream names or an empty array if no log streams are found
+ * @throws Error if the log streams cannot be retrieved
+ */
+const getLogStreamNames = (cwlClient, logGroupName, startMillis, endMillis) => __awaiter(void 0, void 0, void 0, function* () {
+    const config = {
+        logGroupName,
+        descending: true,
+        orderBy: client_cloudwatch_logs_1.OrderBy.LastEventTime,
+        limit: DEFAULT_LOG_STREAMS,
+    };
+    const rangeSpecified = startMillis !== undefined && endMillis !== undefined;
+    if (rangeSpecified) {
+        config.limit = MAX_LOG_STREAMS;
+    }
+    const command = new client_cloudwatch_logs_1.DescribeLogStreamsCommand(config);
+    const response = yield cwlClient.send(command);
+    const logStreams = response.logStreams;
+    if (logStreams === undefined || logStreams.length === 0) {
+        return [];
+    }
+    const output = [];
+    for (const logStream of logStreams) {
+        const logStreamName = logStream.logStreamName;
+        if (!logStreamName) {
+            continue;
+        }
+        if (rangeSpecified) {
+            const firstEventTime = logStream.firstEventTimestamp;
+            const lastEventTime = logStream.lastEventTimestamp;
+            if (lastEventTime && lastEventTime < startMillis) {
+                continue;
+            }
+            if (firstEventTime && firstEventTime > endMillis) {
+                continue;
+            }
+        }
+        output.push(logStreamName);
+    }
+    // Reverse array so the oldest log is created first, so Support Staff can sort by creation time
+    return output.reverse();
+});
+exports.getLogStreamNames = getLogStreamNames;
+/**
+ * Gets the log events for a log stream
+ * @param cwlClient
+ * @param logGroupName
+ * @param logStreamName
+ * @param startMillis
+ * @param endMillis
+ * @returns the log events or an empty array if no log events are found
+ * @throws Error if the log events cannot be retrieved
+ */
+const getLogEvents = (cwlClient, logGroupName, logStreamName, startMillis, endMillis) => __awaiter(void 0, void 0, void 0, function* () {
+    const config = {
+        logGroupName,
+        logStreamName,
+        limit: MAX_LOG_EVENTS_PER_STREAM,
+    };
+    if (startMillis !== undefined && endMillis !== undefined) {
+        config.startTime = startMillis;
+        config.endTime = endMillis;
+    }
+    const command = new client_cloudwatch_logs_1.GetLogEventsCommand(config);
+    const response = yield cwlClient.send(command);
+    const logEvents = response.events;
+    if (logEvents === undefined) {
+        return [];
+    }
+    return logEvents;
+});
+exports.getLogEvents = getLogEvents;
+/**
+ * Gets all CloudWatch logs for a function
+ * @param region
+ * @param functionName
+ * @param startMillis start time in milliseconds or undefined if no end time is specified
+ * @param endMillis end time in milliseconds or undefined if no end time is specified
+ * @returns a map of log stream names to log events or an empty map if no logs are found
+ */
+const getAllLogs = (region, functionName, startMillis, endMillis) => __awaiter(void 0, void 0, void 0, function* () {
+    const logs = new Map();
+    const cwlClient = new client_cloudwatch_logs_1.CloudWatchLogsClient({ region });
+    if (functionName.startsWith('arn:aws')) {
+        functionName = functionName.split(':')[6];
+    }
+    const logGroupName = `/aws/lambda/${functionName}`;
+    let logStreamNames;
+    try {
+        logStreamNames = yield exports.getLogStreamNames(cwlClient, logGroupName, startMillis, endMillis);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : '';
+        throw new Error(`Unable to get log streams: ${msg}`);
+    }
+    for (const logStreamName of logStreamNames) {
+        let logEvents;
+        try {
+            logEvents = yield exports.getLogEvents(cwlClient, logGroupName, logStreamName, startMillis, endMillis);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : '';
+            throw new Error(`Unable to get log events for stream ${logStreamName}: ${msg}`);
+        }
+        logs.set(logStreamName, logEvents);
+    }
+    return logs;
+});
+exports.getAllLogs = getAllLogs;
+/**
+ * Gets the tags for a function
+ * @param lambdaClient
+ * @param region
+ * @param arn
+ * @returns the tags or an empty object if no tags are found
+ * @throws Error if the tags cannot be retrieved
+ */
+const getTags = (lambdaClient, region, arn) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!arn.startsWith('arn:aws')) {
+        throw Error(`Invalid function ARN: ${arn}`);
+    }
+    const command = new client_lambda_1.ListTagsCommand({
+        Resource: arn,
+    });
+    try {
+        const response = yield lambdaClient.send(command);
+        return (_a = response.Tags) !== null && _a !== void 0 ? _a : {};
+    }
+    catch (err) {
+        let message = '';
+        if (err instanceof Error) {
+            message = err.message;
+        }
+        throw Error(`Unable to get resource tags: ${message}`);
+    }
+});
+exports.getTags = getTags;
+/**
+ * Write the function config to a file
+ * @param filePath path to the file
+ * @param data the data to write
+ * @throws Error if the file cannot be written
+ */
+const writeFile = (filePath, data) => {
+    try {
+        fs.writeFileSync(filePath, data);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw Error(`Unable to create function configuration file: ${err.message}`);
+        }
+    }
+};
+exports.writeFile = writeFile;
+/**
+ * Convert the log events to a CSV string
+ * @param logEvents array of log events
+ * @returns the CSV string
+ */
+const convertToCSV = (logEvents) => {
+    var _a, _b;
+    const rows = [['timestamp', 'datetime', 'message']];
+    for (const logEvent of logEvents) {
+        const timestamp = `"${(_a = logEvent.timestamp) !== null && _a !== void 0 ? _a : ''}"`;
+        let datetime = '';
+        if (logEvent.timestamp) {
+            const date = new Date(logEvent.timestamp);
+            datetime = date.toISOString().replace('T', ' ').replace('Z', '');
+        }
+        const message = `"${(_b = logEvent.message) !== null && _b !== void 0 ? _b : ''}"`;
+        rows.push([timestamp, datetime, message]);
+    }
+    return rows.join('\n');
+};
+exports.convertToCSV = convertToCSV;
+/**
+ * @param ms number of milliseconds to sleep
+ */
+const sleep = (ms) => __awaiter(void 0, void 0, void 0, function* () {
+    yield new Promise((resolve) => setTimeout(resolve, ms));
+});
+exports.sleep = sleep;
+/**
+ * Zip the contents of the flare folder
+ * @param rootFolderPath path to the root folder to zip
+ * @param zipPath path to save the zip file
+ * @throws Error if the zip fails
+ */
+const zipContents = (rootFolderPath, zipPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const zip = new jszip_1.default();
+    const addFolderToZip = (folderPath) => {
+        if (!fs.existsSync(folderPath)) {
+            throw Error(`Folder does not exist: ${folderPath}`);
+        }
+        const folder = fs.statSync(folderPath);
+        if (!folder.isDirectory()) {
+            throw Error(`Path is not a directory: ${folderPath}`);
+        }
+        const contents = fs.readdirSync(folderPath);
+        for (const item of contents) {
+            const fullPath = path.join(folderPath, item);
+            const file = fs.statSync(fullPath);
+            if (file.isDirectory()) {
+                addFolderToZip(fullPath);
+            }
+            else {
+                const data = fs.readFileSync(fullPath);
+                zip.file(path.relative(rootFolderPath, fullPath), data);
+            }
+        }
+    };
+    try {
+        addFolderToZip(rootFolderPath);
+        const zipContent = yield zip.generateAsync({ type: 'nodebuffer' });
+        fs.writeFileSync(zipPath, zipContent);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw Error(`Unable to zip the flare files: ${err.message}`);
+        }
+    }
+});
+exports.zipContents = zipContents;
+/**
+ * Calculates the full endpoint URL
+ * @throws Error if the site is invalid
+ * @returns the full endpoint URL
+ */
+const getEndpointUrl = () => {
+    var _a, _b;
+    const baseUrl = (_b = (_a = process.env[constants_2.CI_SITE_ENV_VAR]) !== null && _a !== void 0 ? _a : process.env[constants_2.SITE_ENV_VAR]) !== null && _b !== void 0 ? _b : constants_1.DATADOG_SITE_US1;
+    // The DNS doesn't redirect to the proper endpoint when a subdomain is not present in the baseUrl.
+    // There is a DNS inconsistency
+    let endpointUrl = baseUrl;
+    if ([constants_1.DATADOG_SITE_US1, constants_1.DATADOG_SITE_EU1, constants_1.DATADOG_SITE_GOV].includes(baseUrl)) {
+        endpointUrl = 'app.' + baseUrl;
+    }
+    if (!validation_1.isValidDatadogSite(baseUrl)) {
+        throw Error(`Invalid site: ${baseUrl}. Must be one of: ${constants_1.DATADOG_SITES.join(', ')}`);
+    }
+    return 'https://' + endpointUrl + ENDPOINT_PATH;
+};
+exports.getEndpointUrl = getEndpointUrl;
+/**
+ * Send the zip file to Datadog support
+ * @param zipPath
+ * @param caseId
+ * @param email
+ * @param apiKey
+ * @param rootFolderPath
+ * @throws Error if the request fails
+ */
+const sendToDatadog = (zipPath, caseId, email, apiKey, rootFolderPath) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b, _c, _d;
+    const endpointUrl = exports.getEndpointUrl();
+    const form = new form_data_1.default();
+    form.append('case_id', caseId);
+    form.append('flare_file', fs.createReadStream(zipPath));
+    form.append('datadog_ci_version', version);
+    form.append('email', email);
+    const headerConfig = {
+        headers: Object.assign(Object.assign({}, form.getHeaders()), { 'DD-API-KEY': apiKey }),
+    };
+    try {
+        yield axios_1.default.post(endpointUrl, form, headerConfig);
+    }
+    catch (err) {
+        // Ensure the root folder is deleted if the request fails
+        exports.deleteFolder(rootFolderPath);
+        if (axios_1.default.isAxiosError(err)) {
+            const errResponse = (_c = (_b = err.response) === null || _b === void 0 ? void 0 : _b.data.error) !== null && _c !== void 0 ? _c : '';
+            const errorMessage = (_d = err.message) !== null && _d !== void 0 ? _d : '';
+            throw Error(`Failed to send flare file to Datadog Support: ${errorMessage}. ${errResponse}\n`);
+        }
+        throw err;
+    }
+});
+exports.sendToDatadog = sendToDatadog;
+LambdaFlareCommand.addPath('lambda', 'flare');
+LambdaFlareCommand.addOption('isDryRun', clipanion_1.Command.Boolean('-d,--dry'));
+LambdaFlareCommand.addOption('withLogs', clipanion_1.Command.Boolean('--with-logs'));
+LambdaFlareCommand.addOption('functionName', clipanion_1.Command.String('-f,--function'));
+LambdaFlareCommand.addOption('region', clipanion_1.Command.String('-r,--region'));
+LambdaFlareCommand.addOption('caseId', clipanion_1.Command.String('-c,--case-id'));
+LambdaFlareCommand.addOption('email', clipanion_1.Command.String('-e,--email'));
+LambdaFlareCommand.addOption('start', clipanion_1.Command.String('--start'));
+LambdaFlareCommand.addOption('end', clipanion_1.Command.String('--end'));
+//# sourceMappingURL=flare.js.map