Add functional tests to cover all diagnostic channel autocollection

AutoCollection/CorrelationContextManager.ts

@@ -226,6 +226,26 @@ export class CorrelationContextManager {
 
             // Restore Zone stack rewriting settings
             (<any>orig).stackRewrite = stackRewrite;
+
+            // Remove unexpected bits from stack trace
+            if (this.stack && typeof this.stack === "string") {
+                var stackFrames: string[] = (<string>this.stack).split("\n");
+                // Remove this class
+                if (stackFrames.length > 3) {
+                    if (stackFrames[2].trim().indexOf("at Error.AppInsightsAsyncCorrelatedErrorWrapper") === 0) {
+                        stackFrames.splice(2, 1);
+                    }
+                }
+                // Remove AI correlation ids
+                this.stack = stackFrames.map((v) => {
+                    let startIndex = v.indexOf(") [");
+                    if (startIndex > -1) {
+                        v = v.substr(0, startIndex + 1);
+                    }
+                    return v;
+                }).join("\n");
+            }
+
 
             // getOwnPropertyNames should be a superset of Object.keys...
             // This appears to not always be the case

AutoCollection/diagnostic-channel/console.sub.ts

@@ -11,7 +11,12 @@ let clients: TelemetryClient[] = [];
 
 const subscriber = (event: IStandardEvent<consolePub.IConsoleData>) => {
     clients.forEach((client) => {
-        client.trackTrace({message: event.data.message, severity: (event.data.stderr ? SeverityLevel.Warning : SeverityLevel.Information)});
+        // Message can have a trailing newline
+        let message = event.data.message;
+        if (message.lastIndexOf("\n") == message.length - 1) {
+            message = message.substring(0, message.length - 1);
+        }
+        client.trackTrace({message: message, severity: (event.data.stderr ? SeverityLevel.Warning : SeverityLevel.Information)});
     });
 };
 

AutoCollection/diagnostic-channel/mongodb.sub.ts

@@ -21,10 +21,6 @@ export const subscriber = (event: IStandardEvent<mongodb.IMongoData>) => {
                 resultCode: event.data.succeeded ? "0" : "1",
                 dependencyTypeName: 'mongodb'
             });
-
-        if (!event.data.succeeded) {
-            client.trackException({exception:new Error(event.data.event.failure)});
-        }
     });
 };
 

AutoCollection/diagnostic-channel/postgres.sub.ts

@@ -10,7 +10,7 @@ let clients: TelemetryClient[] = [];
 export const subscriber = (event: IStandardEvent<pg.IPostgresData>) => {
     clients.forEach((client) => {
         const q = event.data.query;
-        const sql = q.preparable.text || q.plan || q.text || "unknown query";
+        const sql = (q.preparable && q.preparable.text) || q.plan || q.text || "unknown query";
         const success = !event.data.error;
         const conn = `${event.data.database.host}:${event.data.database.port}`;
         client.trackDependency({

AutoCollection/diagnostic-channel/winston.sub.ts

@@ -22,19 +22,19 @@ const winstonToAILevelMap: { [key: string]: (og: string) => number } = {
             debug: SeverityLevel.Verbose
         };
 
-        return map[og] || SeverityLevel.Information;
+        return map[og] === undefined ? SeverityLevel.Information : map[og];
     },
     npm(og: string) {
-        const map: { [key: string]: number } = {
-            error: SeverityLevel.Critical,
+        const map: { [key: string ]: number } = {
+            error: SeverityLevel.Error,
             warn: SeverityLevel.Warning,
             info: SeverityLevel.Information,
             verbose: SeverityLevel.Verbose,
             debug: SeverityLevel.Verbose,
             silly: SeverityLevel.Verbose
         };
 
-        return map[og] || SeverityLevel.Information;
+        return map[og] === undefined ? SeverityLevel.Information : map[og];
     },
     unknown(og: string) {
         return SeverityLevel.Information;

Tests/FunctionalTests/RunFunctionalTests.js

@@ -62,14 +62,33 @@ function runAsync(cmd, workingDir) {
 }
 
 function startDocker() {
-    const mongo = run("docker run -d -p 27017:27017 --name ainjsmongo mongo");
-
-    return mongo.code === 0;
+    const tasks =  [
+        run("docker run -d -p 27017:27017 --name ainjsmongo mongo"),
+        run("docker run -e MYSQL_ROOT_PASSWORD=dummypw -e MYSQL_DATABASE=testdb -d -p 33060:3306 --name ainjsmysql mysql"),
+        run("docker run -d -p 63790:6379 --name ainjsredis redis:alpine"),
+        run("docker run -d -p 54320:5432 --name ainjspostgres postgres:alpine")
+    ];
+
+    for(let i = 0; i < tasks.length; i++) {
+        if (tasks[i].code !== 0) {
+            console.error("Failed to start container!");
+            console.error(tasks[i].output);
+            return false;
+        }
+    }
+    return true;
 }
 
 function cleanUpDocker() {
     run("docker stop ainjsmongo");
+    run("docker stop ainjsmysql");
+    run("docker stop ainjsredis");
+    run("docker stop ainjspostgres");
+
     run("docker rm ainjsmongo");
+    run("docker rm ainjsmysql");
+    run("docker rm ainjsredis");
+    run("docker rm ainjspostgres");
 }
 
 function main() {
@@ -111,7 +130,8 @@ function main() {
         return 1;
     }
     console.log("Installing " + path);
-    if (run("npm install " + path, "./TestApp").code !== 0) {
+    run("npm uninstall applicationinsights", "./TestApp");
+    if (run("npm install --no-save " + path, "./TestApp").code !== 0) {
         console.error("Could not install SDK!");
         return 1;
     }

Tests/FunctionalTests/Runner/Main.js

@@ -51,7 +51,7 @@ const validateTestSequence = (index) => {
     }
 };
 const runAndValidateLongTest = () => {
-    Utils.Logging.enterSubunit("Performing stress test sequence for " + Config.StressTestTime + "ms");
+    Utils.Logging.enterSubunit("Performing parallel requests test sequence for " + Config.StressTestTime + "ms");
 
     // Find stress test
     let testSequence = null;
@@ -65,7 +65,7 @@ const runAndValidateLongTest = () => {
 
     // Don't continue if we don't have one
     if (!testSequence) {
-        Utils.Logging.info("No stress test sequence defined. Skipping.");
+        Utils.Logging.info("No parallel test sequence defined. Skipping.");
         Utils.Logging.exitSubunit();
         return Promise.resolve(false);
     } else if (!successfulRun) {