fix: [@W-18962100@] fix client config for trace server (#92)

* fix: separate logger channel from extension channel

* chore: fix tests

* chore: setup nls support for package text

* chore: config alignment fixes

* chore: simplify applying client config to server

* chore: where is trace

* chore: let vscode client fully control output

* chore: fix missing labels

Author: peternhale

packages/apex-ls-node/src/index.ts

@@ -40,13 +40,24 @@ import {
   setLogNotificationHandler,
   getLogger,
   setLoggerFactory,
+  setLogLevel,
 } from '@salesforce/apex-lsp-logging';
 
 import { NodeLogNotificationHandler } from './utils/NodeLogNotificationHandler';
 import { LSPLoggerFactory } from './utils/LSPLoggerFactory';
 import { NodeFileSystemApexStorage } from './storage/NodeFileSystemApexStorage';
 import { createNodeApexLibAdapter } from './utils/NodeApexLibAdapter';
 
+/**
+ * Interface for server initialization options
+ */
+interface ApexServerInitializationOptions {
+  logLevel?: string;
+  enableDocumentSymbols?: boolean;
+  trace?: string;
+  [key: string]: any;
+}
+
 export function startServer() {
   // Create a connection for the server based on command line arguments
   let connection: Connection;
@@ -95,6 +106,17 @@ export function startServer() {
   connection.onInitialize((params: InitializeParams): InitializeResult => {
     logger.info('Apex Language Server initializing...');
 
+    // Extract and set log level from initialization options
+    const initOptions = params.initializationOptions as
+      | ApexServerInitializationOptions
+      | undefined;
+    const logLevel = initOptions?.logLevel || 'error';
+
+    logger.info(`Setting log level to: ${logLevel}`);
+
+    // Set the log level in the logging system
+    setLogLevel(logLevel);
+
     // Process initialization parameters and settings
     configurationManager.processInitializeParams(params);
 
@@ -136,9 +158,6 @@ export function startServer() {
     // Register for configuration changes
     configurationManager.registerForConfigurationChanges();
 
-    // Request initial configuration from client
-    configurationManager.requestConfiguration();
-
     // Register the apexlib/resolve request handler
     connection.onRequest('apexlib/resolve', async (params) => {
       logger.debug(

packages/apex-ls-node/src/utils/LSPLoggerFactory.ts

@@ -19,6 +19,37 @@ import {
  * configured LogNotificationHandler to the LSP client.
  */
 class LSPLogger implements LoggerInterface {
+  /**
+   * Formats a timestamp in the format [5:46:20 AM]
+   * @returns Formatted timestamp string
+   */
+  private formatTimestamp(): string {
+    const now = new Date();
+    const timeString = now.toLocaleTimeString('en-US', {
+      hour: 'numeric',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: true,
+    });
+    return `[${timeString}]`;
+  }
+
+  /**
+   * Formats a message type in the format [INFO]
+   * @param messageType The message type to format
+   * @returns Formatted message type string
+   */
+  private formatMessageType(messageType: LogMessageType): string {
+    const typeMap: Record<LogMessageType, string> = {
+      debug: '[DEBUG]',
+      info: '[INFO]',
+      log: '[LOG]',
+      warning: '[WARNING]',
+      error: '[ERROR]',
+    };
+    return typeMap[messageType] || `[${messageType.toUpperCase()}]`;
+  }
+
   /**
    * Logs a message with the specified type.
    * @param messageType The LSP message type.
@@ -33,29 +64,31 @@ class LSPLogger implements LoggerInterface {
       return;
     }
 
-    const message =
+    const rawMessage =
       typeof messageOrProvider === 'function'
         ? messageOrProvider()
         : messageOrProvider;
-    const handler = getLogNotificationHandler();
 
-    // Add ISO timestamp and log level to every message
-    const timestamp = new Date().toISOString();
-    const logLevel = messageType.toUpperCase();
-    const messageWithTimestamp = `[${timestamp}] [${logLevel}] ${message}`;
+    // Format the message with timestamp and message type prefix
+    const timestamp = this.formatTimestamp();
+    const typePrefix = this.formatMessageType(messageType);
+    const message = `${timestamp} ${typePrefix} ${rawMessage}`;
+
+    const handler = getLogNotificationHandler();
 
+    // Send the formatted message to the LSP client
     if (handler && typeof handler.sendLogMessage === 'function') {
       // For backward compatibility, map debug to log for older LSP clients
       const mappedType = messageType === 'debug' ? 'log' : messageType;
       handler.sendLogMessage({
         type: mappedType,
-        message: messageWithTimestamp,
+        message,
       });
     } else {
       const fallbackType = messageType.toString();
       console.warn(
         '[LSPLogger] LogNotificationHandler not available or invalid. ' +
-          `Fallback log (${fallbackType}): ${messageWithTimestamp}`,
+          `Fallback log (${fallbackType}): ${message}`,
       );
     }
   }

packages/apex-ls-node/test/index.test.ts

@@ -247,6 +247,7 @@ jest.mock('@salesforce/apex-lsp-logging', () => ({
   setLogNotificationHandler: jest.fn(),
   getLogger: () => mockLogger,
   setLoggerFactory: jest.fn(),
+  setLogLevel: jest.fn(),
   LogLevel: {
     Error: 'ERROR',
     Warn: 'WARN',