refactor(logger): deeply nested objects fail to show up in logs.

packages/core/src/codewhispererChat/controllers/chat/controller.ts

@@ -53,6 +53,7 @@ import { uiEventRecorder } from '../../../amazonq/util/eventRecorder'
 import { globals } from '../../../shared'
 import { telemetry } from '../../../shared/telemetry'
 import { isSsoConnection } from '../../../auth/connection'
+import { inspect } from '../../../shared/utilities/collectionUtils'
 
 export interface ChatControllerMessagePublishers {
     readonly processPromptChatMessage: MessagePublisher<PromptMessage>
@@ -624,7 +625,9 @@ export class ChatController {
                     triggerPayload.relevantTextDocuments = await LspController.instance.query(triggerPayload.message)
                     triggerPayload.relevantTextDocuments.forEach((doc) => {
                         getLogger().info(
-                            `amazonq: Using workspace files ${doc.relativeFilePath}, content(partial): ${doc.text?.substring(0, 200)}`
+                            `amazonq: Using workspace files ${
+                                doc.relativeFilePath
+                            }, content(partial): ${doc.text?.substring(0, 200)}`
                         )
                     })
                     triggerPayload.projectContextQueryLatencyMs = performance.now() - start
@@ -650,7 +653,11 @@ export class ChatController {
 
         const request = triggerPayloadToChatRequest(triggerPayload)
         const session = this.sessionStorage.getSession(tabID)
-        getLogger().info(`request from tab: ${tabID} conversationID: ${session.sessionIdentifier} request: %O`, request)
+        getLogger().info(
+            `request from tab: ${tabID} conversationID: ${session.sessionIdentifier} request: ${inspect(request, {
+                depth: 12,
+            })}`
+        )
         let response: MessengerResponseType | undefined = undefined
         session.createNewTokenSource()
         try {
@@ -675,8 +682,7 @@ export class ChatController {
             getLogger().info(
                 `response to tab: ${tabID} conversationID: ${session.sessionIdentifier} requestID: ${
                     response.$metadata.requestId
-                } metadata: %O`,
-                response.$metadata
+                } metadata: ${inspect(response.$metadata, { depth: 12 })}`
             )
             await this.messenger.sendAIResponse(response, session, tabID, triggerID, triggerPayload)
         } catch (e: any) {

packages/core/src/shared/utilities/collectionUtils.ts

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { isWeb } from '../extensionGlobals'
+import { InspectOptions as nodeInspectOptions, inspect as nodeInspect } from 'util'
 import { AsyncCollection, toCollection } from './asyncCollection'
 import { SharedProp, AccumulableKeys, Coalesce, isNonNullable } from './tsUtils'
 
@@ -297,7 +299,6 @@
  * - depth=2 returns `obj` with its children and their children.
  * - and so on...
  *
- * TODO: node's `util.inspect()` function is better, but doesn't work in web browser?
  *
  * @param obj Object to clone.
  * @param depth
@@ -329,6 +330,31 @@
     return clonedObj
 }
 
+type inspectOptions = Partial<
+    nodeInspectOptions & {
+        omitKeys: string[]
+        replacement: any
+    }
+>
+
+/**
+ * Wrapper around nodes inspect function that works on web. Defaults to JSON.stringify on web.
+ * @param obj object to show
+ * @param opt options for showing (ex. depth, omitting keys)
+ */
+export function inspect(obj: any, opt?: inspectOptions): string {
+    const options = {
+        depth: opt?.depth ?? 3,
+        omitKeys: opt?.omitKeys ?? [],
+        replacement: opt?.replacement,
+        showHidden: opt?.showHidden ?? false,
+        color: opt?.colors ?? false,
+    }
+    return isWeb()
+        ? JSON.stringify(partialClone(obj, options.depth, options.omitKeys, options.replacement), undefined, 2)
+        : nodeInspect(obj, options)
+}
+
 /** Recursively delete undefined key/value pairs */
 export function stripUndefined<T extends Record<string, any>>(
     obj: T
@@ -365,7 +391,7 @@
     TResponse,
     TTokenProp extends SharedProp<TRequest, TResponse>,
     TTokenType extends TRequest[TTokenProp] & TResponse[TTokenProp],
-    TResult extends AccumulableKeys<TResponse> = never,
+    TResult extends AccumulableKeys<TResponse> = never
 >(
     requester: (request: TRequest) => Promise<TResponse>,
     request: TRequest,

packages/core/src/test/shared/utilities/collectionUtils.test.ts

@@ -31,6 +31,7 @@ import {
     joinAll,
     isPresent,
     partialClone,
+    inspect,
 } from '../../../shared/utilities/collectionUtils'
 
 import { asyncGenerator } from '../../../shared/utilities/collectionUtils'
@@ -511,7 +512,7 @@ describe('CollectionUtils', async function () {
         const requester = async (request: { next?: string }) => pages[request.next ?? 'page1']
 
         it('creates a new AsyncCollection', async function () {
-            const collection = pageableToCollection(requester, {}, 'next', 'data')
+            const collection = pageableToCollection(requester, {}, 'next' as never, 'data')
             assert.deepStrictEqual(await collection.promise(), [[0, 1, 2], [3, 4], [5], []])
         })
 
@@ -540,7 +541,7 @@ describe('CollectionUtils', async function () {
 
         describe('last', function () {
             it('it persists last element when mapped', async function () {
-                const collection = pageableToCollection(requester, {}, 'next', 'data')
+                const collection = pageableToCollection(requester, {}, 'next' as never, 'data')
                 const mapped = collection.map((i) => i[0] ?? -1)
                 assert.strictEqual(await last(mapped), -1)
             })
@@ -679,6 +680,36 @@ describe('CollectionUtils', async function () {
         })
     })
 
+    describe('inspect', function () {
+        let testData: any
+        before(function () {
+            testData = {
+                root: {
+                    A: {
+                        B: {
+                            C: {
+                                D: {
+                                    E: 'data',
+                                },
+                            },
+                        },
+                    },
+                },
+            }
+        })
+
+        it('defaults to a depth of 3', function () {
+            assert.strictEqual(inspect(testData), '{\n  root: { A: { B: { C: [Object] } } }\n}')
+        })
+
+        it('allows depth to be set manually', function () {
+            assert.strictEqual(
+                inspect(testData, { depth: 6 }),
+                "{\n  root: {\n    A: {\n      B: { C: { D: { E: 'data' } } }\n    }\n  }\n}"
+            )
+        })
+    })
+
     describe('partialClone', function () {
         it('omits properties by depth', function () {
             const testObj = {