Add configurable logging levels to control debug message visibility (#3)

* Initial plan

* Implement logging level options functionality

Co-authored-by: HeyItsGilbert <615265+HeyItsGilbert@users.noreply.github.com>

* Add Unreleased section to changelog with logging levels feature

Co-authored-by: HeyItsGilbert <615265+HeyItsGilbert@users.noreply.github.com>

---------

Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: HeyItsGilbert <615265+HeyItsGilbert@users.noreply.github.com>

Author: Copilot

CHANGELOG.md

@@ -6,6 +6,18 @@ in this file.
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 to structure this file.
 
+## [Unreleased]
+
+### Added
+- Configurable logging levels to control debug message visibility
+  - New `powershellLocalization.logLevel` setting with four hierarchical levels:
+    - `error` - Only error messages
+    - `warn` - Error and warning messages
+    - `info` - Error, warning, and info messages (default)
+    - `debug` - All messages including debug output
+  - Smart log filtering that respects the configured log level
+  - Debug messages are now filtered out by default, providing cleaner output
+
 ## [0.1.0] Initial Release
 
 - Foundational script `LocalizationParser` looks for `psm1` that container

package.json

@@ -67,6 +67,17 @@
             "**/.git/**"
           ],
           "description": "Configure glob patterns for excluding directories and files from PowerShell module scanning."
+        },
+        "powershellLocalization.logLevel": {
+          "type": "string",
+          "enum": [
+            "error",
+            "warn", 
+            "info",
+            "debug"
+          ],
+          "default": "info",
+          "description": "Set the logging level for the PowerShell Localization extension. Debug logs are only shown when set to 'debug'."
         }
       }
     }

src/configuration.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { ExtensionConfig } from './types';
+import { ExtensionConfig, LogLevel } from './types';
 import { CONFIGURATION_BASENAME } from './utils';
 
 /**
@@ -20,7 +20,8 @@ export class ConfigurationManager {
         '**/out/**',
         '**/dist/**',
         '**/.git/**'
-      ])
+      ]),
+      logLevel: config.get<LogLevel>('logLevel', 'info')
     };
   }
 
@@ -45,6 +46,13 @@ export class ConfigurationManager {
     return this.getConfiguration().searchExclude;
   }
 
+  /**
+   * Gets the current log level
+   */
+  public static getLogLevel(): LogLevel {
+    return this.getConfiguration().logLevel;
+  }
+
   /**
    * Registers configuration change listener
    */

src/logger.ts

@@ -1,12 +1,20 @@
 import * as vscode from 'vscode';
 import { EXTENSION_NAME, Utils } from './utils';
+import { LogLevel } from './types';
+import { ConfigurationManager } from './configuration';
 
 /**
  * Logging utility for the PowerShell Localization extension
  */
 export class Logger {
   private static instance: Logger;
   private outputChannel: vscode.OutputChannel;
+  private static readonly LOG_LEVELS: Record<LogLevel, number> = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3
+  };
 
   private constructor() {
     this.outputChannel = vscode.window.createOutputChannel(EXTENSION_NAME);
@@ -22,36 +30,52 @@ export class Logger {
     return Logger.instance;
   }
 
+  /**
+   * Checks if a message should be logged based on the current log level
+   */
+  private shouldLog(messageLevel: LogLevel): boolean {
+    const currentLevel = ConfigurationManager.getLogLevel();
+    return Logger.LOG_LEVELS[messageLevel] <= Logger.LOG_LEVELS[currentLevel];
+  }
+
   /**
    * Logs an informational message
    */
   public info(message: string): void {
-    this.outputChannel.appendLine(`[INFO] ${Utils.formatTimestamp()}: ${message}`);
+    if (this.shouldLog('info')) {
+      this.outputChannel.appendLine(`[INFO] ${Utils.formatTimestamp()}: ${message}`);
+    }
   }
 
   /**
    * Logs an error message
    */
   public error(message: string, error?: Error): void {
-    const errorMessage = error ? `${message}: ${error.message}` : message;
-    this.outputChannel.appendLine(`[ERROR] ${Utils.formatTimestamp()}: ${errorMessage}`);
-    if (error?.stack) {
-      this.outputChannel.appendLine(`Stack trace: ${error.stack}`);
+    if (this.shouldLog('error')) {
+      const errorMessage = error ? `${message}: ${error.message}` : message;
+      this.outputChannel.appendLine(`[ERROR] ${Utils.formatTimestamp()}: ${errorMessage}`);
+      if (error?.stack) {
+        this.outputChannel.appendLine(`Stack trace: ${error.stack}`);
+      }
     }
   }
 
   /**
    * Logs a warning message
    */
   public warn(message: string): void {
-    this.outputChannel.appendLine(`[WARN] ${Utils.formatTimestamp()}: ${message}`);
+    if (this.shouldLog('warn')) {
+      this.outputChannel.appendLine(`[WARN] ${Utils.formatTimestamp()}: ${message}`);
+    }
   }
 
   /**
    * Logs a debug message
    */
   public debug(message: string): void {
-    this.outputChannel.appendLine(`[DEBUG] ${Utils.formatTimestamp()}: ${message}`);
+    if (this.shouldLog('debug')) {
+      this.outputChannel.appendLine(`[DEBUG] ${Utils.formatTimestamp()}: ${message}`);
+    }
   }
 
   /**

src/test/extension.test.ts

@@ -231,6 +231,21 @@ Write-Host $LocalizedData.Key2
 			});
 		});
 
+		test('Should have log level configuration', () => {
+			const config = vscode.workspace.getConfiguration('powershellLocalization');
+
+			// Test that the log level configuration exists
+			const logLevel = config.get('logLevel');
+			assert.strictEqual(typeof logLevel, 'string', 'logLevel should be a string');
+
+			// Check that it's one of the valid values
+			const validLevels = ['error', 'warn', 'info', 'debug'];
+			assert.ok(validLevels.includes(logLevel as string), 'logLevel should be one of the valid values');
+
+			// Check default value
+			assert.strictEqual(logLevel, 'info', 'Default log level should be info');
+		});
+
 		test('Should respect configuration changes', async () => {
 			const config = vscode.workspace.getConfiguration('powershellLocalization');
 			const originalValue = config.get('enableInlineValues');
@@ -430,4 +445,47 @@ function Test-Function {
 				'No paths should be excluded when patterns array is empty');
 		});
 	});
+
+	suite('Logger Functionality', () => {
+		test('Should respect log level configuration for debug messages', () => {
+			// This test verifies the logger respects the log level setting
+			// Since we can't easily mock the configuration in this test environment,
+			// we'll test the log level logic conceptually
+
+			const logLevels = ['error', 'warn', 'info', 'debug'];
+			const logLevelPriorities = { error: 0, warn: 1, info: 2, debug: 3 };
+
+			// Test that debug messages should be filtered when log level is info
+			const currentLevel = 'info';
+			const debugLevel = 'debug';
+			
+			const shouldShowDebug = logLevelPriorities[debugLevel] <= logLevelPriorities[currentLevel];
+			assert.strictEqual(shouldShowDebug, false, 'Debug messages should not show when log level is info');
+
+			// Test that info messages should show when log level is info
+			const infoLevel = 'info';
+			const shouldShowInfo = logLevelPriorities[infoLevel] <= logLevelPriorities[currentLevel];
+			assert.strictEqual(shouldShowInfo, true, 'Info messages should show when log level is info');
+
+			// Test that error messages always show
+			const errorLevel = 'error';
+			const shouldShowError = logLevelPriorities[errorLevel] <= logLevelPriorities[currentLevel];
+			assert.strictEqual(shouldShowError, true, 'Error messages should always show');
+		});
+
+		test('Should have valid log level hierarchy', () => {
+			const logLevels = ['error', 'warn', 'info', 'debug'];
+			const logLevelPriorities = { error: 0, warn: 1, info: 2, debug: 3 };
+
+			// Verify hierarchy is correct (lower numbers = higher priority)
+			assert.ok(logLevelPriorities.error < logLevelPriorities.warn, 'Error should have higher priority than warn');
+			assert.ok(logLevelPriorities.warn < logLevelPriorities.info, 'Warn should have higher priority than info');
+			assert.ok(logLevelPriorities.info < logLevelPriorities.debug, 'Info should have higher priority than debug');
+
+			// Verify all levels are represented
+			logLevels.forEach(level => {
+				assert.ok(level in logLevelPriorities, `Log level ${level} should be in priorities`);
+			});
+		});
+	});
 });

src/types.ts

@@ -17,4 +17,7 @@ export interface ExtensionConfig {
   enableInlineValues: boolean;
   enableDecorations: boolean;
   searchExclude: string[];
+  logLevel: LogLevel;
 }
+
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';