feat: generalize performance logging into utility

Author: Hweinstock

packages/core/src/shared/clients/clientWrapper.ts

@@ -8,6 +8,8 @@ import { AwsClient, AwsClientConstructor, AwsCommand, AwsCommandConstructor } fr
 import { PaginationConfiguration, Paginator } from '@aws-sdk/types'
 import { AsyncCollection, toCollection } from '../utilities/asyncCollection'
 import { isDefined } from '../utilities/tsUtils'
+import { withPerfLogOnFail } from '../logger/perfLogger'
+import { truncateProps } from '../utilities/textUtilities'
 
 type SDKPaginator<C, CommandInput extends object, CommandOutput extends object> = (
     config: Omit<PaginationConfiguration, 'client'> & { client: C },
@@ -35,7 +37,14 @@ export abstract class ClientWrapper<C extends AwsClient> implements vscode.Dispo
         CommandOptions extends CommandInput,
         Command extends AwsCommand<CommandInput, CommandOutput>,
     >(command: AwsCommandConstructor<CommandInput, Command>, commandOptions: CommandOptions): Promise<CommandOutput> {
-        return await this.getClient().send(new command(commandOptions))
+        const makeRequest = withPerfLogOnFail(
+            'API Request',
+            () => this.getClient().send(new command(commandOptions)),
+            truncateProps(commandOptions, 20, ['nextToken']),
+            mapNameToCode
+        )
+
+        return makeRequest()
     }
 
     protected makePaginatedRequest<CommandInput extends object, CommandOutput extends object, Output extends object>(
@@ -65,3 +74,7 @@ export abstract class ClientWrapper<C extends AwsClient> implements vscode.Dispo
         this.client?.destroy()
     }
 }
+
+function mapNameToCode<E extends Error>(e: E): E & { code: string } {
+    return { ...e, message: e.message, name: e.name, stack: e.stack, code: e.message }
+}

packages/core/src/shared/logger/perfLogger.ts

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ToolkitError } from '../errors'
 import { getLogger } from './logger'
 
 export class PerfLog {
@@ -27,3 +28,39 @@ export class PerfLog {
         this.log.verbose('%s took %dms', this.topic, elapsed.toFixed(1))
     }
 }
+
+/**
+ * Call a function f and if it fails, log the error with performance information included.
+ * @param action label of action in the error log.
+ * @param f action to attempt.
+ * @param params params that were passed to f.
+ * @param errMap optional mapping to apply to error to potentially add information.
+ * @returns result of f
+ */
+export function withPerfLogOnFail<Result, E extends Error = never>(
+    action: string,
+    f: () => Result | Promise<Result>,
+    params: object = {},
+    errMap?: (e: Error) => E
+) {
+    return async function () {
+        const perflog = new PerfLog(action)
+        try {
+            return await f()
+        } catch (e) {
+            if (e instanceof Error) {
+                const errWithoutStack = errMap ? errMap(e) : { ...e }
+                delete errWithoutStack['stack']
+                const timecost = perflog.elapsed().toFixed(1)
+                getLogger().error(
+                    `${action} failed (time: %dms) \nparams: %O\nerror: %O`,
+                    timecost,
+                    params,
+                    errWithoutStack
+                )
+                throw new ToolkitError(`${action}: ${e.message}`, { code: e.message, cause: e })
+            }
+            throw e
+        }
+    }
+}