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

package/dist/index.js

@@ -4,15 +4,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
-var os = require('os');
 var url = require('url');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var coreClient = require('@azure/core-client');
 var fs = require('fs');
+var os = require('os');
 var path = require('path');
 var child_process = require('child_process');
 var util = require('util');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var sdkMetricsBase = require('@opentelemetry/sdk-metrics-base');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -34,11 +35,11 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
 var coreClient__namespace = /*#__PURE__*/_interopNamespace(coreClient);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
 
@@ -1745,7 +1746,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.7";
+const packageVersion = "1.0.0-beta.8";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -1828,6 +1829,200 @@ function msToTimeSpan(ms) {
     return `${daysText + hour}:${min}:${sec}`;
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * Azure Monitor OpenTelemetry Trace Exporter.
+ */
+class AzureMonitorBaseExporter {
+    /**
+     * Initializes a new instance of the AzureMonitorBaseExporter class.
+     * @param AzureExporterConfig - Exporter configuration.
+     */
+    constructor(options = {}) {
+        var _a, _b, _c, _d;
+        this._numConsecutiveRedirects = 0;
+        const connectionString = options.connectionString || process.env[ENV_CONNECTION_STRING];
+        this._options = Object.assign({}, DEFAULT_EXPORTER_CONFIG);
+        this._options.apiVersion = (_a = options.apiVersion) !== null && _a !== void 0 ? _a : this._options.apiVersion;
+        this._options.aadTokenCredential = options.aadTokenCredential;
+        if (connectionString) {
+            const parsedConnectionString = ConnectionStringParser.parse(connectionString);
+            this._options.instrumentationKey =
+                (_b = parsedConnectionString.instrumentationkey) !== null && _b !== void 0 ? _b : this._options.instrumentationKey;
+            this._options.endpointUrl =
+                (_d = (_c = parsedConnectionString.ingestionendpoint) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : this._options.endpointUrl;
+        }
+        // Instrumentation key is required
+        if (!this._options.instrumentationKey) {
+            const message = "No instrumentation key or connection string was provided to the Azure Monitor Exporter";
+            api.diag.error(message);
+            throw new Error(message);
+        }
+        this._instrumentationKey = this._options.instrumentationKey;
+        this._sender = new HttpSender(this._options);
+        this._persister = new FileSystemPersist(this._options);
+        this._retryTimer = null;
+        api.diag.debug("AzureMonitorTraceExporter was successfully setup");
+    }
+    /**
+     * Persist envelopes to disk
+     */
+    async _persist(envelopes) {
+        try {
+            const success = await this._persister.push(envelopes);
+            return success
+                ? { code: core.ExportResultCode.SUCCESS }
+                : {
+                    code: core.ExportResultCode.FAILED,
+                    error: new Error("Failed to persist envelope in disk."),
+                };
+        }
+        catch (ex) {
+            return { code: core.ExportResultCode.FAILED, error: ex };
+        }
+    }
+    /**
+     * Shutdown exporter
+     */
+    async _shutdown() {
+        return this._sender.shutdown();
+    }
+    /**
+     * Export envelopes
+     */
+    async _exportEnvelopes(envelopes) {
+        api.diag.info(`Exporting ${envelopes.length} envelope(s)`);
+        try {
+            const { result, statusCode } = await this._sender.send(envelopes);
+            this._numConsecutiveRedirects = 0;
+            if (statusCode === 200) {
+                // Success -- @todo: start retry timer
+                if (!this._retryTimer) {
+                    this._retryTimer = setTimeout(() => {
+                        this._retryTimer = null;
+                        this._sendFirstPersistedFile();
+                    }, this._options.batchSendRetryIntervalMs);
+                    this._retryTimer.unref();
+                }
+                return { code: core.ExportResultCode.SUCCESS };
+            }
+            else if (statusCode && isRetriable(statusCode)) {
+                // Failed -- persist failed data
+                if (result) {
+                    api.diag.info(result);
+                    const breezeResponse = JSON.parse(result);
+                    const filteredEnvelopes = [];
+                    if (breezeResponse.errors) {
+                        breezeResponse.errors.forEach((error) => {
+                            if (error.statusCode && isRetriable(error.statusCode)) {
+                                filteredEnvelopes.push(envelopes[error.index]);
+                            }
+                        });
+                    }
+                    if (filteredEnvelopes.length > 0) {
+                        // calls resultCallback(ExportResult) based on result of persister.push
+                        return await this._persist(filteredEnvelopes);
+                    }
+                    // Failed -- not retriable
+                    return {
+                        code: core.ExportResultCode.FAILED,
+                    };
+                }
+                else {
+                    // calls resultCallback(ExportResult) based on result of persister.push
+                    return await this._persist(envelopes);
+                }
+            }
+            else {
+                // Failed -- not retriable
+                return {
+                    code: core.ExportResultCode.FAILED,
+                };
+            }
+        }
+        catch (error) {
+            const restError = error;
+            if (restError.statusCode &&
+                (restError.statusCode === 307 || // Temporary redirect
+                    restError.statusCode === 308)) {
+                // Permanent redirect
+                this._numConsecutiveRedirects++;
+                // To prevent circular redirects
+                if (this._numConsecutiveRedirects < 10) {
+                    if (restError.response && restError.response.headers) {
+                        const location = restError.response.headers.get("location");
+                        if (location) {
+                            // Update sender URL
+                            this._sender.handlePermanentRedirect(location);
+                            // Send to redirect endpoint as HTTPs library doesn't handle redirect automatically
+                            return this._exportEnvelopes(envelopes);
+                        }
+                    }
+                }
+                else {
+                    return { code: core.ExportResultCode.FAILED, error: new Error("Circular redirect") };
+                }
+            }
+            else if (restError.statusCode && isRetriable(restError.statusCode)) {
+                return await this._persist(envelopes);
+            }
+            if (this._isNetworkError(restError)) {
+                api.diag.error("Retrying due to transient client side error. Error message:", restError.message);
+                return await this._persist(envelopes);
+            }
+            api.diag.error("Envelopes could not be exported and are not retriable. Error message:", restError.message);
+            return { code: core.ExportResultCode.FAILED, error: restError };
+        }
+    }
+    async _sendFirstPersistedFile() {
+        try {
+            const envelopes = (await this._persister.shift());
+            if (envelopes) {
+                await this._sender.send(envelopes);
+            }
+        }
+        catch (err) {
+            api.diag.warn(`Failed to fetch persisted file`, err);
+        }
+    }
+    _isNetworkError(error) {
+        if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
+            return true;
+        }
+        return false;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+function createTagsFromResource(resource) {
+    const context = getInstance();
+    const tags = Object.assign({}, context.tags);
+    if (resource && resource.attributes) {
+        const serviceName = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
+        const serviceNamespace = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
+        if (serviceName) {
+            if (serviceNamespace) {
+                tags[KnownContextTagKeys.AiCloudRole] = `${serviceNamespace}.${serviceName}`;
+            }
+            else {
+                tags[KnownContextTagKeys.AiCloudRole] = String(serviceName);
+            }
+        }
+        const serviceInstanceId = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
+        if (serviceInstanceId) {
+            tags[KnownContextTagKeys.AiCloudRoleInstance] = String(serviceInstanceId);
+        }
+        else {
+            tags[KnownContextTagKeys.AiCloudRoleInstance] = os__default["default"] && os__default["default"].hostname();
+        }
+        const endUserId = resource.attributes[semanticConventions.SemanticAttributes.ENDUSER_ID];
+        if (endUserId) {
+            tags[KnownContextTagKeys.AiUserId] = String(endUserId);
+        }
+    }
+    return tags;
+}
+
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 /**
@@ -1893,36 +2088,21 @@ const parseEventHubSpan = (span, baseData) => {
 };
 
 // Copyright (c) Microsoft Corporation.
-function createTagsFromSpan(span) {
-    const context = getInstance();
-    const tags = Object.assign({}, context.tags);
+function createGenericTagsFromSpan(span) {
+    const tags = createTagsFromResource(span.resource);
     tags[KnownContextTagKeys.AiOperationId] = span.spanContext().traceId;
     if (span.parentSpanId) {
         tags[KnownContextTagKeys.AiOperationParentId] = span.parentSpanId;
     }
-    if (span.resource && span.resource.attributes) {
-        const serviceName = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
-        const serviceNamespace = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
-        if (serviceName) {
-            if (serviceNamespace) {
-                tags[KnownContextTagKeys.AiCloudRole] = `${serviceNamespace}.${serviceName}`;
-            }
-            else {
-                tags[KnownContextTagKeys.AiCloudRole] = String(serviceName);
-            }
-        }
-        const serviceInstanceId = span.resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
-        if (serviceInstanceId) {
-            tags[KnownContextTagKeys.AiCloudRoleInstance] = String(serviceInstanceId);
-        }
-        else {
-            tags[KnownContextTagKeys.AiCloudRoleInstance] = os__default["default"] && os__default["default"].hostname();
-        }
-        const endUserId = span.resource.attributes[semanticConventions.SemanticAttributes.ENDUSER_ID];
-        if (endUserId) {
-            tags[KnownContextTagKeys.AiUserId] = String(endUserId);
-        }
+    const httpUserAgent = span.attributes[semanticConventions.SemanticAttributes.HTTP_USER_AGENT];
+    if (httpUserAgent) {
+        // TODO: Not exposed in Swagger, need to update def
+        tags["ai.user.userAgent"] = String(httpUserAgent);
     }
+    return tags;
+}
+function createTagsFromSpan(span) {
+    const tags = createGenericTagsFromSpan(span);
     if (span.kind === api.SpanKind.SERVER) {
         const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
         const httpClientIp = span.attributes[semanticConventions.SemanticAttributes.HTTP_CLIENT_IP];
@@ -1956,25 +2136,33 @@ function createTagsFromSpan(span) {
         }
     }
     // TODO: Operation Name and Location IP TBD for non server spans
-    const httpUserAgent = span.attributes[semanticConventions.SemanticAttributes.HTTP_USER_AGENT];
-    if (httpUserAgent) {
-        // TODO: Not exposed in Swagger, need to update def
-        tags["ai.user.userAgent"] = String(httpUserAgent);
-    }
     return tags;
 }
-function createPropertiesFromSpan(span) {
+function createPropertiesFromSpanAttributes(attributes) {
     const properties = {};
-    const measurements = {};
-    for (const key of Object.keys(span.attributes)) {
-        if (!(key.startsWith("http.") ||
-            key.startsWith("rpc.") ||
-            key.startsWith("db.") ||
-            key.startsWith("peer.") ||
-            key.startsWith("net."))) {
-            properties[key] = span.attributes[key];
+    if (attributes) {
+        for (const key of Object.keys(attributes)) {
+            if (!(key.startsWith("http.") ||
+                key.startsWith("rpc.") ||
+                key.startsWith("db.") ||
+                key.startsWith("peer.") ||
+                key.startsWith("message.") ||
+                key.startsWith("messaging.") ||
+                key.startsWith("enduser.") ||
+                key.startsWith("net.") ||
+                key.startsWith("exception.") ||
+                key.startsWith("thread.") ||
+                key.startsWith("faas.") ||
+                key.startsWith("code."))) {
+                properties[key] = attributes[key];
+            }
         }
     }
+    return properties;
+}
+function createPropertiesFromSpan(span) {
+    const properties = createPropertiesFromSpanAttributes(span.attributes);
+    const measurements = {};
     const links = span.links.map((link) => ({
         operation_Id: link.context.traceId,
         id: link.context.spanId,
@@ -2103,7 +2291,7 @@ function createDependencyData(span) {
                     }
                 }
             }
-            catch (error) { }
+            catch (ex) { }
             remoteDependencyData.target = `${target}`;
         }
     }
@@ -2241,172 +2429,219 @@ function readableSpanToEnvelope(span, ikey) {
         },
     };
 }
+/**
+ * Span Events to Azure envelopes parsing.
+ * @internal
+ */
+function spanEventsToEnvelopes(span, ikey) {
+    let envelopes = [];
+    if (span.events) {
+        span.events.forEach((event) => {
+            let baseType;
+            const sampleRate = 100;
+            let time = new Date(core.hrTimeToMilliseconds(event.time));
+            let name = "";
+            let baseData;
+            const properties = createPropertiesFromSpanAttributes(event.attributes);
+            const tags = createGenericTagsFromSpan(span);
+            if (event.name == "exception") {
+                name = "Microsoft.ApplicationInsights.Exception";
+                baseType = "ExceptionData";
+                let typeName = "";
+                let message = "Exception";
+                let stack = "";
+                let hasFullStack = false;
+                if (event.attributes) {
+                    typeName = String(event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE]);
+                    stack = String(event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE]);
+                    if (stack) {
+                        hasFullStack = true;
+                    }
+                    let exceptionMsg = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
+                    if (exceptionMsg) {
+                        message = String(exceptionMsg);
+                    }
+                    let escaped = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED];
+                    if (escaped != undefined) {
+                        properties[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED] = String(escaped);
+                    }
+                }
+                let exceptionDetails = {
+                    typeName: typeName,
+                    message: message,
+                    stack: stack,
+                    hasFullStack: hasFullStack,
+                };
+                let exceptionData = {
+                    exceptions: [exceptionDetails],
+                    version: 2,
+                    properties: properties,
+                };
+                baseData = exceptionData;
+            }
+            else {
+                name = "Microsoft.ApplicationInsights.Message";
+                baseType = "MessageData";
+                let messageData = {
+                    message: event.name,
+                    version: 2,
+                    properties: properties,
+                };
+                baseData = messageData;
+            }
+            let env = {
+                name: name,
+                time: time,
+                instrumentationKey: ikey,
+                version: 1,
+                sampleRate: sampleRate,
+                data: {
+                    baseType: baseType,
+                    baseData: baseData,
+                },
+                tags: tags,
+            };
+            envelopes.push(env);
+        });
+    }
+    return envelopes;
+}
 
 // Copyright (c) Microsoft Corporation.
 /**
  * Azure Monitor OpenTelemetry Trace Exporter.
  */
-class AzureMonitorTraceExporter {
+class AzureMonitorTraceExporter extends AzureMonitorBaseExporter {
     /**
      * Initializes a new instance of the AzureMonitorTraceExporter class.
      * @param AzureExporterConfig - Exporter configuration.
      */
     constructor(options = {}) {
-        var _a, _b, _c, _d;
-        this._numConsecutiveRedirects = 0;
-        const connectionString = options.connectionString || process.env[ENV_CONNECTION_STRING];
-        this._options = Object.assign({}, DEFAULT_EXPORTER_CONFIG);
-        this._options.apiVersion = (_a = options.apiVersion) !== null && _a !== void 0 ? _a : this._options.apiVersion;
-        this._options.aadTokenCredential = options.aadTokenCredential;
-        if (connectionString) {
-            const parsedConnectionString = ConnectionStringParser.parse(connectionString);
-            this._options.instrumentationKey =
-                (_b = parsedConnectionString.instrumentationkey) !== null && _b !== void 0 ? _b : this._options.instrumentationKey;
-            this._options.endpointUrl =
-                (_d = (_c = parsedConnectionString.ingestionendpoint) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : this._options.endpointUrl;
-        }
-        // Instrumentation key is required
-        if (!this._options.instrumentationKey) {
-            const message = "No instrumentation key or connection string was provided to the Azure Monitor Exporter";
-            api.diag.error(message);
-            throw new Error(message);
-        }
-        this._sender = new HttpSender(this._options);
-        this._persister = new FileSystemPersist(this._options);
-        this._retryTimer = null;
+        super(options);
         api.diag.debug("AzureMonitorTraceExporter was successfully setup");
     }
-    async _persist(envelopes) {
-        try {
-            const success = await this._persister.push(envelopes);
-            return success
-                ? { code: core.ExportResultCode.SUCCESS }
-                : {
-                    code: core.ExportResultCode.FAILED,
-                    error: new Error("Failed to persist envelope in disk."),
-                };
-        }
-        catch (ex) {
-            return { code: core.ExportResultCode.FAILED, error: ex };
-        }
-    }
-    async exportEnvelopes(envelopes) {
-        api.diag.info(`Exporting ${envelopes.length} envelope(s)`);
-        try {
-            const { result, statusCode } = await this._sender.send(envelopes);
-            this._numConsecutiveRedirects = 0;
-            if (statusCode === 200) {
-                // Success -- @todo: start retry timer
-                if (!this._retryTimer) {
-                    this._retryTimer = setTimeout(() => {
-                        this._retryTimer = null;
-                        this._sendFirstPersistedFile();
-                    }, this._options.batchSendRetryIntervalMs);
-                    this._retryTimer.unref();
-                }
-                return { code: core.ExportResultCode.SUCCESS };
-            }
-            else if (statusCode && isRetriable(statusCode)) {
-                // Failed -- persist failed data
-                if (result) {
-                    api.diag.info(result);
-                    const breezeResponse = JSON.parse(result);
-                    const filteredEnvelopes = [];
-                    breezeResponse.errors.forEach((error) => {
-                        if (error.statusCode && isRetriable(error.statusCode)) {
-                            filteredEnvelopes.push(envelopes[error.index]);
-                        }
-                    });
-                    if (filteredEnvelopes.length > 0) {
-                        // calls resultCallback(ExportResult) based on result of persister.push
-                        return await this._persist(filteredEnvelopes);
-                    }
-                    // Failed -- not retriable
-                    return {
-                        code: core.ExportResultCode.FAILED,
-                    };
-                }
-                else {
-                    // calls resultCallback(ExportResult) based on result of persister.push
-                    return await this._persist(envelopes);
-                }
+    /**
+     * Export OpenTelemetry spans.
+     * @param spans - Spans to export.
+     * @param resultCallback - Result callback.
+     */
+    async export(spans, resultCallback) {
+        api.diag.info(`Exporting ${spans.length} span(s). Converting to envelopes...`);
+        let envelopes = [];
+        spans.forEach((span) => {
+            envelopes.push(readableSpanToEnvelope(span, this._instrumentationKey));
+            let spanEventEnvelopes = spanEventsToEnvelopes(span, this._instrumentationKey);
+            if (spanEventEnvelopes.length > 0) {
+                envelopes.push(...spanEventEnvelopes);
             }
-            else {
-                // Failed -- not retriable
-                return {
-                    code: core.ExportResultCode.FAILED,
+        });
+        resultCallback(await this._exportEnvelopes(envelopes));
+    }
+    /**
+     * Shutdown AzureMonitorTraceExporter.
+     */
+    async shutdown() {
+        api.diag.info("Azure Monitor Trace Exporter shutting down");
+        return this._shutdown();
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Metric to Azure envelope parsing.
+ * @internal
+ */
+function resourceMetricsToEnvelope(metrics, ikey) {
+    let envelopes = [];
+    const time = new Date();
+    const instrumentationKey = ikey;
+    const tags = createTagsFromResource(metrics.resource);
+    metrics.scopeMetrics.forEach((scopeMetric) => {
+        let baseData = {
+            metrics: [],
+            version: 2,
+        };
+        scopeMetric.metrics.forEach((metric) => {
+            metric.dataPoints.forEach((dataPoint) => {
+                var metricDataPoint = {
+                    name: metric.descriptor.name,
+                    value: 0,
+                    dataPointType: "Aggregation",
                 };
-            }
-        }
-        catch (error) {
-            const restError = error;
-            if (restError.statusCode &&
-                (restError.statusCode === 307 || // Temporary redirect
-                    restError.statusCode === 308)) {
-                // Permanent redirect
-                this._numConsecutiveRedirects++;
-                // To prevent circular redirects
-                if (this._numConsecutiveRedirects < 10) {
-                    if (restError.response && restError.response.headers) {
-                        const location = restError.response.headers.get("location");
-                        if (location) {
-                            // Update sender URL
-                            this._sender.handlePermanentRedirect(location);
-                            // Send to redirect endpoint as HTTPs library doesn't handle redirect automatically
-                            return this.exportEnvelopes(envelopes);
-                        }
-                    }
+                if (metric.dataPointType == sdkMetricsBase.DataPointType.SINGULAR) {
+                    metricDataPoint.value = dataPoint.value;
+                    metricDataPoint.count = 1;
                 }
                 else {
-                    return { code: core.ExportResultCode.FAILED, error: new Error("Circular redirect") };
+                    metricDataPoint.value = dataPoint.value.sum;
+                    metricDataPoint.count = dataPoint.value.count;
                 }
-            }
-            else if (restError.statusCode && isRetriable(restError.statusCode)) {
-                return await this._persist(envelopes);
-            }
-            if (this._isNetworkError(restError)) {
-                api.diag.error("Retrying due to transient client side error. Error message:", restError.message);
-                return await this._persist(envelopes);
-            }
-            api.diag.error("Envelopes could not be exported and are not retriable. Error message:", restError.message);
-            return { code: core.ExportResultCode.FAILED, error: restError };
-        }
+                baseData.metrics.push(metricDataPoint);
+            });
+        });
+        let envelope = {
+            name: "Microsoft.ApplicationInsights.Metric",
+            time: time,
+            sampleRate: 100,
+            instrumentationKey: instrumentationKey,
+            tags: tags,
+            version: 1,
+            data: {
+                baseType: "MetricData",
+                baseData: Object.assign({}, baseData),
+            },
+        };
+        envelopes.push(envelope);
+    });
+    return envelopes;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Azure Monitor OpenTelemetry Metric Exporter.
+ */
+class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
+    /**
+     * Initializes a new instance of the AzureMonitorMetricExporter class.
+     * @param AzureExporterConfig - Exporter configuration.
+     */
+    constructor(options = {}) {
+        super(options);
+        api.diag.debug("AzureMonitorMetricExporter was successfully setup");
     }
     /**
-     * Export OpenTelemetry spans.
-     * @param spans - Spans to export.
+     * Export OpenTelemetry resource metrics.
+     * @param metrics - Resource metrics to export.
      * @param resultCallback - Result callback.
      */
-    async export(spans, resultCallback) {
-        api.diag.info(`Exporting ${spans.length} span(s). Converting to envelopes...`);
-        const envelopes = spans.map((span) => readableSpanToEnvelope(span, this._options.instrumentationKey));
-        resultCallback(await this.exportEnvelopes(envelopes));
+    async export(metrics, resultCallback) {
+        api.diag.info(`Exporting ${metrics.scopeMetrics.length} metrics(s). Converting to envelopes...`);
+        let envelopes = resourceMetricsToEnvelope(metrics, this._instrumentationKey);
+        resultCallback(await this._exportEnvelopes(envelopes));
     }
     /**
-     * Shutdown AzureMonitorTraceExporter.
+     * Shutdown AzureMonitorMetricExporter.
      */
     async shutdown() {
         api.diag.info("Azure Monitor Trace Exporter shutting down");
-        return this._sender.shutdown();
+        return this._shutdown();
     }
-    async _sendFirstPersistedFile() {
-        try {
-            const envelopes = (await this._persister.shift());
-            if (envelopes) {
-                await this._sender.send(envelopes);
-            }
-        }
-        catch (err) {
-            api.diag.warn(`Failed to fetch persisted file`, err);
-        }
+    /**
+     * Select aggregation temporality
+     */
+    selectAggregationTemporality() {
+        return sdkMetricsBase.AggregationTemporality.CUMULATIVE;
     }
-    _isNetworkError(error) {
-        if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
-            return true;
-        }
-        return false;
+    /**
+     * Force flush
+     */
+    async forceFlush() {
+        // TODO: https://github.com/open-telemetry/opentelemetry-js/issues/3060
+        throw new Error("Method not implemented.");
     }
 }
 
+exports.AzureMonitorBaseExporter = AzureMonitorBaseExporter;
+exports.AzureMonitorMetricExporter = AzureMonitorMetricExporter;
 exports.AzureMonitorTraceExporter = AzureMonitorTraceExporter;
 //# sourceMappingURL=index.js.map