@datadog/datadog-ci 1.1.1 → 1.3.0-alpha

package/dist/commands/dsyms/upload.js

@@ -15,6 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UploadCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const clipanion_1 = require("clipanion");
+const fs_1 = require("fs");
+const glob_1 = __importDefault(require("glob"));
 const path_1 = __importDefault(require("path"));
 const tiny_async_pool_1 = __importDefault(require("tiny-async-pool"));
 const apikey_1 = require("../../helpers/apikey");
@@ -22,44 +24,155 @@ const errors_1 = require("../../helpers/errors");
 const metrics_1 = require("../../helpers/metrics");
 const upload_1 = require("../../helpers/upload");
 const utils_1 = require("../../helpers/utils");
+const interfaces_1 = require("./interfaces");
 const renderer_1 = require("./renderer");
 const utils_2 = require("./utils");
 class UploadCommand extends clipanion_1.Command {
     constructor() {
-        super(...arguments);
+        super();
         this.config = {
             apiKey: process.env.DATADOG_API_KEY,
             datadogSite: process.env.DATADOG_SITE || 'datadoghq.com',
         };
         this.dryRun = false;
         this.maxConcurrency = 20;
+        this.compressDSYMsToDirectory = (dsyms, directoryPath) => __awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.mkdir(directoryPath, { recursive: true });
+            return Promise.all(dsyms.map((dsym) => __awaiter(this, void 0, void 0, function* () {
+                const archivePath = utils_1.buildPath(directoryPath, `${dsym.slices[0].uuid}.zip`);
+                yield utils_2.zipDirectoryToArchive(dsym.bundlePath, archivePath);
+                return new interfaces_1.CompressedDsym(archivePath, dsym);
+            })));
+        });
+        this.findDSYMsInDirectory = (directoryPath) => __awaiter(this, void 0, void 0, function* () {
+            const dsyms = [];
+            for (const dSYMPath of glob_1.default.sync(utils_1.buildPath(directoryPath, '**/*.dSYM'))) {
+                try {
+                    const stdout = (yield utils_2.executeDwarfdump(dSYMPath)).stdout;
+                    const archSlices = this.parseDwarfdumpOutput(stdout);
+                    dsyms.push({ bundlePath: dSYMPath, slices: archSlices });
+                }
+                catch (_a) {
+                    this.context.stdout.write(renderer_1.renderInvalidDsymWarning(dSYMPath));
+                }
+            }
+            return Promise.all(dsyms);
+        });
+        /**
+         * Parses the output of `dwarfdump --uuid` command (ref.: https://www.unix.com/man-page/osx/1/dwarfdump/).
+         * It returns one or many arch slices read from the output.
+         *
+         * Example `dwarfdump --uuid` output:
+         * ```
+         * $ dwarfdump --uuid DDTest.framework.dSYM
+         * UUID: C8469F85-B060-3085-B69D-E46C645560EA (armv7) DDTest.framework.dSYM/Contents/Resources/DWARF/DDTest
+         * UUID: 06EE3D68-D605-3E92-B92D-2F48C02A505E (arm64) DDTest.framework.dSYM/Contents/Resources/DWARF/DDTest
+         * ```
+         */
+        this.parseDwarfdumpOutput = (output) => {
+            const lineRegexp = /UUID: ([0-9A-F]{8}-(?:[0-9A-F]{4}-){3}[0-9A-F]{12}) \(([a-z0-9_]+)\) (.+)/;
+            return output
+                .split('\n')
+                .map((line) => {
+                const match = line.match(lineRegexp);
+                return match ? [{ arch: match[2], objectPath: match[3], uuid: match[1] }] : [];
+            })
+                .reduce((acc, nextSlice) => acc.concat(nextSlice), []);
+        };
+        /**
+         * It takes fat dSYM as input and returns multiple dSYMs by extracting **each arch**
+         * to separate dSYM file. New files are saved to `intermediatePath` and named by their object uuid (`<uuid>.dSYM`).
+         *
+         * For example, given `<source path>/Foo.dSYM/Contents/Resources/DWARF/Foo` dSYM with two arch slices: `arm64` (uuid1)
+         * and `x86_64` (uuid2), it will:
+         * - create `<intermediate path>/<uuid1>.dSYM/Contents/Resources/DWARF/Foo` for `arm64`,
+         * - create `<intermediate path>/<uuid2>.dSYM/Contents/Resources/DWARF/Foo` for `x86_64`.
+         */
+        this.thinDSYM = (dsym, intermediatePath) => __awaiter(this, void 0, void 0, function* () {
+            const slimmedDSYMs = [];
+            for (const slice of dsym.slices) {
+                try {
+                    const newDSYMBundleName = `${slice.uuid}.dSYM`;
+                    const newDSYMBundlePath = utils_1.buildPath(intermediatePath, newDSYMBundleName);
+                    const newObjectPath = utils_1.buildPath(newDSYMBundlePath, path_1.default.relative(dsym.bundlePath, slice.objectPath));
+                    // Extract arch slice:
+                    yield fs_1.promises.mkdir(path_1.default.dirname(newObjectPath), { recursive: true });
+                    yield utils_2.executeLipo(slice.objectPath, slice.arch, newObjectPath);
+                    // The original dSYM bundle can also include `Info.plist` file, so copy it to the `<uuid>.dSYM` as well.
+                    // Ref.: https://opensource.apple.com/source/lldb/lldb-179.1/www/symbols.html
+                    const infoPlistPath = glob_1.default.sync(utils_1.buildPath(dsym.bundlePath, '**/Info.plist'))[0];
+                    if (infoPlistPath) {
+                        const newInfoPlistPath = utils_1.buildPath(newDSYMBundlePath, path_1.default.relative(dsym.bundlePath, infoPlistPath));
+                        yield fs_1.promises.mkdir(path_1.default.dirname(newInfoPlistPath), { recursive: true });
+                        yield fs_1.promises.copyFile(infoPlistPath, newInfoPlistPath);
+                    }
+                    slimmedDSYMs.push({
+                        bundlePath: newDSYMBundlePath,
+                        slices: [{ arch: slice.arch, uuid: slice.uuid, objectPath: newObjectPath }],
+                    });
+                }
+                catch (_b) {
+                    this.context.stdout.write(renderer_1.renderDSYMSlimmingFailure(dsym, slice));
+                }
+            }
+            return Promise.all(slimmedDSYMs);
+        });
+        /**
+         * It takes `N` dSYMs and returns `N` or more dSYMs. If a dSYM includes more than one arch slice,
+         * it will be thinned by extracting each arch to a new dSYM in `intermediatePath`.
+         */
+        this.thinDSYMs = (dsyms, intermediatePath) => __awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.mkdir(intermediatePath, { recursive: true });
+            let slimDSYMs = [];
+            for (const dsym of dsyms) {
+                if (dsym.slices.length > 1) {
+                    slimDSYMs = slimDSYMs.concat(yield this.thinDSYM(dsym, intermediatePath));
+                }
+                else {
+                    slimDSYMs.push(dsym);
+                }
+            }
+            return Promise.all(slimDSYMs);
+        });
+        this.cliVersion = require('../../../package.json').version;
     }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
+            // Normalizing the basePath to resolve .. and .
             this.basePath = path_1.default.posix.normalize(this.basePath);
-            const cliVersion = require('../../../package.json').version;
+            this.context.stdout.write(renderer_1.renderCommandInfo(this.basePath, this.maxConcurrency, this.dryRun));
             const metricsLogger = metrics_1.getMetricsLogger({
                 datadogSite: process.env.DATADOG_SITE,
-                defaultTags: [`cli_version:${cliVersion}`],
+                defaultTags: [`cli_version:${this.cliVersion}`],
                 prefix: 'datadog.ci.dsyms.',
             });
-            this.context.stdout.write(renderer_1.renderCommandInfo(this.basePath, this.maxConcurrency, this.dryRun));
-            const initialTime = Date.now();
-            let searchPath = this.basePath;
-            if (yield utils_2.isZipFile(this.basePath)) {
-                searchPath = yield utils_2.unzipToTmpDir(this.basePath);
-            }
             const apiKeyValidator = apikey_1.newApiKeyValidator({
                 apiKey: this.config.apiKey,
                 datadogSite: this.config.datadogSite,
                 metricsLogger: metricsLogger.logger,
             });
-            const payloads = yield utils_2.getMatchingDSYMFiles(searchPath, this.context);
-            const validPayloads = payloads.filter((payload) => payload !== undefined);
+            const initialTime = Date.now();
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            const intermediateDirectory = utils_1.buildPath(tmpDirectory, 'datadog-ci', 'dsyms', 'intermediate');
+            const uploadDirectory = utils_1.buildPath(tmpDirectory, 'datadog-ci', 'dsyms', 'upload');
+            this.context.stdout.write(renderer_1.renderCommandDetail(intermediateDirectory, uploadDirectory));
+            // The CLI input path can be a folder or `.zip` archive with `*.dSYM` files.
+            // In case of `.zip`, extract it to temporary location, so it can be handled the same way as folder.
+            let dSYMsSearchDirectory = this.basePath;
+            if (yield utils_2.isZipFile(this.basePath)) {
+                yield utils_2.unzipArchiveToDirectory(this.basePath, tmpDirectory);
+                dSYMsSearchDirectory = tmpDirectory;
+            }
+            const dsyms = yield this.findDSYMsInDirectory(dSYMsSearchDirectory);
+            // Reduce dSYMs size by extracting arch slices from fat dSYMs to separate single-arch dSYMs in intermediate location.
+            // This is to avoid exceeding intake limit whenever possible.
+            const slimDSYMs = yield this.thinDSYMs(dsyms, intermediateDirectory);
+            // Compress each dSYM into single `.zip` archive.
+            const compressedDSYMs = yield this.compressDSYMsToDirectory(slimDSYMs, uploadDirectory);
             const requestBuilder = this.getRequestBuilder();
             const uploadDSYM = this.uploadDSYM(requestBuilder, metricsLogger, apiKeyValidator);
             try {
-                const results = yield tiny_async_pool_1.default(this.maxConcurrency, validPayloads, uploadDSYM);
+                const results = yield tiny_async_pool_1.default(this.maxConcurrency, compressedDSYMs, uploadDSYM);
                 const totalTime = (Date.now() - initialTime) / 1000;
                 this.context.stdout.write(renderer_1.renderSuccessfulCommand(results, totalTime, this.dryRun));
                 metricsLogger.logger.gauge('duration', totalTime);
@@ -74,6 +187,7 @@ class UploadCommand extends clipanion_1.Command {
                 throw error;
             }
             finally {
+                yield utils_2.deleteDirectory(tmpDirectory);
                 try {
                     yield metricsLogger.flush();
                 }
@@ -94,7 +208,7 @@ class UploadCommand extends clipanion_1.Command {
     }
     uploadDSYM(requestBuilder, metricsLogger, apiKeyValidator) {
         return (dSYM) => __awaiter(this, void 0, void 0, function* () {
-            const payload = yield dSYM.asMultipartPayload();
+            const payload = dSYM.asMultipartPayload();
             if (this.dryRun) {
                 this.context.stdout.write(`[DRYRUN] ${renderer_1.renderUpload(dSYM)}`);
                 return upload_1.UploadStatus.Success;

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

@@ -1,9 +1,15 @@
-import { BaseContext } from 'clipanion';
-import { Dsym } from './interfaces';
 export declare const isZipFile: (filepath: string) => Promise<boolean>;
-export declare const getMatchingDSYMFiles: (absoluteFolderPath: string, context: BaseContext) => Promise<(Dsym | undefined)[]>;
-export declare const dwarfdumpUUID: (filePath: string) => Promise<string[]>;
-export declare const zipToTmpDir: (sourcePath: string, targetFilename: string) => Promise<string>;
-export declare const unzipToTmpDir: (sourcePath: string) => Promise<string>;
+export declare const createUniqueTmpDirectory: () => Promise<string>;
+export declare const deleteDirectory: (directoryPath: string) => Promise<void>;
+export declare const zipDirectoryToArchive: (directoryPath: string, archivePath: string) => Promise<void>;
+export declare const unzipArchiveToDirectory: (archivePath: string, directoryPath: string) => Promise<void>;
+export declare const executeDwarfdump: (dSYMPath: string) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export declare const executeLipo: (objectPath: string, arch: string, newObjectPath: string) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
 export declare const getBaseIntakeUrl: () => string;
 export declare const pluralize: (nb: number, singular: string, plural: string) => string;

package/dist/commands/dsyms/utils.js

@@ -12,18 +12,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluralize = exports.getBaseIntakeUrl = exports.unzipToTmpDir = exports.zipToTmpDir = exports.dwarfdumpUUID = exports.getMatchingDSYMFiles = exports.isZipFile = void 0;
+exports.pluralize = exports.getBaseIntakeUrl = exports.executeLipo = exports.executeDwarfdump = exports.unzipArchiveToDirectory = exports.zipDirectoryToArchive = exports.deleteDirectory = exports.createUniqueTmpDirectory = exports.isZipFile = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
-const glob_1 = __importDefault(require("glob"));
 const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
+const rimraf_1 = __importDefault(require("rimraf"));
 const util_1 = require("util");
-const interfaces_1 = require("./interfaces");
 const utils_1 = require("../../helpers/utils");
-const renderer_1 = require("./renderer");
-const UUID_REGEX = '[0-9A-F]{8}-([0-9A-F]{4}-){3}[0-9A-F]{12}';
-const globAsync = util_1.promisify(glob_1.default);
 const isZipFile = (filepath) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const stats = yield fs_1.promises.stat(filepath);
@@ -35,54 +31,30 @@ const isZipFile = (filepath) => __awaiter(void 0, void 0, void 0, function* () {
     }
 });
 exports.isZipFile = isZipFile;
-const getMatchingDSYMFiles = (absoluteFolderPath, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const dSYMFiles = yield globAsync(utils_1.buildPath(absoluteFolderPath, '**/*.dSYM'), {});
-    const allDsyms = dSYMFiles.map((dSYMPath) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            const uuids = yield exports.dwarfdumpUUID(dSYMPath);
-            return new interfaces_1.Dsym(dSYMPath, uuids);
-        }
-        catch (_a) {
-            context.stdout.write(renderer_1.renderInvalidDsymWarning(dSYMPath));
-            return undefined;
-        }
-    }));
-    return Promise.all(allDsyms);
+const createUniqueTmpDirectory = () => __awaiter(void 0, void 0, void 0, function* () {
+    const uniqueValue = Math.random() * Number.MAX_SAFE_INTEGER;
+    const directoryPath = utils_1.buildPath(os_1.tmpdir(), uniqueValue.toString());
+    yield fs_1.promises.mkdir(directoryPath, { recursive: true });
+    return directoryPath;
 });
-exports.getMatchingDSYMFiles = getMatchingDSYMFiles;
-const dwarfdumpUUID = (filePath) => __awaiter(void 0, void 0, void 0, function* () {
-    const output = yield execute(`dwarfdump --uuid '${filePath}'`);
-    const uuids = [];
-    output.stdout.split('\n').forEach((line) => {
-        const regexMatches = line.match(UUID_REGEX);
-        if (regexMatches && regexMatches.length > 0) {
-            uuids.push(regexMatches[0]);
-        }
-    });
-    return uuids;
-});
-exports.dwarfdumpUUID = dwarfdumpUUID;
-const tmpFolder = utils_1.buildPath(os_1.tmpdir(), 'datadog-ci', 'dsyms');
-const zipToTmpDir = (sourcePath, targetFilename) => __awaiter(void 0, void 0, void 0, function* () {
-    yield fs_1.promises.mkdir(tmpFolder, { recursive: true });
-    const targetPath = utils_1.buildPath(tmpFolder, targetFilename);
-    const sourceDir = path_1.default.dirname(sourcePath);
-    const sourceFile = path_1.default.basename(sourcePath);
-    // `zip -r foo.zip f1/f2/f3/foo.dSYM`
-    // this keeps f1/f2/f3 folders in foo.zip, we don't want this
-    // `cwd: sourceDir` is passed to avoid that
-    yield execute(`zip -r '${targetPath}' '${sourceFile}'`, sourceDir);
-    return targetPath;
+exports.createUniqueTmpDirectory = createUniqueTmpDirectory;
+const deleteDirectory = (directoryPath) => __awaiter(void 0, void 0, void 0, function* () { return new Promise((resolve, reject) => rimraf_1.default(directoryPath, () => resolve())); });
+exports.deleteDirectory = deleteDirectory;
+const zipDirectoryToArchive = (directoryPath, archivePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const cwd = path_1.default.dirname(directoryPath);
+    const directoryName = path_1.default.basename(directoryPath);
+    yield execute(`zip -r '${archivePath}' '${directoryName}'`, cwd);
 });
-exports.zipToTmpDir = zipToTmpDir;
-const unzipToTmpDir = (sourcePath) => __awaiter(void 0, void 0, void 0, function* () {
-    const targetPath = utils_1.buildPath(tmpFolder, path_1.default.basename(sourcePath, '.zip'), Date.now().toString());
-    const dirPath = path_1.default.dirname(targetPath);
-    yield fs_1.promises.mkdir(dirPath, { recursive: true });
-    yield execute(`unzip -o '${sourcePath}' -d '${targetPath}'`);
-    return targetPath;
+exports.zipDirectoryToArchive = zipDirectoryToArchive;
+const unzipArchiveToDirectory = (archivePath, directoryPath) => __awaiter(void 0, void 0, void 0, function* () {
+    yield fs_1.promises.mkdir(directoryPath, { recursive: true });
+    yield execute(`unzip -o '${archivePath}' -d '${directoryPath}'`);
 });
-exports.unzipToTmpDir = unzipToTmpDir;
+exports.unzipArchiveToDirectory = unzipArchiveToDirectory;
+const executeDwarfdump = (dSYMPath) => __awaiter(void 0, void 0, void 0, function* () { return execute(`dwarfdump --uuid '${dSYMPath}'`); });
+exports.executeDwarfdump = executeDwarfdump;
+const executeLipo = (objectPath, arch, newObjectPath) => __awaiter(void 0, void 0, void 0, function* () { return execute(`lipo '${objectPath}' -thin ${arch} -output '${newObjectPath}'`); });
+exports.executeLipo = executeLipo;
 const execProc = util_1.promisify(child_process_1.exec);
 const execute = (cmd, cwd) => execProc(cmd, {
     cwd,

package/dist/commands/junit/__tests__/upload.test.js

@@ -172,6 +172,20 @@ describe('upload', () => {
                 key2: 'value2',
             });
         }));
+        test('should set logsEnabled for each file', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.DD_CIVISIBILITY_LOGS_ENABLED = 'true';
+            const context = createMockContext();
+            const command = new upload_1.UploadJUnitXMLCommand();
+            const [firstFile, secondFile] = yield command['getMatchingJUnitXMLFiles'].call({
+                basePaths: ['./src/commands/junit/__tests__/fixtures'],
+                config: {},
+                context,
+                logs: true,
+                service: 'service',
+            });
+            expect(firstFile.logsEnabled).toBe(true);
+            expect(secondFile.logsEnabled).toBe(true);
+        }));
     });
 });
 describe('execute', () => {
@@ -179,7 +193,7 @@ describe('execute', () => {
         const cli = makeCli();
         const context = createMockContext();
         process.env = { DATADOG_API_KEY: 'PLACEHOLDER' };
-        const code = yield cli.run(['junit', 'upload', '--service', 'test-service', '--dry-run', ...paths], context);
+        const code = yield cli.run(['junit', 'upload', '--service', 'test-service', '--dry-run', '--logs', ...paths], context);
         return { context, code };
     });
     test('relative path with double dots', () => __awaiter(void 0, void 0, void 0, function* () {

package/dist/commands/junit/api.js

@@ -39,6 +39,9 @@ const uploadJUnitXML = (request) => (jUnitXML, write) => __awaiter(void 0, void
         fileName = 'default_file_name';
     }
     const spanTags = Object.assign(Object.assign({ service: jUnitXML.service }, jUnitXML.spanTags), { '_dd.cireport_version': '2' });
+    if (jUnitXML.logsEnabled) {
+        spanTags['_dd.junitxml_logs'] = 'true';
+    }
     form.append('event', JSON.stringify(spanTags), { filename: 'event.json' });
     let uniqueFileName = `${fileName}-${jUnitXML.service}-${spanTags[tags_1.GIT_SHA]}`;
     if (spanTags[tags_1.CI_PIPELINE_URL]) {

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

@@ -3,6 +3,7 @@ import { AxiosPromise, AxiosResponse } from 'axios';
 import { Writable } from 'stream';
 import { SpanTags } from '../../helpers/interfaces';
 export interface Payload {
+    logsEnabled: boolean;
     service: string;
     spanTags: SpanTags;
     xmlPath: string;

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

@@ -5,6 +5,7 @@ export declare class UploadJUnitXMLCommand extends Command {
     private config;
     private dryRun;
     private env?;
+    private logs;
     private maxConcurrency;
     private service?;
     private tags?;

package/dist/commands/junit/upload.js

@@ -51,6 +51,7 @@ class UploadJUnitXMLCommand extends clipanion_1.Command {
             envVarTags: process.env.DD_TAGS,
         };
         this.dryRun = false;
+        this.logs = false;
         this.maxConcurrency = 20;
     }
     execute() {
@@ -69,6 +70,11 @@ class UploadJUnitXMLCommand extends clipanion_1.Command {
             if (!this.config.env) {
                 this.config.env = this.env;
             }
+            if (!this.logs &&
+                process.env.DD_CIVISIBILITY_LOGS_ENABLED &&
+                !['false', '0'].includes(process.env.DD_CIVISIBILITY_LOGS_ENABLED.toLowerCase())) {
+                this.logs = true;
+            }
             const api = this.getApiHelper();
             // Normalizing the basePath to resolve .. and .
             // Always using the posix version to avoid \ on Windows.
@@ -113,6 +119,7 @@ class UploadJUnitXMLCommand extends clipanion_1.Command {
                 return true;
             });
             return validUniqueFiles.map((jUnitXMLFilePath) => ({
+                logsEnabled: this.logs,
                 service: this.service,
                 spanTags,
                 xmlPath: jUnitXMLFilePath,
@@ -168,6 +175,10 @@ UploadJUnitXMLCommand.usage = clipanion_1.Command.Usage({
             'Upload all jUnit XML test report files in current directory to the datadoghq.eu site',
             'DATADOG_SITE=datadoghq.eu datadog-ci junit upload --service my-service .',
         ],
+        [
+            'Upload all jUnit XML test report files in current directory while also collecting logs',
+            'datadog-ci junit upload --service my-service --logs .',
+        ],
     ],
 });
 UploadJUnitXMLCommand.addPath('junit', 'upload');
@@ -177,3 +188,4 @@ UploadJUnitXMLCommand.addOption('dryRun', clipanion_1.Command.Boolean('--dry-run
 UploadJUnitXMLCommand.addOption('tags', clipanion_1.Command.Array('--tags'));
 UploadJUnitXMLCommand.addOption('basePaths', clipanion_1.Command.Rest({ required: 1 }));
 UploadJUnitXMLCommand.addOption('maxConcurrency', clipanion_1.Command.String('--max-concurrency'));
+UploadJUnitXMLCommand.addOption('logs', clipanion_1.Command.Boolean('--logs'));

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

@@ -10,8 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* tslint:disable:no-string-literal */
-jest.mock('aws-sdk');
 const aws_sdk_1 = require("aws-sdk");
+jest.mock('aws-sdk');
+const aws_sdk_2 = require("aws-sdk");
 const constants_1 = require("../../constants");
 const commons_1 = require("../../functions/commons");
 const instrument_1 = require("../../instrument");
@@ -149,7 +150,7 @@ describe('commons', () => {
     describe('findLatestLayerVersion', () => {
         test('finds latests version for Python39', () => __awaiter(void 0, void 0, void 0, function* () {
             const layer = `arn:aws:lambda:sa-east-1:${constants_1.DEFAULT_LAYER_AWS_ACCOUNT}:layer:Datadog-Python39`;
-            aws_sdk_1.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {
+            aws_sdk_2.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {
                 [`${layer}:1`]: {
                     LayerVersionArn: `${layer}:1`,
                     Version: 1,
@@ -187,7 +188,7 @@ describe('commons', () => {
         }));
         test('finds latests version for Node14', () => __awaiter(void 0, void 0, void 0, function* () {
             const layer = `arn:aws:lambda:us-east-1:${constants_1.DEFAULT_LAYER_AWS_ACCOUNT}:layer:Datadog-Node14-x`;
-            aws_sdk_1.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {
+            aws_sdk_2.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {
                 [`${layer}:1`]: {
                     LayerVersionArn: `${layer}:1`,
                     Version: 1,
@@ -221,7 +222,7 @@ describe('commons', () => {
         }));
         test('returns 0 when no layer can be found', () => __awaiter(void 0, void 0, void 0, function* () {
             ;
-            aws_sdk_1.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {}));
+            aws_sdk_2.Lambda.mockImplementation(() => fixtures_1.makeMockLambda({}, {}));
             const runtime = 'python3.7';
             const region = 'us-east-1';
             const expectedLatestVersion = 0;
@@ -238,17 +239,28 @@ describe('commons', () => {
         afterAll(() => {
             process.env = OLD_ENV;
         });
-        test('returns true when any AWS credential is missing', () => {
+        test('returns true when only AWS_SECRET_ACCESS_KEY env var is set and `~/.aws/credentials` are missing', () => {
             process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] = 'SOME-AWS-SECRET-ACCESS-KEY';
-            expect(commons_1.isMissingAWSCredentials()).toBe(true);
-            // Reset env
-            process.env = {};
+            aws_sdk_1.config.credentials = undefined;
+            expect(commons_1.isMissingAWSCredentials()).toBe(true); // We return true since AWS_ACCESS_KEY_ID_ENV_VAR is missing
+        });
+        test('returns true when only AWS_ACCESS_KEY_ID environment variable is set and `~/.aws/credentials` are missing', () => {
             process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] = 'SOME-AWS-ACCESS-KEY-ID';
-            expect(commons_1.isMissingAWSCredentials()).toBe(true);
+            aws_sdk_1.config.credentials = undefined;
+            expect(commons_1.isMissingAWSCredentials()).toBe(true); // We return true since AWS_SECRET_ACCESS_KEY_ENV_VAR is missing
         });
-        test('returns false when AWS credentials are set', () => {
+        test('returns false when AWS credentials via environment variables are set', () => {
             process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] = 'SOME-AWS-ACCESS-KEY-ID';
             process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] = 'SOME-AWS-SECRET-ACCESS-KEY';
+            aws_sdk_1.config.credentials = { foo: 'bar' };
+            expect(commons_1.isMissingAWSCredentials()).toBe(false);
+        });
+        test('returns true when both environment variables and `~/.aws/credentials` are missing', () => {
+            aws_sdk_1.config.credentials = undefined;
+            expect(commons_1.isMissingAWSCredentials()).toBe(true);
+        });
+        test('returns false when AWS credentials via `~/.aws/credentials` are set', () => {
+            aws_sdk_1.config.credentials = { foo: 'bar' };
             expect(commons_1.isMissingAWSCredentials()).toBe(false);
         });
     });

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

@@ -155,7 +155,10 @@ const findLatestLayerVersion = (layer, region) => __awaiter(void 0, void 0, void
     return latestVersion;
 });
 exports.findLatestLayerVersion = findLatestLayerVersion;
-const isMissingAWSCredentials = () => process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] === undefined || process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] === undefined;
+const isMissingAWSCredentials = () => 
+// If env vars and aws_sdk_config.credentials are not set return true otherwise return false
+(process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] === undefined || process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] === undefined) &&
+    !aws_sdk_1.config.credentials;
 exports.isMissingAWSCredentials = isMissingAWSCredentials;
 const isMissingDatadogSiteEnvVar = () => {
     const site = process.env[constants_1.CI_SITE_ENV_VAR];

package/dist/commands/synthetics/__tests__/run-test.test.js

@@ -129,30 +129,36 @@ describe('run-test', () => {
             expect(startTunnelSpy).toHaveBeenCalledTimes(1);
             expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
         }));
-        test('getTestsList throws', () => __awaiter(void 0, void 0, void 0, function* () {
-            const serverError = new Error('Server Error');
-            serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
-            serverError.config = { baseURL: 'baseURL', url: 'url' };
-            const apiHelper = {
-                searchTests: jest.fn(() => {
-                    throw serverError;
-                }),
-            };
-            jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
-            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { testSearchQuery: 'a-search-query', tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError('UNAVAILABLE_TEST_CONFIG'));
-        }));
-        test('getTestsToTrigger throws', () => __awaiter(void 0, void 0, void 0, function* () {
-            const serverError = new Error('Server Error');
-            serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
-            serverError.config = { baseURL: 'baseURL', url: 'url' };
-            const apiHelper = {
-                getTest: jest.fn(() => {
-                    throw serverError;
-                }),
-            };
-            jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
-            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { publicIds: ['public-id-1'], tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError('UNAVAILABLE_TEST_CONFIG'));
-        }));
+        const cases = [
+            [403, 'AUTHORIZATION_ERROR'],
+            [502, 'UNAVAILABLE_TEST_CONFIG'],
+        ];
+        describe.each(cases)('%s triggers %s', (status, error) => {
+            test(`getTestsList throws - ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const serverError = new Error('Server Error');
+                serverError.response = { data: { errors: ['Error'] }, status };
+                serverError.config = { baseURL: 'baseURL', url: 'url' };
+                const apiHelper = {
+                    searchTests: jest.fn(() => {
+                        throw serverError;
+                    }),
+                };
+                jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
+                yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { testSearchQuery: 'a-search-query', tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError(error));
+            }));
+            test(`getTestsToTrigger throws - ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const serverError = new Error('Server Error');
+                serverError.response = { data: { errors: ['Bad Gateway'] }, status };
+                serverError.config = { baseURL: 'baseURL', url: 'url' };
+                const apiHelper = {
+                    getTest: jest.fn(() => {
+                        throw serverError;
+                    }),
+                };
+                jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
+                yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { publicIds: ['public-id-1'], tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError(error));
+            }));
+        });
         test('getPresignedURL throws', () => __awaiter(void 0, void 0, void 0, function* () {
             jest.spyOn(utils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
                 overriddenTestsToTrigger: [],

package/dist/commands/synthetics/__tests__/utils.test.js

@@ -87,27 +87,36 @@ describe('utils', () => {
         test('runTests sends batch metadata', () => __awaiter(void 0, void 0, void 0, function* () {
             jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
             const payloadMetadataSpy = jest.fn();
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            axiosMock.mockImplementation((() => (e) => {
-                payloadMetadataSpy(e.data.metadata);
-                if (e.url === '/synthetics/tests/trigger/ci') {
+            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
+                payloadMetadataSpy(request.data.metadata);
+                if (request.url === '/synthetics/tests/trigger/ci') {
                     return { data: fakeTrigger };
                 }
             }));
             yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
-            expect(payloadMetadataSpy).toHaveBeenCalledWith({
-                ci: { job: {}, pipeline: {}, provider: {}, stage: {} },
-                git: { commit: { author: {}, committer: {} } },
-                trigger_app: 'npm_package',
-            });
+            expect(payloadMetadataSpy).toHaveBeenCalledWith(undefined);
             const metadata = {
                 ci: { job: { name: 'job' }, pipeline: {}, provider: { name: 'jest' }, stage: {} },
                 git: { commit: { author: {}, committer: {}, message: 'test' } },
             };
             jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => metadata);
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(payloadMetadataSpy).toHaveBeenCalledWith(metadata);
+        }));
+        test('runTests api call includes trigger app header', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
+            const headersMetadataSpy = jest.fn();
+            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
+                headersMetadataSpy(request.headers);
+                if (request.url === '/synthetics/tests/trigger/ci') {
+                    return { data: fakeTrigger };
+                }
+            }));
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'npm_package' }));
             utils.setCiTriggerApp('unit_test');
             yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
-            expect(payloadMetadataSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, metadata), { trigger_app: 'unit_test' }));
+            expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'unit_test' }));
         }));
         test('should run test with publicId from url', () => __awaiter(void 0, void 0, void 0, function* () {
             const axiosMock = jest.spyOn(axios_1.default, 'create');