feat: improve logging messages

Author: seanwu1105

src/designer/create-ui.ts

@@ -5,15 +5,11 @@ import { FileType, workspace } from 'vscode'
 import type { URI } from 'vscode-uri'
 import type { CommandDeps } from '../commands'
 import { getTargetDocumentUri } from '../commands'
-import type { ExecError, StdErrError } from '../run'
 import { run } from '../run'
 import { getToolCommand$ } from '../tool-utils'
 import type { ErrorResult, SuccessResult } from '../types'
 
-export async function createUi(
-  { extensionUri }: CommandDeps,
-  ...args: any[]
-): Promise<CreateUiResult> {
+export async function createUi({ extensionUri }: CommandDeps, ...args: any[]) {
   const targetDocumentUriResult = getTargetDocumentUri(...args)
 
   if (targetDocumentUriResult.kind !== 'Success') return targetDocumentUriResult
@@ -43,14 +39,6 @@ export async function createUi(
   })
 }
 
-type CreateUiResult =
-  | SuccessResult<string>
-  | ExecError
-  | StdErrError
-  | ErrorResult<'NotFound'>
-  | ErrorResult<'Type'>
-  | ErrorResult<'IO'>
-
 async function getDirectoryPath(uri: URI): Promise<GetDirectoryPathResult> {
   let stat: FileStat
   try {

src/designer/edit-ui.ts

@@ -1,15 +1,10 @@
 import { firstValueFrom } from 'rxjs'
 import type { CommandDeps } from '../commands'
 import { getTargetDocumentUri } from '../commands'
-import type { ExecError, StdErrError } from '../run'
 import { run } from '../run'
 import { getToolCommand$ } from '../tool-utils'
-import type { ErrorResult, SuccessResult } from '../types'
 
-export async function editUi(
-  { extensionUri }: CommandDeps,
-  ...args: any[]
-): Promise<EditUiResult> {
+export async function editUi({ extensionUri }: CommandDeps, ...args: any[]) {
   const targetDocumentUriResult = getTargetDocumentUri(...args)
 
   if (targetDocumentUriResult.kind !== 'Success') return targetDocumentUriResult
@@ -34,10 +29,3 @@ export async function editUi(
     ],
   })
 }
-
-type EditUiResult =
-  | SuccessResult<string>
-  | ExecError
-  | StdErrError
-  | ErrorResult<'NotFound'>
-  | ErrorResult<'Type'>

src/extension.ts

@@ -11,6 +11,8 @@ import type { ErrorResult, SuccessResult } from './types'
 import { registerUicLiveExecution$ } from './uic/uic-live-execution'
 import { toDisposable } from './utils'
 
+const JSON_INDENT = 2
+
 export async function activate({
   extensionUri,
   subscriptions,
@@ -33,7 +35,15 @@ export async function activate({
       onResultReceived(
         {
           kind: 'UnexpectedError',
-          message: `Unexpected error: ${JSON.stringify(e)}`,
+          message: `${JSON.stringify(e, null, JSON_INDENT)}`,
+        },
+        outputChannel,
+      ),
+    complete: () =>
+      onResultReceived(
+        {
+          kind: 'Success',
+          value: 'An observable is completed',
         },
         outputChannel,
       ),
@@ -46,9 +56,11 @@ export async function activate({
           catchError((err: unknown, caught$) => {
             return of({
               kind: 'UnexpectedError',
-              message: `Unexpected error: ${JSON.stringify(
+              message: `${JSON.stringify(
                 err,
-              )} (caught: ${JSON.stringify(caught$)})`,
+                null,
+                JSON_INDENT,
+              )}\n(caught: ${JSON.stringify(caught$, null, JSON_INDENT)})`,
             } as const)
           }),
         )
@@ -60,20 +72,22 @@ export async function activate({
 }
 
 function onResultReceived(result: Result, outputChannel: OutputChannel) {
-  const indent = 2
   switch (result.kind) {
     case 'Success':
       return outputChannel.appendLine(
         prefixLogging({
-          message: JSON.stringify(result.value, null, indent),
+          message:
+            typeof result.value === 'string'
+              ? result.value
+              : JSON.stringify(result.value, null, JSON_INDENT),
           severity: 'INFO',
         }),
       )
     case 'ParseError':
     case 'TypeError':
     case 'NotFoundError':
     case 'UnexpectedError':
-      return showError(result.message, outputChannel)
+      return showError(`${result.kind}: ${result.message}`, outputChannel)
     case 'ExecError':
       return showError(
         `${result.stderr}\n${result.stdout}\n${result.error.message ?? ''}`,

src/python.ts

@@ -22,7 +22,7 @@ export function resolveScriptCommand$({
           ...result.value,
           path.join(extensionUri.fsPath, 'python', 'scripts', `${tool}.py`),
         ],
-      }
+      } as const
     }),
   )
 }
@@ -37,9 +37,7 @@ export type ResolveScriptCommandResult =
   | SuccessResult<CommandArgs>
   | ErrorResult<'NotFound'>
 
-function getPythonInterpreterPath$(
-  resource: URI | undefined,
-): Observable<GetPythonInterpreterPathResult> {
+function getPythonInterpreterPath$(resource: URI | undefined) {
   return defer(async () => getPythonExtensionApi()).pipe(
     concatMap(result => {
       if (result.kind !== 'Success') return of(result)
@@ -61,7 +59,7 @@ type GetPythonInterpreterPathResult =
   | SuccessResult<CommandArgs>
   | ErrorResult<'NotFound'>
 
-async function getPythonExtensionApi(): Promise<GetPythonExtensionApiResult> {
+async function getPythonExtensionApi() {
   const pythonExtensionApi = await extensions
     .getExtension<PythonExtensionApi>('ms-python.python')
     ?.activate()
@@ -70,42 +68,31 @@ async function getPythonExtensionApi(): Promise<GetPythonExtensionApiResult> {
     return {
       kind: 'NotFoundError',
       message: 'Python extension not found.',
-    }
+    } as const
 
   await pythonExtensionApi.ready
 
-  return { kind: 'Success', value: pythonExtensionApi }
+  return { kind: 'Success', value: pythonExtensionApi } as const
 }
 
-type GetPythonExtensionApiResult =
-  | SuccessResult<PythonExtensionApi>
-  | ErrorResult<'NotFound'>
-
-function getPythonExecCommand({
-  api,
-  resource,
-}: GetPythonExecCommandArgs): GetPythonExecCommandResult {
+function getPythonExecCommand({ api, resource }: GetPythonExecCommandArgs) {
   const command = api.settings.getExecutionDetails(resource).execCommand
 
   if (isNil(command) || command.length === 0)
     return {
       kind: 'NotFoundError',
       message:
         'Python interpreter cannot could not be retrieved from the Python extension.',
-    }
+    } as const
 
-  return { kind: 'Success', value: [...command] }
+  return { kind: 'Success', value: [...command] } as const
 }
 
 type GetPythonExecCommandArgs = {
   readonly api: PythonExtensionApi
   readonly resource: URI | undefined
 }
 
-type GetPythonExecCommandResult =
-  | SuccessResult<string[]>
-  | ErrorResult<'NotFound'>
-
 // Excerpt from: https://github.com/microsoft/vscode-python/blob/344c912a1c15d07eb9b14bf749c7529a7fa0877b/src/client/apiTypes.ts
 type PythonExtensionApi = {
   ready: Promise<void>

src/qmlls/client.ts

@@ -20,15 +20,14 @@ import {
 } from 'vscode-languageclient/node'
 import type { URI } from 'vscode-uri'
 import { getEnabledFromConfig$ } from '../configurations'
-import type { CommandArgs, ExecError, StdErrError } from '../run'
+import type { CommandArgs } from '../run'
 import { run, wrapAndJoinCommandArgsWithQuotes } from '../run'
 import { getToolCommand$ } from '../tool-utils'
-import type { ErrorResult, SuccessResult } from '../types'
 
 export function registerQmlLanguageServer$({
   extensionUri,
   outputChannel,
-}: RegisterQmlLanguageServerArgs): Observable<RegisterQmlLanguageServerResult> {
+}: RegisterQmlLanguageServerArgs) {
   const client$ = new ReplaySubject<LanguageClient | undefined>(1)
 
   const createClient$ = getToolCommand$({
@@ -67,9 +66,9 @@ export function registerQmlLanguageServer$({
                 await client?.start()
                 return {
                   kind: 'Success',
-                  value: `qmlls is enabled with latest config: ${JSON.stringify(
-                    result.value,
-                  )}`,
+                  value: `qmlls is running with the command: '${wrapAndJoinCommandArgsWithQuotes(
+                    [...result.value.command, ...result.value.options],
+                  )}'`,
                 } as const
               }),
             ),
@@ -83,7 +82,7 @@ export function registerQmlLanguageServer$({
       if (!enabled)
         return defer(async () => {
           client$.next(undefined)
-          return { kind: 'Success', value: 'qmlls is disabled' } as const
+          return { kind: 'Success', value: 'qmlls has been stopped' } as const
         })
 
       return createClient$
@@ -96,12 +95,6 @@ type RegisterQmlLanguageServerArgs = {
   readonly outputChannel: OutputChannel
 }
 
-type RegisterQmlLanguageServerResult =
-  | ErrorResult<'NotFound'>
-  | ExecError
-  | StdErrError
-  | SuccessResult<string>
-
 async function checkQmllsExists(command: CommandArgs) {
   return run({ command: [...command, '--help'] })
 }

src/rcc/compile-resource.ts

@@ -1,15 +1,13 @@
 import { firstValueFrom } from 'rxjs'
 import type { CommandDeps } from '../commands'
 import { getTargetDocumentUri } from '../commands'
-import type { ExecError, StdErrError } from '../run'
 import { run } from '../run'
 import { getToolCommand$ } from '../tool-utils'
-import type { ErrorResult, SuccessResult } from '../types'
 
 export async function compileResource(
   { extensionUri }: CommandDeps,
   ...args: any[]
-): Promise<CompileResourceResult> {
+) {
   const targetDocumentUriResult = getTargetDocumentUri(...args)
 
   if (targetDocumentUriResult.kind !== 'Success') return targetDocumentUriResult
@@ -34,10 +32,3 @@ export async function compileResource(
     ],
   })
 }
-
-type CompileResourceResult =
-  | SuccessResult<string>
-  | ExecError
-  | StdErrError
-  | ErrorResult<'NotFound'>
-  | ErrorResult<'Type'>

src/run.ts

@@ -5,36 +5,54 @@ import { exec } from 'node:child_process'
 import type { SuccessResult } from './types'
 import { notNil } from './utils'
 
-export async function run({ command, cwd }: RunArgs): Promise<RunResult> {
+export async function run({ command, cwd }: RunArgs) {
+  const commandString = wrapAndJoinCommandArgsWithQuotes(command)
+
   return new Promise<RunResult>(resolve => {
-    exec(
-      wrapAndJoinCommandArgsWithQuotes(command),
-      { cwd },
-      (error, stdout, stderr) => {
-        if (notNil(error)) resolve({ kind: 'ExecError', error, stdout, stderr })
-        if (stderr.length !== 0)
-          resolve({ kind: 'StdErrError', stdout, stderr })
-        resolve({ kind: 'Success', value: stdout })
-      },
-    )
+    exec(commandString, { cwd }, (error, stdout, stderr) => {
+      if (notNil(error))
+        resolve({
+          kind: 'ExecError',
+          command: commandString,
+          error,
+          stdout,
+          stderr,
+        })
+      if (stderr.length !== 0)
+        resolve({ kind: 'StdErrError', command: commandString, stdout, stderr })
+      resolve({
+        kind: 'Success',
+        value: {
+          stdout,
+          command: commandString,
+        },
+      })
+    })
   })
 }
 
 type RunArgs = { readonly command: CommandArgs; readonly cwd?: string }
 
 export type CommandArgs = readonly string[]
 
-export type RunResult = SuccessResult<string> | ExecError | StdErrError
+export type RunResult = SuccessResult<RunSuccessValue> | ExecError | StdErrError
+
+type RunSuccessValue = {
+  readonly stdout: string
+  readonly command: string
+}
 
 export type ExecError = {
   readonly kind: 'ExecError'
+  readonly command: string
   readonly error: Partial<ExecException>
   readonly stdout: string
   readonly stderr: string
 }
 
 export type StdErrError = {
   readonly kind: 'StdErrError'
+  readonly command: string
   readonly stdout: string
   readonly stderr: string
 }

src/test/suite/run.test.ts

@@ -18,19 +18,24 @@ suite('run', () => {
   suite(
     'when execute cat command to read exist file with spaces in filename',
     () => {
-      setup(async () => {
-        const filePath = path.resolve(
-          TEST_ASSETS_PATH,
-          'filename with spaces.txt',
-        )
-
-        if (process.platform === 'win32')
-          result = await run({ command: ['type', filePath] })
-        else result = await run({ command: ['cat', filePath] })
-      })
+      const filePath = path.resolve(
+        TEST_ASSETS_PATH,
+        'filename with spaces.txt',
+      )
+
+      const command =
+        process.platform === 'win32' ? ['type', filePath] : ['cat', filePath]
+
+      setup(async () => (result = await run({ command })))
 
       test('should return Success with contents', async () => {
-        const expected: RunResult = { kind: 'Success', value: 'hello' }
+        const expected: RunResult = {
+          kind: 'Success',
+          value: {
+            stdout: 'hello',
+            command: wrapAndJoinCommandArgsWithQuotes(command),
+          },
+        }
         assert.deepStrictEqual(result, expected)
       })
     },