Used the new logger implementation.

Author: Kasun Kodagoda

BuildTask/ssl-labs-test/SslLabsService.ts

@@ -4,6 +4,7 @@ import { inject, injectable } from 'inversify';
 
 import { ITaskInput } from './interfaces/ITaskInput';
 import { ISslLabsService } from './interfaces/ISslLabsService';
+import { ILogger } from './interfaces/ILogger';
 
 import { CertificateGrade, CertificateGradeScore } from './Constants';
 
@@ -12,11 +13,14 @@ import TYPES from './di/types';
 @injectable()
 export class SslLabsService implements ISslLabsService {
     private _taskInput: ITaskInput;
+    private _logger: ILogger;
 
     constructor(
-        @inject(TYPES.ITaskInput) taskInput: ITaskInput
+        @inject(TYPES.ITaskInput) taskInput: ITaskInput,
+        @inject(TYPES.ILogger) logger: ILogger
     ) {
         this._taskInput = taskInput;
+        this._logger = logger;
     }
 
     executeSslTest(): Promise<any> {
@@ -51,6 +55,8 @@ export class SslLabsService implements ISslLabsService {
                     reject('SSLLabs Scan Result is null or undefined');
                 }
 
+                this._logger.logDebug(`SSLResult endpoint length: ${sslResult.endpoints.length}`);
+
                 if (sslResult.endpoints.length > 0) {
                     const endpoint: any = sslResult.endpoints[0];
                     const gradeScore: Number = this.convertCertificateGradeToNumber(endpoint.grade);
@@ -73,16 +79,18 @@ export class SslLabsService implements ISslLabsService {
                     reject('SSLLabs Scan Result is null or undefined');
                 }
 
+                this._logger.logDebug(`SSLResult endpoint length: ${sslResult.endpoints.length}`);
+
                 if (sslResult.endpoints.length > 0) {
                     const endpoint: any = sslResult.endpoints[0];
 
                     const expDate = Number(endpoint.details.cert.notAfter);
-                    console.log(`Certificate expire date: ${new Date(expDate)}`);
+                    this._logger.logConsole(`Certificate expire date: ${new Date(expDate)}`);
 
                     const currDate = Date.now();
                     const singleDay = 24 * 60 * 60 * 1000;
                     const dateDiff = Math.round(Math.abs((expDate - currDate) / singleDay));
-                    console.log(`Days till certificate expires: ${dateDiff}`);
+                    this._logger.logConsole(`Days till certificate expires: ${dateDiff}`);
 
                     resolve(dateDiff);
 
@@ -97,7 +105,7 @@ export class SslLabsService implements ISslLabsService {
     }
 
     private convertCertificateGradeToNumber(grade: string): Number {
-        console.log(`Certificate Grade: ${grade}`);
+        this._logger.logConsole(`Certificate Grade: ${grade}`);
 
         let gradeScore: Number = 0;
         switch (grade) {

BuildTask/ssl-labs-test/ssl-labs-test.ts

@@ -7,6 +7,7 @@ import TYPES from './di/types';
 import { AlertMode } from './Constants';
 import { ISslLabsService } from './interfaces/ISslLabsService';
 import { ITaskInput } from './interfaces/ITaskInput';
+import { ILogger } from './interfaces/ILogger';
 
 Task.setResourcePath(path.join(__dirname, 'task.json'));
 
@@ -16,22 +17,23 @@ async function run(): Promise<string> {
 
             const taskInput: ITaskInput = container.get<ITaskInput>(TYPES.ITaskInput);
             const sslLabsService: ISslLabsService = container.get<ISslLabsService>(TYPES.ISslLabsService);
+            const logger: ILogger = container.get<ILogger>(TYPES.ILogger);
 
-            Task.debug(taskInput.toJSON());
-            Task.debug('Executing SSL Labs Scan with the given inputs');
-            console.log(`Starting SSL Labs Scan for the hostname: ${taskInput.Hostname}`);
+            logger.logDebug(taskInput.toJSON());
+            logger.logDebug('Executing SSL Labs Scan with the given inputs');
+            logger.logConsole(`Starting SSL Labs Scan for the hostname: ${taskInput.Hostname}`);
 
-            const scanResult = await sslLabsService.executeSslTest();
-            console.log('Scan Completed...');
+            const scanResult: any = await sslLabsService.executeSslTest();
+            logger.logConsole('Scan Completed...');
 
 
             // Check for Verifications
             if (taskInput.EnableVerification) {
-                console.log(`Verifications are Enabled with the Alert Mode: ${taskInput.AlertMode}`);
+                logger.logConsole(`Verifications are Enabled with the Alert Mode: ${taskInput.AlertMode}`);
                 const certGradeScore = await sslLabsService.getSslCertificateGrade(scanResult);
 
                 if (Number(taskInput.MinimumCertGrade) > certGradeScore) {
-                    console.log('Minimum certifiate grade threshold exceeded. Executing Alert');
+                    logger.logConsole('Minimum certifiate grade threshold exceeded. Executing Alert');
                     // If certificate grade threshold is passed
                     switch (taskInput.AlertMode) {
                         case AlertMode.BREAK_BUILD:
@@ -45,11 +47,11 @@ async function run(): Promise<string> {
             }
 
             if (taskInput.EnableExpirationAlert) {
-                console.log('Certificate expiration alerts Enabled.');
+                logger.logConsole('Certificate expiration alerts Enabled.');
                 const daysTillExpire: number = await sslLabsService.timeTillCertificateExpiration(scanResult);
 
                 if (daysTillExpire < taskInput.DaysBeforeExpiration) {
-                    console.log('Minimum certifiate expire threshold exceeded. Executing Alert');
+                    logger.logConsole('Minimum certifiate expire threshold exceeded. Executing Alert');
                     switch (taskInput.AlertMode) {
                         case AlertMode.BREAK_BUILD:
                             throw new Error(`SSL certificate is nearing expireation and will expire in ${daysTillExpire} Days.`);