@coralogix/rum-cli 1.1.26 → 1.1.28

package/README.md

@@ -1,23 +1,26 @@
 # Official Coralogix RUM CLI
 
-The Coralogix RUM CLI is a command-line interface tool that simplifies the process of uploading rum data . This CLI tool provides an easy and efficient way to authenticate with the Coralogix API.
+The Coralogix RUM CLI is a command-line tool designed to simplify the process of uploading RUM (Real User Monitoring)
+data. It provides a streamlined way to authenticate with the Coralogix API and manage source maps, dSYM files, and
+ProGuard mappings.
 
 [![npm version](https://img.shields.io/npm/v/@coralogix/browser.svg)](https://www.npmjs.com/package/@coralogix/browser)
 
-# Links
+## Links
 
 - [Coralogix Real User Monitoring Docs](https://coralogix.com/docs/real-user-monitoring/)
-
 - [Coralogix SDK for Browsers](https://www.npmjs.com/package/@coralogix/browser)
 
-# Installation
+## Installation
 
 To install the Coralogix RUM CLI, follow these steps:
 
 1. Open a terminal or command prompt.
-2. Run the following command to install the CLI globally: `npm install -g coralogix-rum-cli`
-3. Once the installation is complete, you can use the CLI by running the `coralogix-rum-cli` command in your terminal.
-
+2. Run the following command to install the CLI globally:
+   ```bash
+   npm install -g coralogix-rum-cli
+   ```
+3. Once installed, you can use the CLI by running `coralogix-rum-cli` in your terminal.
 
 ## Commands
 
@@ -25,122 +28,130 @@ Here are some examples of how to use the Coralogix RUM CLI:
 
 ### Web:
 
-1. Upload source maps:
+Upload source maps:
 
-    - `coralogix-rum-cli upload-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
+```bash
+coralogix-rum-cli upload-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>
+```
 
 ### React Native:
 
-1. Upload React Native source maps:
+Upload React Native source maps:
 
-   - `coralogix-rum-cli upload-react-native-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
+```bash
+coralogix-rum-cli upload-react-native-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>
+```
 
 ### iOS:
 
-1. Upload dSYM files:
+Upload dSYM file:
 
-   - `coralogix-rum-cli upload-dsym -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
+```bash
+coralogix-rum-cli upload-dsym -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>
+```
+
+### Android:
+
+Upload ProGuard file:
+
+```bash
+coralogix-rum-cli upload-proguard -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>
+```
 
 ## Options
 
 - `-k, --private-key <privateKey>`: Private key to authenticate with the Coralogix API.
 - `-a, --application <application>`: Name of the application.
-- `-v, --version <version>`: The application version - must match the version used by RUM sdk.
-- `-f, --folder-path <folderPath>`: Path to the folder containing the source maps.
-- `-e, --env <env>`: Your environment.
+- `-v, --version <version>`: The application version (must match the version used by the RUM SDK).
+- `-f, --folder-path <folderPath>`: Path to the folder containing the Source Maps, dSYM file, or ProGuard mapping file.
+- `-e, --env <env>`: Your environment (e.g., EU1, US1).
 - `-c, --commit-hash <commitHash>`: GitHub commit hash (optional).
 - `-n, --repo-name <repoName>`: GitHub repository name (optional).
 - `-o, --org-name <orgName>`: GitHub organization name (optional).
-- `-g, --generate <generate>`: Update existing release or create a new one if not found (optional).
+- `-g, --generate`: Update existing release or create a new one if not found (optional).
 - `-h, --help`: Display help.
 
 ## Environments
 
-The Coralogix RUM CLI supports the following environments:
+Specify the appropriate environment using the `-e` option:
 
--  EU1: https://ng-api-grpc.coralogix.com:443, // eu-west-1 (Ireland)
--  EU2: https://ng-api-grpc.eu2.coralogix.com:443, // eu-north-1 (Stockholm)
--  US1: https://ng-api-grpc.coralogix.us:443, // us-east-2 (Ohio)
--  US2: https://ng-api-grpc.cx498.coralogix.com:443, // us-west-2 (Oregon)
--  AP1: https://ng-api-grpc.app.coralogix.in:443, // ap-south-1 (Mumbai)
--  AP2: https://ng-api-grpc.coralogixsg.com:443, // ap-southeast-1 (Singapore)
+- **EU1:** `https://ng-api-grpc.coralogix.com:443` (eu-west-1, Ireland)
+- **EU2:** `https://ng-api-grpc.eu2.coralogix.com:443` (eu-north-1, Stockholm)
+- **US1:** `https://ng-api-grpc.coralogix.us:443` (us-east-2, Ohio)
+- **US2:** `https://ng-api-grpc.cx498.coralogix.com:443` (us-west-2, Oregon)
+- **AP1:** `https://ng-api-grpc.app.coralogix.in:443` (ap-south-1, Mumbai)
+- **AP2:** `https://ng-api-grpc.coralogixsg.com:443` (ap-southeast-1, Singapore)
 
+## Folder Size Limits
 
-Please use the appropriate environment value when specifying the `-e, --env` option.
-
-## React Native Source maps folder size limit
+Ensure your files do not exceed the following size limits:
 
-The source map folder size limit is 200MB in this project. Please ensure that it does not exceed this limit.
+- **React Native Source Maps:** 200MB per folder
+- **Source Maps:** 200MB per folder
+- **ProGuard Files:** 200MB per folder
+- **dSYM Files:** 400MB per file
 
-## Source maps folder size limit
+## Integration
 
-The source map folder size limit is 200MB in this project. Please ensure that it does not exceed this limit.
+### CI Integration:
 
-## Dsym folder size limit
+To automate the upload process in your CI pipeline:
 
-The dsym folder size limit is 500MB in this project. Please ensure that it does not exceed this limit.
+1. **Create a Shell Script:**
+   - Name it according to the use case (
+     e.g., `upload-source-maps.sh`, `upload-react-native-source-maps.sh`, `upload-dsym.sh`, or `upload-proguard.sh`).
 
+2. **Template for the Script:**
+   ```bash
+   #! /usr/bin/env bash
 
-## Folder Size Limits
-- **Source Maps (including React Native)**: The source map folder size limit is 200MB. Please ensure that it does not exceed this limit.
-- **dSYM**: The dSYM folder size limit is 400MB. Please ensure that it does not exceed this limit.
+   # Replace these values with your actual information
+   REPO_NAME="your-repo-name"
+   ORG_NAME="your-github-username"
+   APPLICATION="your-application-name"
+   ENV="your-environment"
+   FILES_PATH="your-files-path"
+   PRIVATE_KEY="your-coralogix-private-key"
+   VERSION="your-application-version"
 
+   # Get the commit hash using git rev-parse
+   COMMIT_HASH=$(git rev-parse HEAD)
 
-## Integration
+   # Run Coralogix RUM CLI to upload the respective files
+   coralogix-rum-cli upload-<command> -k "$PRIVATE_KEY" -a "$APPLICATION" -v "$VERSION" -f "$FILES_PATH" -e "$ENV" -c "$COMMIT_HASH" -n "$REPO_NAME" -o "$ORG_NAME"
+   ```
 
-### <u> CI Integration: </u>
+   Replace `<command>` with `source-maps`, `react-native-source-maps`, `dsym`, or `proguard` based on the file type.
 
-1. Create a new file named `upload-source-maps.sh` and open it for editing.
+### Non-CI Integration:
 
-2. Copy and paste the following script into the file, replacing the placeholder values with your actual information:
+For manual uploads, use the corresponding command in your terminal:
 
 ```bash
-#! /usr/bin/env bash
-
-# Replace these values with your actual information
-REPO_NAME="your-repo-name"
-ORG_NAME="your-github-username"
-APPLICATION="your-application-name"
-ENV="your-environment"
-SOURCE_MAPS_PATH="your-source-maps-path"
-PRIVATE_KEY="your-coralogix-private-key"
-VERSION="your-application-version"
-
-# Get the commit hash using git rev-parse
-COMMIT_HASH=$(git rev-parse HEAD)
-
-# Run Coralogix RUM CLI to upload source maps
-coralogix-rum-cli upload-source-maps -k "$PRIVATE_KEY" -a "$APPLICATION" -v "$VERSION" -f "$SOURCE_MAPS_PATH" -e "$ENV" -c "$COMMIT_HASH" -n "$REPO_NAME" -o "$ORG_NAME"
+coralogix-rum-cli upload-<command> -k "$PRIVATE_KEY" -a "$APPLICATION" -v "$VERSION" -f "$FILES_PATH" -e "$ENV" -c "$COMMIT_HASH" -n "$REPO_NAME" -o "$ORG_NAME"
 ```
 
-### <u> Non-CI Integration: </u>
-
-1. Open a terminal window,and run the following command:
-```bash
-coralogix-rum-cli upload-source-maps -k "$PRIVATE_KEY" -a "$APPLICATION" -v "$VERSION" -f "$SOURCE_MAPS_PATH" -e "$ENV" -c "$COMMIT_HASH" -n "$REPO_NAME" -o "$ORG_NAME"
-```
+Replace `<command>` with one of the following as needed:
 
-<br>
+- `source-maps`
+- `react-native-source-maps`
+- `dsym`
+- `proguard`
 
-| IMPORTANT: The $VERSION param must align with the content of the version field in your CoralogixRum.init() configuration in [Coralogix SDK for Browsers](https://www.npmjs.com/package/@coralogix/browser) |
-|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| IMPORTANT: The $VERSION parameter must exactly match the version specified in the SDK initialization (init) function configuration in your [Coralogix SDK for Browsers](https://www.npmjs.com/package/@coralogix/browser) |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 
 
 ## Optional GitHub Information
 
-The following options are optional and relate to GitHub information, providing context for source maps:
-
-- `-c, --commit-hash <commitHash>`: This option allows you to provide the GitHub commit hash associated with the source maps. Including this hash can help in tracking down issues specific to a particular commit.
-
-
-- `-n, --repo-name <repoName>`: By specifying the GitHub repository name, you're indicating the repository where the source code is hosted. This information aids in correlating source maps with the correct repository.
-
+You can provide additional GitHub-related options to enhance source map management:
 
-- `-o, --org-name <orgName>`: This option enables you to input your GitHub organization user, helping to attribute the source maps to the appropriate organization user.
+- `-c, --commit-hash <commitHash>`: The commit hash associated with the source maps.
+- `-n, --repo-name <repoName>`: The repository name where the source code is hosted.
+- `-o, --org-name <orgName>`: The organization user associated with the repository.
 
-<br>
-  Providing these GitHub-related options can enhance the accuracy of source map management and issue tracking within Coralogix RUM. However, they are not mandatory and can be omitted if not applicable.
+These options are optional but can improve issue tracking within Coralogix RUM.
 
 ## License
 
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/api/client/request-builder.ts

@@ -1,12 +1,17 @@
 import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
-import { DsymMetadata, EntityMetadata, SourceMapMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+import {
+  DsymMetadata,
+  EntityMetadata,
+  ProguardMetadata,
+  SourceMapMetadata,
+} from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
 import { CreateEntityReleaseRequest } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';
-import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { ReactNativeMetadata, ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
 import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
 import { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
 
 export class RequestBuilder {
-  private static createSourceMapMetadata(
+  static createSourceMapMetadata(
     application: string,
     version: string,
     repoName: string | undefined,
@@ -25,7 +30,26 @@ export class RequestBuilder {
     };
   }
 
-  private static createDsymMetadata(
+  static createProguardMetadata(
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+  ): { $case: 'proguardMetadata'; proguardMetadata: ProguardMetadata } {
+    return {
+      $case: 'proguardMetadata',
+      proguardMetadata: {
+        application,
+        releaseId: version,
+        repoName: repoName || '',
+        commitHash: commitHash || '',
+        orgName: orgName || '',
+      },
+    };
+  }
+
+  static createDsymMetadata(
     application: string,
     version: string,
     repoName: string | undefined,
@@ -44,70 +68,29 @@ export class RequestBuilder {
     };
   }
 
-  static buildUploadBlobRequest(
-    uploadBlobRequest: UploadBlobRequest,
+  static createUploadBlobRequest(
+    metadata:
+      | { $case: 'dsymMetadata'; dsymMetadata: DsymMetadata }
+      | { $case: 'sourceMapMetadata'; sourceMapMetadata: SourceMapMetadata }
+      | { $case: 'proguardMetadata'; proguardMetadata: ProguardMetadata },
     entityType: EntityType,
-    metadata: { $case: 'dsymMetadata'; dsymMetadata: DsymMetadata } | { $case: 'sourceMapMetadata'; sourceMapMetadata: SourceMapMetadata },
+    uploadBlobRequest: UploadBlobRequest,
   ): UploadBlobRequest {
     const entityMetadata: EntityMetadata = { metadata };
 
     return { ...uploadBlobRequest, entityType, entityMetadata };
   }
 
-  static buildCreateEntityReleaseRequest(
+  static createEntityReleaseRequest(
+    metadata:
+      | { $case: 'dsymMetadata'; dsymMetadata: DsymMetadata }
+      | { $case: 'sourceMapMetadata'; sourceMapMetadata: SourceMapMetadata }
+      | { $case: 'reactNativeMetadata'; reactNativeMetadata: ReactNativeMetadata }
+      | { $case: 'proguardMetadata'; proguardMetadata: ProguardMetadata },
     releaseEntityType: ReleaseEntityType,
-    metadata: { $case: 'dsymMetadata'; dsymMetadata: DsymMetadata } | { $case: 'sourceMapMetadata'; sourceMapMetadata: SourceMapMetadata },
   ): CreateEntityReleaseRequest {
     const releaseEntityMetadata: ReleaseEntityMetadata = { metadata };
 
     return CreateEntityReleaseRequest.create({ releaseEntityType, releaseEntityMetadata });
   }
-
-  static createSourceMapsUploadBlobRequest(
-    entityType: EntityType,
-    uploadBlobRequest: UploadBlobRequest,
-    application: string,
-    version: string,
-    repoName: string | undefined,
-    commitHash: string | undefined,
-    orgName: string | undefined,
-  ): UploadBlobRequest {
-    const metadata = this.createSourceMapMetadata(application, version, repoName, commitHash, orgName);
-    return this.buildUploadBlobRequest(uploadBlobRequest, entityType, metadata);
-  }
-
-  static createDsymUploadBlobRequest(
-    uploadBlobRequest: UploadBlobRequest,
-    application: string,
-    version: string,
-    repoName: string | undefined,
-    commitHash: string | undefined,
-    orgName: string | undefined,
-  ): UploadBlobRequest {
-    const metadata = this.createDsymMetadata(application, version, repoName, commitHash, orgName);
-    return this.buildUploadBlobRequest(uploadBlobRequest, EntityType.ENTITY_TYPE_DSYM, metadata);
-  }
-
-  static createDsymReleaseRequest(
-    application: string,
-    version: string,
-    repoName: string | undefined,
-    commitHash: string | undefined,
-    orgName: string | undefined,
-  ): CreateEntityReleaseRequest {
-    const metadata = this.createDsymMetadata(application, version, repoName, commitHash, orgName);
-    return this.buildCreateEntityReleaseRequest(ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM, metadata);
-  }
-
-  static createReactNativeReleaseRequest(
-    application: string,
-    version: string,
-    repoName: string | undefined,
-    commitHash: string | undefined,
-    orgName: string | undefined,
-    releaseEntityType: ReleaseEntityType,
-  ): CreateEntityReleaseRequest {
-    const metadata = this.createSourceMapMetadata(application, version, repoName, commitHash, orgName);
-    return this.buildCreateEntityReleaseRequest(releaseEntityType, metadata);
-  }
 }

package/api/dsym.api.ts

@@ -4,12 +4,13 @@ import { BlobSetServiceDefinition, UploadBlobRequest } from '../proto-models/com
 import { consoleError, createUploadBlobRequestChunks, validateCompressedFilesSize } from '../utils/shared.utils';
 import { ReleaseEntityType } from '../proto-models/com/coralogix/rum/v2/release_entity_type';
 import { ClientFactory } from './client/client-factory';
-import { RumSourceMapServiceDefinition } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import { CreateEntityReleaseRequest, RumSourceMapServiceDefinition } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
 import { RequestBuilder } from './client/request-builder';
+import { EntityType } from '../proto-models/com/coralogix/blobset/v2/entity_type';
 
 export class DsymApi {
   static async uploadDsym(
-    uploadBlobRequest: UploadBlobRequest,
+    request: UploadBlobRequest,
     application: string,
     version: string,
     repoName: string | undefined,
@@ -25,7 +26,7 @@ export class DsymApi {
       const metadata = new Metadata();
       metadata.set('Authorization', `Bearer ${privateKey}`);
 
-      validateCompressedFilesSize(uploadBlobRequest.data.length, config.rumApi.reactNativeMaxCompressedFilesSize);
+      validateCompressedFilesSize(request.data.length, config.rumApi.reactNativeMaxCompressedFilesSize);
 
       const { exists } = await rumSourceMapClient.isEntityReleaseExists(
         { releaseId: version, application, releaseEntityType: ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM },
@@ -37,22 +38,24 @@ export class DsymApi {
         return;
       }
 
-      const updatedUploadBlobRequest = RequestBuilder.createDsymUploadBlobRequest(
-        uploadBlobRequest,
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
+      const dsymMetadata = RequestBuilder.createDsymMetadata(application, version, repoName, commitHash, orgName);
+
+      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createUploadBlobRequest(
+        dsymMetadata,
+        EntityType.ENTITY_TYPE_DSYM,
+        request,
       );
 
-      const iterableRequest = createUploadBlobRequestChunks(updatedUploadBlobRequest);
+      const iterableRequest = createUploadBlobRequestChunks(uploadBlobRequest);
 
       await blobSetClient.uploadBlob(iterableRequest, { metadata });
 
-      const uploadEntityReleaseRequest = RequestBuilder.createDsymReleaseRequest(application, version, repoName, commitHash, orgName);
+      const entityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createEntityReleaseRequest(
+        dsymMetadata,
+        ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM,
+      );
 
-      await rumSourceMapClient.createEntityRelease(uploadEntityReleaseRequest, { metadata });
+      await rumSourceMapClient.createEntityRelease(entityReleaseRequest, { metadata });
     } catch (error) {
       consoleError(`Failed to upload dSYMs: ${error}`);
       throw error;

package/api/proguard.api.ts

@@ -0,0 +1,64 @@
+import { Client, Metadata } from 'nice-grpc';
+import { BlobSetServiceDefinition, UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { consoleError, createUploadBlobRequestChunks, validateCompressedFilesSize } from '../utils/shared.utils';
+import { ClientFactory } from './client/client-factory';
+import { RequestBuilder } from './client/request-builder';
+import { EntityType } from '../proto-models/com/coralogix/blobset/v2/entity_type';
+import config from '../config/config';
+import { CreateEntityReleaseRequest, RumSourceMapServiceDefinition } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import { ReleaseEntityType } from '../proto-models/com/coralogix/rum/v2/release_entity_type';
+
+export class ProguardApi {
+  static async uploadProguard(
+    request: UploadBlobRequest,
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    env: string,
+    privateKey: string,
+  ): Promise<void> {
+    try {
+      const blobSetClient: Client<typeof BlobSetServiceDefinition> = ClientFactory.getBlobSetGrpcClient(env);
+      const rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition> = ClientFactory.getRumSourceMapGrpcClient(env);
+
+      const metadata: Metadata = new Metadata();
+      metadata.set('Authorization', `Bearer ${privateKey}`);
+
+      validateCompressedFilesSize(request.data.length, config.rumApi.proguardMaxCompressedFilesSize);
+
+      const { exists } = await rumSourceMapClient.isEntityReleaseExists(
+        { releaseId: version, application, releaseEntityType: ReleaseEntityType.RELEASE_ENTITY_TYPE_PROGUARD },
+        { metadata },
+      );
+
+      if (exists) {
+        consoleError(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+        return;
+      }
+
+      const proguardMetadata = RequestBuilder.createProguardMetadata(application, version, repoName, commitHash, orgName);
+
+      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createUploadBlobRequest(
+        proguardMetadata,
+        EntityType.ENTITY_TYPE_PROGUARD,
+        request,
+      );
+
+      const iterableRequest = createUploadBlobRequestChunks(uploadBlobRequest);
+
+      await blobSetClient.uploadBlob(iterableRequest, { metadata });
+
+      const entityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createEntityReleaseRequest(
+        proguardMetadata,
+        ReleaseEntityType.RELEASE_ENTITY_TYPE_PROGUARD,
+      );
+
+      await rumSourceMapClient.createEntityRelease(entityReleaseRequest, { metadata });
+    } catch (error) {
+      consoleError(`Failed to upload proguard: ${error}`);
+      throw error;
+    }
+  }
+}

package/api/react-native.api.ts

@@ -38,30 +38,24 @@ export class ReactNativeApi {
         return;
       }
 
-      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createSourceMapsUploadBlobRequest(
-        EntityType.ENTITY_TYPE_REACT_NATIVE,
+      const reactNativeMetadata = RequestBuilder.createSourceMapMetadata(application, version, repoName, commitHash, orgName);
+
+      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createUploadBlobRequest(
+        reactNativeMetadata,
+        EntityType.ENTITY_TYPE_SOURCE_MAP,
         request,
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
       );
 
       const iterableRequest = createUploadBlobRequestChunks(uploadBlobRequest);
 
       await blobSetClient.uploadBlob(iterableRequest, { metadata });
 
-      const uploadEntityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createReactNativeReleaseRequest(
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
+      const entityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createEntityReleaseRequest(
+        reactNativeMetadata,
         ReleaseEntityType.RELEASE_ENTITY_TYPE_REACT_NATIVE,
       );
 
-      await rumSourceMapClient.createEntityRelease(uploadEntityReleaseRequest, { metadata });
+      await rumSourceMapClient.createEntityRelease(entityReleaseRequest, { metadata });
     } catch (error) {
       consoleError(`Failed to upload react native source maps: ${error}`);
       throw error;

package/api/source-maps.api.ts

@@ -38,30 +38,24 @@ export class SourceMapsApi {
         return;
       }
 
-      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createSourceMapsUploadBlobRequest(
+      const sourceMapMetadata = RequestBuilder.createSourceMapMetadata(application, version, repoName, commitHash, orgName);
+
+      const uploadBlobRequest: UploadBlobRequest = RequestBuilder.createUploadBlobRequest(
+        sourceMapMetadata,
         EntityType.ENTITY_TYPE_SOURCE_MAP,
         request,
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
       );
 
       const iterableRequest = createUploadBlobRequestChunks(uploadBlobRequest);
 
       await blobSetClient.uploadBlob(iterableRequest, { metadata });
 
-      const uploadEntityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createReactNativeReleaseRequest(
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
+      const entityReleaseRequest: CreateEntityReleaseRequest = RequestBuilder.createEntityReleaseRequest(
+        sourceMapMetadata,
         ReleaseEntityType.RELEASE_ENTITY_TYPE_SOURCE_MAP,
       );
 
-      await rumSourceMapClient.createEntityRelease(uploadEntityReleaseRequest, { metadata });
+      await rumSourceMapClient.createEntityRelease(entityReleaseRequest, { metadata });
     } catch (error) {
       consoleError(`Failed to upload source maps: ${error}`);
       throw error;

package/cli/commands/proguard/index.ts

@@ -0,0 +1,5 @@
+import { uploadProguardCommand } from './upload-proguard-command';
+
+const proguardCommands = { uploadProguardCommand };
+
+export default proguardCommands;

package/cli/commands/proguard/upload-proguard-command.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { validateEnvironment } from '../../validators';
+import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
+import { UploadProguardCommandOptions } from '../../../models/proguard-commands.model';
+import { ProguardService } from '../../../services/proguard.service';
+
+export const uploadProguardCommand = () => {
+  const uploadCommand = new Command('upload-proguard')
+    .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+    .option('-a, --application <application>', 'Name of the application')
+    .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+    .option('-f, --folder-path <folderPath>', 'Path to the folder containing the proguard mapping file')
+    .option('-e, --env <env>', 'Your environment', validateEnvironment)
+    .option('-c, --commit-hash <commitHash>', 'GitHub commit hash (optional)')
+    .option('-n, --repo-name <repoName>', 'GitHub Repository name (optional)')
+    .option('-o, --org-name <orgName>', 'GitHub user name (optional)')
+    .description('Upload Proguard mapping file')
+    .action(async (options: UploadProguardCommandOptions) => {
+      try {
+        if (options.help) {
+          uploadCommand.outputHelp();
+          process.exit(0);
+        }
+
+        const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+
+        checkMissingArguments<UploadProguardCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+
+        await ProguardService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+      } catch (error) {
+        consoleError(error);
+      }
+    });
+
+  return uploadCommand;
+};

package/cli/rum-cli.ts

@@ -3,6 +3,7 @@ import { Command } from 'commander';
 import sourceMapsCommands from './commands/source-maps';
 import reactNativeCommands from './commands/react-native';
 import dsymCommands from './commands/dsym';
+import proguardCommands from './commands/proguard';
 
 const program: Command = new Command();
 
@@ -15,6 +16,8 @@ const uploadReactNativeSourceMapsCommand: Command = reactNativeCommands.uploadRe
 
 const uploadDsymCommand: Command = dsymCommands.uploadDsymCommand();
 
+const uploadProguardCommand: Command = proguardCommands.uploadProguardCommand();
+
 // Register commands
 program.addCommand(uploadSourceMapCommand);
 
@@ -22,5 +25,7 @@ program.addCommand(uploadReactNativeSourceMapsCommand);
 
 program.addCommand(uploadDsymCommand);
 
+program.addCommand(uploadProguardCommand);
+
 // Parse command line arguments
 program.parse(process.argv);

package/config/config.ts

@@ -14,6 +14,7 @@ export interface rumApiConfig {
   reactNativeMaxCompressedFilesSize: number;
   sourceMapsMaxCompressedFilesSize: number;
   dsymMaxCompressedFilesSize: number;
+  proguardMaxCompressedFilesSize: number;
 }
 
 export interface Config {
@@ -33,6 +34,7 @@ const config: Config = {
     dsymMaxMessageSize: 400 * MB, // 400MB(in bytes)
     reactNativeMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
     sourceMapsMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
+    proguardMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
     dsymMaxCompressedFilesSize: 400 * MB, // 400MB (in bytes)
     chunkSize: MB, // 1MB (in bytes)
   },