Merge pull request #86 from austb/logging_class

Add Logger and a setting to manage all log output

Author: jpogran

client/package.json

@@ -104,6 +104,11 @@
           "type":"string",
           "default": "",
           "description": "Set the local Puppet Language Server to send debug information to a file"
+        },
+        "puppet.languageclient.minimumUserLogLevel": {
+          "type": "string",
+          "default": "normal",
+          "description": "Set the minimum log level that the user will see on the Puppet OutputChannel (Allowed values: verbose, debug, normal, warning, error)"
         }
       }
     }

client/src/commands/puppetResourceCommand.ts

@@ -3,6 +3,7 @@
 import * as vscode from 'vscode';
 import { PuppetResourceRequestParams, PuppetResourceRequest } from '../messages';
 import { IConnectionManager, ConnectionStatus } from '../connection';
+import { Logger } from '../logging';
 
 class RequestParams implements PuppetResourceRequestParams {
   typename: string;
@@ -11,9 +12,11 @@ class RequestParams implements PuppetResourceRequestParams {
 
 export class puppetResourceCommand {
   private _connectionManager: IConnectionManager = undefined;
+  private logger: Logger = undefined;
 
-  constructor(connMgr: IConnectionManager) {
+  constructor(connMgr: IConnectionManager, logger: Logger) {
     this._connectionManager = connMgr;
+    this.logger = logger;
   }
 
   private pickPuppetResource(): Thenable<string> {
@@ -47,8 +50,7 @@ export class puppetResourceCommand {
           .sendRequest(PuppetResourceRequest.type, requestParams)
           .then( (resourceResult) => {
             if (resourceResult.error != undefined && resourceResult.error.length > 0) {
-            // TODO Log any errors
-              console.error(resourceResult.error);
+              this.logger.error(resourceResult.error);
               return;
             }
             if (resourceResult.data == undefined || resourceResult.data.length == 0) return;

client/src/connection.ts

@@ -2,6 +2,7 @@ import net = require('net');
 import path = require('path');
 import vscode = require('vscode');
 import cp = require('child_process');
+import { Logger } from '../src/logging';
 import { LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-languageclient';
 import { setupPuppetCommands } from '../src/puppetcommands';
 import * as messages from '../src/messages';
@@ -43,9 +44,9 @@ export class ConnectionManager implements IConnectionManager {
   private connectionConfiguration: IConnectionConfiguration;
   private languageServerClient: LanguageClient = undefined;
   private languageServerProcess = undefined;
-  private puppetOutputChannel = undefined;
   private extensionContext = undefined;
   private commandsRegistered = false;
+  private logger: Logger = undefined;
 
   public get status() : ConnectionStatus {
     return this.connectionStatus;
@@ -54,9 +55,8 @@ export class ConnectionManager implements IConnectionManager {
     return this.languageServerClient;
   }
 
-  constructor(context: vscode.ExtensionContext) {
-    this.puppetOutputChannel = vscode.window.createOutputChannel('Puppet');
-    
+  constructor(context: vscode.ExtensionContext, logger: Logger) {
+    this.logger = logger;
     this.extensionContext = context;
   }
 
@@ -67,10 +67,9 @@ export class ConnectionManager implements IConnectionManager {
     var contextPath = this.extensionContext.asAbsolutePath(path.join('vendor', 'languageserver', 'puppet-languageserver'));
 
     if (!this.commandsRegistered) {
-      this.puppetOutputChannel.appendLine('Configuring commands');
-      console.log('Configuring commands');
+      this.logger.debug('Configuring commands');
 
-      setupPuppetCommands(langID, this, this.extensionContext);
+      setupPuppetCommands(langID, this, this.extensionContext, this.logger);
       this.commandsRegistered = true;
     }
 
@@ -89,7 +88,7 @@ export class ConnectionManager implements IConnectionManager {
     this.setConnectionStatus("Starting Puppet...", ConnectionStatus.Starting);
 
     if (this.connectionConfiguration.type == ConnectionType.Local) {
-      this.languageServerProcess = this.createLanguageServerProcess(contextPath, this.puppetOutputChannel);
+      this.languageServerProcess = this.createLanguageServerProcess(contextPath);
       if (this.languageServerProcess == undefined) {
         if (this.connectionStatus == ConnectionStatus.Failed) {
           // We've already handled this state.  Just return
@@ -99,8 +98,7 @@ export class ConnectionManager implements IConnectionManager {
       }
 
       this.languageServerProcess.stdout.on('data', (data) => {
-        console.log("OUTPUT: " + data.toString());
-        this.puppetOutputChannel.appendLine("OUTPUT: " + data.toString());
+        this.logger.debug("OUTPUT: " + data.toString());
 
         // If the language client isn't already running and it's sent the trigger text, start up a client
         if ( (this.languageServerClient == undefined) && (data.toString().match("LANGUAGE SERVER RUNNING") != null) ) {
@@ -110,22 +108,19 @@ export class ConnectionManager implements IConnectionManager {
       });
 
       this.languageServerProcess.on('close', (exitCode) => {
-        console.log("SERVER terminated with exit code: " + exitCode);
-        this.puppetOutputChannel.appendLine("SERVER terminated with exit code: " + exitCode);
+        this.logger.debug("SERVER terminated with exit code: " + exitCode);
       });
     }
     else {
       this.languageServerClient = this.startLangClientTCP();
       this.extensionContext.subscriptions.push(this.languageServerClient.start());
     }
 
-    console.log('Congratulations, your extension "vscode-puppet" is now active!');
-    this.puppetOutputChannel.appendLine('Congratulations, your extension "vscode-puppet" is now active!');
+    this.logger.debug('Congratulations, your extension "vscode-puppet" is now active!');
   }
 
   public stop() {
-    console.log('Stopping...');
-    this.puppetOutputChannel.appendLine('Stopping...')
+    this.logger.debug('Stopping...')
 
     if (this.connectionStatus === ConnectionStatus.Failed) {
       this.languageServerClient = undefined;
@@ -150,14 +145,12 @@ export class ConnectionManager implements IConnectionManager {
     }
 
     this.connectionStatus = ConnectionStatus.NotStarted;
-    
-    console.log('Stopped');
-    this.puppetOutputChannel.appendLine('Stopped');
+
+    this.logger.debug('Stopped');
   }
 
   public dispose() : void {
-    console.log('Disposing...');
-    this.puppetOutputChannel.appendLine('Disposing...');
+    this.logger.debug('Disposing...');
     // Stop the current session
     this.stop();
 
@@ -166,8 +159,8 @@ export class ConnectionManager implements IConnectionManager {
     this.extensionContext.subscriptions.clear();
   }
 
-  private createLanguageServerProcess(serverExe: string, myOutputChannel: vscode.OutputChannel) {
-    myOutputChannel.appendLine('Language server found at: ' + serverExe)
+  private createLanguageServerProcess(serverExe: string) {
+    this.logger.debug('Language server found at: ' + serverExe)
 
     let cmd: string = undefined;
     let args = [serverExe];
@@ -208,7 +201,7 @@ export class ConnectionManager implements IConnectionManager {
         };
         break;
       default:
-        myOutputChannel.appendLine('Starting language server')
+        this.logger.debug('Starting language server')
 
         // Try and find the puppet-agent ruby
         let rubyPath: string = '/opt/puppetlabs/puppet/bin/ruby';
@@ -241,17 +234,15 @@ export class ConnectionManager implements IConnectionManager {
       args.push('--debug=' + this.connectionConfiguration.debugFilePath);
     }
 
-    console.log("Starting the language server with " + cmd + " " + args.join(" "));
-    myOutputChannel.appendLine("Starting the language server with " + cmd + " " + args.join(" "));
+    this.logger.debug("Starting the language server with " + cmd + " " + args.join(" "));
     var proc = cp.spawn(cmd, args, options)
-    console.log("ProcID = " + proc.pid);
-    myOutputChannel.appendLine('Language server PID:' + proc.pid)
+    this.logger.debug('Language server PID:' + proc.pid)
 
     return proc;
   }
 
   private startLangClientTCP(): LanguageClient {
-    this.puppetOutputChannel.appendLine('Configuring language server options')
+    this.logger.debug('Configuring language server options')
 
     var connMgr:ConnectionManager = this;
     let serverOptions: ServerOptions = function () {
@@ -261,24 +252,25 @@ export class ConnectionManager implements IConnectionManager {
           resolve({ reader: client, writer: client });
         });
         client.on('error', function (err) {
-          console.log(`[Puppet Lang Server Client] ` + err);
+          this.logger.error(`[Puppet Lang Server Client] ` + err);
           connMgr.setSessionFailure("Could not start language client: ", err.message);
-          
+
           return null;
         })
       });
     }
 
-    this.puppetOutputChannel.appendLine('Configuring language server client options')
+    this.logger.debug('Configuring language server client options')
     let clientOptions: LanguageClientOptions = {
       documentSelector: [langID],
     }
 
-    this.puppetOutputChannel.appendLine(`Starting language server client (host ${this.connectionConfiguration.host} port ${this.connectionConfiguration.port})`)
+    this.logger.debug(`Starting language server client (host ${this.connectionConfiguration.host} port ${this.connectionConfiguration.port})`)
+
     var title = `tcp lang server (host ${this.connectionConfiguration.host} port ${this.connectionConfiguration.port})`;
     var languageServerClient = new LanguageClient(title, serverOptions, clientOptions)
     languageServerClient.onReady().then(() => {
-      this.puppetOutputChannel.appendLine('Language server client started, setting puppet version')
+      this.logger.debug('Language server client started, setting puppet version')
       languageServerClient.sendRequest(messages.PuppetVersionRequest.type).then((versionDetails) => {
         this.setConnectionStatus(versionDetails.puppetVersion, ConnectionStatus.Running);
       });

client/src/extension.ts

@@ -4,6 +4,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 
 import { ConnectionManager, IConnectionConfiguration, ConnectionType } from './connection';
+import { Logger } from './logging';
 
 const langID = 'puppet'; // don't change this
 var statusBarItem;
@@ -31,10 +32,10 @@ export class ConnectionConfiguration implements IConnectionConfiguration {
 }
 
 export function activate(context: vscode.ExtensionContext) {
-  connManager = new ConnectionManager(context);
+  var logger = new Logger();
+  connManager = new ConnectionManager(context, logger);
 
   var configSettings = new ConnectionConfiguration(context);
-
   connManager.start(configSettings);
 }
 

client/src/logging.ts

@@ -0,0 +1,86 @@
+'use strict';
+
+import * as vscode from 'vscode';
+
+export enum LogLevel {
+    Verbose,
+    Debug,
+    Normal,
+    Warning,
+    Error
+}
+
+export class Logger {
+
+  private logChannel: vscode.OutputChannel;
+
+  // Minimum log level that is shown to users on logChannel
+  private minimumUserLogLevel: LogLevel = undefined;
+
+  constructor() {
+    this.logChannel = vscode.window.createOutputChannel("Puppet");
+    this.logChannel.show();
+
+    let config = vscode.workspace.getConfiguration('puppet');
+    let logLevelName = config['languageclient']['minimumUserLogLevel'];
+    let logLevel = this.logLevelFromString(logLevelName);
+
+    if(logLevel == undefined) {
+      this.minimumUserLogLevel = LogLevel.Normal;
+      this.error("Logger could not interpret " + logLevelName + " as a log level setting");
+    } else {
+      this.minimumUserLogLevel = logLevel;
+    }
+  }
+
+  public verbose(message: string) {
+    this.logWithLevel(LogLevel.Verbose, message);
+  }
+
+  public debug(message: string) {
+    this.logWithLevel(LogLevel.Debug, message);
+  }
+
+  public normal(message: string) {
+    this.logWithLevel(LogLevel.Normal, message);
+  }
+
+  public warning(message: string) {
+    this.logWithLevel(LogLevel.Warning, message);
+  }
+
+  public error(message: string) {
+    this.logWithLevel(LogLevel.Error, message);
+  }
+
+  private logWithLevel(level: LogLevel, message) {
+    let logMessage = this.logLevelPrefixAsString(level) + message
+
+    console.log(logMessage);
+    if (level >= this.minimumUserLogLevel) {
+      this.logChannel.appendLine(logMessage);
+    }
+  }
+
+  private logLevelFromString(logLevelName: String): LogLevel {
+    switch (logLevelName.toLowerCase()) {
+      case "verbose": return LogLevel.Verbose;
+      case "debug": return LogLevel.Debug;
+      case "normal": return LogLevel.Normal;
+      case "warning": return LogLevel.Warning;
+      case "error": return LogLevel.Error;
+      default:  return undefined;
+    }
+  }
+
+  private logLevelPrefixAsString(level: LogLevel): String {
+    switch (level) {
+      case LogLevel.Verbose: return "VERBOSE: ";
+      case LogLevel.Debug: return "DEBUG: ";
+      case LogLevel.Warning: return "WARNING: ";
+      case LogLevel.Error: return "ERROR: ";
+      default: return "";
+    }
+  }
+}
+

client/src/puppetcommands.ts

@@ -3,10 +3,11 @@ import { puppetResourceCommand } from '../src/commands/puppetResourceCommand';
 import * as messages from '../src/messages';
 import { PuppetNodeGraphContentProvider, isNodeGraphFile, getNodeGraphUri, showNodeGraph } from '../src/providers/previewNodeGraphProvider';
 import { IConnectionManager } from './connection';
+import { Logger } from './logging';
 
-export function setupPuppetCommands(langID:string, connManager:IConnectionManager, ctx:vscode.ExtensionContext){
+export function setupPuppetCommands(langID:string, connManager:IConnectionManager, ctx:vscode.ExtensionContext, logger: Logger){
 
-  let resourceCommand = new puppetResourceCommand(connManager);
+  let resourceCommand = new puppetResourceCommand(connManager, logger);
   ctx.subscriptions.push(resourceCommand);
   ctx.subscriptions.push(vscode.commands.registerCommand(messages.PuppetCommandStrings.PuppetResourceCommandId, () => {
     resourceCommand.run();