@azure/monitor-opentelemetry-exporter 1.0.0-beta.4 → 1.0.0-beta.7

package/dist/index.js

@@ -2,20 +2,52 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
-var fs = require('fs');
 var os = require('os');
+var url = require('url');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var coreRestPipeline = require('@azure/core-rest-pipeline');
+var coreClient = require('@azure/core-client');
+var fs = require('fs');
 var path = require('path');
+var child_process = require('child_process');
 var util = require('util');
-var url = require('url');
-var url__default = _interopDefault(url);
-var coreHttp = require('@azure/core-http');
-var conventions = require('@opentelemetry/semantic-conventions');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
+var coreClient__namespace = /*#__PURE__*/_interopNamespace(coreClient);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * Azure service API version.
+ */
+exports.ServiceApiVersion = void 0;
 (function (ServiceApiVersion) {
     /**
      * V2 Version
@@ -83,7 +115,7 @@ var PerformanceCounter;
  * Map a PerformanceCounter/QuickPulseCounter to a QuickPulseCounter. If no mapping exists, mapping is *undefined*
  * @internal
  */
-const PerformanceToQuickPulseCounter = {
+({
     [PerformanceCounter.PROCESSOR_TIME]: QuickPulseCounter.PROCESSOR_TIME,
     [PerformanceCounter.REQUEST_RATE]: QuickPulseCounter.REQUEST_RATE,
     [PerformanceCounter.REQUEST_DURATION]: QuickPulseCounter.REQUEST_DURATION,
@@ -93,8 +125,8 @@ const PerformanceToQuickPulseCounter = {
     [QuickPulseCounter.DEPENDENCY_RATE]: QuickPulseCounter.DEPENDENCY_RATE,
     [QuickPulseCounter.DEPENDENCY_FAILURE_RATE]: QuickPulseCounter.DEPENDENCY_FAILURE_RATE,
     [QuickPulseCounter.DEPENDENCY_DURATION]: QuickPulseCounter.DEPENDENCY_DURATION,
-    [QuickPulseCounter.EXCEPTION_RATE]: QuickPulseCounter.EXCEPTION_RATE
-};
+    [QuickPulseCounter.EXCEPTION_RATE]: QuickPulseCounter.EXCEPTION_RATE,
+});
 
 // Copyright (c) Microsoft Corporation.
 /**
@@ -161,7 +193,6 @@ class ConnectionStringParser {
 ConnectionStringParser.FIELDS_SEPARATOR = ";";
 ConnectionStringParser.FIELD_KEY_VALUE_SEPARATOR = "=";
 
-// Copyright (c) Microsoft Corporation.
 const DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS = 60000;
 const DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING = 10;
 /**
@@ -173,25 +204,191 @@ const DEFAULT_EXPORTER_CONFIG = {
     endpointUrl: DEFAULT_BREEZE_ENDPOINT,
     batchSendRetryIntervalMs: DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS,
     maxConsecutiveFailuresBeforeWarning: DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING,
-    apiVersion: DEFAULT_BREEZE_API_VERSION
+    apiVersion: DEFAULT_BREEZE_API_VERSION,
 };
 
 // Copyright (c) Microsoft Corporation.
-const readdirAsync = util.promisify(fs.readdir);
-const statAsync = util.promisify(fs.stat);
-const lstatAsync = util.promisify(fs.lstat);
-const mkdirAsync = util.promisify(fs.mkdir);
+class FileAccessControl {
+    // Check if file access control could be enabled
+    static checkFileProtection() {
+        if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION &&
+            !FileAccessControl.OS_FILE_PROTECTION_CHECKED) {
+            FileAccessControl.OS_FILE_PROTECTION_CHECKED = true;
+            // Node's chmod levels do not appropriately restrict file access on Windows
+            // Use the built-in command line tool ICACLS on Windows to properly restrict
+            // access to the temporary directory used for disk retry mode.
+            if (FileAccessControl.USE_ICACLS) {
+                // This should be async - but it's currently safer to have this synchronous
+                // This guarantees we can immediately fail setDiskRetryMode if we need to
+                try {
+                    FileAccessControl.OS_PROVIDES_FILE_PROTECTION = fs__namespace.existsSync(FileAccessControl.ICACLS_PATH);
+                }
+                catch (e) {
+                    // Ignore error
+                }
+                if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION) {
+                    api.diag.warn("Could not find ICACLS in expected location! This is necessary to use disk retry mode on Windows.");
+                }
+            }
+            else {
+                // chmod works everywhere else
+                FileAccessControl.OS_PROVIDES_FILE_PROTECTION = true;
+            }
+        }
+    }
+    static async applyACLRules(directory) {
+        if (FileAccessControl.USE_ICACLS) {
+            if (FileAccessControl.ACLED_DIRECTORIES[directory] === undefined) {
+                // Avoid multiple calls race condition by setting ACLED_DIRECTORIES to false for this directory immediately
+                // If batches are being failed faster than the processes spawned below return, some data won't be stored to disk
+                // This is better than the alternative of potentially infinitely spawned processes
+                FileAccessControl.ACLED_DIRECTORIES[directory] = false;
+                try {
+                    // Restrict this directory to only current user and administrator access
+                    let identity = await this._getACLIdentity();
+                    await this._runICACLS(this._getACLArguments(directory, identity));
+                    FileAccessControl.ACLED_DIRECTORIES[directory] = true;
+                }
+                catch (ex) {
+                    FileAccessControl.ACLED_DIRECTORIES[directory] = false; // false is used to cache failed (vs undefined which is "not yet tried")
+                    throw ex;
+                }
+            }
+            else {
+                if (!FileAccessControl.ACLED_DIRECTORIES[directory]) {
+                    throw new Error("Setting ACL restrictions did not succeed (cached result)");
+                }
+            }
+        }
+    }
+    static applyACLRulesSync(directory) {
+        if (FileAccessControl.USE_ICACLS) {
+            // For performance, only run ACL rules if we haven't already during this session
+            if (FileAccessControl.ACLED_DIRECTORIES[directory] === undefined) {
+                this._runICACLSSync(this._getACLArguments(directory, this._getACLIdentitySync()));
+                FileAccessControl.ACLED_DIRECTORIES[directory] = true; // If we get here, it succeeded. _runIACLSSync will throw on failures
+                return;
+            }
+            else if (!FileAccessControl.ACLED_DIRECTORIES[directory]) {
+                // falsy but not undefined
+                throw new Error("Setting ACL restrictions did not succeed (cached result)");
+            }
+        }
+    }
+    static _runICACLS(args) {
+        return new Promise((resolve, reject) => {
+            var aclProc = child_process__namespace.spawn(FileAccessControl.ICACLS_PATH, args, {
+                windowsHide: true,
+            });
+            aclProc.on("error", (e) => reject(e));
+            aclProc.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Setting ACL restrictions did not succeed (ICACLS returned code ${code})`));
+                }
+            });
+        });
+    }
+    static _runICACLSSync(args) {
+        // Some very old versions of Node (< 0.11) don't have this
+        if (child_process__namespace.spawnSync) {
+            var aclProc = child_process__namespace.spawnSync(FileAccessControl.ICACLS_PATH, args, {
+                windowsHide: true,
+            });
+            if (aclProc.error) {
+                throw aclProc.error;
+            }
+            else if (aclProc.status !== 0) {
+                throw new Error(`Setting ACL restrictions did not succeed (ICACLS returned code ${aclProc.status})`);
+            }
+        }
+        else {
+            throw new Error("Could not synchronously call ICACLS under current version of Node.js");
+        }
+    }
+    static _getACLIdentity() {
+        return new Promise((resolve, reject) => {
+            if (FileAccessControl.ACL_IDENTITY) {
+                resolve(FileAccessControl.ACL_IDENTITY);
+            }
+            var psProc = child_process__namespace.spawn(FileAccessControl.POWERSHELL_PATH, ["-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"], {
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"], // Needed to prevent hanging on Win 7
+            });
+            let data = "";
+            psProc.stdout.on("data", (d) => (data += d));
+            psProc.on("error", (e) => reject(e));
+            psProc.on("close", (code) => {
+                FileAccessControl.ACL_IDENTITY = data && data.trim();
+                if (code === 0) {
+                    resolve(FileAccessControl.ACL_IDENTITY);
+                }
+                else {
+                    reject(new Error(`Getting ACL identity did not succeed (PS returned code ${code})`));
+                }
+            });
+        });
+    }
+    static _getACLIdentitySync() {
+        if (FileAccessControl.ACL_IDENTITY) {
+            return FileAccessControl.ACL_IDENTITY;
+        }
+        // Some very old versions of Node (< 0.11) don't have this
+        if (child_process__namespace.spawnSync) {
+            var psProc = child_process__namespace.spawnSync(FileAccessControl.POWERSHELL_PATH, ["-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"], {
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"], // Needed to prevent hanging on Win 7
+            });
+            if (psProc.error) {
+                throw psProc.error;
+            }
+            else if (psProc.status !== 0) {
+                throw new Error(`Getting ACL identity did not succeed (PS returned code ${psProc.status})`);
+            }
+            FileAccessControl.ACL_IDENTITY = psProc.stdout && psProc.stdout.toString().trim();
+            return FileAccessControl.ACL_IDENTITY;
+        }
+        else {
+            throw new Error("Could not synchronously get ACL identity under current version of Node.js");
+        }
+    }
+    static _getACLArguments(directory, identity) {
+        return [
+            directory,
+            "/grant",
+            "*S-1-5-32-544:(OI)(CI)F",
+            "/grant",
+            `${identity}:(OI)(CI)F`,
+            "/inheritance:r",
+        ]; // Remove all inherited permissions
+    }
+}
+FileAccessControl.ICACLS_PATH = `${process.env.systemdrive}/windows/system32/icacls.exe`;
+FileAccessControl.POWERSHELL_PATH = `${process.env.systemdrive}/windows/system32/windowspowershell/v1.0/powershell.exe`;
+FileAccessControl.ACLED_DIRECTORIES = {};
+FileAccessControl.ACL_IDENTITY = null;
+FileAccessControl.OS_FILE_PROTECTION_CHECKED = false;
+FileAccessControl.OS_PROVIDES_FILE_PROTECTION = false;
+FileAccessControl.USE_ICACLS = os__namespace.type() === "Windows_NT";
+
+// Copyright (c) Microsoft Corporation.
+const readdirAsync$1 = util.promisify(fs__namespace.readdir);
+const statAsync$1 = util.promisify(fs__namespace.stat);
+const lstatAsync = util.promisify(fs__namespace.lstat);
+const mkdirAsync = util.promisify(fs__namespace.mkdir);
 /**
  * Computes the size (in bytes) of all files in a directory at the root level. Asynchronously.
  * @internal
  */
 const getShallowDirectorySize = async (directory) => {
     // Get the directory listing
-    const files = await readdirAsync(directory);
+    const files = await readdirAsync$1(directory);
     let totalSize = 0;
     // Query all file sizes
     for (const file of files) {
-        const fileStats = await statAsync(path.join(directory, file));
+        const fileStats = await statAsync$1(path__namespace.join(directory, file));
         if (fileStats.isFile()) {
             totalSize += fileStats.size;
         }
@@ -225,11 +422,11 @@ const confirmDirExists = async (directory) => {
 };
 
 // Copyright (c) Microsoft Corporation.
-const statAsync$1 = util.promisify(fs.stat);
-const readdirAsync$1 = util.promisify(fs.readdir);
-const readFileAsync = util.promisify(fs.readFile);
-const unlinkAsync = util.promisify(fs.unlink);
-const writeFileAsync = util.promisify(fs.writeFile);
+const statAsync = util.promisify(fs__namespace.stat);
+const readdirAsync = util.promisify(fs__namespace.readdir);
+const readFileAsync = util.promisify(fs__namespace.readFile);
+const unlinkAsync = util.promisify(fs__namespace.unlink);
+const writeFileAsync = util.promisify(fs__namespace.writeFile);
 /**
  * File system persist class.
  * @internal
@@ -239,36 +436,56 @@ class FileSystemPersist {
         this.fileRetemptionPeriod = 7 * 24 * 60 * 60 * 1000; // 7 days
         this.cleanupTimeOut = 60 * 60 * 1000; // 1 hour
         this.maxBytesOnDisk = 50000000; // ~50MB
+        this._tempDirectory = "";
         this._fileCleanupTimer = null;
         this._options = Object.assign(Object.assign({}, DEFAULT_EXPORTER_CONFIG), options);
+        this._enabled = true;
+        FileAccessControl.checkFileProtection();
+        if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION) {
+            this._enabled = false;
+            api.diag.error("Sufficient file protection capabilities were not detected. Files will not be persisted");
+        }
         if (!this._options.instrumentationKey) {
-            api.diag.error(`No instrumentation key was provided to FileSystemPersister. Files may not be properly persisted`);
+            this._enabled = false;
+            api.diag.error(`No instrumentation key was provided to FileSystemPersister. Files will not be persisted`);
         }
-        this._tempDirectory = path.join(os.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
-        // Starts file cleanup task
-        if (!this._fileCleanupTimer) {
-            this._fileCleanupTimer = setTimeout(() => {
-                this._fileCleanupTask();
-            }, this.cleanupTimeOut);
-            this._fileCleanupTimer.unref();
+        if (this._enabled) {
+            this._tempDirectory = path__namespace.join(os__namespace.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
+            // Starts file cleanup task
+            if (!this._fileCleanupTimer) {
+                this._fileCleanupTimer = setTimeout(() => {
+                    this._fileCleanupTask();
+                }, this.cleanupTimeOut);
+                this._fileCleanupTimer.unref();
+            }
         }
     }
     push(value) {
-        api.diag.debug("Pushing value to persistent storage", value.toString());
-        return this._storeToDisk(JSON.stringify(value));
+        if (this._enabled) {
+            api.diag.debug("Pushing value to persistent storage", value.toString());
+            return this._storeToDisk(JSON.stringify(value));
+        }
+        return new Promise((resolve) => {
+            resolve(false);
+        });
     }
     async shift() {
-        api.diag.debug("Searching for filesystem persisted files");
-        try {
-            const buffer = await this._getFirstFileOnDisk();
-            if (buffer) {
-                return JSON.parse(buffer.toString("utf8"));
+        if (this._enabled) {
+            api.diag.debug("Searching for filesystem persisted files");
+            try {
+                const buffer = await this._getFirstFileOnDisk();
+                if (buffer) {
+                    return JSON.parse(buffer.toString("utf8"));
+                }
             }
+            catch (e) {
+                api.diag.debug("Failed to read persisted file", e);
+            }
+            return null;
         }
-        catch (e) {
-            api.diag.debug("Failed to read persisted file", e);
-        }
-        return null;
+        return new Promise((resolve) => {
+            resolve(null);
+        });
     }
     /**
      * Check for temp telemetry files
@@ -276,16 +493,16 @@ class FileSystemPersist {
      */
     async _getFirstFileOnDisk() {
         try {
-            const stats = await statAsync$1(this._tempDirectory);
+            const stats = await statAsync(this._tempDirectory);
             if (stats.isDirectory()) {
-                const origFiles = await readdirAsync$1(this._tempDirectory);
-                const files = origFiles.filter((f) => path.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
+                const origFiles = await readdirAsync(this._tempDirectory);
+                const files = origFiles.filter((f) => path__namespace.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
                 if (files.length === 0) {
                     return null;
                 }
                 else {
                     const firstFile = files[0];
-                    const filePath = path.join(this._tempDirectory, firstFile);
+                    const filePath = path__namespace.join(this._tempDirectory, firstFile);
                     const payload = await readFileAsync(filePath);
                     // delete the file first to prevent double sending
                     await unlinkAsync(filePath);
@@ -324,7 +541,7 @@ class FileSystemPersist {
             return false;
         }
         const fileName = `${new Date().getTime()}${FileSystemPersist.FILENAME_SUFFIX}`;
-        const fileFullPath = path.join(this._tempDirectory, fileName);
+        const fileFullPath = path__namespace.join(this._tempDirectory, fileName);
         // Mode 600 is w/r for creator and no read access for others
         api.diag.info(`saving data to disk at: ${fileFullPath}`);
         try {
@@ -338,10 +555,10 @@ class FileSystemPersist {
     }
     async _fileCleanupTask() {
         try {
-            const stats = await statAsync$1(this._tempDirectory);
+            const stats = await statAsync(this._tempDirectory);
             if (stats.isDirectory()) {
-                const origFiles = await readdirAsync$1(this._tempDirectory);
-                const files = origFiles.filter((f) => path.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
+                const origFiles = await readdirAsync(this._tempDirectory);
+                const files = origFiles.filter((f) => path__namespace.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
                 if (files.length === 0) {
                     return false;
                 }
@@ -351,7 +568,7 @@ class FileSystemPersist {
                         const fileCreationDate = new Date(parseInt(file.split(FileSystemPersist.FILENAME_SUFFIX)[0]));
                         const expired = new Date(+new Date() - this.fileRetemptionPeriod) > fileCreationDate;
                         if (expired) {
-                            const filePath = path.join(this._tempDirectory, file);
+                            const filePath = path__namespace.join(this._tempDirectory, file);
                             await unlinkAsync(filePath);
                         }
                     });
@@ -369,6 +586,61 @@ class FileSystemPersist {
 FileSystemPersist.TEMPDIR_PREFIX = "ot-azure-exporter-";
 FileSystemPersist.FILENAME_SUFFIX = ".ai.json";
 
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+/** Known values of {@link DataPointType} that the service accepts. */
+var KnownDataPointType;
+(function (KnownDataPointType) {
+    KnownDataPointType["Measurement"] = "Measurement";
+    KnownDataPointType["Aggregation"] = "Aggregation";
+})(KnownDataPointType || (KnownDataPointType = {}));
+/** Known values of {@link SeverityLevel} that the service accepts. */
+var KnownSeverityLevel;
+(function (KnownSeverityLevel) {
+    KnownSeverityLevel["Verbose"] = "Verbose";
+    KnownSeverityLevel["Information"] = "Information";
+    KnownSeverityLevel["Warning"] = "Warning";
+    KnownSeverityLevel["Error"] = "Error";
+    KnownSeverityLevel["Critical"] = "Critical";
+})(KnownSeverityLevel || (KnownSeverityLevel = {}));
+/** Known values of {@link ContextTagKeys} that the service accepts. */
+var KnownContextTagKeys;
+(function (KnownContextTagKeys) {
+    KnownContextTagKeys["AiApplicationVer"] = "ai.application.ver";
+    KnownContextTagKeys["AiDeviceId"] = "ai.device.id";
+    KnownContextTagKeys["AiDeviceLocale"] = "ai.device.locale";
+    KnownContextTagKeys["AiDeviceModel"] = "ai.device.model";
+    KnownContextTagKeys["AiDeviceOemName"] = "ai.device.oemName";
+    KnownContextTagKeys["AiDeviceOsVersion"] = "ai.device.osVersion";
+    KnownContextTagKeys["AiDeviceType"] = "ai.device.type";
+    KnownContextTagKeys["AiLocationIp"] = "ai.location.ip";
+    KnownContextTagKeys["AiLocationCountry"] = "ai.location.country";
+    KnownContextTagKeys["AiLocationProvince"] = "ai.location.province";
+    KnownContextTagKeys["AiLocationCity"] = "ai.location.city";
+    KnownContextTagKeys["AiOperationId"] = "ai.operation.id";
+    KnownContextTagKeys["AiOperationName"] = "ai.operation.name";
+    KnownContextTagKeys["AiOperationParentId"] = "ai.operation.parentId";
+    KnownContextTagKeys["AiOperationSyntheticSource"] = "ai.operation.syntheticSource";
+    KnownContextTagKeys["AiOperationCorrelationVector"] = "ai.operation.correlationVector";
+    KnownContextTagKeys["AiSessionId"] = "ai.session.id";
+    KnownContextTagKeys["AiSessionIsFirst"] = "ai.session.isFirst";
+    KnownContextTagKeys["AiUserAccountId"] = "ai.user.accountId";
+    KnownContextTagKeys["AiUserId"] = "ai.user.id";
+    KnownContextTagKeys["AiUserAuthUserId"] = "ai.user.authUserId";
+    KnownContextTagKeys["AiCloudRole"] = "ai.cloud.role";
+    KnownContextTagKeys["AiCloudRoleVer"] = "ai.cloud.roleVer";
+    KnownContextTagKeys["AiCloudRoleInstance"] = "ai.cloud.roleInstance";
+    KnownContextTagKeys["AiCloudLocation"] = "ai.cloud.location";
+    KnownContextTagKeys["AiInternalSdkVersion"] = "ai.internal.sdkVersion";
+    KnownContextTagKeys["AiInternalAgentVersion"] = "ai.internal.agentVersion";
+    KnownContextTagKeys["AiInternalNodeName"] = "ai.internal.nodeName";
+})(KnownContextTagKeys || (KnownContextTagKeys = {}));
+
 /*
  * Copyright (c) Microsoft Corporation.
  * Licensed under the MIT License.
@@ -394,7 +666,12 @@ const body = {
         required: true,
         type: {
             name: "Sequence",
-            element: { type: { name: "Composite", className: "TelemetryItem" } }
+            element: {
+                type: {
+                    name: "Composite",
+                    className: "TelemetryItem"
+                }
+            }
         }
     }
 };
@@ -553,7 +830,10 @@ const TrackResponse = {
                 type: {
                     name: "Sequence",
                     element: {
-                        type: { name: "Composite", className: "TelemetryErrorDetails" }
+                        type: {
+                            name: "Composite",
+                            className: "TelemetryErrorDetails"
+                        }
                     }
                 }
             }
@@ -625,24 +905,28 @@ const MetricDataPoint = {
             },
             count: {
                 serializedName: "count",
+                nullable: true,
                 type: {
                     name: "Number"
                 }
             },
             min: {
                 serializedName: "min",
+                nullable: true,
                 type: {
                     name: "Number"
                 }
             },
             max: {
                 serializedName: "max",
+                nullable: true,
                 type: {
                     name: "Number"
                 }
             },
             stdDev: {
                 serializedName: "stdDev",
+                nullable: true,
                 type: {
                     name: "Number"
                 }
@@ -706,7 +990,12 @@ const TelemetryExceptionDetails = {
                 serializedName: "parsedStack",
                 type: {
                     name: "Sequence",
-                    element: { type: { name: "Composite", className: "StackFrame" } }
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "StackFrame"
+                        }
+                    }
                 }
             }
         }
@@ -867,11 +1156,15 @@ const TelemetryExceptionData = {
                 type: {
                     name: "Sequence",
                     element: {
-                        type: { name: "Composite", className: "TelemetryExceptionDetails" }
+                        type: {
+                            name: "Composite",
+                            className: "TelemetryExceptionDetails"
+                        }
                     }
                 }
             }, severityLevel: {
                 serializedName: "severityLevel",
+                nullable: true,
                 type: {
                     name: "String"
                 }
@@ -942,7 +1235,12 @@ const MetricsData = {
                 required: true,
                 type: {
                     name: "Sequence",
-                    element: { type: { name: "Composite", className: "MetricDataPoint" } }
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "MetricDataPoint"
+                        }
+                    }
                 }
             }, properties: {
                 serializedName: "properties",
@@ -1273,9 +1571,7 @@ var Mappers = /*#__PURE__*/Object.freeze({
  * Code generated by Microsoft (R) AutoRest Code Generator.
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
-const packageName = "@azure/monitor-opentelemetry-exporter";
-const packageVersion = "1.0.0-beta.2";
-class ApplicationInsightsClientContext extends coreHttp.ServiceClient {
+class ApplicationInsightsClientContext extends coreClient__namespace.ServiceClient {
     /**
      * Initializes a new instance of the ApplicationInsightsClientContext class.
      * @param options The parameter options
@@ -1285,13 +1581,17 @@ class ApplicationInsightsClientContext extends coreHttp.ServiceClient {
         if (!options) {
             options = {};
         }
-        if (!options.userAgent) {
-            const defaultUserAgent = coreHttp.getDefaultUserAgentValue();
-            options.userAgent = `${packageName}/${packageVersion} ${defaultUserAgent}`;
-        }
-        super(undefined, options);
-        this.requestContentType = "application/json; charset=utf-8";
-        this.baseUri = options.endpoint || "{Host}/v2";
+        const defaults = {
+            requestContentType: "application/json; charset=utf-8"
+        };
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.7`;
+        const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+            ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
+            : `${packageDetails}`;
+        const optionsWithDefaults = Object.assign(Object.assign(Object.assign({}, defaults), options), { userAgentOptions: {
+                userAgentPrefix
+            }, baseUri: options.endpoint || "{Host}/v2.1" });
+        super(optionsWithDefaults);
         // Assigning values to Constant parameters
         this.host = options.host || "https://dc.services.visualstudio.com";
     }
@@ -1318,12 +1618,11 @@ class ApplicationInsightsClient extends ApplicationInsightsClientContext {
      * @param options The options parameters.
      */
     track(body, options) {
-        const operationOptions = coreHttp.operationOptionsToRequestOptionsBase(options || {});
-        return this.sendOperationRequest({ body, options: operationOptions }, trackOperationSpec);
+        return this.sendOperationRequest({ body, options }, trackOperationSpec);
     }
 }
 // Operation Specifications
-const serializer = new coreHttp.Serializer(Mappers, /* isXml */ false);
+const serializer = coreClient__namespace.createSerializer(Mappers, /* isXml */ false);
 const trackOperationSpec = {
     path: "/track",
     httpMethod: "POST",
@@ -1335,19 +1634,24 @@ const trackOperationSpec = {
             bodyMapper: TrackResponse
         },
         400: {
-            bodyMapper: TrackResponse
+            bodyMapper: TrackResponse,
+            isError: true
         },
         402: {
-            bodyMapper: TrackResponse
+            bodyMapper: TrackResponse,
+            isError: true
         },
         429: {
-            bodyMapper: TrackResponse
+            bodyMapper: TrackResponse,
+            isError: true
         },
         500: {
-            bodyMapper: TrackResponse
+            bodyMapper: TrackResponse,
+            isError: true
         },
         503: {
-            bodyMapper: TrackResponse
+            bodyMapper: TrackResponse,
+            isError: true
         }
     },
     requestBody: body,
@@ -1358,6 +1662,7 @@ const trackOperationSpec = {
 };
 
 // Copyright (c) Microsoft Corporation.
+const applicationInsightsResource = "https://monitor.azure.com//.default";
 /**
  * Exporter HTTP sender class
  * @internal
@@ -1367,9 +1672,18 @@ class HttpSender {
         this._exporterOptions = _exporterOptions;
         // Build endpoint using provided configuration or default values
         this._appInsightsClientOptions = {
-            host: this._exporterOptions.endpointUrl
+            host: this._exporterOptions.endpointUrl,
         };
         this._appInsightsClient = new ApplicationInsightsClient(Object.assign({}, this._appInsightsClientOptions));
+        // Handle redirects in HTTP Sender
+        this._appInsightsClient.pipeline.removePolicy({ name: coreRestPipeline.redirectPolicyName });
+        if (this._exporterOptions.aadTokenCredential) {
+            let scopes = [applicationInsightsResource];
+            this._appInsightsClient.pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
+                credential: this._exporterOptions.aadTokenCredential,
+                scopes: scopes,
+            }));
+        }
     }
     /**
      * Send Azure envelopes
@@ -1377,9 +1691,17 @@ class HttpSender {
      */
     async send(envelopes) {
         var _a;
+        let options = {};
         try {
-            const { _response: res } = await this._appInsightsClient.track(envelopes);
-            return { statusCode: res.status, result: (_a = res.bodyAsText) !== null && _a !== void 0 ? _a : "" };
+            let response;
+            function onResponse(rawResponse, flatResponse) {
+                response = rawResponse;
+                if (options.onResponse) {
+                    options.onResponse(rawResponse, flatResponse);
+                }
+            }
+            await this._appInsightsClient.track(envelopes, Object.assign(Object.assign({}, options), { onResponse }));
+            return { statusCode: response === null || response === void 0 ? void 0 : response.status, result: (_a = response === null || response === void 0 ? void 0 : response.bodyAsText) !== null && _a !== void 0 ? _a : "" };
         }
         catch (e) {
             throw e;
@@ -1394,7 +1716,7 @@ class HttpSender {
     }
     handlePermanentRedirect(location) {
         if (location) {
-            const locUrl = new url__default.URL(location);
+            const locUrl = new url__default["default"].URL(location);
             if (locUrl && locUrl.host) {
                 this._appInsightsClient.host = "https://" + locUrl.host;
             }
@@ -1402,6 +1724,37 @@ class HttpSender {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * AI MS Links.
+ * @internal
+ */
+const MS_LINKS = "_MS.links";
+/**
+ * AI enqueued time attribute.
+ * @internal
+ */
+const ENQUEUED_TIME = "enqueuedTime";
+/**
+ * AI time since enqueued attribute.
+ * @internal
+ */
+const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
+/**
+ * AzureMonitorTraceExporter version.
+ * @internal
+ */
+const packageVersion = "1.0.0-beta.7";
+var DependencyTypes;
+(function (DependencyTypes) {
+    DependencyTypes["InProc"] = "InProc";
+    DependencyTypes["QueueMessage"] = "Queue Message";
+    DependencyTypes["Sql"] = "SQL";
+    DependencyTypes["Http"] = "Http";
+    DependencyTypes["Grpc"] = "GRPC";
+})(DependencyTypes || (DependencyTypes = {}));
+
 // Copyright (c) Microsoft Corporation.
 let instance = null;
 /**
@@ -1409,102 +1762,32 @@ let instance = null;
  * @internal
  */
 class Context {
-    constructor(
-    /**
-     * Path to this module's `package.json` relative to
-     * `Context.ROOT_PATH`
-     */
-    _exporterPrefix = "./", 
-    /**
-     * Path to end user application folder which contains `package.json`
-     * relative to `Context.ROOT_PATH`
-     */
-    _appPrefix = "../../../") {
-        this._exporterPrefix = _exporterPrefix;
-        this._appPrefix = _appPrefix;
+    constructor() {
         this.tags = {};
-        this._loadApplicationContext();
         this._loadDeviceContext();
         this._loadInternalContext();
     }
-    _loadApplicationContext() {
-        if (Object.keys(Context.appVersion).length === 0) {
-            // note: this should return the host package.json
-            let packageJson = null;
-            const packageJsonPath = path.resolve(__dirname, Context.JS_NODE_PREFIX, this._appPrefix, Context.ROOT_PATH, "./package.json");
-            const packageJsonPathTsNode = path.resolve(__dirname, this._appPrefix, Context.ROOT_PATH, "./package.json");
-            Context.appVersion[packageJsonPath] = "unknown";
-            try {
-                packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-            }
-            catch (_) {
-                try {
-                    packageJson = JSON.parse(fs.readFileSync(packageJsonPathTsNode, "utf8"));
-                }
-                catch (exception) {
-                    api.diag.warn("Failed to load Application version", exception);
-                }
-            }
-            if (packageJson && typeof packageJson.version === "string") {
-                Context.appVersion[packageJsonPath] = packageJson.version;
-            }
-            this.tags["ai.application.ver"] = Context.appVersion[packageJsonPath];
-        }
-    }
     _loadDeviceContext() {
-        this.tags["ai.device.id"] = "";
-        this.tags["ai.device.osVersion"] = os && `${os.type()} ${os.release()}`;
-        // not yet supported tags
-        this.tags["ai.device.osArchitecture"] = os && os.arch();
-        this.tags["ai.device.osPlatform"] = os && os.platform();
+        this.tags[KnownContextTagKeys.AiDeviceOsVersion] = os__namespace && `${os__namespace.type()} ${os__namespace.release()}`;
     }
     _loadInternalContext() {
-        if (!Context.sdkVersion) {
-            let packageJson = null;
-            const { node } = process.versions;
-            [Context.nodeVersion] = node.split(".");
-            // note: this should return the sdk package.json
-            const packageJsonPath = path.resolve(__dirname, Context.JS_NODE_PREFIX, this._exporterPrefix, Context.ROOT_PATH, "./package.json");
-            const packageJsonPathTsNode = path.resolve(__dirname, this._exporterPrefix, Context.ROOT_PATH, "./package.json");
-            Context.sdkVersion = "unknown";
-            try {
-                packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-            }
-            catch (_) {
-                try {
-                    packageJson = JSON.parse(fs.readFileSync(packageJsonPathTsNode, "utf8"));
-                }
-                catch (exception) {
-                    api.diag.warn("Failed to load Exporter version", exception);
-                    throw exception;
-                }
-            }
-            if (packageJson && typeof packageJson.version === "string") {
-                Context.sdkVersion = packageJson.version;
-            }
-        }
-        this.tags["ai.internal.sdkVersion"] = `node${Context.nodeVersion}:ot${core.SDK_INFO.VERSION}:ext${Context.sdkVersion}`;
+        const { node } = process.versions;
+        [Context.nodeVersion] = node.split(".");
+        Context.opentelemetryVersion = core.SDK_INFO[semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION];
+        Context.sdkVersion = packageVersion;
+        this.tags[KnownContextTagKeys.AiInternalSdkVersion] = `node${Context.nodeVersion}:otel${Context.opentelemetryVersion}:ext${Context.sdkVersion}`;
     }
 }
-Context.appVersion = {};
 Context.sdkVersion = null;
 Context.opentelemetryVersion = null;
 Context.nodeVersion = "";
-/**
- * Add extra ../ to access on environments not using ts-node
- */
-Context.JS_NODE_PREFIX = "../";
-/**
- * Path to azure-opentelemetry-exporter
- */
-Context.ROOT_PATH = "../../../../";
 /**
  * Singleton Context instance.
  * @internal
  */
-function getInstance(exporterPrefix, appPrefix) {
+function getInstance() {
     if (!instance) {
-        instance = new Context(exporterPrefix, appPrefix);
+        instance = new Context();
     }
     return instance;
 }
@@ -1516,12 +1799,13 @@ function getInstance(exporterPrefix, appPrefix) {
  * @internal
  */
 function isRetriable(statusCode) {
-    return (statusCode === 206 || // Retriable
+    return (statusCode === 206 || // Partial Accept
+        statusCode === 401 || // Unauthorized
+        statusCode === 403 || // Forbidden
         statusCode === 408 || // Timeout
-        statusCode === 429 || // Throttle
-        statusCode === 439 || // Quota
+        statusCode === 429 || // Too many requests
         statusCode === 500 || // Server Error
-        statusCode === 503 // Server Unavilable
+        statusCode === 503 // Server Unavailable
     );
 }
 /**
@@ -1544,100 +1828,6 @@ function msToTimeSpan(ms) {
     return `${daysText + hour}:${min}:${sec}`;
 }
 
-// Copyright (c) Microsoft Corporation.
-/**
- * OpenTelemetry HTTP method attribute.
- * @internal
- */
-const HTTP_METHOD = conventions.SemanticAttributes.HTTP_METHOD;
-/**
- * OpenTelemetry HTTP URL attribute.
- * @internal
- */
-const HTTP_URL = conventions.SemanticAttributes.HTTP_URL;
-/**
- * OpenTelemetry HTTP route attribute.
- * @internal
- */
-const HTTP_ROUTE = conventions.SemanticAttributes.HTTP_ROUTE;
-/**
- * OpenTelemetry HTTP status code attribute.
- * @internal
- */
-const HTTP_STATUS_CODE = conventions.SemanticAttributes.HTTP_STATUS_CODE;
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * AI cloud role tag name.
- * @internal
- */
-const AI_CLOUD_ROLE = "ai.cloud.role";
-/**
- * AI cloud role isntance tag name.
- * @internal
- */
-const AI_CLOUD_ROLE_INSTACE = "ai.cloud.roleInstance";
-/**
- * AI operation Id tag name.
- * @internal
- */
-const AI_OPERATION_ID = "ai.operation.id";
-/**
- * AI operation parent Id tag name.
- * @internal
- */
-const AI_OPERATION_PARENT_ID = "ai.operation.parentId";
-/**
- * AI operation tag name.
- * @internal
- */
-const AI_OPERATION_NAME = "ai.operation.name";
-/**
- * AI MS Links.
- * @internal
- */
-const MS_LINKS = "_MS.links";
-/**
- * AI InProc attribute.
- * @internal
- */
-const INPROC = "InProc";
-/**
- * AI enqueued time attribute.
- * @internal
- */
-const ENQUEUED_TIME = "enqueuedTime";
-/**
- * AI time since enqueued attribute.
- * @internal
- */
-const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
-
-// Copyright (c) Microsoft Corporation.
-/**
- * OpenTelemetry GRPC method attribute.
- * @internal
- */
-const GRPC_METHOD = conventions.SemanticAttributes.RPC_METHOD;
-/**
- * OpenTelemetry GRPC status code attribute.
- * @internal
- */
-const GRPC_STATUS_CODE = conventions.SemanticAttributes.RPC_GRPC_STATUS_CODE;
-
-// Copyright (c) Microsoft Corporation.
-/**
- * OpenTelemetry DB name attribute.
- * @internal
- */
-const DB_NAME = conventions.SemanticAttributes.DB_NAME;
-/**
- * OpenTelemetry DB statement attribute.
- * @internal
- */
-const DB_STATEMENT = conventions.SemanticAttributes.DB_STATEMENT;
-
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 /**
@@ -1681,7 +1871,7 @@ const getTimeSinceEnqueued = (span) => {
  */
 const parseEventHubSpan = (span, baseData) => {
     const namespace = span.attributes[AzNamespace];
-    const peerAddress = (span.attributes[conventions.SemanticAttributes.NET_PEER_NAME] ||
+    const peerAddress = (span.attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME] ||
         span.attributes["peer.address"] ||
         "unknown").replace(/\/$/g, ""); // remove trailing "/"
     const messageBusDestination = (span.attributes[MessageBusDestination] || "unknown");
@@ -1706,35 +1896,70 @@ const parseEventHubSpan = (span, baseData) => {
 function createTagsFromSpan(span) {
     const context = getInstance();
     const tags = Object.assign({}, context.tags);
-    tags[AI_OPERATION_ID] = span.spanContext().traceId;
+    tags[KnownContextTagKeys.AiOperationId] = span.spanContext().traceId;
     if (span.parentSpanId) {
-        tags[AI_OPERATION_PARENT_ID] = span.parentSpanId;
+        tags[KnownContextTagKeys.AiOperationParentId] = span.parentSpanId;
     }
     if (span.resource && span.resource.attributes) {
-        const serviceName = span.resource.attributes[conventions.ResourceAttributes.SERVICE_NAME];
-        const serviceNamespace = span.resource.attributes[conventions.ResourceAttributes.SERVICE_NAMESPACE];
-        const serviceInstanceId = span.resource.attributes[conventions.ResourceAttributes.SERVICE_INSTANCE_ID];
+        const serviceName = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
+        const serviceNamespace = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
         if (serviceName) {
             if (serviceNamespace) {
-                tags[AI_CLOUD_ROLE] = `${serviceNamespace}.${serviceName}`;
+                tags[KnownContextTagKeys.AiCloudRole] = `${serviceNamespace}.${serviceName}`;
             }
             else {
-                tags[AI_CLOUD_ROLE] = String(serviceName);
+                tags[KnownContextTagKeys.AiCloudRole] = String(serviceName);
             }
         }
+        const serviceInstanceId = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
         if (serviceInstanceId) {
-            tags[AI_CLOUD_ROLE_INSTACE] = String(serviceInstanceId);
+            tags[KnownContextTagKeys.AiCloudRoleInstance] = String(serviceInstanceId);
+        }
+        else {
+            tags[KnownContextTagKeys.AiCloudRoleInstance] = os__default["default"] && os__default["default"].hostname();
+        }
+        const endUserId = span.resource.attributes[semanticConventions.SemanticAttributes.ENDUSER_ID];
+        if (endUserId) {
+            tags[KnownContextTagKeys.AiUserId] = String(endUserId);
         }
     }
-    // @todo: is this for RequestData only?
-    if ((span.kind === api.SpanKind.SERVER || span.kind === api.SpanKind.CONSUMER) &&
-        span.attributes[GRPC_METHOD]) {
-        tags[AI_OPERATION_NAME] = String(span.attributes[GRPC_METHOD]);
+    if (span.kind === api.SpanKind.SERVER) {
+        const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
+        const httpClientIp = span.attributes[semanticConventions.SemanticAttributes.HTTP_CLIENT_IP];
+        const netPeerIp = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+        if (httpMethod) {
+            const httpRoute = span.attributes[semanticConventions.SemanticAttributes.HTTP_ROUTE];
+            const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+            tags[KnownContextTagKeys.AiOperationName] = span.name; // Default
+            if (httpRoute) {
+                tags[KnownContextTagKeys.AiOperationName] = `${httpMethod} ${httpRoute}`;
+            }
+            else if (httpUrl) {
+                try {
+                    let url$1 = new url.URL(String(httpUrl));
+                    tags[KnownContextTagKeys.AiOperationName] = `${httpMethod} ${url$1.pathname}`;
+                }
+                catch (ex) { }
+            }
+            if (httpClientIp) {
+                tags[KnownContextTagKeys.AiLocationIp] = String(httpClientIp);
+            }
+            else if (netPeerIp) {
+                tags[KnownContextTagKeys.AiLocationIp] = String(netPeerIp);
+            }
+        }
+        else {
+            tags[KnownContextTagKeys.AiOperationName] = span.name;
+            if (netPeerIp) {
+                tags[KnownContextTagKeys.AiLocationIp] = String(netPeerIp);
+            }
+        }
     }
-    if ((span.kind === api.SpanKind.SERVER || span.kind === api.SpanKind.CONSUMER) &&
-        span.attributes[HTTP_METHOD] &&
-        span.attributes[HTTP_ROUTE]) {
-        tags[AI_OPERATION_NAME] = `${span.attributes[HTTP_METHOD]} ${span.attributes[HTTP_ROUTE]}`;
+    // TODO: Operation Name and Location IP TBD for non server spans
+    const httpUserAgent = span.attributes[semanticConventions.SemanticAttributes.HTTP_USER_AGENT];
+    if (httpUserAgent) {
+        // TODO: Not exposed in Swagger, need to update def
+        tags["ai.user.userAgent"] = String(httpUserAgent);
     }
     return tags;
 }
@@ -1742,99 +1967,223 @@ function createPropertiesFromSpan(span) {
     const properties = {};
     const measurements = {};
     for (const key of Object.keys(span.attributes)) {
-        if (!(key.startsWith("http.") || key.startsWith("rpc.") || key.startsWith("db."))) {
+        if (!(key.startsWith("http.") ||
+            key.startsWith("rpc.") ||
+            key.startsWith("db.") ||
+            key.startsWith("peer.") ||
+            key.startsWith("net."))) {
             properties[key] = span.attributes[key];
         }
     }
     const links = span.links.map((link) => ({
         operation_Id: link.context.traceId,
-        id: link.context.spanId
+        id: link.context.spanId,
     }));
     if (links.length > 0) {
         properties[MS_LINKS] = JSON.stringify(links);
     }
     return [properties, measurements];
 }
+function isSqlDB(dbSystem) {
+    return (dbSystem === semanticConventions.DbSystemValues.DB2 ||
+        dbSystem === semanticConventions.DbSystemValues.DERBY ||
+        dbSystem === semanticConventions.DbSystemValues.MARIADB ||
+        dbSystem === semanticConventions.DbSystemValues.MSSQL ||
+        dbSystem === semanticConventions.DbSystemValues.ORACLE ||
+        dbSystem === semanticConventions.DbSystemValues.SQLITE ||
+        dbSystem === semanticConventions.DbSystemValues.OTHER_SQL ||
+        dbSystem === semanticConventions.DbSystemValues.HSQLDB ||
+        dbSystem === semanticConventions.DbSystemValues.H2);
+}
+function getUrl(span) {
+    const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
+    if (httpMethod) {
+        const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+        if (httpUrl) {
+            return String(httpUrl);
+        }
+        else {
+            const httpScheme = span.attributes[semanticConventions.SemanticAttributes.HTTP_SCHEME];
+            const httpTarget = span.attributes[semanticConventions.SemanticAttributes.HTTP_TARGET];
+            if (httpScheme && httpTarget) {
+                const httpHost = span.attributes[semanticConventions.SemanticAttributes.HTTP_HOST];
+                if (httpHost) {
+                    return `${httpScheme}://${httpHost}${httpTarget}`;
+                }
+                else {
+                    const netPeerPort = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_PORT];
+                    if (netPeerPort) {
+                        const netPeerName = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME];
+                        if (netPeerName) {
+                            return `${httpScheme}://${netPeerName}:${netPeerPort}${httpTarget}`;
+                        }
+                        else {
+                            const netPeerIp = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+                            if (netPeerIp) {
+                                return `${httpScheme}://${netPeerIp}:${netPeerPort}${httpTarget}`;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return "";
+}
+function getDependencyTarget(span) {
+    const peerService = span.attributes[semanticConventions.SemanticAttributes.PEER_SERVICE];
+    const httpHost = span.attributes[semanticConventions.SemanticAttributes.HTTP_HOST];
+    const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+    const netPeerName = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME];
+    const netPeerIp = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+    if (peerService) {
+        return String(peerService);
+    }
+    else if (httpHost) {
+        return String(httpHost);
+    }
+    else if (httpUrl) {
+        return String(httpUrl);
+    }
+    else if (netPeerName) {
+        return String(netPeerName);
+    }
+    else if (netPeerIp) {
+        return String(netPeerIp);
+    }
+    return "";
+}
 function createDependencyData(span) {
-    const data = {
+    const remoteDependencyData = {
         name: span.name,
-        id: `|${span.spanContext().traceId}.${span.spanContext().spanId}.`,
-        success: span.status.code === api.SpanStatusCode.OK,
-        resultCode: String(span.status.code),
-        target: span.attributes[HTTP_URL],
+        id: `${span.spanContext().spanId}`,
+        success: span.status.code != api.SpanStatusCode.ERROR,
+        resultCode: "0",
         type: "Dependency",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
-        version: 1
+        version: 2,
     };
-    if (span.attributes[HTTP_STATUS_CODE]) {
-        data.type = "HTTP";
-        data.resultCode = String(span.attributes[HTTP_STATUS_CODE]);
-    }
-    if (span.attributes[GRPC_STATUS_CODE] !== undefined) {
-        data.type = "GRPC";
-        data.resultCode = String(span.attributes[GRPC_STATUS_CODE]);
-    }
-    if (span.attributes[GRPC_METHOD]) {
-        data.target = String(span.attributes[GRPC_METHOD]);
-        data.data = String(span.attributes[GRPC_METHOD]);
+    if (span.kind === api.SpanKind.PRODUCER) {
+        remoteDependencyData.type = DependencyTypes.QueueMessage;
+    }
+    if (span.kind === api.SpanKind.INTERNAL && span.parentSpanId) {
+        remoteDependencyData.type = DependencyTypes.InProc;
+    }
+    const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
+    const dbSystem = span.attributes[semanticConventions.SemanticAttributes.DB_SYSTEM];
+    const rpcSystem = span.attributes[semanticConventions.SemanticAttributes.RPC_SYSTEM];
+    // HTTP Dependency
+    if (httpMethod) {
+        const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+        if (httpUrl) {
+            try {
+                let dependencyUrl = new url.URL(String(httpUrl));
+                remoteDependencyData.name = `${httpMethod} ${dependencyUrl.pathname}`;
+            }
+            catch (ex) { }
+        }
+        remoteDependencyData.type = DependencyTypes.Http;
+        remoteDependencyData.data = getUrl(span);
+        const httpStatusCode = span.attributes[semanticConventions.SemanticAttributes.HTTP_STATUS_CODE];
+        if (httpStatusCode) {
+            remoteDependencyData.resultCode = String(httpStatusCode);
+        }
+        let target = getDependencyTarget(span);
+        if (target) {
+            try {
+                // Remove default port
+                let portRegex = new RegExp(/(https?)(:\/\/.*)(:\d+)(\S*)/);
+                let res = portRegex.exec(target);
+                if (res != null) {
+                    let protocol = res[1];
+                    let port = res[3];
+                    if ((protocol == "https" && port == ":443") || (protocol == "http" && port == ":80")) {
+                        // Drop port
+                        target = res[1] + res[2] + res[4];
+                    }
+                }
+            }
+            catch (error) { }
+            remoteDependencyData.target = `${target}`;
+        }
     }
-    if (span.attributes[HTTP_URL]) {
-        const url$1 = new url.URL(span.attributes[HTTP_URL]);
-        data.target = url$1.hostname;
-        data.data = url$1.href;
-        if (span.attributes[HTTP_METHOD]) {
-            data.name = `${span.attributes[HTTP_METHOD]} ${url$1.pathname}`;
+    // DB Dependency
+    else if (dbSystem) {
+        // TODO: Remove special logic when Azure UX supports OpenTelemetry dbSystem
+        if (String(dbSystem) === semanticConventions.DbSystemValues.MYSQL) {
+            remoteDependencyData.type = "mysql";
+        }
+        else if (String(dbSystem) === semanticConventions.DbSystemValues.POSTGRESQL) {
+            remoteDependencyData.type = "postgresql";
+        }
+        else if (String(dbSystem) === semanticConventions.DbSystemValues.MONGODB) {
+            remoteDependencyData.type = "mongodb";
+        }
+        else if (String(dbSystem) === semanticConventions.DbSystemValues.REDIS) {
+            remoteDependencyData.type = "redis";
+        }
+        else if (isSqlDB(String(dbSystem))) {
+            remoteDependencyData.type = "SQL";
+        }
+        else {
+            remoteDependencyData.type = String(dbSystem);
+        }
+        const dbStatement = span.attributes[semanticConventions.SemanticAttributes.DB_STATEMENT];
+        const dbOperation = span.attributes[semanticConventions.SemanticAttributes.DB_OPERATION];
+        if (dbStatement) {
+            remoteDependencyData.data = String(dbStatement);
+        }
+        else if (dbOperation) {
+            remoteDependencyData.data = String(dbOperation);
+        }
+        let target = getDependencyTarget(span);
+        const dbName = span.attributes[semanticConventions.SemanticAttributes.DB_NAME];
+        if (target) {
+            remoteDependencyData.target = dbName ? `${target}|${dbName}` : `${target}`;
+        }
+        else {
+            remoteDependencyData.target = dbName ? `${dbName}` : `${dbSystem}`;
         }
     }
-    if (span.attributes[DB_STATEMENT]) {
-        data.name = String(span.attributes[DB_STATEMENT]);
-        data.data = String(span.attributes[DB_STATEMENT]);
-        data.type = "DB";
-        if (span.attributes[DB_NAME]) {
-            data.target = String(span.attributes[DB_NAME]);
+    // grpc Dependency
+    else if (rpcSystem) {
+        remoteDependencyData.type = DependencyTypes.Grpc;
+        const grpcStatusCode = span.attributes[semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE];
+        if (grpcStatusCode) {
+            remoteDependencyData.resultCode = String(grpcStatusCode);
+        }
+        let target = getDependencyTarget(span);
+        if (target) {
+            remoteDependencyData.target = `${target}`;
+        }
+        else if (rpcSystem) {
+            remoteDependencyData.target = String(rpcSystem);
         }
     }
-    return data;
+    return remoteDependencyData;
 }
 function createRequestData(span) {
-    const data = {
-        name: span.name,
-        id: `|${span.spanContext().traceId}.${span.spanContext().spanId}.`,
-        success: span.status.code === api.SpanStatusCode.OK,
-        responseCode: String(span.status.code),
+    const requestData = {
+        id: `${span.spanContext().spanId}`,
+        success: span.status.code != api.SpanStatusCode.ERROR,
+        responseCode: "0",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
-        version: 1,
-        source: undefined
+        version: 2,
+        source: undefined,
     };
-    if (span.attributes[HTTP_METHOD]) {
-        data.name = span.attributes[HTTP_METHOD];
-        if (span.attributes[HTTP_STATUS_CODE]) {
-            data.responseCode = String(span.attributes[HTTP_STATUS_CODE]);
-        }
-        if (span.attributes[HTTP_URL]) {
-            data.url = span.attributes[HTTP_URL];
-        }
-        if (span.attributes[HTTP_ROUTE]) {
-            data.name = `${span.attributes[HTTP_METHOD]} ${span.attributes[HTTP_ROUTE]}`;
+    const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
+    const grpcStatusCode = span.attributes[semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE];
+    if (httpMethod) {
+        requestData.url = getUrl(span);
+        const httpStatusCode = span.attributes[semanticConventions.SemanticAttributes.HTTP_STATUS_CODE];
+        if (httpStatusCode) {
+            requestData.responseCode = String(httpStatusCode);
         }
-        else if (span.attributes[HTTP_URL]) {
-            const url$1 = new url.URL(span.attributes[HTTP_URL]);
-            data.name = `${span.attributes[HTTP_METHOD]} ${url$1.pathname}`;
-        }
-    }
-    if (span.attributes[GRPC_STATUS_CODE]) {
-        data.responseCode = String(span.attributes[GRPC_STATUS_CODE]);
     }
-    if (span.attributes[GRPC_METHOD]) {
-        data.url = String(span.attributes[GRPC_METHOD]);
+    else if (grpcStatusCode) {
+        requestData.responseCode = String(grpcStatusCode);
     }
-    return data;
-}
-function createInProcData(span) {
-    const data = createDependencyData(span);
-    data.type = INPROC;
-    data.success = true;
-    return data;
+    return requestData;
 }
 /**
  * Span to Azure envelope parsing.
@@ -1852,6 +2201,7 @@ function readableSpanToEnvelope(span, ikey) {
     switch (span.kind) {
         case api.SpanKind.CLIENT:
         case api.SpanKind.PRODUCER:
+        case api.SpanKind.INTERNAL:
             name = "Microsoft.ApplicationInsights.RemoteDependency";
             baseType = "RemoteDependencyData";
             baseData = createDependencyData(span);
@@ -1861,25 +2211,20 @@ function readableSpanToEnvelope(span, ikey) {
             name = "Microsoft.ApplicationInsights.Request";
             baseType = "RequestData";
             baseData = createRequestData(span);
-            break;
-        case api.SpanKind.INTERNAL:
-            baseType = "RemoteDependencyData";
-            name = "Microsoft.ApplicationInsights.RemoteDependency";
-            baseData = createInProcData(span);
+            baseData.name = tags[KnownContextTagKeys.AiOperationName];
             break;
         default:
             // never
             api.diag.error(`Unsupported span kind ${span.kind}`);
             throw new Error(`Unsupported span kind ${span.kind}`);
     }
-    if (span.attributes[AzNamespace] === MicrosoftEventHub) {
-        parseEventHubSpan(span, baseData);
-    }
-    else if (span.attributes[AzNamespace]) {
-        switch (span.kind) {
-            case api.SpanKind.INTERNAL:
-                baseData.type = `${INPROC} | ${span.attributes[AzNamespace]}`;
-                break;
+    // Azure SDK
+    if (span.attributes[AzNamespace]) {
+        if (span.kind === api.SpanKind.INTERNAL) {
+            baseData.type = `${DependencyTypes.InProc} | ${span.attributes[AzNamespace]}`;
+        }
+        if (span.attributes[AzNamespace] === MicrosoftEventHub) {
+            parseEventHubSpan(span, baseData);
         }
     }
     return {
@@ -1892,8 +2237,8 @@ function readableSpanToEnvelope(span, ikey) {
         data: {
             baseType,
             baseData: Object.assign(Object.assign({}, baseData), { properties,
-                measurements })
-        }
+                measurements }),
+        },
     };
 }
 
@@ -1912,6 +2257,7 @@ class AzureMonitorTraceExporter {
         const connectionString = options.connectionString || process.env[ENV_CONNECTION_STRING];
         this._options = Object.assign({}, DEFAULT_EXPORTER_CONFIG);
         this._options.apiVersion = (_a = options.apiVersion) !== null && _a !== void 0 ? _a : this._options.apiVersion;
+        this._options.aadTokenCredential = options.aadTokenCredential;
         if (connectionString) {
             const parsedConnectionString = ConnectionStringParser.parse(connectionString);
             this._options.instrumentationKey =
@@ -1937,7 +2283,7 @@ class AzureMonitorTraceExporter {
                 ? { code: core.ExportResultCode.SUCCESS }
                 : {
                     code: core.ExportResultCode.FAILED,
-                    error: new Error("Failed to persist envelope in disk.")
+                    error: new Error("Failed to persist envelope in disk."),
                 };
         }
         catch (ex) {
@@ -1977,7 +2323,7 @@ class AzureMonitorTraceExporter {
                     }
                     // Failed -- not retriable
                     return {
-                        code: core.ExportResultCode.FAILED
+                        code: core.ExportResultCode.FAILED,
                     };
                 }
                 else {
@@ -1988,7 +2334,7 @@ class AzureMonitorTraceExporter {
             else {
                 // Failed -- not retriable
                 return {
-                    code: core.ExportResultCode.FAILED
+                    code: core.ExportResultCode.FAILED,
                 };
             }
         }