Fix validation + add telemetry

Author: Artem

redisinsight/api/src/constants/telemetry-events.ts

@@ -14,6 +14,11 @@ export enum TelemetryEvents {
   RedisInstanceConnectionFailed = 'DATABASE_CONNECTION_FAILED',
   RedisInstanceListReceived = 'CONFIG_DATABASES_DATABASE_LIST_DISPLAYED',
 
+  // Databases import
+  DatabaseImportParseFailed = 'CONFIG_DATABASES_REDIS_IMPORT_PARSE_FAILED',
+  DatabaseImportFailed = 'CONFIG_DATABASES_REDIS_IMPORT_FAILED',
+  DatabaseImportSucceeded = 'CONFIG_DATABASES_REDIS_IMPORT_SUCCEEDED',
+
   // Events for autodiscovery flows
   REClusterDiscoverySucceed = 'CONFIG_DATABASES_RE_CLUSTER_AUTODISCOVERY_SUCCEEDED',
   REClusterDiscoveryFailed = 'CONFIG_DATABASES_RE_CLUSTER_AUTODISCOVERY_FAILED',

redisinsight/api/src/modules/database-import/database-import.analytics.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@nestjs/common';
+import { TelemetryBaseService } from 'src/modules/analytics/telemetry.base.service';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { TelemetryEvents } from 'src/constants';
+import { DatabaseImportResponse } from 'src/modules/database-import/dto/database-import.response';
+
+@Injectable()
+export class DatabaseImportAnalytics extends TelemetryBaseService {
+  constructor(protected eventEmitter: EventEmitter2) {
+    super(eventEmitter);
+  }
+
+  sendImportResults(importResult: DatabaseImportResponse): void {
+    if (importResult.success) {
+      this.sendEvent(
+        TelemetryEvents.DatabaseImportSucceeded,
+        {
+          succeed: importResult.success,
+        },
+      );
+    }
+
+    if (importResult.errors?.length) {
+      this.sendEvent(
+        TelemetryEvents.DatabaseImportFailed,
+        {
+          failed: importResult.errors.length,
+          errors: importResult.errors.map((e) => (e?.constructor?.name || 'UncaughtError')),
+        },
+      );
+    }
+  }
+
+  sendImportFailed(e: Error): void {
+    this.sendEvent(
+      TelemetryEvents.DatabaseImportParseFailed,
+      {
+        error: e?.constructor?.name || 'UncaughtError',
+      },
+    );
+  }
+}

redisinsight/api/src/modules/database-import/database-import.controller.ts

@@ -1,5 +1,4 @@
 import {
-  BadRequestException,
   Controller, HttpCode, Post, UploadedFile,
   UseInterceptors, UsePipes, ValidationPipe,
 } from '@nestjs/common';
@@ -35,14 +34,6 @@ export class DatabaseImportController {
   async import(
     @UploadedFile() file: any,
   ): Promise<DatabaseImportResponse> {
-    // todo: create FileValidation class
-    if (!file) {
-      throw new BadRequestException('No import file provided');
-    }
-    if (file?.size > 1024 * 1024 * 10) {
-      throw new BadRequestException('Import file is too big. Maximum 10mb allowed');
-    }
-
     return this.service.import(file);
   }
 }

redisinsight/api/src/modules/database-import/database-import.module.ts

@@ -1,11 +1,13 @@
 import { Module } from '@nestjs/common';
 import { DatabaseImportController } from 'src/modules/database-import/database-import.controller';
 import { DatabaseImportService } from 'src/modules/database-import/database-import.service';
+import { DatabaseImportAnalytics } from 'src/modules/database-import/database-import.analytics';
 
 @Module({
   controllers: [DatabaseImportController],
   providers: [
     DatabaseImportService,
+    DatabaseImportAnalytics,
   ],
 })
 export class DatabaseImportModule {}

redisinsight/api/src/modules/database-import/database-import.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { isArray, get, set } from 'lodash';
 import { Database } from 'src/modules/database/models/database';
 import { plainToClass } from 'class-transformer';
@@ -8,6 +8,11 @@ import { DatabaseImportResponse } from 'src/modules/database-import/dto/database
 import { Validator } from 'class-validator';
 import { ImportDatabaseDto } from 'src/modules/database-import/dto/import.database.dto';
 import { classToClass } from 'src/utils';
+import { DatabaseImportAnalytics } from 'src/modules/database-import/database-import.analytics';
+import {
+  SizeLimitExceededDatabaseImportFileException,
+  NoDatabaseImportFileProvidedException, UnableToParseDatabaseImportFileException,
+} from 'src/modules/database-import/exceptions';
 
 @Injectable()
 export class DatabaseImportService {
@@ -27,36 +32,65 @@ export class DatabaseImportService {
 
   constructor(
     private readonly databaseRepository: DatabaseRepository,
+    private readonly analytics: DatabaseImportAnalytics,
   ) {}
 
   /**
    * Import databases from the file
    * @param file
    */
   public async import(file): Promise<DatabaseImportResponse> {
-    const items = DatabaseImportService.parseFile(file);
+    try {
+      // todo: create FileValidation class
+      if (!file) {
+        throw new NoDatabaseImportFileProvidedException('No import file provided');
+      }
+      if (file?.size > 1024 * 1024 * 10) {
+        throw new SizeLimitExceededDatabaseImportFileException('Import file is too big. Maximum 10mb allowed');
+      }
 
-    if (!isArray(items) || !items?.length) {
-      let filename = file?.originalname || 'import file';
-      if (filename.length > 50) {
-        filename = `${filename.slice(0, 50)}...`;
+      const items = DatabaseImportService.parseFile(file);
+
+      if (!isArray(items) || !items?.length) {
+        let filename = file?.originalname || 'import file';
+        if (filename.length > 50) {
+          filename = `${filename.slice(0, 50)}...`;
+        }
+        throw new UnableToParseDatabaseImportFileException(`Unable to parse ${filename}`);
       }
-      return Promise.reject(new BadRequestException(`Unable to parse ${filename}`));
-    }
 
-    const response = {
-      total: items.length,
-      success: 0,
-    };
+      let response = {
+        total: items.length,
+        success: 0,
+        errors: [],
+      };
+
+      // it is very important to insert databases on-by-one to avoid db constraint errors
+      await items.reduce((prev, item) => prev.finally(() => this.createDatabase(item)
+        .then(() => {
+          response.success += 1;
+        })
+        .catch((e) => {
+          let error = e;
+          if (isArray(e)) {
+            [error] = e;
+          }
+          this.logger.warn(`Unable to import database: ${error?.constructor?.name || 'UncaughtError'}`, error);
+          response.errors.push(error);
+        })), Promise.resolve());
+
+      this.analytics.sendImportResults(response);
+
+      response = plainToClass(DatabaseImportResponse, response);
+
+      return response;
+    } catch (e) {
+      this.logger.warn(`Unable to import databases: ${e?.constructor?.name || 'UncaughtError'}`, e);
 
-    // it is very important to insert databases on-by-one to avoid db constraint errors
-    await items.reduce((prev, item) => prev.finally(() => this.createDatabase(item)
-      .then(() => {
-        response.success += 1;
-      })
-      .catch(() => { /* just ignore errors */ })), Promise.resolve());
+      this.analytics.sendImportFailed(e);
 
-    return plainToClass(DatabaseImportResponse, response);
+      throw e;
+    }
   }
 
   /**
@@ -101,14 +135,9 @@ export class DatabaseImportService {
         }, {}),
     );
 
-    try {
-      await this.validator.validateOrReject(dto, {
-        whitelist: true,
-      });
-    } catch (e) {
-      this.logger.warn('Invalid data for database import entry', e);
-      return Promise.reject(e);
-    }
+    await this.validator.validateOrReject(dto, {
+      whitelist: true,
+    });
 
     const database = classToClass(Database, dto);
 

redisinsight/api/src/modules/database-import/dto/database-import.response.ts

@@ -1,15 +1,21 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { Exclude, Expose } from 'class-transformer';
 
 export class DatabaseImportResponse {
   @ApiProperty({
     description: 'Total elements processed from the import file',
     type: Number,
   })
+  @Expose()
   total: number;
 
   @ApiProperty({
     description: 'Number of imported database',
     type: Number,
   })
+  @Expose()
   success: number;
+
+  @Exclude()
+  errors: Error[];
 }

redisinsight/api/src/modules/database-import/dto/import.database.dto.ts

@@ -1,7 +1,15 @@
 import { PickType } from '@nestjs/swagger';
 import { Database } from 'src/modules/database/models/database';
+import { Expose, Type } from 'class-transformer';
+import { IsInt, IsNotEmpty } from 'class-validator';
 
 export class ImportDatabaseDto extends PickType(Database, [
   'host', 'port', 'name', 'db', 'username', 'password',
   'connectionType',
-] as const) {}
+] as const) {
+  @Expose()
+  @IsNotEmpty()
+  @IsInt({ always: true })
+  @Type(() => Number)
+  port: number;
+}

redisinsight/api/src/modules/database-import/exceptions/index.ts

@@ -0,0 +1,3 @@
+export * from './size-limit-exceeded-database-import-file.exception';
+export * from './no-database-import-file-provided.exception';
+export * from './unable-to-parse-database-import-file.exception';

redisinsight/api/src/modules/database-import/exceptions/no-database-import-file-provided.exception.ts

@@ -0,0 +1,13 @@
+import { HttpException } from '@nestjs/common';
+
+export class NoDatabaseImportFileProvidedException extends HttpException {
+  constructor(message: string = 'No import file provided') {
+    const response = {
+      message,
+      statusCode: 400,
+      error: 'No Database Import File Provided',
+    };
+
+    super(response, 400);
+  }
+}

redisinsight/api/src/modules/database-import/exceptions/size-limit-exceeded-database-import-file.exception.ts

@@ -0,0 +1,13 @@
+import { HttpException } from '@nestjs/common';
+
+export class SizeLimitExceededDatabaseImportFileException extends HttpException {
+  constructor(message: string = 'Invalid import file') {
+    const response = {
+      message,
+      statusCode: 400,
+      error: 'Invalid Database Import File',
+    };
+
+    super(response, 400);
+  }
+}