@azure/monitor-opentelemetry-exporter 1.0.0-beta.10 → 1.0.0-beta.11

package/README.md

@@ -28,9 +28,10 @@ Add the exporter to your existing OpenTelemetry tracer provider (`NodeTracerProv
 
 ```js
 const { AzureMonitorTraceExporter } = require("@azure/monitor-opentelemetry-exporter");
-const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
 const { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");
-
+const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
+const { Resource } = require("@opentelemetry/resources"); 
+const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions"); 
 
 const provider = new NodeTracerProvider({
   resource: new Resource({
@@ -60,9 +61,9 @@ Add the exporter to your existing OpenTelemetry tracer provider (`NodeTracerProv
 
 ```js
 const { MeterProvider, PeriodicExportingMetricReader } = require("@opentelemetry/sdk-metrics");
+const { AzureMonitorMetricExporter } = require("@azure/monitor-opentelemetry-exporter");
 const { Resource } = require("@opentelemetry/resources");
 const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions");
-const { AzureMonitorMetricExporter } = require("@azure/monitor-opentelemetry-exporter");
 
 // Add the exporter into the MetricReader and register it with the MeterProvider
 const provider = new MeterProvider();
@@ -75,7 +76,6 @@ const metricReaderOptions = {
 };
 const metricReader = new PeriodicExportingMetricReader(metricReaderOptions);
 provider.addMetricReader(metricReader);
-);
 ```
 
 ### Logs
@@ -88,8 +88,8 @@ You can enable sampling to limit the amount of telemetry records you receive. In
 
 ```js
 const { ApplicationInsightsSampler } = require("@azure/monitor-opentelemetry-exporter");
-const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
 const { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");
+const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
 
 // Sampler expects a sample rate of between 0 and 1 inclusive
 // A rate of 0.75 means approximately 75 % of your traces will be sent
@@ -118,7 +118,7 @@ For more information on the OpenTelemetry project, please review the [**OpenTele
 You can enable debug logging by changing the logging level of your provider.
 
 ```js
-const { diag, DiagConsoleLogger, DiagLogLevel } = require("@opentelemetry/api");
+const { DiagConsoleLogger, DiagLogLevel, diag } = require("@opentelemetry/api");
 const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
 
 const provider = new NodeTracerProvider();

package/dist/index.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
-var coreRestPipeline = require('@azure/core-rest-pipeline');
 var sdkMetrics = require('@opentelemetry/sdk-metrics');
+var coreRestPipeline = require('@azure/core-rest-pipeline');
 var os$1 = require('os');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 var url = require('url');
@@ -66,7 +66,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.10";
+const packageVersion = "1.0.0-beta.11";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -1756,7 +1756,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.9`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.11`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -1893,7 +1893,7 @@ class HttpSender {
 }
 
 // Copyright (c) Microsoft Corporation.
-let instance = null;
+let instance$1 = null;
 /**
  * Azure Telemetry context.
  * @internal
@@ -1922,11 +1922,11 @@ Context.nodeVersion = "";
  * Singleton Context instance.
  * @internal
  */
-function getInstance() {
-    if (!instance) {
-        instance = new Context();
+function getInstance$1() {
+    if (!instance$1) {
+        instance$1 = new Context();
     }
-    return instance;
+    return instance$1;
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -2001,6 +2001,8 @@ var StatsbeatCounter;
     StatsbeatCounter["THROTTLE_COUNT"] = "Throttle Count";
     StatsbeatCounter["EXCEPTION_COUNT"] = "Exception Count";
     StatsbeatCounter["AVERAGE_DURATION"] = "Request Duration";
+    StatsbeatCounter["ATTACH"] = "Attach";
+    StatsbeatCounter["FEATURE"] = "Feature";
 })(StatsbeatCounter || (StatsbeatCounter = {}));
 const AIMS_URI = "http://169.254.169.254/metadata/instance/compute";
 const AIMS_API_VERSION = "api-version=2017-12-01";
@@ -2018,60 +2020,23 @@ const EU_ENDPOINTS = [
     "swedencentral",
     "switzerlandnorth",
     "switzerlandwest",
+    "uksouth",
+    "ukwest",
 ];
+var StatsbeatFeatureType;
+(function (StatsbeatFeatureType) {
+    StatsbeatFeatureType["FEATURE"] = "Feature";
+    StatsbeatFeatureType["INSTRUMENTATION"] = "Instrumentation";
+})(StatsbeatFeatureType || (StatsbeatFeatureType = {}));
 
 // Copyright (c) Microsoft Corporation.
 const os = require("os");
 class StatsbeatMetrics {
-    constructor(options) {
-        this._isInitialized = false;
-        this._networkStatsbeatCollection = [];
-        this._statsCollectionShortInterval = 900000; // 15 minutes
-        // Custom dimensions
+    constructor() {
         this._resourceProvider = StatsbeatResourceProvider.unknown;
+        this._vmInfo = {};
         this._os = os.type();
-        this._attach = "sdk";
-        this._connectionString = this._getConnectionString(options.endpointUrl);
-        this._meterProvider = new sdkMetrics.MeterProvider();
-        const exporterConfig = {
-            connectionString: this._connectionString,
-        };
-        this._azureExporter = new _AzureMonitorStatsbeatExporter(exporterConfig);
-        const metricReaderOptions = {
-            exporter: this._azureExporter,
-            exportIntervalMillis: options.collectionInterval || this._statsCollectionShortInterval, // 15 minutes
-        };
-        // Exports Network Statsbeat every 15 minutes
-        this._metricReader = new sdkMetrics.PeriodicExportingMetricReader(metricReaderOptions);
-        this._meterProvider.addMetricReader(this._metricReader);
-        this._meter = this._meterProvider.getMeter("Azure Monitor NetworkStatsbeat");
-        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._meter.createObservableGauge(StatsbeatCounter.SUCCESS_COUNT);
-        this._failureCountGauge = this._meter.createObservableGauge(StatsbeatCounter.FAILURE_COUNT);
-        this._retryCountGauge = this._meter.createObservableGauge(StatsbeatCounter.RETRY_COUNT);
-        this._throttleCountGauge = this._meter.createObservableGauge(StatsbeatCounter.THROTTLE_COUNT);
-        this._exceptionCountGauge = this._meter.createObservableGauge(StatsbeatCounter.EXCEPTION_COUNT);
-        this._averageDurationGauge = this._meter.createObservableGauge(StatsbeatCounter.AVERAGE_DURATION);
-        this._commonProperties = {
-            os: this._os,
-            rp: this._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._isInitialized = true;
-        this._initialize();
+        this._resourceIdentifier = "";
     }
     async _getResourceProvider() {
         // Check resource provider
@@ -2086,6 +2051,11 @@ class StatsbeatMetrics {
         }
         else if (await this.getAzureComputeMetadata()) {
             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;
+            }
         }
         else {
             this._resourceProvider = StatsbeatResourceProvider.unknown;
@@ -2105,6 +2075,23 @@ class StatsbeatMetrics {
             .sendRequest(request)
             .then((res) => {
             if (res.status === 200) {
+                // Success; VM
+                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"] || "";
+                    }
+                    catch (error) {
+                        api.diag.debug("Failed to parse JSON: ", error);
+                    }
+                });
                 return true;
             }
             else {
@@ -2116,27 +2103,88 @@ class StatsbeatMetrics {
         });
         return false;
     }
+    _getConnectionString(endpointUrl) {
+        let currentEndpoint = endpointUrl;
+        for (let i = 0; i < EU_ENDPOINTS.length; i++) {
+            if (currentEndpoint.includes(EU_ENDPOINTS[i])) {
+                return EU_CONNECTION_STRING;
+            }
+        }
+        return NON_EU_CONNECTION_STRING;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+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();
+        const exporterConfig = {
+            connectionString: this._connectionString,
+        };
+        this._networkAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
+        // Exports Network Statsbeat every 15 minutes
+        const networkMetricReaderOptions = {
+            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._networkProperties = {
+            endpoint: this._endpointUrl,
+            host: this._host,
+        };
+        this._isInitialized = true;
+        this._initialize();
+    }
     isInitialized() {
         return this._isInitialized;
     }
     shutdown() {
-        this._meterProvider.shutdown();
+        this._networkStatsbeatMeterProvider.shutdown();
     }
     async _initialize() {
         try {
-            await this._getResourceProvider();
-            // Add observable callbacks
+            await super._getResourceProvider();
+            // Add network observable callbacks
             this._successCountGauge.addCallback(this._successCallback.bind(this));
-            this._meter.addBatchObservableCallback(this._failureCallback.bind(this), [
+            this._networkStatsbeatMeter.addBatchObservableCallback(this._failureCallback.bind(this), [
                 this._failureCountGauge,
             ]);
-            this._meter.addBatchObservableCallback(this._retryCallback.bind(this), [
+            this._networkStatsbeatMeter.addBatchObservableCallback(this._retryCallback.bind(this), [
                 this._retryCountGauge,
             ]);
-            this._meter.addBatchObservableCallback(this._throttleCallback.bind(this), [
+            this._networkStatsbeatMeter.addBatchObservableCallback(this._throttleCallback.bind(this), [
                 this._throttleCountGauge,
             ]);
-            this._meter.addBatchObservableCallback(this._exceptionCallback.bind(this), [
+            this._networkStatsbeatMeter.addBatchObservableCallback(this._exceptionCallback.bind(this), [
                 this._exceptionCountGauge,
             ]);
             this._averageDurationGauge.addCallback(this._durationCallback.bind(this));
@@ -2299,21 +2347,123 @@ class StatsbeatMetrics {
             if (res != null && res.length > 1) {
                 shortHost = res[1];
             }
+            shortHost = shortHost.replace(".in.applicationinsights.azure.com", "");
         }
         catch (error) {
             api.diag.debug("Failed to get the short host name.");
         }
         return shortHost;
     }
-    _getConnectionString(endpointUrl) {
-        let currentEndpoint = endpointUrl;
-        for (let i = 0; i < EU_ENDPOINTS.length; i++) {
-            if (currentEndpoint.includes(EU_ENDPOINTS[i])) {
-                return EU_CONNECTION_STRING;
+}
+
+// Copyright (c) Microsoft Corporation.
+let instance = null;
+/**
+ * Long Interval Statsbeat Metrics
+ * @internal
+ */
+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);
+        const exporterConfig = {
+            connectionString: this._connectionString,
+        };
+        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;
+            }
+            catch (error) {
+                api.diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
             }
         }
-        return NON_EU_CONNECTION_STRING;
+        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
+        };
+        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._attachProperties = {
+            rpId: super._resourceIdentifier,
+        };
+        this._isInitialized = true;
+        this._initialize();
+    }
+    async _initialize() {
+        try {
+            await this._getResourceProvider();
+            // Add long interval observable callbacks
+            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) => {
+                if (result.code !== core.ExportResultCode.SUCCESS) {
+                    api.diag.error(`LongIntervalStatsbeat: metrics export failed (error ${result.error})`);
+                }
+            });
+        }
+        catch (error) {
+            api.diag.debug("Call to get the resource provider failed.");
+        }
+    }
+    _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._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);
+        observableResult.observe(1, attributes);
     }
+    isInitialized() {
+        return this._isInitialized;
+    }
+    shutdown() {
+        this._longIntervalStatsbeatMeterProvider.shutdown();
+    }
+}
+/**
+ * Singleton LongIntervalStatsbeatMetrics instance.
+ * @internal
+ */
+function getInstance(options) {
+    if (!instance) {
+        instance = new LongIntervalStatsbeatMetrics(options);
+    }
+    return instance;
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -2357,7 +2507,11 @@ class AzureMonitorBaseExporter {
         this._persister = new FileSystemPersist(this._instrumentationKey, this._options);
         if (!this._isStatsbeatExporter) {
             // Initialize statsbeatMetrics
-            this._statsbeatMetrics = new StatsbeatMetrics({
+            this._networkStatsbeatMetrics = new NetworkStatsbeatMetrics({
+                instrumentationKey: this._instrumentationKey,
+                endpointUrl: this._endpointUrl,
+            });
+            this._longIntervalStatsbeatMetrics = getInstance({
                 instrumentationKey: this._instrumentationKey,
                 endpointUrl: this._endpointUrl,
             });
@@ -2413,13 +2567,13 @@ class AzureMonitorBaseExporter {
                     this._retryTimer.unref();
                 }
                 // If we are not exportings statsbeat and statsbeat is not disabled -- count success
-                (_a = this._statsbeatMetrics) === 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._statsbeatMetrics) === 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);
@@ -2433,27 +2587,27 @@ class AzureMonitorBaseExporter {
                         });
                     }
                     if (filteredEnvelopes.length > 0) {
-                        (_c = this._statsbeatMetrics) === 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);
                     }
                     // Failed -- not retriable
-                    (_d = this._statsbeatMetrics) === 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._statsbeatMetrics) === null || _e === void 0 ? void 0 : _e.countRetry(statusCode);
+                    (_e = this._networkStatsbeatMetrics) === null || _e === void 0 ? void 0 : _e.countRetry(statusCode);
                     return await this._persist(envelopes);
                 }
             }
             else {
                 // Failed -- not retriable
-                if (this._statsbeatMetrics) {
+                if (this._networkStatsbeatMetrics) {
                     if (statusCode) {
-                        this._statsbeatMetrics.countFailure(duration, statusCode);
+                        this._networkStatsbeatMetrics.countFailure(duration, statusCode);
                     }
                 }
                 else {
@@ -2485,34 +2639,35 @@ class AzureMonitorBaseExporter {
                 }
                 else {
                     let redirectError = new Error("Circular redirect");
-                    (_f = this._statsbeatMetrics) === null || _f === void 0 ? void 0 : _f.countException(redirectError);
+                    (_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._statsbeatMetrics) === null || _g === void 0 ? void 0 : _g.countRetry(restError.statusCode);
+                (_g = this._networkStatsbeatMetrics) === null || _g === void 0 ? void 0 : _g.countRetry(restError.statusCode);
                 return await this._persist(envelopes);
             }
             if (this._isNetworkError(restError)) {
                 if (restError.statusCode) {
-                    (_h = this._statsbeatMetrics) === 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);
             }
-            (_j = this._statsbeatMetrics) === 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 };
         }
     }
     // Disable collection of statsbeat metrics after max failures
     _incrementStatsbeatFailure() {
-        var _a;
+        var _a, _b;
         this._statsbeatFailureCount++;
         if (this._statsbeatFailureCount > MAX_STATSBEAT_FAILURES) {
             this._isStatsbeatExporter = false;
-            (_a = this._statsbeatMetrics) === null || _a === void 0 ? void 0 : _a.shutdown();
-            this._statsbeatMetrics = undefined;
+            (_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;
         }
     }
@@ -2537,7 +2692,7 @@ class AzureMonitorBaseExporter {
 
 // Copyright (c) Microsoft Corporation.
 function createTagsFromResource(resource) {
-    const context = getInstance();
+    const context = getInstance$1();
     const tags = Object.assign({}, context.tags);
     if (resource && resource.attributes) {
         const serviceName = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
@@ -3283,10 +3438,9 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
 
 // Copyright (c) Microsoft Corporation.
 /**
- * @internal
  * Azure Monitor Statsbeat Exporter
  */
-class _AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
+class AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
     /**
      * Initializes a new instance of the AzureMonitorStatsbeatExporter class.
      * @param options - Exporter configuration
@@ -3331,6 +3485,6 @@ class _AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
 exports.ApplicationInsightsSampler = ApplicationInsightsSampler;
 exports.AzureMonitorBaseExporter = AzureMonitorBaseExporter;
 exports.AzureMonitorMetricExporter = AzureMonitorMetricExporter;
+exports.AzureMonitorStatsbeatExporter = AzureMonitorStatsbeatExporter;
 exports.AzureMonitorTraceExporter = AzureMonitorTraceExporter;
-exports._AzureMonitorStatsbeatExporter = _AzureMonitorStatsbeatExporter;
 //# sourceMappingURL=index.js.map