@azure/monitor-opentelemetry-exporter 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/index.js

@@ -16,10 +16,7 @@ var child_process = require('child_process');
 var util = require('util');
 var coreClient = require('@azure/core-client');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
         Object.keys(e).forEach(function (k) {
@@ -32,18 +29,16 @@ function _interopNamespace(e) {
             }
         });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
 }
 
-var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
-var os__namespace = /*#__PURE__*/_interopNamespace(os$1);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os$1);
-var coreRestPipeline__namespace = /*#__PURE__*/_interopNamespace(coreRestPipeline);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
-var coreClient__namespace = /*#__PURE__*/_interopNamespace(coreClient);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os$1);
+var coreRestPipeline__namespace = /*#__PURE__*/_interopNamespaceDefault(coreRestPipeline);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var child_process__namespace = /*#__PURE__*/_interopNamespaceDefault(child_process);
+var coreClient__namespace = /*#__PURE__*/_interopNamespaceDefault(coreClient);
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -66,7 +61,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.16";
+const packageVersion = "1.0.0-beta.18";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -97,26 +92,26 @@ const ApplicationInsightsEventBaseType = "EventData";
 class ApplicationInsightsSampler {
     /**
      * Initializes a new instance of the ApplicationInsightsSampler class.
-     * @param samplingRatio Value in the range [0,1], 1 meaning all data will sampled and 0 all Tracing data will be sampled out.
+     * @param samplingRatio - Value in the range [0,1], 1 meaning all data will sampled and 0 all Tracing data will be sampled out.
      */
     constructor(samplingRatio = 1) {
-        this._samplingRatio = samplingRatio;
-        if (this._samplingRatio > 1) {
+        this.samplingRatio = samplingRatio;
+        if (this.samplingRatio > 1) {
             throw new Error("Wrong sampling rate, data will not be sampled out");
         }
-        this._sampleRate = Math.round(this._samplingRatio * 100);
+        this._sampleRate = Math.round(this.samplingRatio * 100);
     }
     /**
      * Checks whether span needs to be created and tracked.
      *
-     * @param context Parent Context which may contain a span.
-     * @param traceId of the span to be created. It can be different from the
+     * @param context - Parent Context which may contain a span.
+     * @param traceId - traceif of the span to be created. It can be different from the
      *     traceId in the {@link SpanContext}. Typically in situations when the
      *     span to be created starts a new trace.
-     * @param spanName of the span to be created.
-     * @param spanKind of the span to be created.
-     * @param attributes Initial set of SpanAttributes for the Span being constructed.
-     * @param links Collection of links that will be associated with the Span to
+     * @param spanName - Name of the span to be created.
+     * @param spanKind - Kind of the span to be created.
+     * @param attributes - Initial set of SpanAttributes for the Span being constructed.
+     * @param links - Collection of links that will be associated with the Span to
      *     be created. Typically useful for batch operations.
      * @returns a {@link SamplingResult}.
      */
@@ -130,10 +125,10 @@ class ApplicationInsightsSampler {
     // @ts-ignore
     links) {
         let isSampledIn = false;
-        if (this._sampleRate == 100) {
+        if (this._sampleRate === 100) {
             isSampledIn = true;
         }
-        else if (this._sampleRate == 0) {
+        else if (this._sampleRate === 0) {
             isSampledIn = false;
         }
         else {
@@ -150,19 +145,19 @@ class ApplicationInsightsSampler {
      * Return Sampler description
      */
     toString() {
-        return `ApplicationInsightsSampler{${this._samplingRatio}}`;
+        return `ApplicationInsightsSampler{${this.samplingRatio}}`;
     }
     _getSamplingHashCode(input) {
-        var csharpMin = -2147483648;
-        var csharpMax = 2147483647;
-        var hash = 5381;
+        const csharpMin = -2147483648;
+        const csharpMax = 2147483647;
+        let hash = 5381;
         if (!input) {
             return 0;
         }
         while (input.length < 8) {
             input = input + input;
         }
-        for (var i = 0; i < input.length; i++) {
+        for (let i = 0; i < input.length; i++) {
             // JS doesn't respond to integer overflow by wrapping around. Simulate it with bitwise operators ( | 0)
             hash = ((((hash << 5) + hash) | 0) + input.charCodeAt(i)) | 0;
         }
@@ -263,6 +258,7 @@ var PerformanceCounter;
 });
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * ConnectionString parser.
  * @internal
@@ -318,16 +314,27 @@ class ConnectionStringParser {
             newUrl = newUrl.replace("http://", "https://");
         }
         // Remove final slash if present
-        if (newUrl[newUrl.length - 1] == "/") {
+        if (newUrl[newUrl.length - 1] === "/") {
             newUrl = newUrl.slice(0, -1);
         }
         return newUrl;
     }
+    static validateInstrumentationKey(iKey) {
+        if (iKey.startsWith("InstrumentationKey=")) {
+            const startIndex = iKey.indexOf("InstrumentationKey=") + "InstrumentationKey=".length;
+            const endIndex = iKey.indexOf(";", startIndex);
+            iKey = iKey.substring(startIndex, endIndex);
+        }
+        const UUID_Regex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+        const regexp = new RegExp(UUID_Regex);
+        return regexp.test(iKey);
+    }
 }
 ConnectionStringParser.FIELDS_SEPARATOR = ";";
 ConnectionStringParser.FIELD_KEY_VALUE_SEPARATOR = "=";
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Trace Exporter.
  */
@@ -350,16 +357,17 @@ class AzureMonitorBaseExporter {
          *Flag to determine if exporter will generate Statsbeat data
          */
         this.trackStatsbeat = false;
-        this._options = options;
+        this.options = options;
         this.instrumentationKey = "";
         this.endpointUrl = DEFAULT_BREEZE_ENDPOINT;
-        const connectionString = this._options.connectionString || process.env[ENV_CONNECTION_STRING];
-        this._isStatsbeatExporter = isStatsbeatExporter ? isStatsbeatExporter : false;
+        const connectionString = this.options.connectionString || process.env[ENV_CONNECTION_STRING];
+        this.isStatsbeatExporter = isStatsbeatExporter ? isStatsbeatExporter : false;
         if (connectionString) {
             const parsedConnectionString = ConnectionStringParser.parse(connectionString);
             this.instrumentationKey =
                 parsedConnectionString.instrumentationkey || this.instrumentationKey;
             this.endpointUrl = ((_a = parsedConnectionString.ingestionendpoint) === null || _a === void 0 ? void 0 : _a.trim()) || this.endpointUrl;
+            this.aadAudience = parsedConnectionString.aadaudience;
         }
         // Instrumentation key is required
         if (!this.instrumentationKey) {
@@ -367,12 +375,18 @@ class AzureMonitorBaseExporter {
             api.diag.error(message);
             throw new Error(message);
         }
-        this.trackStatsbeat = !this._isStatsbeatExporter && !process.env[ENV_DISABLE_STATSBEAT];
+        if (!ConnectionStringParser.validateInstrumentationKey(this.instrumentationKey)) {
+            const message = "Invalid instrumentation key was provided to the Azure Monitor Exporter";
+            api.diag.error(message);
+            throw new Error(message);
+        }
+        this.trackStatsbeat = !this.isStatsbeatExporter && !process.env[ENV_DISABLE_STATSBEAT];
         api.diag.debug("AzureMonitorExporter was successfully setup");
     }
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 class FileAccessControl {
     // Check if file access control could be enabled
     static checkFileProtection() {
@@ -410,7 +424,7 @@ class FileAccessControl {
                 FileAccessControl.ACLED_DIRECTORIES[directory] = false;
                 try {
                     // Restrict this directory to only current user and administrator access
-                    let identity = await this._getACLIdentity();
+                    const identity = await this._getACLIdentity();
                     await this._runICACLS(this._getACLArguments(directory, identity));
                     FileAccessControl.ACLED_DIRECTORIES[directory] = true;
                 }
@@ -442,7 +456,7 @@ class FileAccessControl {
     }
     static _runICACLS(args) {
         return new Promise((resolve, reject) => {
-            var aclProc = child_process__namespace.spawn(FileAccessControl.ICACLS_PATH, args, {
+            const aclProc = child_process__namespace.spawn(FileAccessControl.ICACLS_PATH, args, {
                 windowsHide: true,
             });
             aclProc.on("error", (e) => reject(e));
@@ -459,7 +473,7 @@ class FileAccessControl {
     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, {
+            const aclProc = child_process__namespace.spawnSync(FileAccessControl.ICACLS_PATH, args, {
                 windowsHide: true,
             });
             if (aclProc.error) {
@@ -478,7 +492,7 @@ class FileAccessControl {
             if (FileAccessControl.ACL_IDENTITY) {
                 resolve(FileAccessControl.ACL_IDENTITY);
             }
-            var psProc = child_process__namespace.spawn(FileAccessControl.POWERSHELL_PATH, ["-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"], {
+            const 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
             });
@@ -502,7 +516,7 @@ class FileAccessControl {
         }
         // 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"], {
+            const 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
             });
@@ -539,6 +553,7 @@ FileAccessControl.OS_PROVIDES_FILE_PROTECTION = false;
 FileAccessControl.USE_ICACLS = os__namespace.type() === "Windows_NT";
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const readdirAsync$1 = util.promisify(fs__namespace.readdir);
 const statAsync$1 = util.promisify(fs__namespace.stat);
 const lstatAsync = util.promisify(fs__namespace.lstat);
@@ -588,6 +603,7 @@ const confirmDirExists = async (directory) => {
 };
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const statAsync = util.promisify(fs__namespace.stat);
 const readdirAsync = util.promisify(fs__namespace.readdir);
 const readFileAsync = util.promisify(fs__namespace.readFile);
@@ -1752,23 +1768,23 @@ const RequestData = {
 
 var Mappers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    TelemetryItem: TelemetryItem,
-    MonitorBase: MonitorBase,
-    MonitorDomain: MonitorDomain,
-    TrackResponse: TrackResponse,
-    TelemetryErrorDetails: TelemetryErrorDetails,
-    MetricDataPoint: MetricDataPoint,
-    TelemetryExceptionDetails: TelemetryExceptionDetails,
-    StackFrame: StackFrame,
     AvailabilityData: AvailabilityData,
-    TelemetryEventData: TelemetryEventData,
-    TelemetryExceptionData: TelemetryExceptionData,
     MessageData: MessageData,
+    MetricDataPoint: MetricDataPoint,
     MetricsData: MetricsData,
+    MonitorBase: MonitorBase,
+    MonitorDomain: MonitorDomain,
     PageViewData: PageViewData,
     PageViewPerfData: PageViewPerfData,
     RemoteDependencyData: RemoteDependencyData,
-    RequestData: RequestData
+    RequestData: RequestData,
+    StackFrame: StackFrame,
+    TelemetryErrorDetails: TelemetryErrorDetails,
+    TelemetryEventData: TelemetryEventData,
+    TelemetryExceptionData: TelemetryExceptionData,
+    TelemetryExceptionDetails: TelemetryExceptionDetails,
+    TelemetryItem: TelemetryItem,
+    TrackResponse: TrackResponse
 });
 
 /*
@@ -1792,7 +1808,7 @@ class ApplicationInsightsClient extends coreClient__namespace.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.16`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.18`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -1868,6 +1884,8 @@ const trackOperationSpec = {
     serializer
 };
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 class NetworkStatsbeat {
     constructor(endpoint, host) {
         this.endpoint = endpoint;
@@ -1889,18 +1907,19 @@ const STATSBEAT_LANGUAGE = "node";
 const MAX_STATSBEAT_FAILURES = 3;
 const StatsbeatResourceProvider = {
     appsvc: "appsvc",
+    aks: "aks",
     functions: "functions",
     vm: "vm",
     unknown: "unknown",
 };
 var StatsbeatCounter;
 (function (StatsbeatCounter) {
-    StatsbeatCounter["SUCCESS_COUNT"] = "Request Success Count";
-    StatsbeatCounter["FAILURE_COUNT"] = "Request Failure Count";
-    StatsbeatCounter["RETRY_COUNT"] = "Retry Count";
-    StatsbeatCounter["THROTTLE_COUNT"] = "Throttle Count";
-    StatsbeatCounter["EXCEPTION_COUNT"] = "Exception Count";
-    StatsbeatCounter["AVERAGE_DURATION"] = "Request Duration";
+    StatsbeatCounter["SUCCESS_COUNT"] = "Request_Success_Count";
+    StatsbeatCounter["FAILURE_COUNT"] = "Request_Failure_Count";
+    StatsbeatCounter["RETRY_COUNT"] = "Retry_Count";
+    StatsbeatCounter["THROTTLE_COUNT"] = "Throttle_Count";
+    StatsbeatCounter["EXCEPTION_COUNT"] = "Exception_Count";
+    StatsbeatCounter["AVERAGE_DURATION"] = "Request_Duration";
     StatsbeatCounter["ATTACH"] = "Attach";
     StatsbeatCounter["FEATURE"] = "Feature";
 })(StatsbeatCounter || (StatsbeatCounter = {}));
@@ -1925,40 +1944,53 @@ const EU_ENDPOINTS = [
 ];
 var StatsbeatFeatureType;
 (function (StatsbeatFeatureType) {
-    StatsbeatFeatureType["FEATURE"] = "Feature";
-    StatsbeatFeatureType["INSTRUMENTATION"] = "Instrumentation";
+    StatsbeatFeatureType[StatsbeatFeatureType["FEATURE"] = 0] = "FEATURE";
+    StatsbeatFeatureType[StatsbeatFeatureType["INSTRUMENTATION"] = 1] = "INSTRUMENTATION";
 })(StatsbeatFeatureType || (StatsbeatFeatureType = {}));
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const os = require("os");
 class StatsbeatMetrics {
     constructor() {
-        this._resourceProvider = StatsbeatResourceProvider.unknown;
-        this._vmInfo = {};
-        this._os = os.type();
-        this._resourceIdentifier = "";
+        this.resourceProvider = StatsbeatResourceProvider.unknown;
+        this.vmInfo = {};
+        this.os = os.type();
+        this.resourceIdentifier = "";
     }
-    async _getResourceProvider() {
+    async getResourceProvider() {
         // Check resource provider
-        this._resourceProvider = StatsbeatResourceProvider.unknown;
-        if (process.env.WEBSITE_SITE_NAME) {
+        this.resourceProvider = StatsbeatResourceProvider.unknown;
+        if (process.env.AKS_ARM_NAMESPACE_ID) {
+            // AKS
+            this.resourceProvider = StatsbeatResourceProvider.aks;
+            this.resourceIdentifier = process.env.AKS_ARM_NAMESPACE_ID;
+        }
+        else if (process.env.WEBSITE_SITE_NAME) {
             // Web apps
-            this._resourceProvider = StatsbeatResourceProvider.appsvc;
+            this.resourceProvider = StatsbeatResourceProvider.appsvc;
+            this.resourceIdentifier = process.env.WEBSITE_SITE_NAME;
+            if (process.env.WEBSITE_HOME_STAMPNAME) {
+                this.resourceIdentifier += "/" + process.env.WEBSITE_HOME_STAMPNAME;
+            }
         }
         else if (process.env.FUNCTIONS_WORKER_RUNTIME) {
             // Function apps
-            this._resourceProvider = StatsbeatResourceProvider.functions;
+            this.resourceProvider = StatsbeatResourceProvider.functions;
+            if (process.env.WEBSITE_HOSTNAME) {
+                this.resourceIdentifier = process.env.WEBSITE_HOSTNAME;
+            }
         }
         else if (await this.getAzureComputeMetadata()) {
-            this._resourceProvider = StatsbeatResourceProvider.vm;
-            this._resourceIdentifier = this._vmInfo.id + "/" + this._vmInfo.subscriptionId;
+            this.resourceProvider = StatsbeatResourceProvider.vm;
+            this.resourceIdentifier = this.vmInfo.id + "/" + this.vmInfo.subscriptionId;
             // Overrride OS as VM info have higher precedence
-            if (this._vmInfo.osType) {
-                this._os = this._vmInfo.osType;
+            if (this.vmInfo.osType) {
+                this.os = this.vmInfo.osType;
             }
         }
         else {
-            this._resourceProvider = StatsbeatResourceProvider.unknown;
+            this.resourceProvider = StatsbeatResourceProvider.unknown;
         }
     }
     async getAzureComputeMetadata() {
@@ -1976,17 +2008,17 @@ class StatsbeatMetrics {
             .then((res) => {
             if (res.status === 200) {
                 // Success; VM
-                this._vmInfo.isVM = true;
+                this.vmInfo.isVM = true;
                 let virtualMachineData = "";
                 res.on("data", (data) => {
                     virtualMachineData += data;
                 });
                 res.on("end", () => {
                     try {
-                        let data = JSON.parse(virtualMachineData);
-                        this._vmInfo.id = data["vmId"] || "";
-                        this._vmInfo.subscriptionId = data["subscriptionId"] || "";
-                        this._vmInfo.osType = data["osType"] || "";
+                        const data = JSON.parse(virtualMachineData);
+                        this.vmInfo.id = data["vmId"] || "";
+                        this.vmInfo.subscriptionId = data["subscriptionId"] || "";
+                        this.vmInfo.osType = data["osType"] || "";
                     }
                     catch (error) {
                         api.diag.debug("Failed to parse JSON: ", error);
@@ -2003,8 +2035,8 @@ class StatsbeatMetrics {
         });
         return false;
     }
-    _getConnectionString(endpointUrl) {
-        let currentEndpoint = endpointUrl;
+    getConnectionString(endpointUrl) {
+        const currentEndpoint = endpointUrl;
         for (let i = 0; i < EU_ENDPOINTS.length; i++) {
             if (currentEndpoint.includes(EU_ENDPOINTS[i])) {
                 return EU_CONNECTION_STRING;
@@ -2015,6 +2047,7 @@ class StatsbeatMetrics {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function createPropertiesFromMetricAttributes(attributes) {
     const properties = {};
     if (attributes) {
@@ -2029,7 +2062,7 @@ function createPropertiesFromMetricAttributes(attributes) {
  * @internal
  */
 function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
-    let envelopes = [];
+    const envelopes = [];
     const time = new Date();
     const instrumentationKey = ikey;
     const tags = createTagsFromResource(metrics.resource);
@@ -2043,19 +2076,19 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
     metrics.scopeMetrics.forEach((scopeMetric) => {
         scopeMetric.metrics.forEach((metric) => {
             metric.dataPoints.forEach((dataPoint) => {
-                let baseData = {
+                const baseData = {
                     metrics: [],
                     version: 2,
                     properties: {},
                 };
                 baseData.properties = createPropertiesFromMetricAttributes(dataPoint.attributes);
-                var metricDataPoint = {
+                const metricDataPoint = {
                     name: metric.descriptor.name,
                     value: 0,
                     dataPointType: "Aggregation",
                 };
-                if (metric.dataPointType == sdkMetrics.DataPointType.SUM ||
-                    metric.dataPointType == sdkMetrics.DataPointType.GAUGE) {
+                if (metric.dataPointType === sdkMetrics.DataPointType.SUM ||
+                    metric.dataPointType === sdkMetrics.DataPointType.GAUGE) {
                     metricDataPoint.value = dataPoint.value;
                     metricDataPoint.count = 1;
                 }
@@ -2066,7 +2099,7 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
                     metricDataPoint.min = dataPoint.value.min;
                 }
                 baseData.metrics.push(metricDataPoint);
-                let envelope = {
+                const envelope = {
                     name: envelopeName,
                     time: time,
                     sampleRate: 100,
@@ -2086,6 +2119,7 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor Statsbeat Exporter
  */
@@ -2100,7 +2134,12 @@ class AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
          * Flag to determine if the Exporter is shutdown.
          */
         this._isShutdown = false;
-        this._sender = new HttpSender(this.endpointUrl, this.instrumentationKey, this.trackStatsbeat, options);
+        this._sender = new HttpSender({
+            endpointUrl: this.endpointUrl,
+            instrumentationKey: this.instrumentationKey,
+            trackStatsbeat: this.trackStatsbeat,
+            exporterOptions: options,
+        });
     }
     /**
      * Export Statsbeat metrics.
@@ -2110,7 +2149,7 @@ class AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
             setTimeout(() => resultCallback({ code: core.ExportResultCode.FAILED }), 0);
             return;
         }
-        let envelopes = resourceMetricsToEnvelope(metrics, this.instrumentationKey, true // isStatsbeat flag passed to create a Statsbeat envelope.
+        const envelopes = resourceMetricsToEnvelope(metrics, this.instrumentationKey, true // isStatsbeat flag passed to create a Statsbeat envelope.
         );
         // Supress tracing until OpenTelemetry Metrics SDK support it
         api.context.with(core.suppressTracing(api.context.active()), async () => {
@@ -2133,140 +2172,138 @@ class AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 class NetworkStatsbeatMetrics extends StatsbeatMetrics {
     constructor(options) {
         super();
-        this._isInitialized = false;
-        this._statsCollectionShortInterval = 900000; // 15 minutes
-        this._networkStatsbeatCollection = [];
-        this._attach = "sdk";
-        this._connectionString = super._getConnectionString(options.endpointUrl);
-        this._networkStatsbeatMeterProvider = new sdkMetrics.MeterProvider();
+        this.isInitialized = false;
+        this.statsCollectionShortInterval = 900000; // 15 minutes
+        this.networkStatsbeatCollection = [];
+        this.attach = "sdk";
+        this.connectionString = super.getConnectionString(options.endpointUrl);
+        this.networkStatsbeatMeterProvider = new sdkMetrics.MeterProvider();
         const exporterConfig = {
-            connectionString: this._connectionString,
+            connectionString: this.connectionString,
         };
-        this._networkAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
+        this.networkAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
         // Exports Network Statsbeat every 15 minutes
         const networkMetricReaderOptions = {
-            exporter: this._networkAzureExporter,
-            exportIntervalMillis: options.networkCollectionInterval || this._statsCollectionShortInterval, // 15 minutes
+            exporter: this.networkAzureExporter,
+            exportIntervalMillis: options.networkCollectionInterval || this.statsCollectionShortInterval, // 15 minutes
         };
-        this._networkMetricReader = new sdkMetrics.PeriodicExportingMetricReader(networkMetricReaderOptions);
-        this._networkStatsbeatMeterProvider.addMetricReader(this._networkMetricReader);
-        this._networkStatsbeatMeter = this._networkStatsbeatMeterProvider.getMeter("Azure Monitor Network Statsbeat");
-        this._endpointUrl = options.endpointUrl;
-        this._runtimeVersion = process.version;
-        this._language = STATSBEAT_LANGUAGE;
-        this._version = packageVersion;
-        this._host = this._getShortHost(options.endpointUrl);
-        this._cikey = options.instrumentationKey;
-        this._successCountGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.SUCCESS_COUNT);
-        this._failureCountGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.FAILURE_COUNT);
-        this._retryCountGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.RETRY_COUNT);
-        this._throttleCountGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.THROTTLE_COUNT);
-        this._exceptionCountGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.EXCEPTION_COUNT);
-        this._averageDurationGauge = this._networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.AVERAGE_DURATION);
-        this._commonProperties = {
-            os: super._os,
-            rp: super._resourceProvider,
-            cikey: this._cikey,
-            runtimeVersion: this._runtimeVersion,
-            language: this._language,
-            version: this._version,
-            attach: this._attach,
+        this.networkMetricReader = new sdkMetrics.PeriodicExportingMetricReader(networkMetricReaderOptions);
+        this.networkStatsbeatMeterProvider.addMetricReader(this.networkMetricReader);
+        this.networkStatsbeatMeter = this.networkStatsbeatMeterProvider.getMeter("Azure Monitor Network Statsbeat");
+        this.endpointUrl = options.endpointUrl;
+        this.runtimeVersion = process.version;
+        this.language = STATSBEAT_LANGUAGE;
+        this.version = packageVersion;
+        this.host = this.getShortHost(options.endpointUrl);
+        this.cikey = options.instrumentationKey;
+        this.successCountGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.SUCCESS_COUNT);
+        this.failureCountGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.FAILURE_COUNT);
+        this.retryCountGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.RETRY_COUNT);
+        this.throttleCountGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.THROTTLE_COUNT);
+        this.exceptionCountGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.EXCEPTION_COUNT);
+        this.averageDurationGauge = this.networkStatsbeatMeter.createObservableGauge(StatsbeatCounter.AVERAGE_DURATION);
+        this.commonProperties = {
+            os: super.os,
+            rp: super.resourceProvider,
+            cikey: this.cikey,
+            runtimeVersion: this.runtimeVersion,
+            language: this.language,
+            version: this.version,
+            attach: this.attach,
         };
-        this._networkProperties = {
-            endpoint: this._endpointUrl,
-            host: this._host,
+        this.networkProperties = {
+            endpoint: this.endpointUrl,
+            host: this.host,
         };
-        this._isInitialized = true;
-        this._initialize();
-    }
-    isInitialized() {
-        return this._isInitialized;
+        this.isInitialized = true;
+        this.initialize();
     }
     shutdown() {
-        this._networkStatsbeatMeterProvider.shutdown();
+        return this.networkStatsbeatMeterProvider.shutdown();
     }
-    async _initialize() {
+    async initialize() {
         try {
-            await super._getResourceProvider();
+            await super.getResourceProvider();
             // Add network observable callbacks
-            this._successCountGauge.addCallback(this._successCallback.bind(this));
-            this._networkStatsbeatMeter.addBatchObservableCallback(this._failureCallback.bind(this), [
-                this._failureCountGauge,
+            this.successCountGauge.addCallback(this.successCallback.bind(this));
+            this.networkStatsbeatMeter.addBatchObservableCallback(this.failureCallback.bind(this), [
+                this.failureCountGauge,
             ]);
-            this._networkStatsbeatMeter.addBatchObservableCallback(this._retryCallback.bind(this), [
-                this._retryCountGauge,
+            this.networkStatsbeatMeter.addBatchObservableCallback(this.retryCallback.bind(this), [
+                this.retryCountGauge,
             ]);
-            this._networkStatsbeatMeter.addBatchObservableCallback(this._throttleCallback.bind(this), [
-                this._throttleCountGauge,
+            this.networkStatsbeatMeter.addBatchObservableCallback(this.throttleCallback.bind(this), [
+                this.throttleCountGauge,
             ]);
-            this._networkStatsbeatMeter.addBatchObservableCallback(this._exceptionCallback.bind(this), [
-                this._exceptionCountGauge,
+            this.networkStatsbeatMeter.addBatchObservableCallback(this.exceptionCallback.bind(this), [
+                this.exceptionCountGauge,
             ]);
-            this._averageDurationGauge.addCallback(this._durationCallback.bind(this));
+            this.averageDurationGauge.addCallback(this.durationCallback.bind(this));
         }
         catch (error) {
             api.diag.debug("Call to get the resource provider failed.");
         }
     }
     // Observable gauge callbacks
-    _successCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let attributes = Object.assign(Object.assign({}, this._commonProperties), this._networkProperties);
+    successCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const attributes = Object.assign(Object.assign({}, this.commonProperties), this.networkProperties);
         observableResult.observe(counter.totalSuccesfulRequestCount, attributes);
         counter.totalSuccesfulRequestCount = 0;
     }
-    _failureCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
+    failureCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
         /*
           Takes the failureCountGauge, value (of the counter), and attributes
           create a unqiue counter based on statusCode as well
           append statusCode to attributes so the newly created attributes are unique.
         */
-        let attributes = Object.assign(Object.assign(Object.assign({}, this._networkProperties), this._commonProperties), { statusCode: 0 });
+        const attributes = Object.assign(Object.assign(Object.assign({}, this.networkProperties), this.commonProperties), { statusCode: 0 });
         // For each { statusCode -> count } mapping, call observe, passing the count and attributes that include the statusCode
         for (let i = 0; i < counter.totalFailedRequestCount.length; i++) {
             attributes.statusCode = counter.totalFailedRequestCount[i].statusCode;
-            observableResult.observe(this._failureCountGauge, counter.totalFailedRequestCount[i].count, Object.assign({}, attributes));
+            observableResult.observe(this.failureCountGauge, counter.totalFailedRequestCount[i].count, Object.assign({}, attributes));
             counter.totalFailedRequestCount[i].count = 0;
         }
     }
-    _retryCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let attributes = Object.assign(Object.assign(Object.assign({}, this._networkProperties), this._commonProperties), { statusCode: 0 });
+    retryCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const attributes = Object.assign(Object.assign(Object.assign({}, this.networkProperties), this.commonProperties), { statusCode: 0 });
         for (let i = 0; i < counter.retryCount.length; i++) {
             attributes.statusCode = counter.retryCount[i].statusCode;
-            observableResult.observe(this._retryCountGauge, counter.retryCount[i].count, Object.assign({}, attributes));
+            observableResult.observe(this.retryCountGauge, counter.retryCount[i].count, Object.assign({}, attributes));
             counter.retryCount[i].count = 0;
         }
     }
-    _throttleCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let attributes = Object.assign(Object.assign(Object.assign({}, this._networkProperties), this._commonProperties), { statusCode: 0 });
+    throttleCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const attributes = Object.assign(Object.assign(Object.assign({}, this.networkProperties), this.commonProperties), { statusCode: 0 });
         for (let i = 0; i < counter.throttleCount.length; i++) {
             attributes.statusCode = counter.throttleCount[i].statusCode;
-            observableResult.observe(this._throttleCountGauge, counter.throttleCount[i].count, Object.assign({}, attributes));
+            observableResult.observe(this.throttleCountGauge, counter.throttleCount[i].count, Object.assign({}, attributes));
             counter.throttleCount[i].count = 0;
         }
     }
-    _exceptionCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let attributes = Object.assign(Object.assign(Object.assign({}, this._networkProperties), this._commonProperties), { exceptionType: "" });
+    exceptionCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const attributes = Object.assign(Object.assign(Object.assign({}, this.networkProperties), this.commonProperties), { exceptionType: "" });
         for (let i = 0; i < counter.exceptionCount.length; i++) {
             attributes.exceptionType = counter.exceptionCount[i].exceptionType;
-            observableResult.observe(this._exceptionCountGauge, counter.exceptionCount[i].count, Object.assign({}, attributes));
+            observableResult.observe(this.exceptionCountGauge, counter.exceptionCount[i].count, Object.assign({}, attributes));
             counter.exceptionCount[i].count = 0;
         }
     }
-    _durationCallback(observableResult) {
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let attributes = Object.assign(Object.assign({}, this._networkProperties), this._commonProperties);
-        for (let i = 0; i < this._networkStatsbeatCollection.length; i++) {
-            let currentCounter = this._networkStatsbeatCollection[i];
+    durationCallback(observableResult) {
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const attributes = Object.assign(Object.assign({}, this.networkProperties), this.commonProperties);
+        for (let i = 0; i < this.networkStatsbeatCollection.length; i++) {
+            const currentCounter = this.networkStatsbeatCollection[i];
             currentCounter.time = Number(new Date());
-            let intervalRequests = currentCounter.totalRequestCount - currentCounter.lastRequestCount || 0;
+            const intervalRequests = currentCounter.totalRequestCount - currentCounter.lastRequestCount || 0;
             currentCounter.averageRequestExecutionTime =
                 (currentCounter.intervalRequestExecutionTime -
                     currentCounter.lastIntervalRequestExecutionTime) /
@@ -2280,20 +2317,20 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
     }
     // Public methods to increase counters
     countSuccess(duration) {
-        if (!this._isInitialized) {
+        if (!this.isInitialized) {
             return;
         }
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
         counter.totalRequestCount++;
         counter.totalSuccesfulRequestCount++;
         counter.intervalRequestExecutionTime += duration;
     }
     countFailure(duration, statusCode) {
-        if (!this._isInitialized) {
+        if (!this.isInitialized) {
             return;
         }
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let currentStatusCounter = counter.totalFailedRequestCount.find((statusCounter) => statusCode === statusCounter.statusCode);
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const currentStatusCounter = counter.totalFailedRequestCount.find((statusCounter) => statusCode === statusCounter.statusCode);
         if (currentStatusCounter) {
             currentStatusCounter.count++;
         }
@@ -2304,11 +2341,11 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
         counter.intervalRequestExecutionTime += duration;
     }
     countRetry(statusCode) {
-        if (!this._isInitialized) {
+        if (!this.isInitialized) {
             return;
         }
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let currentStatusCounter = counter.retryCount.find((statusCounter) => statusCode === statusCounter.statusCode);
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const currentStatusCounter = counter.retryCount.find((statusCounter) => statusCode === statusCounter.statusCode);
         if (currentStatusCounter) {
             currentStatusCounter.count++;
         }
@@ -2317,11 +2354,11 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
         }
     }
     countThrottle(statusCode) {
-        if (!this._isInitialized) {
+        if (!this.isInitialized) {
             return;
         }
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let currentStatusCounter = counter.throttleCount.find((statusCounter) => statusCode === statusCounter.statusCode);
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const currentStatusCounter = counter.throttleCount.find((statusCounter) => statusCode === statusCounter.statusCode);
         if (currentStatusCounter) {
             currentStatusCounter.count++;
         }
@@ -2330,11 +2367,11 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
         }
     }
     countException(exceptionType) {
-        if (!this._isInitialized) {
+        if (!this.isInitialized) {
             return;
         }
-        let counter = this._getNetworkStatsbeatCounter(this._endpointUrl, this._host);
-        let currentErrorCounter = counter.exceptionCount.find((exceptionCounter) => exceptionType.name === exceptionCounter.exceptionType);
+        const counter = this.getNetworkStatsbeatCounter(this.endpointUrl, this.host);
+        const currentErrorCounter = counter.exceptionCount.find((exceptionCounter) => exceptionType.name === exceptionCounter.exceptionType);
         if (currentErrorCounter) {
             currentErrorCounter.count++;
         }
@@ -2343,26 +2380,26 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
         }
     }
     // Gets a networkStatsbeat counter if one exists for the given endpoint
-    _getNetworkStatsbeatCounter(endpoint, host) {
+    getNetworkStatsbeatCounter(endpoint, host) {
         // Check if the counter is available
-        for (let i = 0; i < this._networkStatsbeatCollection.length; i++) {
+        for (let i = 0; i < this.networkStatsbeatCollection.length; i++) {
             // Same object
-            if (endpoint === this._networkStatsbeatCollection[i].endpoint &&
-                host === this._networkStatsbeatCollection[i].host) {
-                return this._networkStatsbeatCollection[i];
+            if (endpoint === this.networkStatsbeatCollection[i].endpoint &&
+                host === this.networkStatsbeatCollection[i].host) {
+                return this.networkStatsbeatCollection[i];
             }
         }
         // Create a new counter if not found
-        let newCounter = new NetworkStatsbeat(endpoint, host);
-        this._networkStatsbeatCollection.push(newCounter);
+        const newCounter = new NetworkStatsbeat(endpoint, host);
+        this.networkStatsbeatCollection.push(newCounter);
         return newCounter;
     }
-    _getShortHost(originalHost) {
+    getShortHost(originalHost) {
         let shortHost = originalHost;
         try {
-            let hostRegex = new RegExp(/^https?:\/\/(?:www\.)?([^\/.-]+)/);
-            let res = hostRegex.exec(originalHost);
-            if (res != null && res.length > 1) {
+            const hostRegex = new RegExp(/^https?:\/\/(?:www\.)?([^\/.-]+)/);
+            const res = hostRegex.exec(originalHost);
+            if (res !== null && res.length > 1) {
                 shortHost = res[1];
             }
             shortHost = shortHost.replace(".in.applicationinsights.azure.com", "");
@@ -2375,6 +2412,7 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 let instance$1 = null;
 /**
  * Long Interval Statsbeat Metrics
@@ -2383,65 +2421,67 @@ let instance$1 = null;
 class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
     constructor(options) {
         super();
-        this._AZURE_MONITOR_STATSBEAT_FEATURES = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
-        this._statsCollectionLongInterval = 86400000; // 1 day
-        this._isInitialized = false;
-        this._attach = "sdk";
-        this._feature = 0;
-        this._instrumentation = 0;
-        this._connectionString = super._getConnectionString(options.endpointUrl);
+        this.AZURE_MONITOR_STATSBEAT_FEATURES = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
+        this.statsCollectionLongInterval = 86400000; // 1 day
+        this.attach = "sdk";
+        this.feature = 0;
+        this.instrumentation = 0;
+        this.isInitialized = false;
+        this.connectionString = super.getConnectionString(options.endpointUrl);
         const exporterConfig = {
-            connectionString: this._connectionString,
+            connectionString: this.connectionString,
         };
-        if (this._AZURE_MONITOR_STATSBEAT_FEATURES) {
+        if (this.AZURE_MONITOR_STATSBEAT_FEATURES) {
             try {
-                this._feature = JSON.parse(this._AZURE_MONITOR_STATSBEAT_FEATURES).feature;
-                this._instrumentation = JSON.parse(this._AZURE_MONITOR_STATSBEAT_FEATURES).instrumentation;
+                this.feature = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).feature;
+                this.instrumentation = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).instrumentation;
             }
             catch (error) {
                 api.diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
             }
         }
-        this._longIntervalStatsbeatMeterProvider = new sdkMetrics.MeterProvider();
-        this._longIntervalAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
+        this.longIntervalStatsbeatMeterProvider = new sdkMetrics.MeterProvider();
+        this.longIntervalAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
         // Export Long Interval Statsbeats every day
         const longIntervalMetricReaderOptions = {
-            exporter: this._longIntervalAzureExporter,
-            exportIntervalMillis: Number(process.env.LONG_INTERVAL_EXPORT_MILLIS) || this._statsCollectionLongInterval, // 1 day
+            exporter: this.longIntervalAzureExporter,
+            exportIntervalMillis: Number(process.env.LONG_INTERVAL_EXPORT_MILLIS) || this.statsCollectionLongInterval, // 1 day
         };
-        this._longIntervalMetricReader = new sdkMetrics.PeriodicExportingMetricReader(longIntervalMetricReaderOptions);
-        this._longIntervalStatsbeatMeterProvider.addMetricReader(this._longIntervalMetricReader);
-        this._longIntervalStatsbeatMeter = this._longIntervalStatsbeatMeterProvider.getMeter("Azure Monitor Long Interval Statsbeat");
+        this.longIntervalMetricReader = new sdkMetrics.PeriodicExportingMetricReader(longIntervalMetricReaderOptions);
+        this.longIntervalStatsbeatMeterProvider.addMetricReader(this.longIntervalMetricReader);
+        this.longIntervalStatsbeatMeter = this.longIntervalStatsbeatMeterProvider.getMeter("Azure Monitor Long Interval Statsbeat");
         // Assign Common Properties
-        this._runtimeVersion = process.version;
-        this._language = STATSBEAT_LANGUAGE;
-        this._version = packageVersion;
-        this._cikey = options.instrumentationKey;
-        this._featureStatsbeatGauge = this._longIntervalStatsbeatMeter.createObservableGauge(StatsbeatCounter.FEATURE);
-        this._attachStatsbeatGauge = this._longIntervalStatsbeatMeter.createObservableGauge(StatsbeatCounter.ATTACH);
-        this._commonProperties = {
-            os: super._os,
-            rp: super._resourceProvider,
-            cikey: this._cikey,
-            runtimeVersion: this._runtimeVersion,
-            language: this._language,
-            version: this._version,
-            attach: this._attach,
+        this.runtimeVersion = process.version;
+        this.language = STATSBEAT_LANGUAGE;
+        this.version = packageVersion;
+        this.cikey = options.instrumentationKey;
+        this.featureStatsbeatGauge = this.longIntervalStatsbeatMeter.createObservableGauge(StatsbeatCounter.FEATURE);
+        this.attachStatsbeatGauge = this.longIntervalStatsbeatMeter.createObservableGauge(StatsbeatCounter.ATTACH);
+        this.commonProperties = {
+            os: super.os,
+            rp: super.resourceProvider,
+            cikey: this.cikey,
+            runtimeVersion: this.runtimeVersion,
+            language: this.language,
+            version: this.version,
+            attach: this.attach,
         };
-        this._attachProperties = {
-            rpId: super._resourceIdentifier,
+        this.attachProperties = {
+            rpId: super.resourceIdentifier,
         };
-        this._isInitialized = true;
-        this._initialize();
+        this.isInitialized = true;
+        this.initialize();
     }
-    async _initialize() {
+    async initialize() {
         try {
-            await this._getResourceProvider();
+            await this.getResourceProvider();
             // Add long interval observable callbacks
-            this._attachStatsbeatGauge.addCallback(this._attachCallback.bind(this));
-            this._longIntervalStatsbeatMeter.addBatchObservableCallback(this._featureCallback.bind(this), [this._featureStatsbeatGauge]);
+            this.attachStatsbeatGauge.addCallback(this.attachCallback.bind(this));
+            this.longIntervalStatsbeatMeter.addBatchObservableCallback(this.featureCallback.bind(this), [
+                this.featureStatsbeatGauge,
+            ]);
             // Export Feature/Attach Statsbeat once upon app initialization
-            this._longIntervalAzureExporter.export((await this._longIntervalMetricReader.collect()).resourceMetrics, (result) => {
+            this.longIntervalAzureExporter.export((await this.longIntervalMetricReader.collect()).resourceMetrics, (result) => {
                 if (result.code !== core.ExportResultCode.SUCCESS) {
                     api.diag.error(`LongIntervalStatsbeat: metrics export failed (error ${result.error})`);
                 }
@@ -2451,26 +2491,23 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             api.diag.debug("Call to get the resource provider failed.");
         }
     }
-    _featureCallback(observableResult) {
+    featureCallback(observableResult) {
         let attributes;
-        if (this._instrumentation) {
-            attributes = Object.assign(Object.assign({}, this._commonProperties), { feature: this._instrumentation, type: StatsbeatFeatureType.INSTRUMENTATION });
-            observableResult.observe(this._featureStatsbeatGauge, 1, Object.assign({}, attributes));
+        if (this.instrumentation) {
+            attributes = Object.assign(Object.assign({}, this.commonProperties), { feature: this.instrumentation, type: StatsbeatFeatureType.INSTRUMENTATION });
+            observableResult.observe(this.featureStatsbeatGauge, 1, Object.assign({}, attributes));
         }
-        if (this._feature) {
-            attributes = Object.assign(Object.assign({}, this._commonProperties), { feature: this._feature, type: StatsbeatFeatureType.FEATURE });
-            observableResult.observe(this._featureStatsbeatGauge, 1, Object.assign({}, attributes));
+        if (this.feature) {
+            attributes = Object.assign(Object.assign({}, this.commonProperties), { feature: this.feature, type: StatsbeatFeatureType.FEATURE });
+            observableResult.observe(this.featureStatsbeatGauge, 1, Object.assign({}, attributes));
         }
     }
-    _attachCallback(observableResult) {
-        let attributes = Object.assign(Object.assign({}, this._commonProperties), this._attachProperties);
+    attachCallback(observableResult) {
+        const attributes = Object.assign(Object.assign({}, this.commonProperties), this.attachProperties);
         observableResult.observe(1, attributes);
     }
-    isInitialized() {
-        return this._isInitialized;
-    }
     shutdown() {
-        this._longIntervalStatsbeatMeterProvider.shutdown();
+        return this.longIntervalStatsbeatMeterProvider.shutdown();
     }
 }
 /**
@@ -2524,29 +2561,30 @@ function msToTimeSpan(ms) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS = 60000;
 /**
  * Base sender class
  * @internal
  */
 class BaseSender {
-    constructor(endpointUrl, instrumentationKey, trackStatsbeat, options = {}) {
-        this._statsbeatFailureCount = 0;
-        this._batchSendRetryIntervalMs = DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS;
-        this._numConsecutiveRedirects = 0;
-        this._persister = new FileSystemPersist(instrumentationKey, options);
-        if (trackStatsbeat) {
+    constructor(options) {
+        this.statsbeatFailureCount = 0;
+        this.batchSendRetryIntervalMs = DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS;
+        this.numConsecutiveRedirects = 0;
+        this.persister = new FileSystemPersist(options.instrumentationKey, options.exporterOptions);
+        if (options.trackStatsbeat) {
             // Initialize statsbeatMetrics
-            this._networkStatsbeatMetrics = new NetworkStatsbeatMetrics({
-                instrumentationKey: instrumentationKey,
-                endpointUrl: endpointUrl,
+            this.networkStatsbeatMetrics = new NetworkStatsbeatMetrics({
+                instrumentationKey: options.instrumentationKey,
+                endpointUrl: options.endpointUrl,
             });
-            this._longIntervalStatsbeatMetrics = getInstance$1({
-                instrumentationKey: instrumentationKey,
-                endpointUrl: endpointUrl,
+            this.longIntervalStatsbeatMetrics = getInstance$1({
+                instrumentationKey: options.instrumentationKey,
+                endpointUrl: options.endpointUrl,
             });
         }
-        this._retryTimer = null;
+        this.retryTimer = null;
     }
     /**
      * Export envelopes
@@ -2562,24 +2600,24 @@ class BaseSender {
             const { result, statusCode } = await this.send(envelopes);
             const endTime = new Date().getTime();
             const duration = endTime - startTime;
-            this._numConsecutiveRedirects = 0;
+            this.numConsecutiveRedirects = 0;
             if (statusCode === 200) {
                 // Success -- @todo: start retry timer
-                if (!this._retryTimer) {
-                    this._retryTimer = setTimeout(() => {
-                        this._retryTimer = null;
-                        this._sendFirstPersistedFile();
-                    }, this._batchSendRetryIntervalMs);
-                    this._retryTimer.unref();
+                if (!this.retryTimer) {
+                    this.retryTimer = setTimeout(() => {
+                        this.retryTimer = null;
+                        this.sendFirstPersistedFile();
+                    }, this.batchSendRetryIntervalMs);
+                    this.retryTimer.unref();
                 }
                 // If we are not exportings statsbeat and statsbeat is not disabled -- count success
-                (_a = this._networkStatsbeatMetrics) === null || _a === void 0 ? void 0 : _a.countSuccess(duration);
+                (_a = this.networkStatsbeatMetrics) === null || _a === void 0 ? void 0 : _a.countSuccess(duration);
                 return { code: core.ExportResultCode.SUCCESS };
             }
             else if (statusCode && isRetriable(statusCode)) {
                 // Failed -- persist failed data
                 if (statusCode === 429 || statusCode === 439) {
-                    (_b = this._networkStatsbeatMetrics) === null || _b === void 0 ? void 0 : _b.countThrottle(statusCode);
+                    (_b = this.networkStatsbeatMetrics) === null || _b === void 0 ? void 0 : _b.countThrottle(statusCode);
                 }
                 if (result) {
                     api.diag.info(result);
@@ -2593,31 +2631,31 @@ class BaseSender {
                         });
                     }
                     if (filteredEnvelopes.length > 0) {
-                        (_c = this._networkStatsbeatMetrics) === null || _c === void 0 ? void 0 : _c.countRetry(statusCode);
+                        (_c = this.networkStatsbeatMetrics) === null || _c === void 0 ? void 0 : _c.countRetry(statusCode);
                         // calls resultCallback(ExportResult) based on result of persister.push
-                        return await this._persist(filteredEnvelopes);
+                        return await this.persist(filteredEnvelopes);
                     }
                     // Failed -- not retriable
-                    (_d = this._networkStatsbeatMetrics) === null || _d === void 0 ? void 0 : _d.countFailure(duration, statusCode);
+                    (_d = this.networkStatsbeatMetrics) === null || _d === void 0 ? void 0 : _d.countFailure(duration, statusCode);
                     return {
                         code: core.ExportResultCode.FAILED,
                     };
                 }
                 else {
                     // calls resultCallback(ExportResult) based on result of persister.push
-                    (_e = this._networkStatsbeatMetrics) === null || _e === void 0 ? void 0 : _e.countRetry(statusCode);
-                    return await this._persist(envelopes);
+                    (_e = this.networkStatsbeatMetrics) === null || _e === void 0 ? void 0 : _e.countRetry(statusCode);
+                    return await this.persist(envelopes);
                 }
             }
             else {
                 // Failed -- not retriable
-                if (this._networkStatsbeatMetrics) {
+                if (this.networkStatsbeatMetrics) {
                     if (statusCode) {
-                        this._networkStatsbeatMetrics.countFailure(duration, statusCode);
+                        this.networkStatsbeatMetrics.countFailure(duration, statusCode);
                     }
                 }
                 else {
-                    this._incrementStatsbeatFailure();
+                    this.incrementStatsbeatFailure();
                 }
                 return {
                     code: core.ExportResultCode.FAILED,
@@ -2630,9 +2668,9 @@ class BaseSender {
                 (restError.statusCode === 307 || // Temporary redirect
                     restError.statusCode === 308)) {
                 // Permanent redirect
-                this._numConsecutiveRedirects++;
+                this.numConsecutiveRedirects++;
                 // To prevent circular redirects
-                if (this._numConsecutiveRedirects < 10) {
+                if (this.numConsecutiveRedirects < 10) {
                     if (restError.response && restError.response.headers) {
                         const location = restError.response.headers.get("location");
                         if (location) {
@@ -2644,23 +2682,23 @@ class BaseSender {
                     }
                 }
                 else {
-                    let redirectError = new Error("Circular redirect");
-                    (_f = this._networkStatsbeatMetrics) === null || _f === void 0 ? void 0 : _f.countException(redirectError);
+                    const redirectError = new Error("Circular redirect");
+                    (_f = this.networkStatsbeatMetrics) === null || _f === void 0 ? void 0 : _f.countException(redirectError);
                     return { code: core.ExportResultCode.FAILED, error: redirectError };
                 }
             }
             else if (restError.statusCode && isRetriable(restError.statusCode)) {
-                (_g = this._networkStatsbeatMetrics) === null || _g === void 0 ? void 0 : _g.countRetry(restError.statusCode);
-                return await this._persist(envelopes);
+                (_g = this.networkStatsbeatMetrics) === null || _g === void 0 ? void 0 : _g.countRetry(restError.statusCode);
+                return this.persist(envelopes);
             }
-            if (this._isNetworkError(restError)) {
+            if (this.isNetworkError(restError)) {
                 if (restError.statusCode) {
-                    (_h = this._networkStatsbeatMetrics) === null || _h === void 0 ? void 0 : _h.countRetry(restError.statusCode);
+                    (_h = this.networkStatsbeatMetrics) === null || _h === void 0 ? void 0 : _h.countRetry(restError.statusCode);
                 }
                 api.diag.error("Retrying due to transient client side error. Error message:", restError.message);
-                return await this._persist(envelopes);
+                return this.persist(envelopes);
             }
-            (_j = this._networkStatsbeatMetrics) === null || _j === void 0 ? void 0 : _j.countException(restError);
+            (_j = this.networkStatsbeatMetrics) === null || _j === void 0 ? void 0 : _j.countException(restError);
             api.diag.error("Envelopes could not be exported and are not retriable. Error message:", restError.message);
             return { code: core.ExportResultCode.FAILED, error: restError };
         }
@@ -2668,9 +2706,9 @@ class BaseSender {
     /**
      * Persist envelopes to disk
      */
-    async _persist(envelopes) {
+    async persist(envelopes) {
         try {
-            const success = await this._persister.push(envelopes);
+            const success = await this.persister.push(envelopes);
             return success
                 ? { code: core.ExportResultCode.SUCCESS }
                 : {
@@ -2683,19 +2721,19 @@ class BaseSender {
         }
     }
     // Disable collection of statsbeat metrics after max failures
-    _incrementStatsbeatFailure() {
+    incrementStatsbeatFailure() {
         var _a, _b;
-        this._statsbeatFailureCount++;
-        if (this._statsbeatFailureCount > MAX_STATSBEAT_FAILURES) {
-            (_a = this._networkStatsbeatMetrics) === null || _a === void 0 ? void 0 : _a.shutdown();
-            (_b = this._longIntervalStatsbeatMetrics) === null || _b === void 0 ? void 0 : _b.shutdown();
-            this._networkStatsbeatMetrics = undefined;
-            this._statsbeatFailureCount = 0;
+        this.statsbeatFailureCount++;
+        if (this.statsbeatFailureCount > MAX_STATSBEAT_FAILURES) {
+            (_a = this.networkStatsbeatMetrics) === null || _a === void 0 ? void 0 : _a.shutdown();
+            (_b = this.longIntervalStatsbeatMetrics) === null || _b === void 0 ? void 0 : _b.shutdown();
+            this.networkStatsbeatMetrics = undefined;
+            this.statsbeatFailureCount = 0;
         }
     }
-    async _sendFirstPersistedFile() {
+    async sendFirstPersistedFile() {
         try {
-            const envelopes = (await this._persister.shift());
+            const envelopes = (await this.persister.shift());
             if (envelopes) {
                 await this.send(envelopes);
             }
@@ -2704,7 +2742,7 @@ class BaseSender {
             api.diag.warn(`Failed to fetch persisted file`, err);
         }
     }
-    _isNetworkError(error) {
+    isNetworkError(error) {
         if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
             return true;
         }
@@ -2713,23 +2751,30 @@ class BaseSender {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const applicationInsightsResource = "https://monitor.azure.com//.default";
 /**
  * Exporter HTTP sender class
  * @internal
  */
 class HttpSender extends BaseSender {
-    constructor(endpointUrl, instrumentationKey, trackStatsbeat, options) {
-        super(endpointUrl, instrumentationKey, trackStatsbeat, options);
+    constructor(options) {
+        super(options);
         // Build endpoint using provided configuration or default values
-        this._appInsightsClientOptions = Object.assign({ host: endpointUrl }, options);
-        if (options === null || options === void 0 ? void 0 : options.credential) {
+        this.appInsightsClientOptions = Object.assign({ host: options.endpointUrl }, options.exporterOptions);
+        if (this.appInsightsClientOptions.credential) {
             // Add credentialScopes
-            options.credentialScopes = [applicationInsightsResource];
+            if (options.aadAudience) {
+                this.appInsightsClientOptions.credentialScopes = [options.aadAudience];
+            }
+            else {
+                // Default
+                this.appInsightsClientOptions.credentialScopes = [applicationInsightsResource];
+            }
         }
-        this._appInsightsClient = new ApplicationInsightsClient(this._appInsightsClientOptions);
+        this.appInsightsClient = new ApplicationInsightsClient(this.appInsightsClientOptions);
         // Handle redirects in HTTP Sender
-        this._appInsightsClient.pipeline.removePolicy({ name: coreRestPipeline.redirectPolicyName });
+        this.appInsightsClient.pipeline.removePolicy({ name: coreRestPipeline.redirectPolicyName });
     }
     /**
      * Send Azure envelopes
@@ -2737,21 +2782,16 @@ class HttpSender extends BaseSender {
      */
     async send(envelopes) {
         var _a;
-        let options = {};
-        try {
-            let response;
-            function onResponse(rawResponse, flatResponse) {
-                response = rawResponse;
-                if (options.onResponse) {
-                    options.onResponse(rawResponse, flatResponse);
-                }
+        const options = {};
+        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;
         }
+        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 : "" };
     }
     /**
      * Shutdown sender
@@ -2762,15 +2802,16 @@ class HttpSender extends BaseSender {
     }
     handlePermanentRedirect(location) {
         if (location) {
-            const locUrl = new url__default["default"].URL(location);
+            const locUrl = new url.URL(location);
             if (locUrl && locUrl.host) {
-                this._appInsightsClient.host = "https://" + locUrl.host;
+                this.appInsightsClient.host = "https://" + locUrl.host;
             }
         }
     }
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 let instance = null;
 /**
  * Azure Telemetry context.
@@ -2790,13 +2831,13 @@ class Context {
         [Context.nodeVersion] = node.split(".");
         Context.opentelemetryVersion = core.SDK_INFO[semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION];
         Context.sdkVersion = packageVersion;
-        let prefix = process.env["AZURE_MONITOR_AGENT_PREFIX"]
+        const prefix = process.env["AZURE_MONITOR_AGENT_PREFIX"]
             ? process.env["AZURE_MONITOR_AGENT_PREFIX"]
             : "";
-        let version = process.env["AZURE_MONITOR_DISTRO_VERSION"]
+        const version = process.env["AZURE_MONITOR_DISTRO_VERSION"]
             ? `dst${process.env["AZURE_MONITOR_DISTRO_VERSION"]}`
             : `ext${Context.sdkVersion}`;
-        let internalSdkVersion = `${prefix}node${Context.nodeVersion}:otel${Context.opentelemetryVersion}:${version}`;
+        const internalSdkVersion = `${prefix}node${Context.nodeVersion}:otel${Context.opentelemetryVersion}:${version}`;
         this.tags[KnownContextTagKeys.AiInternalSdkVersion] = internalSdkVersion;
     }
 }
@@ -2815,6 +2856,7 @@ function getInstance() {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function createTagsFromResource(resource) {
     const context = getInstance();
     const tags = Object.assign({}, context.tags);
@@ -2892,7 +2934,7 @@ function getCloudRoleInstance(resource) {
         return String(serviceInstanceId);
     }
     // Default
-    return os__default["default"] && os__default["default"].hostname();
+    return os$1 && os$1.hostname();
 }
 function isSqlDB(dbSystem) {
     return (dbSystem === semanticConventions.DbSystemValues.DB2 ||
@@ -2976,20 +3018,20 @@ function createResourceMetricEnvelope(resource, instrumentationKey) {
         for (const key of Object.keys(resource.attributes)) {
             // Avoid duplication ignoring fields already mapped.
             if (!(key.startsWith("_MS.") ||
-                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION ||
-                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE ||
-                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_NAME)) {
+                key === semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION ||
+                key === semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE ||
+                key === semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_NAME)) {
                 resourceAttributes[key] = resource.attributes[key];
             }
         }
         // Only send event when resource attributes are available
         if (Object.keys(resourceAttributes).length > 0) {
-            let baseData = {
+            const baseData = {
                 version: 2,
                 metrics: [{ name: "_OTELRESOURCE_", value: 1 }],
                 properties: resourceAttributes,
             };
-            let envelope = {
+            const envelope = {
                 name: "Microsoft.ApplicationInsights.Metric",
                 time: new Date(),
                 sampleRate: 100,
@@ -3026,6 +3068,7 @@ const MicrosoftEventHub = "Microsoft.EventHub";
 const MessageBusDestination = "message_bus.destination";
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Average span.links[].attributes.enqueuedTime
  */
@@ -3072,6 +3115,7 @@ const parseEventHubSpan = (span, baseData) => {
 };
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function createTagsFromSpan(span) {
     const tags = createTagsFromResource(span.resource);
     tags[KnownContextTagKeys.AiOperationId] = span.spanContext().traceId;
@@ -3124,21 +3168,21 @@ function createPropertiesFromSpanAttributes(attributes) {
         for (const key of Object.keys(attributes)) {
             // Avoid duplication ignoring fields already mapped.
             if (!(key.startsWith("_MS.") ||
-                key == semanticConventions.SemanticAttributes.NET_PEER_IP ||
-                key == semanticConventions.SemanticAttributes.NET_PEER_NAME ||
-                key == semanticConventions.SemanticAttributes.PEER_SERVICE ||
-                key == semanticConventions.SemanticAttributes.HTTP_METHOD ||
-                key == semanticConventions.SemanticAttributes.HTTP_URL ||
-                key == semanticConventions.SemanticAttributes.HTTP_STATUS_CODE ||
-                key == semanticConventions.SemanticAttributes.HTTP_ROUTE ||
-                key == semanticConventions.SemanticAttributes.HTTP_HOST ||
-                key == semanticConventions.SemanticAttributes.HTTP_URL ||
-                key == semanticConventions.SemanticAttributes.DB_SYSTEM ||
-                key == semanticConventions.SemanticAttributes.DB_STATEMENT ||
-                key == semanticConventions.SemanticAttributes.DB_OPERATION ||
-                key == semanticConventions.SemanticAttributes.DB_NAME ||
-                key == semanticConventions.SemanticAttributes.RPC_SYSTEM ||
-                key == semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE)) {
+                key === semanticConventions.SemanticAttributes.NET_PEER_IP ||
+                key === semanticConventions.SemanticAttributes.NET_PEER_NAME ||
+                key === semanticConventions.SemanticAttributes.PEER_SERVICE ||
+                key === semanticConventions.SemanticAttributes.HTTP_METHOD ||
+                key === semanticConventions.SemanticAttributes.HTTP_URL ||
+                key === semanticConventions.SemanticAttributes.HTTP_STATUS_CODE ||
+                key === semanticConventions.SemanticAttributes.HTTP_ROUTE ||
+                key === semanticConventions.SemanticAttributes.HTTP_HOST ||
+                key === semanticConventions.SemanticAttributes.HTTP_URL ||
+                key === semanticConventions.SemanticAttributes.DB_SYSTEM ||
+                key === semanticConventions.SemanticAttributes.DB_STATEMENT ||
+                key === semanticConventions.SemanticAttributes.DB_OPERATION ||
+                key === semanticConventions.SemanticAttributes.DB_NAME ||
+                key === semanticConventions.SemanticAttributes.RPC_SYSTEM ||
+                key === semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE)) {
                 properties[key] = attributes[key];
             }
         }
@@ -3161,7 +3205,7 @@ function createDependencyData(span) {
     const remoteDependencyData = {
         name: span.name,
         id: `${span.spanContext().spanId}`,
-        success: span.status.code != api.SpanStatusCode.ERROR,
+        success: span.status.code !== api.SpanStatusCode.ERROR,
         resultCode: "0",
         type: "Dependency",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
@@ -3198,10 +3242,11 @@ function createDependencyData(span) {
                 // Remove default port
                 const portRegex = new RegExp(/(https?)(:\/\/.*)(:\d+)(\S*)/);
                 const res = portRegex.exec(target);
-                if (res != null) {
+                if (res !== null) {
                     const protocol = res[1];
                     const 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];
                     }
@@ -3269,7 +3314,7 @@ function createDependencyData(span) {
 function createRequestData(span) {
     const requestData = {
         id: `${span.spanContext().spanId}`,
-        success: span.status.code != api.SpanStatusCode.ERROR,
+        success: span.status.code !== api.SpanStatusCode.ERROR,
         responseCode: "0",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
         version: 2,
@@ -3369,7 +3414,7 @@ function spanEventsToEnvelopes(span, ikey) {
                 tags[KnownContextTagKeys.AiOperationParentId] = spanId;
             }
             // Only generate exception telemetry for incoming requests
-            if (event.name == "exception" && span.kind == api.SpanKind.SERVER) {
+            if (event.name === "exception" && span.kind === api.SpanKind.SERVER) {
                 name = "Microsoft.ApplicationInsights.Exception";
                 baseType = "ExceptionData";
                 let typeName = "";
@@ -3387,7 +3432,7 @@ function spanEventsToEnvelopes(span, ikey) {
                         message = String(exceptionMsg);
                     }
                     const escaped = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED];
-                    if (escaped != undefined) {
+                    if (escaped !== undefined) {
                         properties[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED] = String(escaped);
                     }
                 }
@@ -3437,6 +3482,7 @@ function spanEventsToEnvelopes(span, ikey) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Trace Exporter.
  */
@@ -3450,8 +3496,14 @@ class AzureMonitorTraceExporter extends AzureMonitorBaseExporter {
         /**
          * Flag to determine if Exporter is shutdown.
          */
-        this._isShutdown = false;
-        this._sender = new HttpSender(this.endpointUrl, this.instrumentationKey, this.trackStatsbeat, options);
+        this.isShutdown = false;
+        this.sender = new HttpSender({
+            endpointUrl: this.endpointUrl,
+            instrumentationKey: this.instrumentationKey,
+            trackStatsbeat: this.trackStatsbeat,
+            exporterOptions: options,
+            aadAudience: this.aadAudience,
+        });
         api.diag.debug("AzureMonitorTraceExporter was successfully setup");
     }
     /**
@@ -3460,26 +3512,26 @@ class AzureMonitorTraceExporter extends AzureMonitorBaseExporter {
      * @param resultCallback - Result callback.
      */
     async export(spans, resultCallback) {
-        if (this._isShutdown) {
+        if (this.isShutdown) {
             api.diag.info("Exporter shut down. Failed to export spans.");
             setTimeout(() => resultCallback({ code: core.ExportResultCode.FAILED }), 0);
             return;
         }
         api.diag.info(`Exporting ${spans.length} span(s). Converting to envelopes...`);
         if (spans.length > 0) {
-            let envelopes = [];
+            const envelopes = [];
             const resourceMetricEnvelope = createResourceMetricEnvelope(spans[0].resource, this.instrumentationKey);
             if (resourceMetricEnvelope) {
                 envelopes.push(resourceMetricEnvelope);
             }
             spans.forEach((span) => {
                 envelopes.push(readableSpanToEnvelope(span, this.instrumentationKey));
-                let spanEventEnvelopes = spanEventsToEnvelopes(span, this.instrumentationKey);
+                const spanEventEnvelopes = spanEventsToEnvelopes(span, this.instrumentationKey);
                 if (spanEventEnvelopes.length > 0) {
                     envelopes.push(...spanEventEnvelopes);
                 }
             });
-            resultCallback(await this._sender.exportEnvelopes(envelopes));
+            resultCallback(await this.sender.exportEnvelopes(envelopes));
         }
         // No data to export
         resultCallback({ code: core.ExportResultCode.SUCCESS });
@@ -3488,13 +3540,14 @@ class AzureMonitorTraceExporter extends AzureMonitorBaseExporter {
      * Shutdown AzureMonitorTraceExporter.
      */
     async shutdown() {
-        this._isShutdown = true;
+        this.isShutdown = true;
         api.diag.info("AzureMonitorTraceExporter shutting down");
-        return this._sender.shutdown();
+        return this.sender.shutdown();
     }
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Metric Exporter.
  */
@@ -3509,7 +3562,13 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
          * Flag to determine if Exporter is shutdown.
          */
         this._isShutdown = false;
-        this._sender = new HttpSender(this.endpointUrl, this.instrumentationKey, this.trackStatsbeat, options);
+        this._sender = new HttpSender({
+            endpointUrl: this.endpointUrl,
+            instrumentationKey: this.instrumentationKey,
+            trackStatsbeat: this.trackStatsbeat,
+            exporterOptions: options,
+            aadAudience: this.aadAudience,
+        });
         api.diag.debug("AzureMonitorMetricExporter was successfully setup");
     }
     /**
@@ -3524,9 +3583,9 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
             return;
         }
         api.diag.info(`Exporting ${metrics.scopeMetrics.length} metrics(s). Converting to envelopes...`);
-        let envelopes = resourceMetricsToEnvelope(metrics, this.instrumentationKey);
+        const envelopes = resourceMetricsToEnvelope(metrics, this.instrumentationKey);
         // Supress tracing until OpenTelemetry Metrics SDK support it
-        api.context.with(core.suppressTracing(api.context.active()), async () => {
+        await api.context.with(core.suppressTracing(api.context.active()), async () => {
             resultCallback(await this._sender.exportEnvelopes(envelopes));
         });
     }
@@ -3542,8 +3601,8 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
      * Select aggregation temporality
      */
     selectAggregationTemporality(instrumentType) {
-        if (instrumentType == sdkMetrics.InstrumentType.UP_DOWN_COUNTER ||
-            instrumentType == sdkMetrics.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER) {
+        if (instrumentType === sdkMetrics.InstrumentType.UP_DOWN_COUNTER ||
+            instrumentType === sdkMetrics.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER) {
             return sdkMetrics.AggregationTemporality.CUMULATIVE;
         }
         return sdkMetrics.AggregationTemporality.DELTA;
@@ -3557,13 +3616,14 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Log to Azure envelope parsing.
  * @internal
  */
 function logToEnvelope(log, ikey) {
     const time = log.hrTime ? new Date(core.hrTimeToMilliseconds(log.hrTime)) : new Date();
-    let sampleRate = 100;
+    const sampleRate = 100;
     const instrumentationKey = ikey;
     const tags = createTagsFromLog(log);
     const [properties, measurements] = createPropertiesFromLog(log);
@@ -3572,13 +3632,13 @@ function logToEnvelope(log, ikey) {
     let baseData;
     if (!log.attributes[ApplicationInsightsBaseType]) {
         // Get Exception attributes if available
-        let exceptionType = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE];
+        const exceptionType = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE];
         if (exceptionType) {
-            let exceptionMessage = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
-            let exceptionStacktrace = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE];
+            const exceptionMessage = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
+            const exceptionStacktrace = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE];
             name = ApplicationInsightsExceptionName;
             baseType = ApplicationInsightsExceptionBaseType;
-            let exceptionDetails = {
+            const exceptionDetails = {
                 typeName: String(exceptionType),
                 message: String(exceptionMessage),
                 hasFullStack: exceptionStacktrace ? true : false,
@@ -3644,9 +3704,9 @@ function createPropertiesFromLog(log) {
         for (const key of Object.keys(log.attributes)) {
             // Avoid duplication ignoring fields already mapped.
             if (!(key.startsWith("_MS.") ||
-                key == semanticConventions.SemanticAttributes.EXCEPTION_TYPE ||
-                key == semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE ||
-                key == semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE)) {
+                key === semanticConventions.SemanticAttributes.EXCEPTION_TYPE ||
+                key === semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE ||
+                key === semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE)) {
                 properties[key] = log.attributes[key];
             }
         }
@@ -3730,6 +3790,7 @@ function getLegacyApplicationInsightsBaseData(log) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Log Exporter.
  */
@@ -3744,7 +3805,13 @@ class AzureMonitorLogExporter extends AzureMonitorBaseExporter {
          * Flag to determine if Exporter is shutdown.
          */
         this._isShutdown = false;
-        this._sender = new HttpSender(this.endpointUrl, this.instrumentationKey, this.trackStatsbeat, options);
+        this._sender = new HttpSender({
+            endpointUrl: this.endpointUrl,
+            instrumentationKey: this.instrumentationKey,
+            trackStatsbeat: this.trackStatsbeat,
+            exporterOptions: options,
+            aadAudience: this.aadAudience,
+        });
         api.diag.debug("AzureMonitorLogExporter was successfully setup");
     }
     /**
@@ -3759,15 +3826,15 @@ class AzureMonitorLogExporter extends AzureMonitorBaseExporter {
             return;
         }
         api.diag.info(`Exporting ${logs.length} logs(s). Converting to envelopes...`);
-        let envelopes = [];
+        const envelopes = [];
         logs.forEach((log) => {
-            let envelope = logToEnvelope(log, this.instrumentationKey);
+            const envelope = logToEnvelope(log, this.instrumentationKey);
             if (envelope) {
                 envelopes.push(envelope);
             }
         });
         // Supress tracing until OpenTelemetry Logs SDK support it
-        api.context.with(core.suppressTracing(api.context.active()), async () => {
+        await api.context.with(core.suppressTracing(api.context.active()), async () => {
             resultCallback(await this._sender.exportEnvelopes(envelopes));
         });
     }