@coralogix/rum-cli 1.1.26 → 1.1.28

package/services/source-maps.service.ts

@@ -20,7 +20,7 @@ export class SourceMapsService {
     console.log(GRAY_COLOR, '🚀 Uploading source maps...');
 
     try {
-      const totalFiles: number | undefined = await FileProcessor.traverseSourceMapsFolder(folderPath, '.js.map', request);
+      const totalFiles: number | undefined = await FileProcessor.traverse(folderPath, '.js.map', request);
 
       await SourceMapsApi.uploadSourceMaps(request, application, version, repoName, commitHash, orgName, env, privateKey);
 

package/utils/file-processor.utils.ts

@@ -1,19 +1,222 @@
+// import * as fs from 'fs';
+// import { Dirent, promises as fsPromises } from 'fs';
+// import * as path from 'path';
+// import { consoleError } from './shared.utils';
+// import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+// import { UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+// import config from '../config';
+// import pako from 'pako';
+// import { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';
+// import { RED_COLOR } from '../consts/consts';
+// import * as zlib from 'node:zlib';
+//
+// const { readdir, stat, readFile } = fsPromises;
+//
+// export class FileProcessor {
+//   static async traverseDsymFolder(folderPath: string, request: UploadBlobRequest): Promise<void> {
+//     try {
+//       const processDsymFolder = async (dsymFolderPath: string) => {
+//         const dwarfPath = await FileProcessor.getDwarfPath(dsymFolderPath);
+//         const content = await readFile(dwarfPath);
+//         const compressedContent = zlib.gzipSync(content);
+//         request.data = new Uint8Array(compressedContent);
+//       };
+//
+//       // Check if the folder itself is a .dSYM folder
+//       if (folderPath.endsWith('.dSYM')) {
+//         await processDsymFolder(folderPath);
+//         return;
+//       }
+//
+//       const files: Dirent[] = await readdir(folderPath, { withFileTypes: true });
+//
+//       for (const file of files) {
+//         // Skip .DS_Store and hidden files
+//         if (file.name === '.DS_Store' || file.name.startsWith('.')) {
+//           continue;
+//         }
+//
+//         const filePath: string = path.join(folderPath, file.name);
+//
+//         if (file.isDirectory()) {
+//           if (file.name.endsWith('.dSYM')) {
+//             await processDsymFolder(filePath);
+//             return;
+//           } else {
+//             await FileProcessor.traverseDsymFolder(filePath, request);
+//           }
+//         }
+//       }
+//     } catch (error) {
+//       consoleError(`Error traversing directory: ${JSON.stringify(error)}`);
+//     }
+//   }
+//
+//   static async traverseSourceMapsFolder(
+//     folderPath: string,
+//     fileExtension: string,
+//     request: UploadBlobRequest,
+//   ): Promise<number | undefined> {
+//     try {
+//       const stats = await stat(folderPath);
+//
+//       if (stats.isFile() && folderPath.endsWith(fileExtension)) {
+//         return await this.processSourceMapSingleFile(folderPath, fileExtension, request);
+//       } else if (stats.isDirectory()) {
+//         return await this.processSourceMapDirectory(folderPath, fileExtension, request);
+//       }
+//     } catch (error) {
+//       consoleError(`Error traversing directory: ${error}`);
+//     }
+//   }
+//
+//   private static async processSourceMapSingleFile(filePath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+//     try {
+//       const content = await readFile(filePath);
+//
+//       const { name } = path.parse(filePath);
+//
+//       const fileData = { name, content: content.toString('base64') };
+//
+//       const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify([fileData])));
+//
+//       request.data = new Uint8Array(compressedContent);
+//
+//       return 1;
+//     } catch (error) {
+//       consoleError(`Error processing file: ${error}`);
+//       throw error;
+//     }
+//   }
+//
+//   private static async processSourceMapDirectory(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+//     const files = await readdir(folderPath, { withFileTypes: true });
+//     const fileDataList: { name: string; content: string }[] = [];
+//
+//     for (const dirent of files) {
+//       const filePath = path.join(folderPath, dirent.name);
+//
+//       if (dirent.isFile() && dirent.name.endsWith(fileExtension)) {
+//         const content = await readFile(filePath);
+//         const { name } = path.parse(filePath);
+//         fileDataList.push({ name, content: content.toString('base64') });
+//       } else if (dirent.isDirectory()) {
+//         await this.traverseSourceMapsFolder(filePath, fileExtension, request);
+//       }
+//     }
+//
+//     const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify(fileDataList)));
+//
+//     request.data = new Uint8Array(compressedContent);
+//
+//     return fileDataList.length;
+//   }
+//
+//   private static async getDwarfPath(dsymPath: string): Promise<string> {
+//     const dwarfPath: string = 'Contents/Resources/DWARF';
+//     const targetPath: string = path.join(dsymPath, dwarfPath);
+//     const files = fs.readdirSync(targetPath);
+//     if (files.length === 1) {
+//       return path.join(dsymPath, dwarfPath, files[0]);
+//     } else {
+//       consoleError(`Expected exactly one file in the directory, but found: ${files.length}`);
+//       return '';
+//     }
+//   }
+//
+//   static async traverseSourceMapsFolderOld(folderPath: string, request: UploadSourceMapsRequest): Promise<void> {
+//     const stack: string[] = [folderPath];
+//
+//     while (stack.length) {
+//       const currentPath = stack.pop();
+//       const entries: Dirent[] = await readdir(currentPath!, { withFileTypes: true });
+//
+//       await Promise.all(
+//         entries.map(async (file: Dirent) => {
+//           const { name } = file;
+//           const entryPath = path.join(currentPath as string, name);
+//           const isCorrectSuffix = file.isFile() && name.endsWith('.js.map');
+//
+//           if (file.isDirectory()) stack.push(entryPath);
+//           else if (isCorrectSuffix) request.files.push(await FileProcessor.getFileMetadata(entryPath));
+//         }),
+//       );
+//     }
+//   }
+//
+//   static compressFileContentChunks(fileContent: Uint8Array): Uint8Array {
+//     const { chunkSize } = config.rumApi; // 512 KB chunk size
+//     const deflate = new pako.Deflate();
+//     const totalChunks = Math.ceil(fileContent.length / chunkSize);
+//
+//     for (let i = 0; i < totalChunks; i++) {
+//       const start = i * chunkSize;
+//       const end = start + chunkSize;
+//       const chunk = fileContent.subarray(start, end);
+//
+//       const isLastChunk = i === totalChunks - 1;
+//
+//       deflate.push(chunk, isLastChunk);
+//     }
+//
+//     const { err, msg, result } = deflate;
+//
+//     if (err) console.error(RED_COLOR, msg);
+//
+//     return result;
+//   }
+//
+//   private static async getFileMetadata(filePath: string): Promise<FileMetadata> {
+//     const { size } = await stat(filePath);
+//     const { name } = path.parse(filePath);
+//     const content = await readFile(filePath);
+//
+//     return { chunkName: name, size, content };
+//   }
+// }
+
 import * as fs from 'fs';
 import { Dirent, promises as fsPromises } from 'fs';
 import * as path from 'path';
 import { consoleError } from './shared.utils';
 import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
-import { UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
-import config from '../config';
-import pako from 'pako';
-import { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';
-import { RED_COLOR } from '../consts/consts';
 import * as zlib from 'node:zlib';
 
 const { readdir, stat, readFile } = fsPromises;
 
 export class FileProcessor {
-  static async traverseDsymFolder(folderPath: string, request: UploadBlobRequest): Promise<void> {
+  static async traverseProguardFolder(proguardPath: string, request: UploadBlobRequest): Promise<void> {
+    try {
+      const processTxtFile = async (proguardFile: string) => {
+        const content = await readFile(proguardFile);
+        const compressedContent = zlib.gzipSync(content);
+        request.data = new Uint8Array(compressedContent);
+      };
+
+      // Check if the folder itself is a .txt file
+      if (proguardPath.endsWith('.txt')) {
+        await processTxtFile(proguardPath);
+        return;
+      }
+
+      const files: Dirent[] = await readdir(proguardPath, { withFileTypes: true });
+
+      for (const file of files) {
+        const filePath: string = path.join(proguardPath, file.name);
+
+        if (file.name.endsWith('.txt')) {
+          await processTxtFile(filePath);
+          return;
+        } else {
+          await FileProcessor.traverseProguardFolder(filePath, request);
+        }
+      }
+    } catch (error) {
+      consoleError(`Error traversing directory: ${JSON.stringify(error)}`);
+    }
+  }
+
+  static async traverseDsymFolder(dsymPath: string, request: UploadBlobRequest): Promise<void> {
     try {
       const processDsymFolder = async (dsymFolderPath: string) => {
         const dwarfPath = await FileProcessor.getDwarfPath(dsymFolderPath);
@@ -23,12 +226,12 @@ export class FileProcessor {
       };
 
       // Check if the folder itself is a .dSYM folder
-      if (folderPath.endsWith('.dSYM')) {
-        await processDsymFolder(folderPath);
+      if (dsymPath.endsWith('.dSYM')) {
+        await processDsymFolder(dsymPath);
         return;
       }
 
-      const files: Dirent[] = await readdir(folderPath, { withFileTypes: true });
+      const files: Dirent[] = await readdir(dsymPath, { withFileTypes: true });
 
       for (const file of files) {
         // Skip .DS_Store and hidden files
@@ -36,7 +239,7 @@ export class FileProcessor {
           continue;
         }
 
-        const filePath: string = path.join(folderPath, file.name);
+        const filePath: string = path.join(dsymPath, file.name);
 
         if (file.isDirectory()) {
           if (file.name.endsWith('.dSYM')) {
@@ -52,26 +255,27 @@ export class FileProcessor {
     }
   }
 
-  static async traverseSourceMapsFolder(
-    folderPath: string,
-    fileExtension: string,
-    request: UploadBlobRequest,
-  ): Promise<number | undefined> {
+  static async traverse(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number | undefined> {
     try {
       const stats = await stat(folderPath);
 
       if (stats.isFile() && folderPath.endsWith(fileExtension)) {
-        return await this.processSourceMapSingleFile(folderPath, fileExtension, request);
+        return await this.processSingleFile(folderPath, fileExtension, request);
       } else if (stats.isDirectory()) {
-        return await this.processSourceMapDirectory(folderPath, fileExtension, request);
+        return await this.processDirectory(folderPath, fileExtension, request);
       }
     } catch (error) {
       consoleError(`Error traversing directory: ${error}`);
     }
   }
 
-  private static async processSourceMapSingleFile(filePath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+  private static async processSingleFile(filePath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
     try {
+      if (!filePath.endsWith(fileExtension)) {
+        consoleError(`File ${filePath} does not have the correct extension: ${fileExtension}`);
+        return 0;
+      }
+
       const content = await readFile(filePath);
 
       const { name } = path.parse(filePath);
@@ -89,7 +293,7 @@ export class FileProcessor {
     }
   }
 
-  private static async processSourceMapDirectory(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+  private static async processDirectory(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
     const files = await readdir(folderPath, { withFileTypes: true });
     const fileDataList: { name: string; content: string }[] = [];
 
@@ -101,7 +305,7 @@ export class FileProcessor {
         const { name } = path.parse(filePath);
         fileDataList.push({ name, content: content.toString('base64') });
       } else if (dirent.isDirectory()) {
-        await this.traverseSourceMapsFolder(filePath, fileExtension, request);
+        await this.traverse(filePath, fileExtension, request);
       }
     }
 
@@ -123,54 +327,4 @@ export class FileProcessor {
       return '';
     }
   }
-
-  static async traverseSourceMapsFolderOld(folderPath: string, request: UploadSourceMapsRequest): Promise<void> {
-    const stack: string[] = [folderPath];
-
-    while (stack.length) {
-      const currentPath = stack.pop();
-      const entries: Dirent[] = await readdir(currentPath!, { withFileTypes: true });
-
-      await Promise.all(
-        entries.map(async (file: Dirent) => {
-          const { name } = file;
-          const entryPath = path.join(currentPath as string, name);
-          const isCorrectSuffix = file.isFile() && name.endsWith('.js.map');
-
-          if (file.isDirectory()) stack.push(entryPath);
-          else if (isCorrectSuffix) request.files.push(await FileProcessor.getFileMetadata(entryPath));
-        }),
-      );
-    }
-  }
-
-  static compressFileContentChunks(fileContent: Uint8Array): Uint8Array {
-    const { chunkSize } = config.rumApi; // 512 KB chunk size
-    const deflate = new pako.Deflate();
-    const totalChunks = Math.ceil(fileContent.length / chunkSize);
-
-    for (let i = 0; i < totalChunks; i++) {
-      const start = i * chunkSize;
-      const end = start + chunkSize;
-      const chunk = fileContent.subarray(start, end);
-
-      const isLastChunk = i === totalChunks - 1;
-
-      deflate.push(chunk, isLastChunk);
-    }
-
-    const { err, msg, result } = deflate;
-
-    if (err) console.error(RED_COLOR, msg);
-
-    return result;
-  }
-
-  private static async getFileMetadata(filePath: string): Promise<FileMetadata> {
-    const { size } = await stat(filePath);
-    const { name } = path.parse(filePath);
-    const content = await readFile(filePath);
-
-    return { chunkName: name, size, content };
-  }
 }