Clean up error naming (#624)

ejizba · ejizba · commit 60d4fba15c66 · 2022-08-25T18:27:00.000-07:00
diff --git a/src/LegacyFunctionLoader.ts b/src/LegacyFunctionLoader.ts
@@ -3,9 +3,9 @@
 
 import { FunctionCallback } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
+import { AzFuncSystemError } from './errors';
 import { loadScriptFile } from './loadScriptFile';
 import { PackageJson } from './parsers/parsePackageJson';
-import { InternalException } from './utils/InternalException';
 import { nonNullProp } from './utils/nonNull';
 import { RegisteredFunction } from './WorkerChannel';
 
@@ -40,7 +40,7 @@ export class LegacyFunctionLoader implements ILegacyFunctionLoader {
                 callback: loadedFunction.callback.bind(loadedFunction.thisArg),
             };
         } else {
-            throw new InternalException(`Function code for '${functionId}' is not loaded and cannot be invoked.`);
+            throw new AzFuncSystemError(`Function code for '${functionId}' is not loaded and cannot be invoked.`);
         }
     }
 }
@@ -72,9 +72,9 @@ function getEntryPoint(f: any, entryPoint?: string): [FunctionCallback, unknown]
             'If multiple functions are exported, ' +
             "you must indicate the entry point, either by naming it 'run' or 'index', or by naming it " +
             "explicitly via the 'entryPoint' metadata property.";
-        throw new InternalException(msg);
+        throw new AzFuncSystemError(msg);
     } else if (typeof f !== 'function') {
-        throw new InternalException(
+        throw new AzFuncSystemError(
             'The resolved entry point is not a function and cannot be invoked by the functions runtime. Make sure the function has been correctly exported.'
         );
     }
diff --git a/src/Worker.ts b/src/Worker.ts
@@ -2,13 +2,12 @@
 // Licensed under the MIT License.
 
 import * as parseArgs from 'minimist';
+import { AzFuncSystemError, ensureErrorType } from './errors';
 import { CreateGrpcEventStream } from './GrpcClient';
 import { LegacyFunctionLoader } from './LegacyFunctionLoader';
 import { setupCoreModule } from './setupCoreModule';
 import { setupEventStream } from './setupEventStream';
 import { startBlockedMonitor } from './utils/blockedMonitor';
-import { ensureErrorType } from './utils/ensureErrorType';
-import { InternalException } from './utils/InternalException';
 import { systemError, systemLog } from './utils/Logger';
 import { isEnvironmentVariableSet } from './utils/util';
 import { WorkerChannel } from './WorkerChannel';
@@ -27,7 +26,7 @@ export function startNodeWorker(args) {
         if (!requestId) debugInfo.push(`'requestId' is ${requestId}`);
         if (!grpcMaxMessageLength) debugInfo.push(`'grpcMaxMessageLength' is ${grpcMaxMessageLength}`);
 
-        throw new InternalException(`gRPC client connection info is missing or incorrect (${debugInfo.join(', ')}).`);
+        throw new AzFuncSystemError(`gRPC client connection info is missing or incorrect (${debugInfo.join(', ')}).`);
     }
 
     const connection = `${host}:${port}`;
@@ -38,7 +37,7 @@ export function startNodeWorker(args) {
         eventStream = CreateGrpcEventStream(connection, parseInt(grpcMaxMessageLength));
     } catch (err) {
         const error = ensureErrorType(err);
-        error.isAzureFunctionsInternalException = true;
+        error.isAzureFunctionsSystemError = true;
         error.message = 'Error creating GRPC event stream: ' + error.message;
         throw error;
     }
@@ -57,7 +56,7 @@ export function startNodeWorker(args) {
     process.on('uncaughtException', (err: unknown) => {
         const error = ensureErrorType(err);
         let errorMessage: string;
-        if (error.isAzureFunctionsInternalException) {
+        if (error.isAzureFunctionsSystemError) {
             errorMessage = `Worker ${workerId} uncaught exception: ${error.stack || err}`;
         } else {
             errorMessage = `Worker ${workerId} uncaught exception (learn more: https://go.microsoft.com/fwlink/?linkid=2097909 ): ${
diff --git a/src/WorkerChannel.ts b/src/WorkerChannel.ts
@@ -4,10 +4,10 @@
 import { FunctionCallback, HookCallback, HookContext, HookData, ProgrammingModel } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
 import { Disposable } from './Disposable';
+import { AzFuncRangeError, AzFuncSystemError, ensureErrorType } from './errors';
 import { IEventStream } from './GrpcClient';
 import { ILegacyFunctionLoader } from './LegacyFunctionLoader';
 import { PackageJson, parsePackageJson } from './parsers/parsePackageJson';
-import { ensureErrorType } from './utils/ensureErrorType';
 import LogLevel = rpc.RpcLog.Level;
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 
@@ -27,7 +27,7 @@ export class WorkerChannel {
 
     get hostVersion(): string {
         if (!this._hostVersion) {
-            throw new Error('Trying to access hostVersion before it is set.');
+            throw new AzFuncSystemError('Cannot access hostVersion before worker init');
         } else {
             return this._hostVersion;
         }
@@ -116,7 +116,7 @@ export class WorkerChannel {
             case 'appTerminate':
                 return this.#appTerminateHooks;
             default:
-                throw new RangeError(`Unrecognized hook "${hookName}"`);
+                throw new AzFuncRangeError(`Unrecognized hook "${hookName}"`);
         }
     }
 
diff --git a/src/coreApi/converters/handleDefaultEnumCase.ts b/src/coreApi/converters/handleDefaultEnumCase.ts
@@ -1,13 +1,15 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License.
 
+import { AzFuncRangeError } from '../../errors';
+
 export function handleDefaultEnumCase(data: undefined | null | string, typeName: string): undefined | null {
     switch (data) {
         case undefined:
             return undefined;
         case null:
             return null;
         default:
-            throw new RangeError(`Unexpected value "${data}" for type "${typeName}"`);
+            throw new AzFuncRangeError(`Unexpected value "${data}" for type "${typeName}"`);
     }
 }
diff --git a/src/coreApi/registerFunction.ts b/src/coreApi/registerFunction.ts
@@ -5,7 +5,7 @@ import { FunctionCallback, FunctionMetadata } from '@azure/functions-core';
 import { v4 as uuid } from 'uuid';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { Disposable } from '../Disposable';
-import { InternalException } from '../utils/InternalException';
+import { AzFuncSystemError } from '../errors';
 import { WorkerChannel } from '../WorkerChannel';
 import { fromCoreFunctionMetadata } from './converters/fromCoreFunctionMetadata';
 
@@ -15,7 +15,7 @@ export function registerFunction(
     callback: FunctionCallback
 ): Disposable {
     if (channel.hasIndexedFunctions) {
-        throw new InternalException('A function can only be registered during app startup.');
+        throw new AzFuncSystemError('A function can only be registered during app startup.');
     }
     const functionId = uuid();
 
@@ -33,7 +33,7 @@ export function registerFunction(
 
     return new Disposable(() => {
         if (channel.hasIndexedFunctions) {
-            throw new InternalException('A function can only be disposed during app startup.');
+            throw new AzFuncSystemError('A function can only be disposed during app startup.');
         } else {
             delete channel.functions[functionId];
         }
diff --git a/src/errors.ts b/src/errors.ts
@@ -0,0 +1,54 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License.
+
+export interface AzFuncError {
+    /**
+     * System errors can be tracked in our telemetry
+     * User errors cannot be tracked in our telemetry because they could have user information (users can still track it themselves in their app insights resource)
+     */
+    isAzureFunctionsSystemError: boolean;
+}
+
+export class AzFuncSystemError extends Error {
+    isAzureFunctionsSystemError = true;
+}
+
+export class AzFuncTypeError extends TypeError implements AzFuncError {
+    isAzureFunctionsSystemError = true;
+}
+
+export class AzFuncRangeError extends RangeError implements AzFuncError {
+    isAzureFunctionsSystemError = true;
+}
+
+export class ReadOnlyError extends AzFuncTypeError {
+    constructor(propertyName: string) {
+        super(`Cannot assign to read only property '${propertyName}'`);
+    }
+}
+
+export function ensureErrorType(err: unknown): Error & Partial<AzFuncError> {
+    if (err instanceof Error) {
+        return err;
+    } else {
+        let message: string;
+        if (err === undefined || err === null) {
+            message = 'Unknown error';
+        } else if (typeof err === 'string') {
+            message = err;
+        } else if (typeof err === 'object') {
+            message = JSON.stringify(err);
+        } else {
+            message = String(err);
+        }
+        return new Error(message);
+    }
+}
+
+/**
+ * This is mostly for callbacks where `null` or `undefined` indicates there is no error
+ * By contrast, anything thrown/caught is assumed to be an error regardless of what it is
+ */
+export function isError(err: unknown): boolean {
+    return err !== null && err !== undefined;
+}
diff --git a/src/eventHandlers/FunctionLoadHandler.ts b/src/eventHandlers/FunctionLoadHandler.ts
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
-import { ensureErrorType } from '../utils/ensureErrorType';
+import { ensureErrorType } from '../errors';
 import { nonNullProp } from '../utils/nonNull';
 import { WorkerChannel } from '../WorkerChannel';
 import { EventHandler } from './EventHandler';
@@ -27,7 +27,7 @@ export class FunctionLoadHandler extends EventHandler<'functionLoadRequest', 'fu
                 await channel.legacyFunctionLoader.load(functionId, metadata, channel.packageJson);
             } catch (err) {
                 const error = ensureErrorType(err);
-                error.isAzureFunctionsInternalException = true;
+                error.isAzureFunctionsSystemError = true;
                 error.message = `Worker was unable to load function ${metadata.name}: '${error.message}'`;
                 throw error;
             }
diff --git a/src/eventHandlers/InvocationHandler.ts b/src/eventHandlers/InvocationHandler.ts
@@ -18,9 +18,8 @@ import { fromCoreInvocationResponse } from '../coreApi/converters/fromCoreInvoca
 import { fromCoreLogCategory, fromCoreLogLevel } from '../coreApi/converters/fromCoreStatusResult';
 import { toCoreFunctionMetadata } from '../coreApi/converters/toCoreFunctionMetadata';
 import { toCoreInvocationRequest } from '../coreApi/converters/toCoreInvocationRequest';
-import { isError } from '../utils/ensureErrorType';
+import { isError, ReadOnlyError } from '../errors';
 import { nonNullProp } from '../utils/nonNull';
-import { ReadOnlyError } from '../utils/ReadOnlyError';
 import { WorkerChannel } from '../WorkerChannel';
 import { EventHandler } from './EventHandler';
 
diff --git a/src/eventHandlers/WorkerInitHandler.ts b/src/eventHandlers/WorkerInitHandler.ts
@@ -5,8 +5,8 @@ import { access, constants } from 'fs';
 import * as path from 'path';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { version as workerVersion } from '../constants';
+import { isError } from '../errors';
 import { startApp } from '../startApp';
-import { isError } from '../utils/ensureErrorType';
 import { nonNullProp } from '../utils/nonNull';
 import { WorkerChannel } from '../WorkerChannel';
 import { EventHandler } from './EventHandler';
diff --git a/src/eventHandlers/terminateWorker.ts b/src/eventHandlers/terminateWorker.ts
@@ -3,7 +3,7 @@
 
 import { AppTerminateContext } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
-import { ReadOnlyError } from '../utils/ReadOnlyError';
+import { ReadOnlyError } from '../errors';
 import { WorkerChannel } from '../WorkerChannel';
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 import LogLevel = rpc.RpcLog.Level;
diff --git a/src/loadScriptFile.ts b/src/loadScriptFile.ts
@@ -2,8 +2,8 @@
 // Licensed under the MIT License.
 
 import * as url from 'url';
+import { AzFuncSystemError } from './errors';
 import { PackageJson } from './parsers/parsePackageJson';
-import { InternalException } from './utils/InternalException';
 
 export async function loadScriptFile(filePath: string, packageJson: PackageJson): Promise<unknown> {
     let script: unknown;
@@ -13,7 +13,7 @@ export async function loadScriptFile(filePath: string, packageJson: PackageJson)
             // use eval so it doesn't get compiled into a require()
             script = await eval('import(fileUrl.href)');
         } else {
-            throw new InternalException(`'${filePath}' could not be converted to file URL (${fileUrl.href})`);
+            throw new AzFuncSystemError(`'${filePath}' could not be converted to file URL (${fileUrl.href})`);
         }
     } else {
         script = require(/* webpackIgnore: true */ filePath);
diff --git a/src/parsers/parsePackageJson.ts b/src/parsers/parsePackageJson.ts
@@ -3,7 +3,7 @@
 
 import { pathExists, readJson } from 'fs-extra';
 import * as path from 'path';
-import { ensureErrorType } from '../utils/ensureErrorType';
+import { AzFuncSystemError, ensureErrorType } from '../errors';
 
 export interface PackageJson {
     type?: string;
@@ -17,12 +17,12 @@ export async function parsePackageJson(dir: string): Promise<PackageJson> {
     try {
         const filePath = path.join(dir, 'package.json');
         if (!(await pathExists(filePath))) {
-            throw new Error('file does not exist');
+            throw new AzFuncSystemError('file does not exist');
         }
 
         const data: unknown = await readJson(filePath);
         if (typeof data !== 'object' || data === null || Array.isArray(data)) {
-            throw new Error('file content is not an object');
+            throw new AzFuncSystemError('file content is not an object');
         }
 
         const stringFields = ['main', 'type'];
diff --git a/src/setupEventStream.ts b/src/setupEventStream.ts
@@ -2,15 +2,14 @@
 // Licensed under the MIT License.
 
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
+import { AzFuncSystemError, ensureErrorType } from './errors';
 import { EventHandler, SupportedRequest } from './eventHandlers/EventHandler';
 import { FunctionEnvironmentReloadHandler } from './eventHandlers/FunctionEnvironmentReloadHandler';
 import { FunctionLoadHandler } from './eventHandlers/FunctionLoadHandler';
 import { FunctionsMetadataHandler } from './eventHandlers/FunctionsMetadataHandler';
 import { InvocationHandler } from './eventHandlers/InvocationHandler';
 import { terminateWorker } from './eventHandlers/terminateWorker';
 import { WorkerInitHandler } from './eventHandlers/WorkerInitHandler';
-import { ensureErrorType } from './utils/ensureErrorType';
-import { InternalException } from './utils/InternalException';
 import { systemError } from './utils/Logger';
 import { nonNullProp } from './utils/nonNull';
 import { WorkerChannel } from './WorkerChannel';
@@ -30,7 +29,7 @@ export function setupEventStream(workerId: string, channel: WorkerChannel): void
 
     channel.eventStream.on('error', function (err) {
         systemError(`Worker ${workerId} encountered event stream error: `, err);
-        throw new InternalException(err);
+        throw new AzFuncSystemError(err);
     });
 
     // wrap event stream write to validate message correctness
@@ -39,7 +38,7 @@ export function setupEventStream(workerId: string, channel: WorkerChannel): void
         const msgError = rpc.StreamingMessage.verify(msg);
         if (msgError) {
             systemError(`Worker ${workerId} malformed message`, msgError);
-            throw new InternalException(msgError);
+            throw new AzFuncSystemError(msgError);
         }
         oldWrite.apply(channel.eventStream, [msg]);
     };
@@ -90,7 +89,7 @@ async function handleMessage(workerId: string, channel: WorkerChannel, inMsg: rp
                 // Not yet implemented
                 return;
             default:
-                throw new InternalException(`Worker ${workerId} had no handler for message '${eventName}'`);
+                throw new AzFuncSystemError(`Worker ${workerId} had no handler for message '${eventName}'`);
         }
 
         request = nonNullProp(inMsg, eventName);
@@ -99,7 +98,7 @@ async function handleMessage(workerId: string, channel: WorkerChannel, inMsg: rp
         outMsg[eventHandler.responseName] = response;
     } catch (err) {
         const error = ensureErrorType(err);
-        if (error.isAzureFunctionsInternalException) {
+        if (error.isAzureFunctionsSystemError) {
             channel.log({
                 message: error.message,
                 level: LogLevel.Error,
diff --git a/src/startApp.ts b/src/startApp.ts
@@ -3,9 +3,8 @@
 
 import { AppStartContext } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
+import { AzFuncSystemError, ensureErrorType, ReadOnlyError } from './errors';
 import { loadScriptFile } from './loadScriptFile';
-import { ensureErrorType } from './utils/ensureErrorType';
-import { ReadOnlyError } from './utils/ReadOnlyError';
 import { WorkerChannel } from './WorkerChannel';
 import globby = require('globby');
 import path = require('path');
@@ -47,7 +46,7 @@ async function loadEntryPointFile(functionAppDirectory: string, channel: WorkerC
         try {
             const files = await globby(entryPointPattern, { cwd: functionAppDirectory });
             if (files.length === 0) {
-                throw new Error(`Found zero files matching the supplied pattern`);
+                throw new AzFuncSystemError(`Found zero files matching the supplied pattern`);
             }
 
             for (const file of files) {
@@ -65,7 +64,7 @@ async function loadEntryPointFile(functionAppDirectory: string, channel: WorkerC
             }
         } catch (err) {
             const error = ensureErrorType(err);
-            error.isAzureFunctionsInternalException = true;
+            error.isAzureFunctionsSystemError = true;
             error.message = `Worker was unable to load entry point "${entryPointPattern}": ${error.message}`;
             throw error;
         }
diff --git a/src/utils/InternalException.ts b/src/utils/InternalException.ts
diff --git a/src/utils/ReadOnlyError.ts b/src/utils/ReadOnlyError.ts
diff --git a/src/utils/ensureErrorType.ts b/src/utils/ensureErrorType.ts
diff --git a/src/utils/nonNull.ts b/src/utils/nonNull.ts
diff --git a/test/errors.test.ts b/test/errors.test.ts
