.vscode/tasks.json

@@ -1,19 +1,32 @@
 {
-    "version": "0.1.0",
+    "version": "2.0.0",
     "command": "npm",
-    "isShellCommand": true,
-    "showOutput": "silent",
-    "suppressTaskName": true,
     "tasks": [
         {
-            "taskName": "test",
-            "args": ["run", "test"],
-            "isTestCommand": true
+            "label": "test",
+            "type": "shell",
+            "args": [
+                "run",
+                "test"
+            ],
+            "problemMatcher": [],
+            "group": {
+                "_id": "test",
+                "isDefault": false
+            }
         },
         {
-            "taskName": "build",
-            "args": ["run", "build"],
-            "isTestCommand": false
+            "label": "build",
+            "type": "shell",
+            "args": [
+                "run",
+                "build"
+            ],
+            "problemMatcher": [],
+            "group": {
+                "_id": "build",
+                "isDefault": false
+            }
         }
     ]
 }

AutoCollection/PreAggregatedMetrics.ts

@@ -172,17 +172,15 @@ class AutoCollectPreAggregatedMetrics {
             var elapsedMs = currentCounter.time - currentCounter.lastTime;
             var averageRequestExecutionTime = ((currentCounter.intervalExecutionTime - currentCounter.lastIntervalExecutionTime) / intervalRequests) || 0;
             currentCounter.lastIntervalExecutionTime = currentCounter.intervalExecutionTime; // reset
-            if (elapsedMs > 0) {
-                if (intervalRequests > 0) {
-                    this._trackPreAggregatedMetric({
-                        name: "Server response time",
-                        dimensions: currentCounter.dimensions,
-                        value: averageRequestExecutionTime,
-                        count: intervalRequests,
-                        aggregationInterval: elapsedMs,
-                        metricType: Constants.MetricId.REQUESTS_DURATION,
-                    });
-                }
+            if (elapsedMs > 0 && intervalRequests > 0) {
+                this._trackPreAggregatedMetric({
+                    name: "Server response time",
+                    dimensions: currentCounter.dimensions,
+                    value: averageRequestExecutionTime,
+                    count: intervalRequests,
+                    aggregationInterval: elapsedMs,
+                    metricType: Constants.MetricId.REQUESTS_DURATION,
+                });
             }
             // Set last counters
             currentCounter.lastTotalCount = currentCounter.totalCount;
@@ -198,17 +196,15 @@ class AutoCollectPreAggregatedMetrics {
             var elapsedMs = currentCounter.time - currentCounter.lastTime;
             var averageDependencyExecutionTime = ((currentCounter.intervalExecutionTime - currentCounter.lastIntervalExecutionTime) / intervalDependencies) || 0;
             currentCounter.lastIntervalExecutionTime = currentCounter.intervalExecutionTime; // reset
-            if (elapsedMs > 0) {
-                if (intervalDependencies > 0) {
-                    this._trackPreAggregatedMetric({
-                        name: "Dependency duration",
-                        dimensions: currentCounter.dimensions,
-                        value: averageDependencyExecutionTime,
-                        count: intervalDependencies,
-                        aggregationInterval: elapsedMs,
-                        metricType: Constants.MetricId.DEPENDENCIES_DURATION,
-                    });
-                }
+            if (elapsedMs > 0 && intervalDependencies > 0) {
+                this._trackPreAggregatedMetric({
+                    name: "Dependency duration",
+                    dimensions: currentCounter.dimensions,
+                    value: averageDependencyExecutionTime,
+                    count: intervalDependencies,
+                    aggregationInterval: elapsedMs,
+                    metricType: Constants.MetricId.DEPENDENCIES_DURATION,
+                });
             }
             // Set last counters
             currentCounter.lastTotalCount = currentCounter.totalCount;
@@ -219,17 +215,19 @@ class AutoCollectPreAggregatedMetrics {
     private _trackExceptionMetrics() {
         for (let i = 0; i < AutoCollectPreAggregatedMetrics._exceptionCountersCollection.length; i++) {
             var currentCounter = AutoCollectPreAggregatedMetrics._exceptionCountersCollection[i];
+            currentCounter.time = +new Date;
             var intervalExceptions = (currentCounter.totalCount - currentCounter.lastTotalCount) || 0;
             var elapsedMs = currentCounter.time - currentCounter.lastTime;
-            this._trackPreAggregatedMetric({
-                name: "Exceptions",
-                dimensions: currentCounter.dimensions,
-                value: intervalExceptions,
-                count: intervalExceptions,
-                aggregationInterval: elapsedMs,
-                metricType: Constants.MetricId.EXCEPTIONS_COUNT,
-            });
-
+            if (elapsedMs > 0 && intervalExceptions > 0) {
+                this._trackPreAggregatedMetric({
+                    name: "Exceptions",
+                    dimensions: currentCounter.dimensions,
+                    value: intervalExceptions,
+                    count: intervalExceptions,
+                    aggregationInterval: elapsedMs,
+                    metricType: Constants.MetricId.EXCEPTIONS_COUNT,
+                });
+            }
             // Set last counters
             currentCounter.lastTotalCount = currentCounter.totalCount;
             currentCounter.lastTime = currentCounter.time;
@@ -239,17 +237,19 @@ class AutoCollectPreAggregatedMetrics {
     private _trackTraceMetrics() {
         for (let i = 0; i < AutoCollectPreAggregatedMetrics._traceCountersCollection.length; i++) {
             var currentCounter = AutoCollectPreAggregatedMetrics._traceCountersCollection[i];
+            currentCounter.time = +new Date;
             var intervalTraces = (currentCounter.totalCount - currentCounter.lastTotalCount) || 0;
             var elapsedMs = currentCounter.time - currentCounter.lastTime;
-            this._trackPreAggregatedMetric({
-                name: "Traces",
-                dimensions: currentCounter.dimensions,
-                value: intervalTraces,
-                count: intervalTraces,
-                aggregationInterval: elapsedMs,
-                metricType: Constants.MetricId.TRACES_COUNT,
-            });
-
+            if (elapsedMs > 0 && intervalTraces > 0) {
+                this._trackPreAggregatedMetric({
+                    name: "Traces",
+                    dimensions: currentCounter.dimensions,
+                    value: intervalTraces,
+                    count: intervalTraces,
+                    aggregationInterval: elapsedMs,
+                    metricType: Constants.MetricId.TRACES_COUNT,
+                });
+            }
             // Set last counters
             currentCounter.lastTotalCount = currentCounter.totalCount;
             currentCounter.lastTime = currentCounter.time;

AutoCollection/diagnostic-channel/SpanParser.ts

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for details.
+import { URL } from "url";
 import { SpanKind, SpanStatusCode, Link } from "@opentelemetry/api";
 import { SemanticAttributes, DbSystemValues } from "@opentelemetry/semantic-conventions";
 import { ReadableSpan } from "@opentelemetry/tracing";
@@ -39,10 +40,8 @@ function isSqlDB(dbSystem: string) {
         dbSystem === DbSystemValues.DB2 ||
         dbSystem === DbSystemValues.DERBY ||
         dbSystem === DbSystemValues.MARIADB ||
-        dbSystem === DbSystemValues.MYSQL ||
         dbSystem === DbSystemValues.MSSQL ||
         dbSystem === DbSystemValues.ORACLE ||
-        dbSystem === DbSystemValues.POSTGRESQL ||
         dbSystem === DbSystemValues.SQLITE ||
         dbSystem === DbSystemValues.OTHER_SQL ||
         dbSystem === DbSystemValues.HSQLDB ||
@@ -125,6 +124,14 @@ function createDependencyData(span: ReadableSpan): Contracts.DependencyTelemetry
     // HTTP Dependency
     if (httpMethod) {
         remoteDependency.dependencyTypeName = Constants.DependencyTypeName.Http;
+        const httpUrl = span.attributes[SemanticAttributes.HTTP_URL];
+        if (httpUrl) {
+            try {
+                let dependencyUrl = new URL(String(httpUrl));
+                remoteDependency.name = `${httpMethod} ${dependencyUrl.pathname}`;
+            }
+            catch (ex) { }
+        }
         remoteDependency.data = getUrl(span);
         const httpStatusCode = span.attributes[SemanticAttributes.HTTP_STATUS_CODE];
         if (httpStatusCode) {
@@ -139,34 +146,43 @@ function createDependencyData(span: ReadableSpan): Contracts.DependencyTelemetry
                 if (res != null) {
                     let protocol = res[1];
                     let port = res[3];
-                    if ((protocol == "https" && port == ":443") ||
-                        (protocol == "http" && port == ":80")) {
+                    if ((protocol == "https" && port == ":443") || (protocol == "http" && port == ":80")) {
                         // Drop port
                         target = res[1] + res[2] + res[4];
                     }
                 }
-
-            }
-            catch (error) { }
+            } catch (error) { }
             remoteDependency.target = `${target}`;
         }
     }
     // DB Dependency
     else if (dbSystem) {
-        if (isSqlDB(String(dbSystem))) {
+        // TODO: Remove special logic when Azure UX supports OpenTelemetry dbSystem
+        if (String(dbSystem) === DbSystemValues.MYSQL) {
+            remoteDependency.dependencyTypeName = "mysql";
+        } else if (String(dbSystem) === DbSystemValues.POSTGRESQL) {
+            remoteDependency.dependencyTypeName = "postgresql";
+        } else if (String(dbSystem) === DbSystemValues.MONGODB) {
+            remoteDependency.dependencyTypeName = "mongodb";
+        } else if (String(dbSystem) === DbSystemValues.REDIS) {
+            remoteDependency.dependencyTypeName = "redis";
+        } else if (isSqlDB(String(dbSystem))) {
             remoteDependency.dependencyTypeName = "SQL";
-        }
-        else {
+        } else {
             remoteDependency.dependencyTypeName = String(dbSystem);
         }
         const dbStatement = span.attributes[SemanticAttributes.DB_STATEMENT];
+        const dbOperation = span.attributes[SemanticAttributes.DB_OPERATION];
         if (dbStatement) {
             remoteDependency.data = String(dbStatement);
         }
+        else if (dbOperation) {
+            remoteDependency.data = String(dbOperation);
+        }
         let target = getDependencyTarget(span);
         const dbName = span.attributes[SemanticAttributes.DB_NAME];
         if (target) {
-            remoteDependency.target = dbName ? `${target}/${dbName}` : `${target}`;
+            remoteDependency.target = dbName ? `${target}|${dbName}` : `${target}`;
         } else {
             remoteDependency.target = dbName ? `${dbName}` : `${dbSystem}`;
         }
@@ -197,10 +213,24 @@ function createRequestData(span: ReadableSpan): Contracts.RequestTelemetry {
         url: "",
         source: undefined
     };
-
     const httpMethod = span.attributes[SemanticAttributes.HTTP_METHOD];
     const grpcStatusCode = span.attributes[SemanticAttributes.RPC_GRPC_STATUS_CODE];
     if (httpMethod) {
+        // Try to get request name for server spans
+        if (span.kind == SpanKind.SERVER) {
+            const httpRoute = span.attributes[SemanticAttributes.HTTP_ROUTE];
+            const httpUrl = span.attributes[SemanticAttributes.HTTP_URL];
+            if (httpRoute) {
+                requestData.name = `${httpMethod as string} ${httpRoute as string}`;
+            }
+            else if (httpUrl) {
+                try {
+                    let url = new URL(String(httpUrl));
+                    requestData.name = `${httpMethod} ${url.pathname}`;
+                }
+                catch (ex) { }
+            }
+        }
         requestData.url = getUrl(span);
         const httpStatusCode = span.attributes[SemanticAttributes.HTTP_STATUS_CODE];
         if (httpStatusCode) {

Bootstrap/Default.ts

@@ -1,6 +1,7 @@
+import azureCore = require("@azure/core-http");
+
 import * as types from "../applicationinsights";
 import * as Helpers from "./Helpers";
-import * as DataModel from "./DataModel";
 import Constants = require("../Declarations/Constants");
 import { StatusLogger, StatusContract } from "./StatusLogger";
 import { DiagnosticLogger } from "./DiagnosticLogger";
@@ -45,7 +46,7 @@ export function setStatusLogger(statusLogger: StatusLogger) {
  * Try to setup and start this app insights instance if attach is enabled.
  * @param setupString connection string or instrumentation key
  */
-export function setupAndStart(setupString = _setupString): typeof types | null {
+export function setupAndStart(setupString = _setupString, aadTokenCredential?: azureCore.TokenCredential): typeof types | null {
     // If app already contains SDK, skip agent attach
     if (!forceStart && Helpers.sdkAlreadyExists(_logger)) {
         _statusLogger.logStatus({
@@ -102,6 +103,11 @@ export function setupAndStart(setupString = _setupString): typeof types | null {
         _appInsights.defaultClient.setAutoPopulateAzureProperties(true);
         _appInsights.defaultClient.addTelemetryProcessor(prefixInternalSdkVersion);
         _appInsights.defaultClient.addTelemetryProcessor(copyOverPrefixInternalSdkVersionToHeartBeatMetric);
+        if (aadTokenCredential) {
+            _logger.logMessage("Using AAD Token Credential");
+            _appInsights.defaultClient.config.aadTokenCredential = aadTokenCredential;
+        }
+
         _appInsights.start();
         // Add attach flag in Statsbeat
         let statsbeat = _appInsights.defaultClient.getStatsbeat();

Bootstrap/DiagnosticLogger.ts

@@ -1,10 +1,10 @@
 "use strict";
 
 import * as path from "path";
-import * as fs from "fs";
 import * as DataModel from "./DataModel";
 import { FileWriter } from "./FileWriter";
 import { homedir } from "./Helpers/FileHelpers";
+import { APPLICATION_INSIGHTS_SDK_VERSION } from "../Declarations/Constants";
 
 export class DiagnosticLogger {
     public static readonly DEFAULT_FILE_NAME: string = "application-insights-extension.log";
@@ -20,12 +20,12 @@ export class DiagnosticLogger {
             siteName: process.env.WEBSITE_SITE_NAME,
             ikey: process.env.APPINSIGHTS_INSTRUMENTATIONKEY,
             extensionVersion: process.env.ApplicationInsightsAgent_EXTENSION_VERSION,
-            sdkVersion: "2.1.7",
+            sdkVersion: APPLICATION_INSIGHTS_SDK_VERSION,
             subscriptionId: process.env.WEBSITE_OWNER_NAME ? process.env.WEBSITE_OWNER_NAME.split("+")[0] : null,
         }
     }
 
-    constructor(private _writer: DataModel.AgentLogger = console) {}
+    constructor(private _writer: DataModel.AgentLogger = console) { }
 
     logMessage(message: DataModel.DiagnosticLog | string, cb?: (err: Error) => void) {
         if (typeof cb === "function" && this._writer instanceof FileWriter) {

Declarations/Constants.ts

@@ -1,6 +1,6 @@
 import Contracts = require("./Contracts")
-import * as conventions from "@opentelemetry/semantic-conventions";
 
+export const APPLICATION_INSIGHTS_SDK_VERSION = "2.1.8";
 export const DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
 export const DEFAULT_LIVEMETRICS_ENDPOINT = "https://rt.services.visualstudio.com";
 export const DEFAULT_LIVEMETRICS_HOST = "rt.services.visualstudio.com";

Library/AuthorizationHandler.ts

@@ -0,0 +1,35 @@
+import http = require("http");
+import https = require("https");
+import azureCore = require("@azure/core-http");
+
+const applicationInsightsResource = "https://monitor.azure.com//.default";
+
+
+class AuthorizationHandler {
+
+    private _azureTokenPolicy: azureCore.RequestPolicy;
+
+    constructor(credential: azureCore.TokenCredential) {
+        let scopes: string[] = [applicationInsightsResource];
+        let emptyPolicy: azureCore.RequestPolicy = {
+            sendRequest(httpRequest: azureCore.WebResourceLike): Promise<azureCore.HttpOperationResponse> {
+                return null;
+            }
+        };
+        this._azureTokenPolicy = azureCore.bearerTokenAuthenticationPolicy(credential, scopes).create(emptyPolicy, new azureCore.RequestPolicyOptions());
+    }
+
+    /**
+    * Applies the Bearer token to the request through the Authorization header.
+    */
+    public async addAuthorizationHeader(requestOptions: http.RequestOptions | https.RequestOptions): Promise<void> {
+        let authHeaderName = azureCore.Constants.HeaderConstants.AUTHORIZATION;
+        let webResource = new azureCore.WebResource("https://");
+        this
+        await this._azureTokenPolicy.sendRequest(webResource);
+        requestOptions.headers[authHeaderName] = webResource.headers.get(authHeaderName);
+    }
+
+}
+
+export = AuthorizationHandler;

Library/AzureVirtualMachine.ts

@@ -7,7 +7,7 @@ import AutoCollectHttpDependencies = require("../AutoCollection/HttpDependencies
 const AIMS_URI = "http://169.254.169.254/metadata/instance/compute";
 const AIMS_API_VERSION = "api-version=2017-12-01";
 const AIMS_FORMAT = "format=json";
-const ConnectionErrorMessage = "ENETUNREACH";
+const ConnectionErrorMessage = "UNREACH"; // EHOSTUNREACH, ENETUNREACH
 
 export interface IVirtualMachineInfo {
     isVM?: boolean;
@@ -48,7 +48,7 @@ export class AzureVirtualMachine {
                     }
                     catch (error) {
                         // Failed to parse JSON
-                        Logging.warn(AzureVirtualMachine.TAG, error);
+                        Logging.info(AzureVirtualMachine.TAG, error);
                     }
                     callback(vmInfo);
                 });
@@ -65,7 +65,7 @@ export class AzureVirtualMachine {
                 }
                 else{
                     // Only log when is not determined if VM or not to avoid noise outside of Azure VMs
-                    Logging.warn(AzureVirtualMachine.TAG, error);
+                    Logging.info(AzureVirtualMachine.TAG, error);
                 }
                 callback(vmInfo);
             });