Fix error handling in DE (#294)

- Replaced `JSON.stringify(error)` with `error.message`
- Created `ErrorHandlingUtils` and moved all error logging actions in there

src/Common/dataAccess/createCollection.ts

@@ -1,5 +1,4 @@
 import * as DataModels from "../../Contracts/DataModels";
-import * as ErrorParserUtility from "../ErrorParserUtility";
 import { AuthType } from "../../AuthType";
 import { ContainerResponse, DatabaseResponse } from "@azure/cosmos";
 import { ContainerRequest } from "@azure/cosmos/dist-esm/client/Container/ContainerRequest";
@@ -23,21 +22,20 @@ import {
   getGremlinGraph
 } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { createUpdateTable, getTable } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
-import { logConsoleProgress, logConsoleError, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { logConsoleProgress, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
 import { refreshCachedResources } from "../DataAccessUtilityBase";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 import { createDatabase } from "./createDatabase";
 import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
+import { handleError } from "../ErrorHandlingUtils";
 
 export const createCollection = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
-  let collection: DataModels.Collection;
   const clearMessage = logConsoleProgress(
     `Creating a new container ${params.collectionId} for database ${params.databaseId}`
   );
   try {
+    let collection: DataModels.Collection;
     if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
       if (params.createNewDatabase) {
         const createDatabaseParams: DataModels.CreateDatabaseParams = {
@@ -54,18 +52,16 @@ export const createCollection = async (params: DataModels.CreateCollectionParams
     } else {
       collection = await createCollectionWithSDK(params);
     }
+
+    logConsoleInfo(`Successfully created container ${params.collectionId}`);
+    await refreshCachedResources();
+    return collection;
   } catch (error) {
-    const sanitizedError = ErrorParserUtility.replaceKnownError(JSON.stringify(error));
-    logConsoleError(`Error while creating container ${params.collectionId}:\n ${sanitizedError}`);
-    logError(JSON.stringify(error), "CreateCollection", error.code);
-    sendNotificationForError(error);
-    clearMessage();
+    handleError(error, `Error while creating container ${params.collectionId}`, "CreateCollection");
     throw error;
+  } finally {
+    clearMessage();
   }
-  logConsoleInfo(`Successfully created container ${params.collectionId}`);
-  await refreshCachedResources();
-  clearMessage();
-  return collection;
 };
 
 const createCollectionWithARM = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {

src/Common/dataAccess/createDatabase.ts

@@ -24,36 +24,31 @@ import {
   createUpdateGremlinDatabase,
   getGremlinDatabase
 } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { logConsoleProgress, logConsoleError, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
 import { refreshCachedOffers, refreshCachedResources } from "../DataAccessUtilityBase";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export async function createDatabase(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
-  let database: DataModels.Database;
   const clearMessage = logConsoleProgress(`Creating a new database ${params.databaseId}`);
   try {
     if (userContext.defaultExperience === DefaultAccountExperienceType.Table) {
       throw new Error("Creating database resources is not allowed for tables accounts");
     }
-    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
-      database = await createDatabaseWithARM(params);
-    } else {
-      database = await createDatabaseWithSDK(params);
-    }
+    const database: DataModels.Database = await (window.authType === AuthType.AAD && !userContext.useSDKOperations
+      ? createDatabaseWithARM(params)
+      : createDatabaseWithSDK(params));
+
+    await refreshCachedResources();
+    await refreshCachedOffers();
+    logConsoleInfo(`Successfully created database ${params.databaseId}`);
+    return database;
   } catch (error) {
-    logConsoleError(`Error while creating database ${params.databaseId}:\n ${error.message}`);
-    logError(JSON.stringify(error), "CreateDatabase", error.code);
-    sendNotificationForError(error);
-    clearMessage();
+    handleError(error, `Error while creating database ${params.databaseId}`, "CreateDatabase");
     throw error;
+  } finally {
+    clearMessage();
   }
-  logConsoleInfo(`Successfully created database ${params.databaseId}`);
-  await refreshCachedResources();
-  await refreshCachedOffers();
-  clearMessage();
-  return database;
 }
 
 async function createDatabaseWithARM(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {

src/Common/dataAccess/createStoredProcedure.ts

@@ -9,9 +9,8 @@ import {
   createUpdateSqlStoredProcedure,
   getSqlStoredProcedure
 } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function createStoredProcedure(
@@ -66,9 +65,7 @@ export async function createStoredProcedure(
       .scripts.storedProcedures.create(storedProcedure);
     return response?.resource;
   } catch (error) {
-    logConsoleError(`Error while creating stored procedure ${storedProcedure.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "CreateStoredProcedure", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while creating stored procedure ${storedProcedure.id}`, "CreateStoredProcedure");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/createTrigger.ts

@@ -29,7 +29,7 @@ export async function createTrigger(
           trigger.id
         );
         if (getResponse?.properties?.resource) {
-          throw new Error(`Create trigger failed: trigger with id ${trigger.id} already exists`);
+          throw new Error(`Create trigger failed: ${trigger.id} already exists`);
         }
       } catch (error) {
         if (error.code !== "NotFound") {
@@ -61,8 +61,8 @@ export async function createTrigger(
       .scripts.triggers.create(trigger);
     return response.resource;
   } catch (error) {
-    logConsoleError(`Error while creating trigger ${trigger.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "CreateTrigger", error.code);
+    logConsoleError(`Error while creating trigger ${trigger.id}:\n ${error.message}`);
+    logError(error.message, "CreateTrigger", error.code);
     sendNotificationForError(error);
     throw error;
   } finally {

src/Common/dataAccess/createUserDefinedFunction.ts

@@ -9,9 +9,8 @@ import {
   createUpdateSqlUserDefinedFunction,
   getSqlUserDefinedFunction
 } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function createUserDefinedFunction(
@@ -66,9 +65,11 @@ export async function createUserDefinedFunction(
       .scripts.userDefinedFunctions.create(userDefinedFunction);
     return response?.resource;
   } catch (error) {
-    logConsoleError(`Error while creating user defined function ${userDefinedFunction.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "CreateUserupdateUserDefinedFunction", error.code);
-    sendNotificationForError(error);
+    handleError(
+      error,
+      `Error while creating user defined function ${userDefinedFunction.id}`,
+      "CreateUserupdateUserDefinedFunction"
+    );
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/deleteCollection.ts

@@ -5,9 +5,8 @@ import { deleteCassandraTable } from "../../Utils/arm/generatedClients/2020-04-0
 import { deleteMongoDBCollection } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { deleteGremlinGraph } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { deleteTable } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
-import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 import { client } from "../CosmosClient";
 import { refreshCachedResources } from "../DataAccessUtilityBase";
@@ -23,15 +22,14 @@ export async function deleteCollection(databaseId: string, collectionId: string)
         .container(collectionId)
         .delete();
     }
+    logConsoleInfo(`Successfully deleted container ${collectionId}`);
+    await refreshCachedResources();
   } catch (error) {
-    logConsoleError(`Error while deleting container ${collectionId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "DeleteCollection", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while deleting container ${collectionId}`, "DeleteCollection");
     throw error;
+  } finally {
+    clearMessage();
   }
-  logConsoleInfo(`Successfully deleted container ${collectionId}`);
-  clearMessage();
-  await refreshCachedResources();
 }
 
 function deleteCollectionWithARM(databaseId: string, collectionId: string): Promise<void> {

src/Common/dataAccess/deleteDatabase.ts

@@ -4,12 +4,11 @@ import { deleteSqlDatabase } from "../../Utils/arm/generatedClients/2020-04-01/s
 import { deleteCassandraKeyspace } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { deleteMongoDBDatabase } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { deleteGremlinDatabase } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 import { client } from "../CosmosClient";
 import { refreshCachedResources } from "../DataAccessUtilityBase";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
 
 export async function deleteDatabase(databaseId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting database ${databaseId}`);
@@ -25,15 +24,14 @@ export async function deleteDatabase(databaseId: string): Promise<void> {
         .database(databaseId)
         .delete();
     }
+    logConsoleInfo(`Successfully deleted database ${databaseId}`);
+    await refreshCachedResources();
   } catch (error) {
-    logConsoleError(`Error while deleting database ${databaseId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "DeleteDatabase", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while deleting database ${databaseId}`, "DeleteDatabase");
     throw error;
+  } finally {
+    clearMessage();
   }
-  logConsoleInfo(`Successfully deleted database ${databaseId}`);
-  clearMessage();
-  await refreshCachedResources();
 }
 
 function deleteDatabaseWithARM(databaseId: string): Promise<void> {

src/Common/dataAccess/deleteStoredProcedure.ts

@@ -1,9 +1,8 @@
 import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
 import { deleteSqlStoredProcedure } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function deleteStoredProcedure(
@@ -30,9 +29,7 @@ export async function deleteStoredProcedure(
         .delete();
     }
   } catch (error) {
-    logConsoleError(`Error while deleting stored procedure ${storedProcedureId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "DeleteStoredProcedure", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while deleting stored procedure ${storedProcedureId}`, "DeleteStoredProcedure");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/deleteTrigger.ts

@@ -1,9 +1,8 @@
 import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
 import { deleteSqlTrigger } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function deleteTrigger(databaseId: string, collectionId: string, triggerId: string): Promise<void> {
@@ -26,9 +25,7 @@ export async function deleteTrigger(databaseId: string, collectionId: string, tr
         .delete();
     }
   } catch (error) {
-    logConsoleError(`Error while deleting trigger ${triggerId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "DeleteTrigger", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while deleting trigger ${triggerId}`, "DeleteTrigger");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/deleteUserDefinedFunction.ts

@@ -1,9 +1,8 @@
 import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
 import { deleteSqlUserDefinedFunction } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function deleteUserDefinedFunction(databaseId: string, collectionId: string, id: string): Promise<void> {
@@ -26,9 +25,7 @@ export async function deleteUserDefinedFunction(databaseId: string, collectionId
         .delete();
     }
   } catch (error) {
-    logConsoleError(`Error while deleting user defined function ${id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "DeleteUserDefinedFunction", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while deleting user defined function ${id}`, "DeleteUserDefinedFunction");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readCollection.ts

@@ -1,8 +1,7 @@
 import * as DataModels from "../../Contracts/DataModels";
 import { client } from "../CosmosClient";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 
 export async function readCollection(databaseId: string, collectionId: string): Promise<DataModels.Collection> {
   let collection: DataModels.Collection;
@@ -14,9 +13,7 @@ export async function readCollection(databaseId: string, collectionId: string):
       .read();
     collection = response.resource as DataModels.Collection;
   } catch (error) {
-    logConsoleError(`Error while querying container ${collectionId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadCollection", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying container ${collectionId}`, "ReadCollection");
     throw error;
   }
   clearMessage();

src/Common/dataAccess/readCollectionOffer.ts

@@ -4,15 +4,14 @@ import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType
 import { HttpHeaders } from "../Constants";
 import { RequestOptions } from "@azure/cosmos/dist-esm";
 import { client } from "../CosmosClient";
+import { handleError } from "../ErrorHandlingUtils";
 import { getSqlContainerThroughput } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { getMongoDBCollectionThroughput } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { getCassandraTableThroughput } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { getGremlinGraphThroughput } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { getTableThroughput } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { readOffers } from "./readOffers";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export const readCollectionOffer = async (
@@ -57,9 +56,7 @@ export const readCollectionOffer = async (
       }
     );
   } catch (error) {
-    logConsoleError(`Error while querying offer for collection ${params.collectionId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadCollectionOffer", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying offer for collection ${params.collectionId}`, "ReadCollectionOffer");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readCollectionQuotaInfo.ts

@@ -5,9 +5,8 @@ import { ContainerDefinition, Resource } from "@azure/cosmos";
 import { HttpHeaders } from "../Constants";
 import { RequestOptions } from "@azure/cosmos/dist-esm";
 import { client } from "../CosmosClient";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 
 interface ResourceWithStatistics {
   statistics: DataModels.Statistic[];
@@ -38,9 +37,7 @@ export const readCollectionQuotaInfo = async (
 
     return quota;
   } catch (error) {
-    logConsoleError(`Error while querying quota info for container ${collection.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadCollectionQuotaInfo", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying quota info for container ${collection.id}`, "ReadCollectionQuotaInfo");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readCollections.ts

@@ -2,18 +2,16 @@ import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
 import { client } from "../CosmosClient";
+import { handleError } from "../ErrorHandlingUtils";
 import { listSqlContainers } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { listCassandraTables } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { listMongoDBCollections } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { listGremlinGraphs } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { listTables } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function readCollections(databaseId: string): Promise<DataModels.Collection[]> {
-  let collections: DataModels.Collection[];
   const clearMessage = logConsoleProgress(`Querying containers for database ${databaseId}`);
   try {
     if (
@@ -22,22 +20,20 @@ export async function readCollections(databaseId: string): Promise<DataModels.Co
       userContext.defaultExperience !== DefaultAccountExperienceType.MongoDB &&
       userContext.defaultExperience !== DefaultAccountExperienceType.Table
     ) {
-      collections = await readCollectionsWithARM(databaseId);
-    } else {
-      const sdkResponse = await client()
-        .database(databaseId)
-        .containers.readAll()
-        .fetchAll();
-      collections = sdkResponse.resources as DataModels.Collection[];
+      return await readCollectionsWithARM(databaseId);
     }
+
+    const sdkResponse = await client()
+      .database(databaseId)
+      .containers.readAll()
+      .fetchAll();
+    return sdkResponse.resources as DataModels.Collection[];
   } catch (error) {
-    logConsoleError(`Error while querying containers for database ${databaseId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadCollections", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying containers for database ${databaseId}`, "ReadCollections");
     throw error;
+  } finally {
+    clearMessage();
   }
-  clearMessage();
-  return collections;
 }
 
 async function readCollectionsWithARM(databaseId: string): Promise<DataModels.Collection[]> {

src/Common/dataAccess/readDatabaseOffer.ts

@@ -8,10 +8,9 @@ import { getSqlDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-
 import { getMongoDBDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { getCassandraKeyspaceThroughput } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { getGremlinDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { readOffers } from "./readOffers";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export const readDatabaseOffer = async (
@@ -48,9 +47,7 @@ export const readDatabaseOffer = async (
       }
     );
   } catch (error) {
-    logConsoleError(`Error while querying offer for database ${params.databaseId}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadDatabaseOffer", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying offer for database ${params.databaseId}`, "ReadDatabaseOffer");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readDatabases.ts

@@ -2,13 +2,12 @@ import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
 import { client } from "../CosmosClient";
+import { handleError } from "../ErrorHandlingUtils";
 import { listSqlDatabases } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { listCassandraKeyspaces } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { listMongoDBDatabases } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { listGremlinDatabases } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function readDatabases(): Promise<DataModels.Database[]> {
@@ -28,9 +27,7 @@ export async function readDatabases(): Promise<DataModels.Database[]> {
       databases = sdkResponse.resources as DataModels.Database[];
     }
   } catch (error) {
-    logConsoleError(`Error while querying databases:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadDatabases", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying databases`, "ReadDatabases");
     throw error;
   }
   clearMessage();

src/Common/dataAccess/readOffers.ts

@@ -3,10 +3,9 @@ import { ClientDefaults } from "../Constants";
 import { MessageTypes } from "../../Contracts/ExplorerContracts";
 import { Platform, configContext } from "../../ConfigContext";
 import { client } from "../CosmosClient";
-import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { sendCachedDataMessage } from "../MessageHandler";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export const readOffers = async (): Promise<Offer[]> => {
@@ -36,9 +35,7 @@ export const readOffers = async (): Promise<Offer[]> => {
       return [];
     }
 
-    logConsoleError(`Error while querying offers:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadOffers", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while querying offers`, "ReadOffers");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readStoredProcedures.ts

@@ -1,10 +1,9 @@
 import { AuthType } from "../../AuthType";
 import { Resource, StoredProcedureDefinition } from "@azure/cosmos";
 import { client } from "../CosmosClient";
+import { handleError } from "../ErrorHandlingUtils";
 import { listSqlStoredProcedures } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function readStoredProcedures(
@@ -31,9 +30,7 @@ export async function readStoredProcedures(
       .fetchAll();
     return response?.resources;
   } catch (error) {
-    logConsoleError(`Failed to query stored procedures for container ${collectionId}: ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadStoredProcedures", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Failed to query stored procedures for container ${collectionId}`, "ReadStoredProcedures");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readTriggers.ts

@@ -2,10 +2,9 @@ import { AuthType } from "../../AuthType";
 import { Resource, TriggerDefinition } from "@azure/cosmos";
 import { client } from "../CosmosClient";
 import { listSqlTriggers } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
+import { handleError } from "../ErrorHandlingUtils";
 
 export async function readTriggers(
   databaseId: string,
@@ -31,9 +30,7 @@ export async function readTriggers(
       .fetchAll();
     return response?.resources;
   } catch (error) {
-    logConsoleError(`Failed to query triggers for container ${collectionId}: ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadTriggers", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Failed to query triggers for container ${collectionId}`, "ReadTriggers");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/readUserDefinedFunctions.ts

@@ -1,10 +1,9 @@
 import { AuthType } from "../../AuthType";
 import { Resource, UserDefinedFunctionDefinition } from "@azure/cosmos";
 import { client } from "../CosmosClient";
+import { handleError } from "../ErrorHandlingUtils";
 import { listSqlUserDefinedFunctions } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function readUserDefinedFunctions(
@@ -31,9 +30,11 @@ export async function readUserDefinedFunctions(
       .fetchAll();
     return response?.resources;
   } catch (error) {
-    logConsoleError(`Failed to query user defined functions for container ${collectionId}: ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "ReadUserDefinedFunctions", error.code);
-    sendNotificationForError(error);
+    handleError(
+      error,
+      `Failed to query user defined functions for container ${collectionId}`,
+      "ReadUserDefinedFunctions"
+    );
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/sendNotificationForError.ts

@@ -2,7 +2,7 @@ import * as Constants from "../Constants";
 import { sendMessage } from "../MessageHandler";
 import { MessageTypes } from "../../Contracts/ExplorerContracts";
 
-interface CosmosError {
+export interface CosmosError {
   code: number;
   message?: string;
 }

src/Common/dataAccess/updateCollection.ts

@@ -23,10 +23,9 @@ import {
   getGremlinGraph
 } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { createUpdateTable, getTable } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
-import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { refreshCachedResources } from "../DataAccessUtilityBase";
-import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export async function updateCollection(
@@ -58,9 +57,7 @@ export async function updateCollection(
     await refreshCachedResources();
     return collection;
   } catch (error) {
-    logConsoleError(`Failed to update container ${collectionId}: ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "UpdateCollection", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Failed to update container ${collectionId}`, "UpdateCollection");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/updateOffer.ts

@@ -6,12 +6,11 @@ import { OfferDefinition } from "@azure/cosmos";
 import { RequestOptions } from "@azure/cosmos/dist-esm";
 import { ThroughputSettingsUpdateParameters } from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
-import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { readCollectionOffer } from "./readCollectionOffer";
 import { readDatabaseOffer } from "./readDatabaseOffer";
 import { refreshCachedOffers, refreshCachedResources } from "../DataAccessUtilityBase";
-import { sendNotificationForError } from "./sendNotificationForError";
 import {
   updateSqlDatabaseThroughput,
   migrateSqlDatabaseToAutoscale,
@@ -76,9 +75,7 @@ export const updateOffer = async (params: UpdateOfferParams): Promise<Offer> =>
     logConsoleInfo(`Successfully updated offer for ${offerResourceText}`);
     return updatedOffer;
   } catch (error) {
-    logConsoleError(`Error updating offer for ${offerResourceText}: ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "UpdateCollection", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error updating offer for ${offerResourceText}`, "UpdateCollection");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/updateStoredProcedure.ts

@@ -9,9 +9,8 @@ import {
   createUpdateSqlStoredProcedure,
   getSqlStoredProcedure
 } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function updateStoredProcedure(
@@ -60,10 +59,7 @@ export async function updateStoredProcedure(
       .replace(storedProcedure);
     return response?.resource;
   } catch (error) {
-    const errorMessage = error.code === "NotFound" ? `${storedProcedure.id} does not exist.` : JSON.stringify(error);
-    logConsoleError(`Error while updating stored procedure ${storedProcedure.id}:\n ${errorMessage}`);
-    logError(errorMessage, "UpdateStoredProcedure", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while updating stored procedure ${storedProcedure.id}`, "UpdateStoredProcedure");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/updateTrigger.ts

@@ -6,9 +6,8 @@ import {
 import { TriggerDefinition } from "@azure/cosmos";
 import { client } from "../CosmosClient";
 import { createUpdateSqlTrigger, getSqlTrigger } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function updateTrigger(
@@ -57,10 +56,7 @@ export async function updateTrigger(
       .replace(trigger);
     return response?.resource;
   } catch (error) {
-    const errorMessage = error.code === "NotFound" ? `${trigger.id} does not exist.` : JSON.stringify(error);
-    logConsoleError(`Error while updating trigger ${trigger.id}:\n ${errorMessage}`);
-    logError(errorMessage, "UpdateTrigger", error.code);
-    sendNotificationForError(error);
+    handleError(error, `Error while updating trigger ${trigger.id}`, "UpdateTrigger");
     throw error;
   } finally {
     clearMessage();

src/Common/dataAccess/updateUserDefinedFunction.ts

@@ -9,9 +9,8 @@ import {
   createUpdateSqlUserDefinedFunction,
   getSqlUserDefinedFunction
 } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { logError } from "../Logger";
-import { sendNotificationForError } from "./sendNotificationForError";
+import { handleError } from "../ErrorHandlingUtils";
+import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 
 export async function updateUserDefinedFunction(
@@ -60,11 +59,11 @@ export async function updateUserDefinedFunction(
       .replace(userDefinedFunction);
     return response?.resource;
   } catch (error) {
-    const errorMessage =
-      error.code === "NotFound" ? `${userDefinedFunction.id} does not exist.` : JSON.stringify(error);
-    logConsoleError(`Error while updating user defined function ${userDefinedFunction.id}:\n ${errorMessage}`);
-    logError(errorMessage, "UpdateUserupdateUserDefinedFunction", error.code);
-    sendNotificationForError(error);
+    handleError(
+      error,
+      `Error while updating user defined function ${userDefinedFunction.id}`,
+      "UpdateUserupdateUserDefinedFunction"
+    );
     throw error;
   } finally {
     clearMessage();