@datadog/datadog-ci 1.1.0 → 1.2.0

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/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');

package/dist/commands/synthetics/api.d.ts

@@ -1,5 +1,5 @@
 import { AxiosError } from 'axios';
-import { APIConfiguration, Payload, PollResult, Test, TestSearchResult, Trigger } from './interfaces';
+import { APIConfiguration, APIHelper } from './interfaces';
 interface BackendError {
     errors: string[];
 }
@@ -9,17 +9,8 @@ export declare class EndpointError extends Error {
     constructor(message: string, status: number);
 }
 export declare const formatBackendErrors: (requestError: AxiosError<BackendError>) => string;
+export declare const isForbiddenError: (error: AxiosError | EndpointError) => boolean;
 export declare const isNotFoundError: (error: AxiosError | EndpointError) => boolean;
 export declare const is5xxError: (error: AxiosError | EndpointError) => boolean | 0 | undefined;
-export declare const apiConstructor: (configuration: APIConfiguration) => {
-    getPresignedURL: (testIds: string[]) => Promise<{
-        url: string;
-    }>;
-    getTest: (testId: string) => Promise<Test>;
-    pollResults: (resultIds: string[]) => Promise<{
-        results: PollResult[];
-    }>;
-    searchTests: (query: string) => Promise<TestSearchResult>;
-    triggerTests: (data: Payload) => Promise<Trigger>;
-};
+export declare const apiConstructor: (configuration: APIConfiguration) => APIHelper;
 export {};

package/dist/commands/synthetics/api.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiConstructor = exports.is5xxError = exports.isNotFoundError = exports.formatBackendErrors = exports.EndpointError = void 0;
+exports.apiConstructor = exports.is5xxError = exports.isNotFoundError = exports.isForbiddenError = exports.formatBackendErrors = exports.EndpointError = void 0;
 const querystring_1 = require("querystring");
 const utils_1 = require("../../helpers/utils");
 const utils_2 = require("./utils");
@@ -43,6 +43,7 @@ exports.formatBackendErrors = formatBackendErrors;
 const triggerTests = (request) => (data) => __awaiter(void 0, void 0, void 0, function* () {
     const resp = yield retryRequest({
         data,
+        headers: { 'X-Trigger-App': utils_2.ciTriggerApp },
         method: 'POST',
         url: '/synthetics/tests/trigger/ci',
     }, request);
@@ -88,6 +89,8 @@ const retryOn5xxErrors = (retries, error) => {
     }
 };
 const getErrorHttpStatus = (error) => { var _a; return 'status' in error ? error.status : (_a = error.response) === null || _a === void 0 ? void 0 : _a.status; };
+const isForbiddenError = (error) => getErrorHttpStatus(error) === 403;
+exports.isForbiddenError = isForbiddenError;
 const isNotFoundError = (error) => getErrorHttpStatus(error) === 404;
 exports.isNotFoundError = isNotFoundError;
 const is5xxError = (error) => {

package/dist/commands/synthetics/command.js

@@ -142,6 +142,10 @@ class RunTestCommand extends clipanion_1.Command {
                 reporter.log('No test to run.\n');
                 break;
             // Critical command errors
+            case 'AUTHORIZATION_ERROR':
+                reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: authorization error ')}\n${error.message}\n\n`);
+                reporter.log('Credentials refused, make sure `apiKey`, `appKey` and `datadogSite` are correct.\n');
+                break;
             case 'MISSING_APP_KEY':
                 reporter.error(`Missing ${chalk_1.default.red.bold('DATADOG_APP_KEY')} in your environment.\n`);
                 break;

package/dist/commands/synthetics/errors.d.ts

@@ -1,8 +1,8 @@
 declare const nonCriticalErrorCodes: readonly ["NO_TESTS_TO_RUN", "NO_RESULTS_TO_POLL"];
-declare type NonCriticalCiErrorCode = typeof nonCriticalErrorCodes[number];
-declare const criticalErrorCodes: readonly ["UNAVAILABLE_TEST_CONFIG", "MISSING_API_KEY", "MISSING_APP_KEY", "UNAVAILABLE_TUNNEL_CONFIG", "TUNNEL_START_FAILED", "TRIGGER_TESTS_FAILED", "POLL_RESULTS_FAILED"];
-declare type CriticalCiErrorCode = typeof criticalErrorCodes[number];
-declare type CiErrorCode = NonCriticalCiErrorCode | CriticalCiErrorCode;
+export declare type NonCriticalCiErrorCode = typeof nonCriticalErrorCodes[number];
+declare const criticalErrorCodes: readonly ["AUTHORIZATION_ERROR", "MISSING_API_KEY", "MISSING_APP_KEY", "POLL_RESULTS_FAILED", "TRIGGER_TESTS_FAILED", "TUNNEL_START_FAILED", "UNAVAILABLE_TEST_CONFIG", "UNAVAILABLE_TUNNEL_CONFIG"];
+export declare type CriticalCiErrorCode = typeof criticalErrorCodes[number];
+export declare type CiErrorCode = NonCriticalCiErrorCode | CriticalCiErrorCode;
 export declare class CiError extends Error {
     code: CiErrorCode;
     constructor(code: CiErrorCode);

package/dist/commands/synthetics/errors.js

@@ -4,13 +4,14 @@ exports.CriticalError = exports.CiError = void 0;
 /* tslint:disable:max-classes-per-file */
 const nonCriticalErrorCodes = ['NO_TESTS_TO_RUN', 'NO_RESULTS_TO_POLL'];
 const criticalErrorCodes = [
-    'UNAVAILABLE_TEST_CONFIG',
+    'AUTHORIZATION_ERROR',
     'MISSING_API_KEY',
     'MISSING_APP_KEY',
-    'UNAVAILABLE_TUNNEL_CONFIG',
-    'TUNNEL_START_FAILED',
-    'TRIGGER_TESTS_FAILED',
     'POLL_RESULTS_FAILED',
+    'TRIGGER_TESTS_FAILED',
+    'TUNNEL_START_FAILED',
+    'UNAVAILABLE_TEST_CONFIG',
+    'UNAVAILABLE_TUNNEL_CONFIG',
 ];
 class CiError extends Error {
     constructor(code) {

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

@@ -253,12 +253,9 @@ export interface ConfigOverride {
     };
 }
 export interface Payload {
-    metadata?: SyntheticsMetadata;
+    metadata?: Metadata;
     tests: TestPayload[];
 }
-export declare type SyntheticsMetadata = Metadata & {
-    trigger_app: string;
-};
 export interface TestPayload extends ConfigOverride {
     executionRule: ExecutionRule;
     public_id: string;

package/dist/commands/synthetics/reporters/default.js

@@ -195,7 +195,7 @@ class DefaultReporter {
         this.write(error);
     }
     initErrors(errors) {
-        this.write(errors.join('\n') + '\n');
+        this.write(errors.join('\n') + '\n\n');
     }
     log(log) {
         this.write(log);
@@ -246,7 +246,7 @@ class DefaultReporter {
             testsList.push('…');
         }
         const testsDisplay = chalk_1.default.gray(`(${testsList.join(', ')})`);
-        this.write(`\nWaiting for ${chalk_1.default.bold.cyan(tests.length)} test result${tests.length > 1 ? 's' : ''} ${testsDisplay}…\n`);
+        this.write(`Waiting for ${chalk_1.default.bold.cyan(tests.length)} test result${tests.length > 1 ? 's' : ''} ${testsDisplay}…\n`);
     }
     testTrigger(test, testId, executionRule, config) {
         const idDisplay = `[${chalk_1.default.bold.dim(testId)}]`;

package/dist/commands/synthetics/run-test.d.ts

@@ -62,15 +62,5 @@ export declare const getTestsList: (api: APIHelper, config: SyntheticsCIConfig,
     id: string;
     suite: string | undefined;
 }[]>;
-export declare const getApiHelper: (config: SyntheticsCIConfig) => {
-    getPresignedURL: (testIds: string[]) => Promise<{
-        url: string;
-    }>;
-    getTest: (testId: string) => Promise<Test>;
-    pollResults: (resultIds: string[]) => Promise<{
-        results: PollResult[];
-    }>;
-    searchTests: (query: string) => Promise<import("./interfaces").TestSearchResult>;
-    triggerTests: (data: import("./interfaces").Payload) => Promise<Trigger>;
-};
+export declare const getApiHelper: (config: SyntheticsCIConfig) => APIHelper;
 export declare const getDatadogHost: (useIntake: boolean | undefined, config: SyntheticsCIConfig) => string;

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

@@ -32,7 +32,7 @@ const executeTests = (reporter, config) => __awaiter(void 0, void 0, void 0, fun
             testsToTrigger = yield exports.getTestsList(api, config, reporter);
         }
         catch (error) {
-            throw new errors_1.CriticalError('UNAVAILABLE_TEST_CONFIG');
+            throw new errors_1.CriticalError(api_1.isForbiddenError(error) ? 'AUTHORIZATION_ERROR' : 'UNAVAILABLE_TEST_CONFIG');
         }
     }
     if (!testsToTrigger.length) {
@@ -43,7 +43,10 @@ const executeTests = (reporter, config) => __awaiter(void 0, void 0, void 0, fun
         testsToTriggerResult = yield utils_1.getTestsToTrigger(api, testsToTrigger, reporter);
     }
     catch (error) {
-        throw error instanceof errors_1.CiError ? error : new errors_1.CriticalError('UNAVAILABLE_TEST_CONFIG');
+        if (error instanceof errors_1.CiError) {
+            throw error;
+        }
+        throw new errors_1.CriticalError(api_1.isForbiddenError(error) ? 'AUTHORIZATION_ERROR' : 'UNAVAILABLE_TEST_CONFIG');
     }
     const { tests, overriddenTestsToTrigger, summary } = testsToTriggerResult;
     // All tests have been skipped or are missing.

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

@@ -1,5 +1,6 @@
 import { APIHelper, ConfigOverride, ExecutionRule, InternalTest, MainReporter, PollResult, Reporter, Result, Suite, Summary, TestPayload, Trigger, TriggerConfig, TriggerResponse, TriggerResult } from './interfaces';
 import { Tunnel } from './tunnel';
+export declare let ciTriggerApp: string;
 export declare const handleConfig: (test: InternalTest, publicId: string, reporter: MainReporter, config?: ConfigOverride | undefined) => TestPayload;
 export declare const setCiTriggerApp: (source: string) => void;
 export declare const getExecutionRule: (test: InternalTest, configOverride?: ConfigOverride | undefined) => ExecutionRule;