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

package/dist/index.js

@@ -2,22 +2,53 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
+var url = require('url');
+var coreRestPipeline = require('@azure/core-rest-pipeline');
+var coreClient = require('@azure/core-client');
 var fs = require('fs');
 var os = require('os');
-var os__default = _interopDefault(os);
 var path = require('path');
+var child_process = require('child_process');
 var util = require('util');
-var url = require('url');
-var url__default = _interopDefault(url);
-var coreRestPipeline = require('@azure/core-rest-pipeline');
-var coreClient = require('@azure/core-client');
 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 }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var 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);
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * Azure service API version.
+ */
+exports.ServiceApiVersion = void 0;
 (function (ServiceApiVersion) {
     /**
      * V2 Version
@@ -85,7 +116,7 @@ var PerformanceCounter;
  * Map a PerformanceCounter/QuickPulseCounter to a QuickPulseCounter. If no mapping exists, mapping is *undefined*
  * @internal
  */
-const PerformanceToQuickPulseCounter = {
+({
     [PerformanceCounter.PROCESSOR_TIME]: QuickPulseCounter.PROCESSOR_TIME,
     [PerformanceCounter.REQUEST_RATE]: QuickPulseCounter.REQUEST_RATE,
     [PerformanceCounter.REQUEST_DURATION]: QuickPulseCounter.REQUEST_DURATION,
@@ -95,8 +126,8 @@ const PerformanceToQuickPulseCounter = {
     [QuickPulseCounter.DEPENDENCY_RATE]: QuickPulseCounter.DEPENDENCY_RATE,
     [QuickPulseCounter.DEPENDENCY_FAILURE_RATE]: QuickPulseCounter.DEPENDENCY_FAILURE_RATE,
     [QuickPulseCounter.DEPENDENCY_DURATION]: QuickPulseCounter.DEPENDENCY_DURATION,
-    [QuickPulseCounter.EXCEPTION_RATE]: QuickPulseCounter.EXCEPTION_RATE
-};
+    [QuickPulseCounter.EXCEPTION_RATE]: QuickPulseCounter.EXCEPTION_RATE,
+});
 
 // Copyright (c) Microsoft Corporation.
 /**
@@ -163,7 +194,6 @@ class ConnectionStringParser {
 ConnectionStringParser.FIELDS_SEPARATOR = ";";
 ConnectionStringParser.FIELD_KEY_VALUE_SEPARATOR = "=";
 
-// Copyright (c) Microsoft Corporation.
 const DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS = 60000;
 const DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING = 10;
 /**
@@ -175,25 +205,191 @@ const DEFAULT_EXPORTER_CONFIG = {
     endpointUrl: DEFAULT_BREEZE_ENDPOINT,
     batchSendRetryIntervalMs: DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS,
     maxConsecutiveFailuresBeforeWarning: DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING,
-    apiVersion: DEFAULT_BREEZE_API_VERSION
+    apiVersion: DEFAULT_BREEZE_API_VERSION,
 };
 
 // Copyright (c) Microsoft Corporation.
-const readdirAsync = util.promisify(fs.readdir);
-const statAsync = util.promisify(fs.stat);
-const lstatAsync = util.promisify(fs.lstat);
-const mkdirAsync = util.promisify(fs.mkdir);
+class FileAccessControl {
+    // Check if file access control could be enabled
+    static checkFileProtection() {
+        if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION &&
+            !FileAccessControl.OS_FILE_PROTECTION_CHECKED) {
+            FileAccessControl.OS_FILE_PROTECTION_CHECKED = true;
+            // Node's chmod levels do not appropriately restrict file access on Windows
+            // Use the built-in command line tool ICACLS on Windows to properly restrict
+            // access to the temporary directory used for disk retry mode.
+            if (FileAccessControl.USE_ICACLS) {
+                // This should be async - but it's currently safer to have this synchronous
+                // This guarantees we can immediately fail setDiskRetryMode if we need to
+                try {
+                    FileAccessControl.OS_PROVIDES_FILE_PROTECTION = fs__namespace.existsSync(FileAccessControl.ICACLS_PATH);
+                }
+                catch (e) {
+                    // Ignore error
+                }
+                if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION) {
+                    api.diag.warn("Could not find ICACLS in expected location! This is necessary to use disk retry mode on Windows.");
+                }
+            }
+            else {
+                // chmod works everywhere else
+                FileAccessControl.OS_PROVIDES_FILE_PROTECTION = true;
+            }
+        }
+    }
+    static async applyACLRules(directory) {
+        if (FileAccessControl.USE_ICACLS) {
+            if (FileAccessControl.ACLED_DIRECTORIES[directory] === undefined) {
+                // Avoid multiple calls race condition by setting ACLED_DIRECTORIES to false for this directory immediately
+                // If batches are being failed faster than the processes spawned below return, some data won't be stored to disk
+                // This is better than the alternative of potentially infinitely spawned processes
+                FileAccessControl.ACLED_DIRECTORIES[directory] = false;
+                try {
+                    // Restrict this directory to only current user and administrator access
+                    let identity = await this._getACLIdentity();
+                    await this._runICACLS(this._getACLArguments(directory, identity));
+                    FileAccessControl.ACLED_DIRECTORIES[directory] = true;
+                }
+                catch (ex) {
+                    FileAccessControl.ACLED_DIRECTORIES[directory] = false; // false is used to cache failed (vs undefined which is "not yet tried")
+                    throw ex;
+                }
+            }
+            else {
+                if (!FileAccessControl.ACLED_DIRECTORIES[directory]) {
+                    throw new Error("Setting ACL restrictions did not succeed (cached result)");
+                }
+            }
+        }
+    }
+    static applyACLRulesSync(directory) {
+        if (FileAccessControl.USE_ICACLS) {
+            // For performance, only run ACL rules if we haven't already during this session
+            if (FileAccessControl.ACLED_DIRECTORIES[directory] === undefined) {
+                this._runICACLSSync(this._getACLArguments(directory, this._getACLIdentitySync()));
+                FileAccessControl.ACLED_DIRECTORIES[directory] = true; // If we get here, it succeeded. _runIACLSSync will throw on failures
+                return;
+            }
+            else if (!FileAccessControl.ACLED_DIRECTORIES[directory]) {
+                // falsy but not undefined
+                throw new Error("Setting ACL restrictions did not succeed (cached result)");
+            }
+        }
+    }
+    static _runICACLS(args) {
+        return new Promise((resolve, reject) => {
+            var aclProc = child_process__namespace.spawn(FileAccessControl.ICACLS_PATH, args, {
+                windowsHide: true,
+            });
+            aclProc.on("error", (e) => reject(e));
+            aclProc.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Setting ACL restrictions did not succeed (ICACLS returned code ${code})`));
+                }
+            });
+        });
+    }
+    static _runICACLSSync(args) {
+        // Some very old versions of Node (< 0.11) don't have this
+        if (child_process__namespace.spawnSync) {
+            var aclProc = child_process__namespace.spawnSync(FileAccessControl.ICACLS_PATH, args, {
+                windowsHide: true,
+            });
+            if (aclProc.error) {
+                throw aclProc.error;
+            }
+            else if (aclProc.status !== 0) {
+                throw new Error(`Setting ACL restrictions did not succeed (ICACLS returned code ${aclProc.status})`);
+            }
+        }
+        else {
+            throw new Error("Could not synchronously call ICACLS under current version of Node.js");
+        }
+    }
+    static _getACLIdentity() {
+        return new Promise((resolve, reject) => {
+            if (FileAccessControl.ACL_IDENTITY) {
+                resolve(FileAccessControl.ACL_IDENTITY);
+            }
+            var psProc = child_process__namespace.spawn(FileAccessControl.POWERSHELL_PATH, ["-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"], {
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"], // Needed to prevent hanging on Win 7
+            });
+            let data = "";
+            psProc.stdout.on("data", (d) => (data += d));
+            psProc.on("error", (e) => reject(e));
+            psProc.on("close", (code) => {
+                FileAccessControl.ACL_IDENTITY = data && data.trim();
+                if (code === 0) {
+                    resolve(FileAccessControl.ACL_IDENTITY);
+                }
+                else {
+                    reject(new Error(`Getting ACL identity did not succeed (PS returned code ${code})`));
+                }
+            });
+        });
+    }
+    static _getACLIdentitySync() {
+        if (FileAccessControl.ACL_IDENTITY) {
+            return FileAccessControl.ACL_IDENTITY;
+        }
+        // Some very old versions of Node (< 0.11) don't have this
+        if (child_process__namespace.spawnSync) {
+            var psProc = child_process__namespace.spawnSync(FileAccessControl.POWERSHELL_PATH, ["-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"], {
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"], // Needed to prevent hanging on Win 7
+            });
+            if (psProc.error) {
+                throw psProc.error;
+            }
+            else if (psProc.status !== 0) {
+                throw new Error(`Getting ACL identity did not succeed (PS returned code ${psProc.status})`);
+            }
+            FileAccessControl.ACL_IDENTITY = psProc.stdout && psProc.stdout.toString().trim();
+            return FileAccessControl.ACL_IDENTITY;
+        }
+        else {
+            throw new Error("Could not synchronously get ACL identity under current version of Node.js");
+        }
+    }
+    static _getACLArguments(directory, identity) {
+        return [
+            directory,
+            "/grant",
+            "*S-1-5-32-544:(OI)(CI)F",
+            "/grant",
+            `${identity}:(OI)(CI)F`,
+            "/inheritance:r",
+        ]; // Remove all inherited permissions
+    }
+}
+FileAccessControl.ICACLS_PATH = `${process.env.systemdrive}/windows/system32/icacls.exe`;
+FileAccessControl.POWERSHELL_PATH = `${process.env.systemdrive}/windows/system32/windowspowershell/v1.0/powershell.exe`;
+FileAccessControl.ACLED_DIRECTORIES = {};
+FileAccessControl.ACL_IDENTITY = null;
+FileAccessControl.OS_FILE_PROTECTION_CHECKED = false;
+FileAccessControl.OS_PROVIDES_FILE_PROTECTION = false;
+FileAccessControl.USE_ICACLS = os__namespace.type() === "Windows_NT";
+
+// Copyright (c) Microsoft Corporation.
+const readdirAsync$1 = util.promisify(fs__namespace.readdir);
+const statAsync$1 = util.promisify(fs__namespace.stat);
+const lstatAsync = util.promisify(fs__namespace.lstat);
+const mkdirAsync = util.promisify(fs__namespace.mkdir);
 /**
  * Computes the size (in bytes) of all files in a directory at the root level. Asynchronously.
  * @internal
  */
 const getShallowDirectorySize = async (directory) => {
     // Get the directory listing
-    const files = await readdirAsync(directory);
+    const files = await readdirAsync$1(directory);
     let totalSize = 0;
     // Query all file sizes
     for (const file of files) {
-        const fileStats = await statAsync(path.join(directory, file));
+        const fileStats = await statAsync$1(path__namespace.join(directory, file));
         if (fileStats.isFile()) {
             totalSize += fileStats.size;
         }
@@ -227,11 +423,11 @@ const confirmDirExists = async (directory) => {
 };
 
 // Copyright (c) Microsoft Corporation.
-const statAsync$1 = util.promisify(fs.stat);
-const readdirAsync$1 = util.promisify(fs.readdir);
-const readFileAsync = util.promisify(fs.readFile);
-const unlinkAsync = util.promisify(fs.unlink);
-const writeFileAsync = util.promisify(fs.writeFile);
+const statAsync = util.promisify(fs__namespace.stat);
+const readdirAsync = util.promisify(fs__namespace.readdir);
+const readFileAsync = util.promisify(fs__namespace.readFile);
+const unlinkAsync = util.promisify(fs__namespace.unlink);
+const writeFileAsync = util.promisify(fs__namespace.writeFile);
 /**
  * File system persist class.
  * @internal
@@ -241,36 +437,56 @@ class FileSystemPersist {
         this.fileRetemptionPeriod = 7 * 24 * 60 * 60 * 1000; // 7 days
         this.cleanupTimeOut = 60 * 60 * 1000; // 1 hour
         this.maxBytesOnDisk = 50000000; // ~50MB
+        this._tempDirectory = "";
         this._fileCleanupTimer = null;
         this._options = Object.assign(Object.assign({}, DEFAULT_EXPORTER_CONFIG), options);
-        if (!this._options.instrumentationKey) {
-            api.diag.error(`No instrumentation key was provided to FileSystemPersister. Files may not be properly persisted`);
+        this._enabled = true;
+        FileAccessControl.checkFileProtection();
+        if (!FileAccessControl.OS_PROVIDES_FILE_PROTECTION) {
+            this._enabled = false;
+            api.diag.error("Sufficient file protection capabilities were not detected. Files will not be persisted");
         }
-        this._tempDirectory = path.join(os.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
-        // Starts file cleanup task
-        if (!this._fileCleanupTimer) {
-            this._fileCleanupTimer = setTimeout(() => {
-                this._fileCleanupTask();
-            }, this.cleanupTimeOut);
-            this._fileCleanupTimer.unref();
+        if (!this._options.instrumentationKey) {
+            this._enabled = false;
+            api.diag.error(`No instrumentation key was provided to FileSystemPersister. Files will not be persisted`);
+        }
+        if (this._enabled) {
+            this._tempDirectory = path__namespace.join(os__namespace.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
+            // Starts file cleanup task
+            if (!this._fileCleanupTimer) {
+                this._fileCleanupTimer = setTimeout(() => {
+                    this._fileCleanupTask();
+                }, this.cleanupTimeOut);
+                this._fileCleanupTimer.unref();
+            }
         }
     }
     push(value) {
-        api.diag.debug("Pushing value to persistent storage", value.toString());
-        return this._storeToDisk(JSON.stringify(value));
+        if (this._enabled) {
+            api.diag.debug("Pushing value to persistent storage", value.toString());
+            return this._storeToDisk(JSON.stringify(value));
+        }
+        return new Promise((resolve) => {
+            resolve(false);
+        });
     }
     async shift() {
-        api.diag.debug("Searching for filesystem persisted files");
-        try {
-            const buffer = await this._getFirstFileOnDisk();
-            if (buffer) {
-                return JSON.parse(buffer.toString("utf8"));
+        if (this._enabled) {
+            api.diag.debug("Searching for filesystem persisted files");
+            try {
+                const buffer = await this._getFirstFileOnDisk();
+                if (buffer) {
+                    return JSON.parse(buffer.toString("utf8"));
+                }
             }
+            catch (e) {
+                api.diag.debug("Failed to read persisted file", e);
+            }
+            return null;
         }
-        catch (e) {
-            api.diag.debug("Failed to read persisted file", e);
-        }
-        return null;
+        return new Promise((resolve) => {
+            resolve(null);
+        });
     }
     /**
      * Check for temp telemetry files
@@ -278,16 +494,16 @@ class FileSystemPersist {
      */
     async _getFirstFileOnDisk() {
         try {
-            const stats = await statAsync$1(this._tempDirectory);
+            const stats = await statAsync(this._tempDirectory);
             if (stats.isDirectory()) {
-                const origFiles = await readdirAsync$1(this._tempDirectory);
-                const files = origFiles.filter((f) => path.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
+                const origFiles = await readdirAsync(this._tempDirectory);
+                const files = origFiles.filter((f) => path__namespace.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
                 if (files.length === 0) {
                     return null;
                 }
                 else {
                     const firstFile = files[0];
-                    const filePath = path.join(this._tempDirectory, firstFile);
+                    const filePath = path__namespace.join(this._tempDirectory, firstFile);
                     const payload = await readFileAsync(filePath);
                     // delete the file first to prevent double sending
                     await unlinkAsync(filePath);
@@ -326,7 +542,7 @@ class FileSystemPersist {
             return false;
         }
         const fileName = `${new Date().getTime()}${FileSystemPersist.FILENAME_SUFFIX}`;
-        const fileFullPath = path.join(this._tempDirectory, fileName);
+        const fileFullPath = path__namespace.join(this._tempDirectory, fileName);
         // Mode 600 is w/r for creator and no read access for others
         api.diag.info(`saving data to disk at: ${fileFullPath}`);
         try {
@@ -340,10 +556,10 @@ class FileSystemPersist {
     }
     async _fileCleanupTask() {
         try {
-            const stats = await statAsync$1(this._tempDirectory);
+            const stats = await statAsync(this._tempDirectory);
             if (stats.isDirectory()) {
-                const origFiles = await readdirAsync$1(this._tempDirectory);
-                const files = origFiles.filter((f) => path.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
+                const origFiles = await readdirAsync(this._tempDirectory);
+                const files = origFiles.filter((f) => path__namespace.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
                 if (files.length === 0) {
                     return false;
                 }
@@ -353,7 +569,7 @@ class FileSystemPersist {
                         const fileCreationDate = new Date(parseInt(file.split(FileSystemPersist.FILENAME_SUFFIX)[0]));
                         const expired = new Date(+new Date() - this.fileRetemptionPeriod) > fileCreationDate;
                         if (expired) {
-                            const filePath = path.join(this._tempDirectory, file);
+                            const filePath = path__namespace.join(this._tempDirectory, file);
                             await unlinkAsync(filePath);
                         }
                     });
@@ -1356,7 +1572,7 @@ var Mappers = /*#__PURE__*/Object.freeze({
  * Code generated by Microsoft (R) AutoRest Code Generator.
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
-class ApplicationInsightsClientContext extends coreClient.ServiceClient {
+class ApplicationInsightsClientContext extends coreClient__namespace.ServiceClient {
     /**
      * Initializes a new instance of the ApplicationInsightsClientContext class.
      * @param options The parameter options
@@ -1369,13 +1585,13 @@ class ApplicationInsightsClientContext extends coreClient.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.4`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.7`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
         const optionsWithDefaults = Object.assign(Object.assign(Object.assign({}, defaults), options), { userAgentOptions: {
                 userAgentPrefix
-            }, baseUri: options.endpoint || "{Host}/v2" });
+            }, baseUri: options.endpoint || "{Host}/v2.1" });
         super(optionsWithDefaults);
         // Assigning values to Constant parameters
         this.host = options.host || "https://dc.services.visualstudio.com";
@@ -1407,7 +1623,7 @@ class ApplicationInsightsClient extends ApplicationInsightsClientContext {
     }
 }
 // Operation Specifications
-const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);
+const serializer = coreClient__namespace.createSerializer(Mappers, /* isXml */ false);
 const trackOperationSpec = {
     path: "/track",
     httpMethod: "POST",
@@ -1447,6 +1663,7 @@ const trackOperationSpec = {
 };
 
 // Copyright (c) Microsoft Corporation.
+const applicationInsightsResource = "https://monitor.azure.com//.default";
 /**
  * Exporter HTTP sender class
  * @internal
@@ -1456,10 +1673,18 @@ class HttpSender {
         this._exporterOptions = _exporterOptions;
         // Build endpoint using provided configuration or default values
         this._appInsightsClientOptions = {
-            host: this._exporterOptions.endpointUrl
+            host: this._exporterOptions.endpointUrl,
         };
         this._appInsightsClient = new ApplicationInsightsClient(Object.assign({}, this._appInsightsClientOptions));
+        // Handle redirects in HTTP Sender
         this._appInsightsClient.pipeline.removePolicy({ name: coreRestPipeline.redirectPolicyName });
+        if (this._exporterOptions.aadTokenCredential) {
+            let scopes = [applicationInsightsResource];
+            this._appInsightsClient.pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
+                credential: this._exporterOptions.aadTokenCredential,
+                scopes: scopes,
+            }));
+        }
     }
     /**
      * Send Azure envelopes
@@ -1492,7 +1717,7 @@ class HttpSender {
     }
     handlePermanentRedirect(location) {
         if (location) {
-            const locUrl = new url__default.URL(location);
+            const locUrl = new url__default["default"].URL(location);
             if (locUrl && locUrl.host) {
                 this._appInsightsClient.host = "https://" + locUrl.host;
             }
@@ -1521,7 +1746,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.5";
+const packageVersion = "1.0.0-beta.8";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -1544,7 +1769,7 @@ class Context {
         this._loadInternalContext();
     }
     _loadDeviceContext() {
-        this.tags[KnownContextTagKeys.AiDeviceOsVersion] = os && `${os.type()} ${os.release()}`;
+        this.tags[KnownContextTagKeys.AiDeviceOsVersion] = os__namespace && `${os__namespace.type()} ${os__namespace.release()}`;
     }
     _loadInternalContext() {
         const { node } = process.versions;
@@ -1575,12 +1800,13 @@ function getInstance() {
  * @internal
  */
 function isRetriable(statusCode) {
-    return (statusCode === 206 || // Retriable
+    return (statusCode === 206 || // Partial Accept
+        statusCode === 401 || // Unauthorized
+        statusCode === 403 || // Forbidden
         statusCode === 408 || // Timeout
-        statusCode === 429 || // Throttle
-        statusCode === 439 || // Quota
+        statusCode === 429 || // Too many requests
         statusCode === 500 || // Server Error
-        statusCode === 503 // Server Unavilable
+        statusCode === 503 // Server Unavailable
     );
 }
 /**
@@ -1603,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.
 /**
@@ -1668,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 && os__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];
@@ -1731,28 +2136,36 @@ 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
+        id: link.context.spanId,
     }));
     if (links.length > 0) {
         properties[MS_LINKS] = JSON.stringify(links);
@@ -1836,7 +2249,7 @@ function createDependencyData(span) {
         resultCode: "0",
         type: "Dependency",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
-        version: 2
+        version: 2,
     };
     if (span.kind === api.SpanKind.PRODUCER) {
         remoteDependencyData.type = DependencyTypes.QueueMessage;
@@ -1878,7 +2291,7 @@ function createDependencyData(span) {
                     }
                 }
             }
-            catch (error) { }
+            catch (ex) { }
             remoteDependencyData.target = `${target}`;
         }
     }
@@ -1944,7 +2357,7 @@ function createRequestData(span) {
         responseCode: "0",
         duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
         version: 2,
-        source: undefined
+        source: undefined,
     };
     const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
     const grpcStatusCode = span.attributes[semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE];
@@ -2012,140 +2425,101 @@ function readableSpanToEnvelope(span, ikey) {
         data: {
             baseType,
             baseData: Object.assign(Object.assign({}, baseData), { properties,
-                measurements })
-        }
+                measurements }),
+        },
     };
 }
+/**
+ * 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;
-        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);
-                }
-            }
-            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 };
-        }
-    }
     /**
      * Export OpenTelemetry spans.
      * @param spans - Spans to export.
@@ -2153,34 +2527,121 @@ class AzureMonitorTraceExporter {
      */
     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));
+        let envelopes = [];
+        spans.forEach((span) => {
+            envelopes.push(readableSpanToEnvelope(span, this._instrumentationKey));
+            let spanEventEnvelopes = spanEventsToEnvelopes(span, this._instrumentationKey);
+            if (spanEventEnvelopes.length > 0) {
+                envelopes.push(...spanEventEnvelopes);
+            }
+        });
+        resultCallback(await this._exportEnvelopes(envelopes));
     }
     /**
      * Shutdown AzureMonitorTraceExporter.
      */
     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);
-        }
+}
+
+// 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",
+                };
+                if (metric.dataPointType == sdkMetricsBase.DataPointType.SINGULAR) {
+                    metricDataPoint.value = dataPoint.value;
+                    metricDataPoint.count = 1;
+                }
+                else {
+                    metricDataPoint.value = dataPoint.value.sum;
+                    metricDataPoint.count = dataPoint.value.count;
+                }
+                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");
     }
-    _isNetworkError(error) {
-        if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
-            return true;
-        }
-        return false;
+    /**
+     * Export OpenTelemetry resource metrics.
+     * @param metrics - Resource metrics to export.
+     * @param resultCallback - Result callback.
+     */
+    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 AzureMonitorMetricExporter.
+     */
+    async shutdown() {
+        api.diag.info("Azure Monitor Trace Exporter shutting down");
+        return this._shutdown();
+    }
+    /**
+     * Select aggregation temporality
+     */
+    selectAggregationTemporality() {
+        return sdkMetricsBase.AggregationTemporality.CUMULATIVE;
+    }
+    /**
+     * 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