npm - @azure/monitor-opentelemetry-exporter - Versions diffs - 1.0.0-beta.16 → 1.0.0-beta.17 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/index.js CHANGED Viewed

@@ -1,7 +1,5 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
@@ -16,10 +14,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 +27,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 +59,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.16";
+const packageVersion = "1.0.0-beta.17";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -97,26 +90,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 +123,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 +143,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 +256,7 @@ var PerformanceCounter;
 });
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * ConnectionString parser.
  * @internal
@@ -318,16 +312,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 +355,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 +373,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 +422,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 +454,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 +471,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 +490,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 +514,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 +551,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 +601,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 +1766,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 +1806,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.17`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -1868,6 +1882,8 @@ const trackOperationSpec = {
     serializer
 };
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 class NetworkStatsbeat {
     constructor(endpoint, host) {
         this.endpoint = endpoint;
@@ -1895,12 +1911,12 @@ const StatsbeatResourceProvider = {
 };
 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 = {}));
@@ -1930,35 +1946,36 @@ var StatsbeatFeatureType;
 })(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;
+        this.resourceProvider = StatsbeatResourceProvider.unknown;
         if (process.env.WEBSITE_SITE_NAME) {
             // Web apps
-            this._resourceProvider = StatsbeatResourceProvider.appsvc;
+            this.resourceProvider = StatsbeatResourceProvider.appsvc;
         }
         else if (process.env.FUNCTIONS_WORKER_RUNTIME) {
             // Function apps
-            this._resourceProvider = StatsbeatResourceProvider.functions;
+            this.resourceProvider = StatsbeatResourceProvider.functions;
         }
         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 +1993,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 +2020,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 +2032,7 @@ class StatsbeatMetrics {
 }
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function createPropertiesFromMetricAttributes(attributes) {
     const properties = {};
     if (attributes) {
@@ -2029,7 +2047,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 +2061,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 +2084,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 +2104,7 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
 }
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor Statsbeat Exporter
  */
@@ -2100,7 +2119,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 +2134,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 +2157,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 +2302,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 +2326,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 +2339,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 +2352,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 +2365,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 +2397,7 @@ class NetworkStatsbeatMetrics extends StatsbeatMetrics {
 }
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 let instance$1 = null;
 /**
  * Long Interval Statsbeat Metrics
@@ -2383,65 +2406,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 +2476,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 +2546,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 +2585,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 +2616,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 +2653,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 +2667,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 +2691,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 +2706,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 +2727,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 +2736,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 +2767,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 +2787,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 +2816,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 +2841,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 +2919,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 +3003,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 +3053,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 +3100,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 +3153,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 +3190,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 +3227,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 +3299,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 +3399,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 +3417,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 +3467,7 @@ function spanEventsToEnvelopes(span, ikey) {
 }
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Trace Exporter.
  */
@@ -3450,8 +3481,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 +3497,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 +3525,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 +3547,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 +3568,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 +3586,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 +3601,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 +3617,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 +3689,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 +3775,7 @@ function getLegacyApplicationInsightsBaseData(log) {
 }
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Azure Monitor OpenTelemetry Log Exporter.
  */
@@ -3744,7 +3790,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 +3811,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));
         });
     }