@coralogix/rum-cli 1.1.27 → 1.1.29

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/base/base.api.ts

@@ -0,0 +1,118 @@
+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 { GrpcClientFactory } from '../../grpc-client/grpc-client-factory';
+import { CreateEntityReleaseRequest, RumSourceMapServiceDefinition } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+
+export abstract class BaseApi {
+  protected abstract getEntityType(): EntityType;
+  protected abstract getReleaseEntityType(): ReleaseEntityType;
+  protected abstract getMaxCompressedFileSize(): number;
+  protected abstract buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata;
+  protected abstract buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata;
+
+  private async uploadBlob(
+    blobSetClient: Client<typeof BlobSetServiceDefinition>,
+    request: UploadBlobRequest,
+    entityMetadata: EntityMetadata | undefined,
+    metadata: Metadata,
+  ): Promise<void> {
+    request.entityMetadata = entityMetadata;
+    request.entityType = this.getEntityType();
+
+    const iterableRequest = createUploadBlobRequestChunks(request);
+
+    await blobSetClient.uploadBlob(iterableRequest, { metadata });
+  }
+
+  private async createEntityRelease(
+    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+    releaseEntityMetadata: ReleaseEntityMetadata | undefined,
+    metadata: Metadata,
+  ): Promise<void> {
+    const request: CreateEntityReleaseRequest = {
+      releaseEntityType: this.getReleaseEntityType(),
+      releaseEntityMetadata,
+    };
+
+    await rumSourceMapClient.createEntityRelease(request, { metadata });
+  }
+
+  private createGrpcMetadata(privateKey: string): Metadata {
+    const metadata: Metadata = new Metadata();
+    metadata.set('Authorization', `Bearer ${privateKey}`);
+    return metadata;
+  }
+
+  private async checkEntityReleaseExists(
+    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+    application: string,
+    version: string,
+    metadata: Metadata,
+  ): Promise<boolean> {
+    const { exists } = await rumSourceMapClient.isEntityReleaseExists(
+      { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },
+      { metadata },
+    );
+    return exists;
+  }
+
+  public async upload(
+    request: UploadBlobRequest,
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    env: string,
+    privateKey: string,
+  ): Promise<void> {
+    const metadata: Metadata = this.createGrpcMetadata(privateKey);
+    const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());
+    const rumSourceMapClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+
+    try {
+      validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());
+
+      const releaseExists: boolean = await this.checkEntityReleaseExists(rumSourceMapClient, application, version, metadata);
+
+      if (releaseExists) {
+        consoleError(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+        return;
+      }
+
+      const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(
+        application,
+        version,
+        repoName,
+        commitHash,
+        orgName,
+      );
+
+      const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);
+
+      await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+
+      await this.createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata);
+    } catch (error) {
+      consoleError(`Failed to upload: ${error}`);
+      throw error;
+    }
+  }
+}

package/api/dsym/dsym.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class DsymApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_DSYM;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.dsymMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'dsymMetadata',
+        dsymMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'dsymMetadata',
+        dsymMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

package/api/proguard/proguard.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class ProguardApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_PROGUARD;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_PROGUARD;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.proguardMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'proguardMetadata',
+        proguardMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'proguardMetadata',
+        proguardMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

package/api/react-native/react-native.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class ReactNativeApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_REACT_NATIVE;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.reactNativeMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

package/api/source-maps/source-maps.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class SourceMapsApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.sourceMapsMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

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

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { validateEnvironment } from '../../validators';
 import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
-import { DsymService } from '../../../services/dsym.service';
+import { DsymService } from '../../../services/dsym/dsym.service';
 import { UploadDsymCommandOptions } from '../../../models/dsym-commands.model';
 
 export const uploadDsymCommand = () => {
@@ -26,7 +26,9 @@ export const uploadDsymCommand = () => {
 
         checkMissingArguments<UploadDsymCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
 
-        await DsymService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        const service: DsymService = new DsymService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
       } catch (error) {
         consoleError(error);
       }

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

@@ -0,0 +1,38 @@
+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/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']);
+
+        const service: ProguardService = new ProguardService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+      } catch (error) {
+        consoleError(error);
+      }
+    });
+
+  return uploadCommand;
+};