@datadog/datadog-ci 1.1.2 → 1.2.0

package/LICENSE-3rdparty.csv

@@ -10,6 +10,7 @@ Component,Origin,Licence,Copyright
 @types/inquirer,dev,MIT,Copyright Microsoft Corporation
 @types/jest,dev,MIT,Copyright Microsoft Corporation
 @types/node,dev,MIT,Copyright Microsoft Corporation
+@types/rimraf,dev,MIT,Copyright Carlos Ballesteros Velasco <https://github.com/soywiz> and contributors
 @types/ssh2,dev,MIT,Copyright Microsoft Corporation
 @types/ssh2-streams,dev,MIT,Copyright Microsoft Corporation
 @types/sshpk,dev,MIT,Copyright Microsoft Corporation
@@ -34,6 +35,7 @@ pkg,dev,MIT,Copyright (c) 2021 Vercel, Inc.
 prettier,dev,MIT,Copyright © James Long and contributors
 proxy,dev,MIT,Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
 proxy-agent,import,MIT,Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
+rimraf,import,ISC,Copyright (c) 2011-2022 Isaac Z. Schlueter and Contributors
 simple-git,import,MIT,Copyright (c) 2015 Steve King
 ssh2,import,MIT,Copyright (c) Brian White
 ssh2-streams,import,MIT,Copyright (c) 2014 Brian White

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

@@ -8,15 +8,207 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 // tslint:disable: no-string-literal
-// tslint:disable: no-var-requires
 const advanced_1 = require("clipanion/lib/advanced");
+const fs_1 = require("fs");
+const glob_1 = __importDefault(require("glob"));
 const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../../../helpers/utils");
 const upload_1 = require("../upload");
-if (os_1.platform() !== 'darwin') {
-    require('../utils').dwarfdumpUUID = jest.fn().mockResolvedValue(['BD8CE358-D5F3-358B-86DC-CBCF2148097B']);
-}
+const utils_2 = require("../utils");
+/**
+ * `dwarfdump` and `lipo` are only available in macOS, so we mock their behaviour when running tests on other platforms.
+ */
+const mockDwarfdumpAndLipoIfNotMacOS = () => {
+    if (os_1.platform() !== 'darwin') {
+        // For `dwarfdump --uuid` mock, return the same output as the command would give on macOS:
+        require('../utils').executeDwarfdump = jest.fn().mockImplementation((dsymPath) => {
+            let fixture = dsymPath.includes('multiple-archs') ? fatDSYMFixture : undefined;
+            fixture = fixture !== null && fixture !== void 0 ? fixture : (dsymPath.includes('single-arch') ? slimDSYMFixture : undefined);
+            if (fixture !== undefined) {
+                const outputLines = fixture.slices.map((slice) => {
+                    const objectPathInDsym = path_1.default.relative(fixture.bundlePath, slice.objectPath);
+                    const objectPathInMockedDSYM = utils_1.buildPath(dsymPath, objectPathInDsym);
+                    return `UUID: ${slice.uuid} (${slice.arch}) ${objectPathInMockedDSYM}`;
+                });
+                return { stderr: '', stdout: outputLines.join('\n') };
+            }
+            else {
+                throw new Error(`Cannot find mock dSYM fixture for dsymPath: ${dsymPath}`);
+            }
+        });
+        // For `lipo -thin` mock, just copy the object to new location (without extracting the slice as macOS would do):
+        require('../utils').executeLipo = jest
+            .fn()
+            .mockImplementation((objectPath, arch, newObjectPath) => __awaiter(void 0, void 0, void 0, function* () {
+            yield fs_1.promises.copyFile(objectPath, newObjectPath);
+            return { stderr: '', stdout: '' };
+        }));
+    }
+};
+/**
+ * Fixture for dSYM containing two arch slices. This is the same dSYM information as can be
+ * read with `dwarfdump --uuid ./src/commands/dsyms/__tests__/fixtures/multiple-archs/DDTest.framework.dSYM` on macOS.
+ */
+const fatDSYMFixture = {
+    bundlePath: 'src/commands/dsyms/__tests__/fixtures/multiple-archs/DDTest.framework.dSYM',
+    slices: [
+        {
+            arch: 'armv7',
+            objectPath: 'src/commands/dsyms/__tests__/fixtures/multiple-archs/DDTest.framework.dSYM/Contents/Resources/DWARF/DDTest',
+            uuid: 'C8469F85-B060-3085-B69D-E46C645560EA',
+        },
+        {
+            arch: 'arm64',
+            objectPath: 'src/commands/dsyms/__tests__/fixtures/multiple-archs/DDTest.framework.dSYM/Contents/Resources/DWARF/DDTest',
+            uuid: '06EE3D68-D605-3E92-B92D-2F48C02A505E',
+        },
+    ],
+};
+/**
+ * Fixture for dSYM containing single arch slice. This is the same dSYM information as can be
+ * read with `dwarfdump --uuid ./src/commands/dsyms/__tests__/fixtures/single-archs/DDTest.framework.dSYM` on macOS.
+ */
+const slimDSYMFixture = {
+    bundlePath: 'src/commands/dsyms/__tests__/fixtures/single-arch/DDTest.framework.dSYM',
+    slices: [
+        {
+            arch: 'arm64',
+            objectPath: 'src/commands/dsyms/__tests__/fixtures/single-arch/DDTest.framework.dSYM/Contents/Resources/DWARF/DDTest',
+            uuid: '3BC12422-63CC-30E8-B916-E5006CE3286C',
+        },
+    ],
+};
+describe('upload', () => {
+    beforeAll(() => {
+        mockDwarfdumpAndLipoIfNotMacOS();
+    });
+    describe('findDSYMsInDirectory', () => {
+        const command = new upload_1.UploadCommand();
+        test('Should find dSYMs recursively', () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedDSYMs = [fatDSYMFixture, slimDSYMFixture];
+            const actualDSYMs = yield command['findDSYMsInDirectory']('src/commands/dsyms/__tests__/fixtures');
+            expect(actualDSYMs.length).toEqual(2);
+            expect(actualDSYMs).toContainEqual(expectedDSYMs[0]);
+            expect(actualDSYMs).toContainEqual(expectedDSYMs[1]);
+        }));
+    });
+    describe('parseDwarfdumpOutput', () => {
+        const command = new upload_1.UploadCommand();
+        test('Should read arch slice from single-line output', () => {
+            const output = 'UUID: 00000000-1111-2222-3333-444444444444 (arm64) /folder/Foo.dSYM/Contents/Resources/DWARF/Foo';
+            const slices = command['parseDwarfdumpOutput'](output);
+            expect(slices).toEqual([
+                {
+                    arch: 'arm64',
+                    objectPath: '/folder/Foo.dSYM/Contents/Resources/DWARF/Foo',
+                    uuid: '00000000-1111-2222-3333-444444444444',
+                },
+            ]);
+        });
+        test('Should read arch slices from multi-line output', () => {
+            const output = 'UUID: 00000000-1111-2222-3333-444444444444 (arm64) /folder/Foo.dSYM/Contents/Resources/DWARF/Foo\n' +
+                'UUID: AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE (x86_64) /folder/Foo.dSYM/Contents/Resources/DWARF/Foo\n' +
+                'UUID: FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF (armv7) /folder/Foo.dSYM/Contents/Resources/DWARF/Foo\n';
+            const slices = command['parseDwarfdumpOutput'](output);
+            expect(slices).toEqual([
+                {
+                    arch: 'arm64',
+                    objectPath: '/folder/Foo.dSYM/Contents/Resources/DWARF/Foo',
+                    uuid: '00000000-1111-2222-3333-444444444444',
+                },
+                {
+                    arch: 'x86_64',
+                    objectPath: '/folder/Foo.dSYM/Contents/Resources/DWARF/Foo',
+                    uuid: 'AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE',
+                },
+                {
+                    arch: 'armv7',
+                    objectPath: '/folder/Foo.dSYM/Contents/Resources/DWARF/Foo',
+                    uuid: 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF',
+                },
+            ]);
+        });
+        test('Should read arch slice if object path contains whitespaces', () => {
+            const output = 'UUID: 00000000-1111-2222-3333-444444444444 (arm64) /folder with whitespaces/Foo Bar.dSYM/Contents/Resources/DWARF/Foo Bar';
+            const slices = command['parseDwarfdumpOutput'](output);
+            expect(slices).toEqual([
+                {
+                    arch: 'arm64',
+                    objectPath: '/folder with whitespaces/Foo Bar.dSYM/Contents/Resources/DWARF/Foo Bar',
+                    uuid: '00000000-1111-2222-3333-444444444444',
+                },
+            ]);
+        });
+        test('Should read no arch slices from invalid output', () => {
+            const slices = command['parseDwarfdumpOutput']('');
+            expect(slices).toEqual([]);
+        });
+    });
+    describe('thinDSYMs', () => {
+        const command = new upload_1.UploadCommand();
+        test('Given fat dSYM, it should extract each arch slice to separate dSYM in target folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            // Given
+            const inputDSYM = fatDSYMFixture;
+            expect(inputDSYM.slices.length).toBeGreaterThan(1);
+            // When
+            const extractedDSYMs = yield command['thinDSYMs']([inputDSYM], tmpDirectory);
+            // Then
+            expect(extractedDSYMs.length).toEqual(inputDSYM.slices.length);
+            inputDSYM.slices.forEach((slice) => {
+                expect(extractedDSYMs).toContainEqual({
+                    bundlePath: `${utils_1.buildPath(tmpDirectory, slice.uuid)}.dSYM`,
+                    slices: [
+                        {
+                            arch: slice.arch,
+                            objectPath: `${utils_1.buildPath(tmpDirectory, slice.uuid)}.dSYM/Contents/Resources/DWARF/DDTest`,
+                            uuid: slice.uuid,
+                        },
+                    ],
+                });
+            });
+            const objectFilesInTargetFolder = glob_1.default.sync(utils_1.buildPath(tmpDirectory, '**/Contents/Resources/DWARF/DDTest'));
+            expect(objectFilesInTargetFolder.length).toEqual(inputDSYM.slices.length);
+            yield utils_2.deleteDirectory(tmpDirectory);
+        }));
+        test('Given slim dSYM, it should leave it untouched and not extract anything into target folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            // Given
+            const inputDSYM = slimDSYMFixture;
+            expect(inputDSYM.slices.length).toEqual(1);
+            // When
+            const extractedDSYMs = yield command['thinDSYMs']([inputDSYM], tmpDirectory);
+            // Then
+            expect(extractedDSYMs).toEqual([inputDSYM]);
+            const filesInTargetFolder = glob_1.default.sync(utils_1.buildPath(tmpDirectory, '*'));
+            expect(filesInTargetFolder.length).toEqual(0);
+            yield utils_2.deleteDirectory(tmpDirectory);
+        }));
+    });
+    describe('compressDSYMsToDirectory', () => {
+        const command = new upload_1.UploadCommand();
+        test('Should archive dSYMs to target directory and name archives by their UUIDs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            const dsymFixtures = [fatDSYMFixture, slimDSYMFixture];
+            // When
+            const compressedDSYMs = yield command['compressDSYMsToDirectory'](dsymFixtures, tmpDirectory);
+            // Then
+            expect(compressedDSYMs[0].dsym).toEqual(dsymFixtures[0]);
+            expect(compressedDSYMs[0].archivePath).toEqual(utils_1.buildPath(tmpDirectory, `${dsymFixtures[0].slices[0].uuid}.zip`));
+            expect(fs_1.existsSync(compressedDSYMs[0].archivePath)).toBeTruthy();
+            expect(compressedDSYMs[1].dsym).toEqual(dsymFixtures[1]);
+            expect(compressedDSYMs[1].archivePath).toEqual(utils_1.buildPath(tmpDirectory, `${dsymFixtures[1].slices[0].uuid}.zip`));
+            expect(fs_1.existsSync(compressedDSYMs[1].archivePath)).toBeTruthy();
+            yield utils_2.deleteDirectory(tmpDirectory);
+        }));
+    });
+});
 describe('execute', () => {
     const makeCli = () => {
         const cli = new advanced_1.Cli();
@@ -34,33 +226,44 @@ describe('execute', () => {
             },
         };
     };
-    const runCLI = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    const runCLI = (dsymPath) => __awaiter(void 0, void 0, void 0, function* () {
         const cli = makeCli();
         const context = createMockContext();
         process.env = { DATADOG_API_KEY: 'PLACEHOLDER' };
-        const code = yield cli.run(['dsyms', 'upload', path, '--dry-run'], context);
+        const code = yield cli.run(['dsyms', 'upload', dsymPath, '--dry-run'], context);
         return { context, code };
     });
-    test('should succeed with folder input', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { context, code } = yield runCLI('./src/commands/dsyms/__tests__/test files/');
+    beforeAll(() => {
+        mockDwarfdumpAndLipoIfNotMacOS();
+    });
+    test('Should succeed with folder input', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { context, code } = yield runCLI('src/commands/dsyms/__tests__/fixtures/');
         const outputString = context.stdout.toString();
         const output = outputString.split(os_1.EOL);
         expect(outputString).not.toContain('Error');
         expect(code).toBe(0);
         expect(output[1]).toContain('Starting upload with concurrency 20. ');
-        expect(output[2]).toContain('Will look for dSYMs in src/commands/dsyms/__tests__/test files/');
-        expect(output[3]).toContain('Uploading dSYM with BD8CE358-D5F3-358B-86DC-CBCF2148097B from src/commands/dsyms/__tests__/test files/test.dSYM');
-        expect(output[6]).toContain('Handled 1 dSYM with success in');
+        expect(output[2]).toContain('Will look for dSYMs in src/commands/dsyms/__tests__/fixtures/');
+        expect(output[3]).toContain('Will use temporary intermediate directory: ');
+        expect(output[4]).toContain('Will use temporary upload directory: ');
+        expect(output[5]).toContain('Uploading C8469F85-B060-3085-B69D-E46C645560EA.zip (DDTest, arch: armv7, UUID: C8469F85-B060-3085-B69D-E46C645560EA)');
+        expect(output[6]).toContain('Uploading 06EE3D68-D605-3E92-B92D-2F48C02A505E.zip (DDTest, arch: arm64, UUID: 06EE3D68-D605-3E92-B92D-2F48C02A505E)');
+        expect(output[7]).toContain('Uploading 3BC12422-63CC-30E8-B916-E5006CE3286C.zip (DDTest, arch: arm64, UUID: 3BC12422-63CC-30E8-B916-E5006CE3286C)');
+        expect(output[10]).toContain('Handled 3 dSYMs with success');
     }));
-    test('should succeed with zip file input', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { context, code } = yield runCLI('./src/commands/dsyms/__tests__/test files/test.zip');
+    test('Should succeed with zip file input', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { context, code } = yield runCLI('src/commands/dsyms/__tests__/fixtures/all.zip');
         const outputString = context.stdout.toString();
         const output = outputString.split(os_1.EOL);
         expect(outputString).not.toContain('Error');
         expect(code).toBe(0);
         expect(output[1]).toContain('Starting upload with concurrency 20. ');
-        expect(output[2]).toContain('Will look for dSYMs in src/commands/dsyms/__tests__/test files/test.zip');
-        expect(output[3]).toContain('Uploading dSYM with BD8CE358-D5F3-358B-86DC-CBCF2148097B from /');
-        expect(output[6]).toContain('Handled 1 dSYM with success in');
+        expect(output[2]).toContain('Will look for dSYMs in src/commands/dsyms/__tests__/fixtures/all.zip');
+        expect(output[3]).toContain('Will use temporary intermediate directory: ');
+        expect(output[4]).toContain('Will use temporary upload directory: ');
+        expect(output[5]).toContain('Uploading C8469F85-B060-3085-B69D-E46C645560EA.zip (DDTest, arch: armv7, UUID: C8469F85-B060-3085-B69D-E46C645560EA)');
+        expect(output[6]).toContain('Uploading 06EE3D68-D605-3E92-B92D-2F48C02A505E.zip (DDTest, arch: arm64, UUID: 06EE3D68-D605-3E92-B92D-2F48C02A505E)');
+        expect(output[7]).toContain('Uploading 3BC12422-63CC-30E8-B916-E5006CE3286C.zip (DDTest, arch: arm64, UUID: 3BC12422-63CC-30E8-B916-E5006CE3286C)');
+        expect(output[10]).toContain('Handled 3 dSYMs with success');
     }));
 });

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

@@ -1,4 +1,23 @@
 "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) {
@@ -8,51 +27,72 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-// tslint:disable: no-string-literal
-const fs_1 = require("fs");
-const interfaces_1 = require("../interfaces");
-const utils_1 = require("../utils");
-describe('isZipFile', () => {
-    test('Zip file should return true', () => __awaiter(void 0, void 0, void 0, function* () {
-        const zipFile = './src/commands/dsyms/__tests__/test files/test.zip';
-        expect(yield utils_1.isZipFile(zipFile)).toBeTruthy();
-    }));
-    test('Arbitrary file should return false', () => __awaiter(void 0, void 0, void 0, function* () {
-        const dsymFile = './src/commands/dsyms/__tests__/test files/test.dSYM';
-        expect(yield utils_1.isZipFile(dsymFile)).toBeFalsy();
-    }));
-});
-describe('getMatchingDSYMFiles', () => {
-    test('Should find no valid dSYM file in Linux', () => __awaiter(void 0, void 0, void 0, function* () {
-        const write = jest.fn();
-        const mockContext = { stdout: { write } };
-        const folder = './src/commands/dsyms/__tests__/test files/';
-        const foundFiles = yield utils_1.getMatchingDSYMFiles(folder, mockContext);
-        expect(foundFiles).toEqual([undefined]);
-    }));
-    test('Should find one valid dSYM file with mocking', () => __awaiter(void 0, void 0, void 0, function* () {
-        require('../utils').dwarfdumpUUID = jest.fn().mockResolvedValue(['BD8CE358-D5F3-358B-86DC-CBCF2148097B']);
-        const write = jest.fn();
-        const mockContext = { stdout: { write } };
-        const folder = './src/commands/dsyms/__tests__/test files/';
-        const foundFiles = yield utils_1.getMatchingDSYMFiles(folder, mockContext);
-        expect(foundFiles).toEqual([
-            new interfaces_1.Dsym('./src/commands/dsyms/__tests__/test files/test.dSYM', ['BD8CE358-D5F3-358B-86DC-CBCF2148097B']),
-        ]);
-    }));
-});
-describe('zipToTmpDir', () => {
-    test('Zip files to temporary directory', () => __awaiter(void 0, void 0, void 0, function* () {
-        const dsymFile = './src/commands/dsyms/__tests__/test files/test.dSYM';
-        const zippedFile = yield utils_1.zipToTmpDir(dsymFile, `${Date.now().toString()}.zip`);
-        expect((yield fs_1.promises.stat(zippedFile)).size).toBeGreaterThan(0);
-    }));
-});
-describe('unzipToTmpDir', () => {
-    test('Unzip a file to temporary directory', () => __awaiter(void 0, void 0, void 0, function* () {
-        const zipFile = './src/commands/dsyms/__tests__/test files/test.zip';
-        const unzippedFolder = yield utils_1.unzipToTmpDir(zipFile);
-        expect((yield fs_1.promises.stat(unzippedFolder)).size).toBeGreaterThan(0);
-    }));
+const fs_1 = __importStar(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const utils_1 = require("../../../helpers/utils");
+const utils_2 = require("../utils");
+describe('utils', () => {
+    describe('createTmpDirectory', () => {
+        test('Create unique directory', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory1 = yield utils_2.createUniqueTmpDirectory();
+            const tmpDirectory2 = yield utils_2.createUniqueTmpDirectory();
+            expect(fs_1.default.existsSync(tmpDirectory1)).toBeTruthy();
+            expect(fs_1.default.existsSync(tmpDirectory2)).toBeTruthy();
+            expect(tmpDirectory1).not.toEqual(tmpDirectory2);
+            yield utils_2.deleteDirectory(tmpDirectory1);
+            yield utils_2.deleteDirectory(tmpDirectory2);
+        }));
+    });
+    describe('deleteDirectory', () => {
+        test('Delete empty directory', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            yield utils_2.deleteDirectory(tmpDirectory);
+            expect(fs_1.default.existsSync(tmpDirectory)).toBeFalsy();
+        }));
+        test('Delete non-empty directory', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tmpDirectory = yield utils_2.createUniqueTmpDirectory();
+            yield fs_1.promises.mkdir(utils_1.buildPath(tmpDirectory, 'foo'));
+            yield fs_1.promises.writeFile(utils_1.buildPath(tmpDirectory, 'foo', 'bar1'), 'mock1');
+            yield fs_1.promises.writeFile(utils_1.buildPath(tmpDirectory, 'foo', 'bar2'), 'mock2');
+            yield utils_2.deleteDirectory(tmpDirectory);
+            expect(fs_1.default.existsSync(tmpDirectory)).toBeFalsy();
+        }));
+    });
+    describe('zipDirectoryToArchive', () => {
+        test('Compress folder to archive at given path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const archiveDirectory = yield utils_2.createUniqueTmpDirectory();
+            const archivePath = utils_1.buildPath(archiveDirectory, 'archive.zip');
+            yield utils_2.zipDirectoryToArchive('./src/commands/dsyms/__tests__/fixtures', archivePath);
+            expect(fs_1.default.existsSync(archivePath)).toBeTruthy();
+            yield utils_2.deleteDirectory(archiveDirectory);
+        }));
+    });
+    describe('unzipArchiveToDirectory', () => {
+        test('Uncompress archive to given destination', () => __awaiter(void 0, void 0, void 0, function* () {
+            const archiveDirectory = yield utils_2.createUniqueTmpDirectory();
+            const destinationDirectory = yield utils_2.createUniqueTmpDirectory();
+            const archivePath = utils_1.buildPath(archiveDirectory, 'archive.zip');
+            yield utils_2.zipDirectoryToArchive('./src/commands/dsyms/__tests__/fixtures', archivePath);
+            yield utils_2.unzipArchiveToDirectory(archivePath, destinationDirectory);
+            const originalContentList = glob_1.default.sync(utils_1.buildPath('./src/commands/dsyms/__tests__/', 'fixtures/**/*'));
+            const unzippedContentList = glob_1.default.sync(utils_1.buildPath(destinationDirectory, 'fixtures/**/*'));
+            expect(originalContentList.length).toEqual(unzippedContentList.length);
+            yield utils_2.deleteDirectory(archiveDirectory);
+            yield utils_2.deleteDirectory(destinationDirectory);
+        }));
+    });
+    describe('isZipFile', () => {
+        test('Zip file should return true', () => __awaiter(void 0, void 0, void 0, function* () {
+            const file = './src/commands/dsyms/__tests__/fixtures/all.zip';
+            expect(yield utils_2.isZipFile(file)).toBeTruthy();
+        }));
+        test('Arbitrary file should return false', () => __awaiter(void 0, void 0, void 0, function* () {
+            const file = './src/commands/dsyms/__tests__/fixtures/multiple-archs/DDTest.framework.dSYM';
+            expect(yield utils_2.isZipFile(file)).toBeFalsy();
+        }));
+    });
 });

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

@@ -1,7 +1,16 @@
 import { MultipartPayload } from '../../helpers/upload';
-export declare class Dsym {
-    path: string;
-    uuids: string[];
-    constructor(path: string, uuids: string[]);
-    asMultipartPayload(): Promise<MultipartPayload>;
+export interface Dsym {
+    bundlePath: string;
+    slices: ArchSlice[];
+}
+export interface ArchSlice {
+    arch: string;
+    objectPath: string;
+    uuid: string;
+}
+export declare class CompressedDsym {
+    archivePath: string;
+    dsym: Dsym;
+    constructor(archivePath: string, dsym: Dsym);
+    asMultipartPayload(): MultipartPayload;
 }

package/dist/commands/dsyms/interfaces.js

@@ -1,38 +1,25 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dsym = void 0;
+exports.CompressedDsym = void 0;
 const fs_1 = __importDefault(require("fs"));
-const utils_1 = require("./utils");
-class Dsym {
-    constructor(path, uuids) {
-        this.path = path;
-        this.uuids = uuids;
+class CompressedDsym {
+    constructor(archivePath, dsym) {
+        this.archivePath = archivePath;
+        this.dsym = dsym;
     }
     asMultipartPayload() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const concatUUIDs = this.uuids.join();
-            const zipFilePath = yield utils_1.zipToTmpDir(this.path, `${concatUUIDs}.zip`);
-            const content = new Map([
-                ['symbols_archive', { value: fs_1.default.createReadStream(zipFilePath) }],
-                ['type', { value: 'ios_symbols' }],
-                ['uuids', { value: concatUUIDs }],
-            ]);
-            return {
-                content,
-            };
-        });
+        const concatUUIDs = this.dsym.slices.map((slice) => slice.uuid).join();
+        const content = new Map([
+            ['symbols_archive', { value: fs_1.default.createReadStream(this.archivePath) }],
+            ['type', { value: 'ios_symbols' }],
+            ['uuids', { value: concatUUIDs }],
+        ]);
+        return {
+            content,
+        };
     }
 }
-exports.Dsym = Dsym;
+exports.CompressedDsym = CompressedDsym;

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

@@ -1,9 +1,11 @@
-import { Dsym } from './interfaces';
 import { UploadStatus } from '../../helpers/upload';
+import { ArchSlice, CompressedDsym, Dsym } from './interfaces';
 export declare const renderConfigurationError: (error: Error) => string;
-export declare const renderInvalidDsymWarning: (path: string) => string;
-export declare const renderFailedUpload: (dSYM: Dsym, errorMessage: string) => string;
-export declare const renderRetriedUpload: (dSYM: Dsym, errorMessage: string, attempt: number) => string;
+export declare const renderInvalidDsymWarning: (dSYMPath: string) => string;
+export declare const renderDSYMSlimmingFailure: (dSYM: Dsym, slice: ArchSlice) => string;
+export declare const renderFailedUpload: (dSYM: CompressedDsym, errorMessage: string) => string;
+export declare const renderRetriedUpload: (dSYM: CompressedDsym, errorMessage: string, attempt: number) => string;
 export declare const renderSuccessfulCommand: (statuses: UploadStatus[], duration: number, dryRun: boolean) => string;
 export declare const renderCommandInfo: (basePath: string, poolLimit: number, dryRun: boolean) => string;
-export declare const renderUpload: (dSYM: Dsym) => string;
+export declare const renderCommandDetail: (intermediateDirectory: string, uploadDirectory: string) => string;
+export declare const renderUpload: (dSYM: CompressedDsym) => string;

package/dist/commands/dsyms/renderer.js

@@ -3,22 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderUpload = exports.renderCommandInfo = exports.renderSuccessfulCommand = exports.renderRetriedUpload = exports.renderFailedUpload = exports.renderInvalidDsymWarning = exports.renderConfigurationError = void 0;
+exports.renderUpload = exports.renderCommandDetail = exports.renderCommandInfo = exports.renderSuccessfulCommand = exports.renderRetriedUpload = exports.renderFailedUpload = exports.renderDSYMSlimmingFailure = exports.renderInvalidDsymWarning = exports.renderConfigurationError = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const utils_1 = require("./utils");
+const path_1 = __importDefault(require("path"));
 const formatting_1 = require("../../helpers/formatting");
 const upload_1 = require("../../helpers/upload");
+const utils_1 = require("./utils");
 const renderConfigurationError = (error) => chalk_1.default.red(`${formatting_1.ICONS.FAILED} Configuration error: ${error}.\n`);
 exports.renderConfigurationError = renderConfigurationError;
-const renderInvalidDsymWarning = (path) => chalk_1.default.yellow(`${formatting_1.ICONS.WARNING} Invalid dSYM file, will be skipped: ${path}\n`);
+const renderInvalidDsymWarning = (dSYMPath) => chalk_1.default.yellow(`${formatting_1.ICONS.WARNING} Invalid dSYM file, will be skipped: ${dSYMPath}\n`);
 exports.renderInvalidDsymWarning = renderInvalidDsymWarning;
+const renderDSYMSlimmingFailure = (dSYM, slice) => chalk_1.default.yellow(`${formatting_1.ICONS.WARNING} Failed to export '${slice.arch}' arch (${slice.uuid}) from ${dSYM.bundlePath}\n`);
+exports.renderDSYMSlimmingFailure = renderDSYMSlimmingFailure;
 const renderFailedUpload = (dSYM, errorMessage) => {
-    const dSYMPathBold = `[${chalk_1.default.bold.dim(dSYM.path)}]`;
+    const dSYMPathBold = `[${chalk_1.default.bold.dim(dSYM.dsym.bundlePath)}]`;
     return chalk_1.default.red(`${formatting_1.ICONS.FAILED} Failed upload dSYM for ${dSYMPathBold}: ${errorMessage}\n`);
 };
 exports.renderFailedUpload = renderFailedUpload;
 const renderRetriedUpload = (dSYM, errorMessage, attempt) => {
-    const dSYMPathBold = `[${chalk_1.default.bold.dim(dSYM.path)}]`;
+    const dSYMPathBold = `[${chalk_1.default.bold.dim(dSYM.dsym.bundlePath)}]`;
     return chalk_1.default.yellow(`[attempt ${attempt}] Retrying dSYM upload ${dSYMPathBold}: ${errorMessage}\n`);
 };
 exports.renderRetriedUpload = renderRetriedUpload;
@@ -75,5 +78,14 @@ const renderCommandInfo = (basePath, poolLimit, dryRun) => {
     return fullStr;
 };
 exports.renderCommandInfo = renderCommandInfo;
-const renderUpload = (dSYM) => `Uploading dSYM with ${dSYM.uuids} from ${dSYM.path}\n`;
+const renderCommandDetail = (intermediateDirectory, uploadDirectory) => `Will use temporary intermediate directory: ${intermediateDirectory}\n` +
+    `Will use temporary upload directory: ${uploadDirectory}\n`;
+exports.renderCommandDetail = renderCommandDetail;
+const renderUpload = (dSYM) => {
+    const archiveName = path_1.default.basename(dSYM.archivePath);
+    const objectName = dSYM.dsym.slices.map((slice) => path_1.default.basename(slice.objectPath))[0];
+    const archs = dSYM.dsym.slices.map((slice) => slice.arch).join();
+    const uuids = dSYM.dsym.slices.map((slice) => slice.uuid).join();
+    return `Uploading ${archiveName} (${objectName}, arch: ${archs}, UUID: ${uuids})\n`;
+};
 exports.renderUpload = renderUpload;

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

@@ -2,10 +2,41 @@ import { Command } from 'clipanion';
 export declare class UploadCommand extends Command {
     static usage: import("clipanion").Usage;
     private basePath;
+    private cliVersion;
     private config;
     private dryRun;
     private maxConcurrency;
+    constructor();
     execute(): Promise<1 | 0>;
+    private compressDSYMsToDirectory;
+    private findDSYMsInDirectory;
     private getRequestBuilder;
+    /**
+     * 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
+     * ```
+     */
+    private parseDwarfdumpOutput;
+    /**
+     * 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`.
+     */
+    private thinDSYM;
+    /**
+     * 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`.
+     */
+    private thinDSYMs;
     private uploadDSYM;
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datadog/datadog-ci",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Run datadog actions from the CI.",
   "repository": "https://github.com/DataDog/datadog-ci",
   "license": "Apache-2.0",
@@ -64,8 +64,9 @@
     "glob": "7.1.4",
     "inquirer": "8.2.0",
     "proxy-agent": "5.0.0",
+    "rimraf": "^3.0.2",
     "simple-git": "3.3.0",
-    "ssh2": "1.4.0",
+    "ssh2": "1.8.0",
     "ssh2-streams": "0.4.10",
     "sshpk": "1.16.1",
     "tiny-async-pool": "1.2.0",
@@ -83,6 +84,7 @@
     "@types/inquirer": "8.1.3",
     "@types/jest": "24.0.15",
     "@types/node": "10.17.57",
+    "@types/rimraf": "^3.0.2",
     "@types/ssh2": "0.5.46",
     "@types/ssh2-streams": "0.1.8",
     "@types/sshpk": "1.10.5",