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

package/dist/index.js

@@ -2,17 +2,19 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 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 sdkMetrics = require('@opentelemetry/sdk-metrics');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -34,14 +36,126 @@ 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 coreRestPipeline__namespace = /*#__PURE__*/_interopNamespace(coreRestPipeline);
 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.
+/**
+ * AI MS Links.
+ * @internal
+ */
+const MS_LINKS = "_MS.links";
+/**
+ * AI enqueued time attribute.
+ * @internal
+ */
+const ENQUEUED_TIME = "enqueuedTime";
+/**
+ * AI time since enqueued attribute.
+ * @internal
+ */
+const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
+/**
+ * AzureMonitorTraceExporter version.
+ * @internal
+ */
+const packageVersion = "1.0.0-beta.9";
+var DependencyTypes;
+(function (DependencyTypes) {
+    DependencyTypes["InProc"] = "InProc";
+    DependencyTypes["QueueMessage"] = "Queue Message";
+    DependencyTypes["Sql"] = "SQL";
+    DependencyTypes["Http"] = "Http";
+    DependencyTypes["Grpc"] = "GRPC";
+})(DependencyTypes || (DependencyTypes = {}));
+const AzureMonitorSampleRate = "_MS.sampleRate";
+
+/**
+ * ApplicationInsightsSampler is responsible for the following:
+ * Implements same trace id hashing algorithm so that traces are sampled the same across multiple nodes
+ * Adds item count to span attribute if span is sampled (needed for ingestion service)
+ * @param samplingRatio - 0 to 1 value.
+ */
+class ApplicationInsightsSampler {
+    constructor(samplingRatio = 1) {
+        this._samplingRatio = samplingRatio;
+        if (this._samplingRatio > 1) {
+            throw new Error("Wrong sampling rate, data will not be sampled out");
+        }
+        this._sampleRate = Math.round(this._samplingRatio * 100);
+    }
+    /**
+     * Checks whether span needs to be created and tracked.
+     *
+     * @param context Parent Context which may contain a span.
+     * @param traceId of the span to be created. It can be different from the
+     *     traceId in the {@link SpanContext}. Typically in situations when the
+     *     span to be created starts a new trace.
+     * @param spanName of the span to be created.
+     * @param spanKind of the span to be created.
+     * @param attributes Initial set of SpanAttributes for the Span being constructed.
+     * @param links Collection of links that will be associated with the Span to
+     *     be created. Typically useful for batch operations.
+     * @returns a {@link SamplingResult}.
+     */
+    shouldSample(
+    // @ts-ignore
+    context, traceId, 
+    // @ts-ignore
+    spanName, 
+    // @ts-ignore
+    spanKind, attributes, 
+    // @ts-ignore
+    links) {
+        let isSampledIn = false;
+        if (this._sampleRate == 100) {
+            isSampledIn = true;
+        }
+        else if (this._sampleRate == 0) {
+            isSampledIn = false;
+        }
+        else {
+            isSampledIn = this._getSamplingHashCode(traceId) < this._sampleRate;
+        }
+        // Add sample rate as span attribute
+        attributes = attributes || {};
+        attributes[AzureMonitorSampleRate] = this._sampleRate;
+        return isSampledIn
+            ? { decision: sdkTraceBase.SamplingDecision.RECORD_AND_SAMPLED, attributes: attributes }
+            : { decision: sdkTraceBase.SamplingDecision.NOT_RECORD, attributes: attributes };
+    }
+    /**
+     * Return Sampler description
+     */
+    toString() {
+        return `ApplicationInsightsSampler{${this._samplingRatio}}`;
+    }
+    _getSamplingHashCode(input) {
+        var csharpMin = -2147483648;
+        var csharpMax = 2147483647;
+        var hash = 5381;
+        if (!input) {
+            return 0;
+        }
+        while (input.length < 8) {
+            input = input + input;
+        }
+        for (var i = 0; i < input.length; i++) {
+            // JS doesn't respond to integer overflow by wrapping around. Simulate it with bitwise operators ( | 0)
+            hash = ((((hash << 5) + hash) | 0) + input.charCodeAt(i)) | 0;
+        }
+        hash = hash <= csharpMin ? csharpMax : Math.abs(hash);
+        return (hash / csharpMax) * 100;
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 /**
@@ -63,7 +177,7 @@ const DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
  * Default Breeze API version.
  * @internal
  */
-const DEFAULT_BREEZE_API_VERSION = exports.ServiceApiVersion.V2;
+exports.ServiceApiVersion.V2;
 /**
  * Default Live Metrics endpoint.
  * @internal
@@ -193,20 +307,6 @@ class ConnectionStringParser {
 ConnectionStringParser.FIELDS_SEPARATOR = ";";
 ConnectionStringParser.FIELD_KEY_VALUE_SEPARATOR = "=";
 
-const DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS = 60000;
-const DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING = 10;
-/**
- * Internal default Azure exporter configuration
- * @internal
- */
-const DEFAULT_EXPORTER_CONFIG = {
-    instrumentationKey: "",
-    endpointUrl: DEFAULT_BREEZE_ENDPOINT,
-    batchSendRetryIntervalMs: DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS,
-    maxConsecutiveFailuresBeforeWarning: DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING,
-    apiVersion: DEFAULT_BREEZE_API_VERSION,
-};
-
 // Copyright (c) Microsoft Corporation.
 class FileAccessControl {
     // Check if file access control could be enabled
@@ -409,7 +509,8 @@ const confirmDirExists = async (directory) => {
     catch (err) {
         if (err && err.code === "ENOENT") {
             try {
-                await mkdirAsync(directory);
+                const options = { recursive: true };
+                await mkdirAsync(directory, options);
             }
             catch (mkdirErr) {
                 if (mkdirErr && mkdirErr.code !== "EEXIST") {
@@ -432,25 +533,31 @@ const writeFileAsync = util.promisify(fs__namespace.writeFile);
  * @internal
  */
 class FileSystemPersist {
-    constructor(options = {}) {
+    constructor(instrumentationKey, _options) {
+        var _a, _b;
+        this._options = _options;
         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);
+        this._instrumentationKey = instrumentationKey;
+        if ((_a = this._options) === null || _a === void 0 ? void 0 : _a.disableOfflineStorage) {
+            this._enabled = false;
+            return;
+        }
         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");
         }
-        if (!this._options.instrumentationKey) {
+        if (!this._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);
+            this._tempDirectory = path__namespace.join(((_b = this._options) === null || _b === void 0 ? void 0 : _b.storageDirectory) || os__namespace.tmpdir(), "Microsoft", "AzureMonitor", FileSystemPersist.TEMPDIR_PREFIX + this._instrumentationKey);
             // Starts file cleanup task
             if (!this._fileCleanupTimer) {
                 this._fileCleanupTimer = setTimeout(() => {
@@ -596,48 +703,83 @@ FileSystemPersist.FILENAME_SUFFIX = ".ai.json";
 /** Known values of {@link DataPointType} that the service accepts. */
 var KnownDataPointType;
 (function (KnownDataPointType) {
+    /** Measurement */
     KnownDataPointType["Measurement"] = "Measurement";
+    /** Aggregation */
     KnownDataPointType["Aggregation"] = "Aggregation";
 })(KnownDataPointType || (KnownDataPointType = {}));
 /** Known values of {@link SeverityLevel} that the service accepts. */
 var KnownSeverityLevel;
 (function (KnownSeverityLevel) {
+    /** Verbose */
     KnownSeverityLevel["Verbose"] = "Verbose";
+    /** Information */
     KnownSeverityLevel["Information"] = "Information";
+    /** Warning */
     KnownSeverityLevel["Warning"] = "Warning";
+    /** Error */
     KnownSeverityLevel["Error"] = "Error";
+    /** Critical */
     KnownSeverityLevel["Critical"] = "Critical";
 })(KnownSeverityLevel || (KnownSeverityLevel = {}));
 /** Known values of {@link ContextTagKeys} that the service accepts. */
 var KnownContextTagKeys;
 (function (KnownContextTagKeys) {
+    /** AiApplicationVer */
     KnownContextTagKeys["AiApplicationVer"] = "ai.application.ver";
+    /** AiDeviceId */
     KnownContextTagKeys["AiDeviceId"] = "ai.device.id";
+    /** AiDeviceLocale */
     KnownContextTagKeys["AiDeviceLocale"] = "ai.device.locale";
+    /** AiDeviceModel */
     KnownContextTagKeys["AiDeviceModel"] = "ai.device.model";
+    /** AiDeviceOemName */
     KnownContextTagKeys["AiDeviceOemName"] = "ai.device.oemName";
+    /** AiDeviceOsVersion */
     KnownContextTagKeys["AiDeviceOsVersion"] = "ai.device.osVersion";
+    /** AiDeviceType */
     KnownContextTagKeys["AiDeviceType"] = "ai.device.type";
+    /** AiLocationIp */
     KnownContextTagKeys["AiLocationIp"] = "ai.location.ip";
+    /** AiLocationCountry */
     KnownContextTagKeys["AiLocationCountry"] = "ai.location.country";
+    /** AiLocationProvince */
     KnownContextTagKeys["AiLocationProvince"] = "ai.location.province";
+    /** AiLocationCity */
     KnownContextTagKeys["AiLocationCity"] = "ai.location.city";
+    /** AiOperationId */
     KnownContextTagKeys["AiOperationId"] = "ai.operation.id";
+    /** AiOperationName */
     KnownContextTagKeys["AiOperationName"] = "ai.operation.name";
+    /** AiOperationParentId */
     KnownContextTagKeys["AiOperationParentId"] = "ai.operation.parentId";
+    /** AiOperationSyntheticSource */
     KnownContextTagKeys["AiOperationSyntheticSource"] = "ai.operation.syntheticSource";
+    /** AiOperationCorrelationVector */
     KnownContextTagKeys["AiOperationCorrelationVector"] = "ai.operation.correlationVector";
+    /** AiSessionId */
     KnownContextTagKeys["AiSessionId"] = "ai.session.id";
+    /** AiSessionIsFirst */
     KnownContextTagKeys["AiSessionIsFirst"] = "ai.session.isFirst";
+    /** AiUserAccountId */
     KnownContextTagKeys["AiUserAccountId"] = "ai.user.accountId";
+    /** AiUserId */
     KnownContextTagKeys["AiUserId"] = "ai.user.id";
+    /** AiUserAuthUserId */
     KnownContextTagKeys["AiUserAuthUserId"] = "ai.user.authUserId";
+    /** AiCloudRole */
     KnownContextTagKeys["AiCloudRole"] = "ai.cloud.role";
+    /** AiCloudRoleVer */
     KnownContextTagKeys["AiCloudRoleVer"] = "ai.cloud.roleVer";
+    /** AiCloudRoleInstance */
     KnownContextTagKeys["AiCloudRoleInstance"] = "ai.cloud.roleInstance";
+    /** AiCloudLocation */
     KnownContextTagKeys["AiCloudLocation"] = "ai.cloud.location";
+    /** AiInternalSdkVersion */
     KnownContextTagKeys["AiInternalSdkVersion"] = "ai.internal.sdkVersion";
+    /** AiInternalAgentVersion */
     KnownContextTagKeys["AiInternalAgentVersion"] = "ai.internal.agentVersion";
+    /** AiInternalNodeName */
     KnownContextTagKeys["AiInternalNodeName"] = "ai.internal.nodeName";
 })(KnownContextTagKeys || (KnownContextTagKeys = {}));
 
@@ -1571,12 +1713,13 @@ 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__namespace.ServiceClient {
+class ApplicationInsightsClient extends coreClient__namespace.ServiceClient {
     /**
-     * Initializes a new instance of the ApplicationInsightsClientContext class.
+     * Initializes a new instance of the ApplicationInsightsClient class.
      * @param options The parameter options
      */
     constructor(options) {
+        var _a, _b;
         // Initializing default values for options
         if (!options) {
             options = {};
@@ -1584,34 +1727,33 @@ class ApplicationInsightsClientContext extends coreClient__namespace.ServiceClie
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.7`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.9`;
         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.1" });
+            }, baseUri: (_b = (_a = options.endpoint) !== null && _a !== void 0 ? _a : options.baseUri) !== null && _b !== void 0 ? _b : "{Host}/v2.1" });
         super(optionsWithDefaults);
+        if ((options === null || options === void 0 ? void 0 : options.pipeline) && options.pipeline.getOrderedPolicies().length > 0) {
+            const pipelinePolicies = options.pipeline.getOrderedPolicies();
+            const bearerTokenAuthenticationPolicyFound = pipelinePolicies.some((pipelinePolicy) => pipelinePolicy.name ===
+                coreRestPipeline__namespace.bearerTokenAuthenticationPolicyName);
+            if (!bearerTokenAuthenticationPolicyFound) {
+                this.pipeline.removePolicy({
+                    name: coreRestPipeline__namespace.bearerTokenAuthenticationPolicyName
+                });
+                this.pipeline.addPolicy(coreRestPipeline__namespace.bearerTokenAuthenticationPolicy({
+                    scopes: `${optionsWithDefaults.baseUri}/.default`,
+                    challengeCallbacks: {
+                        authorizeRequestOnChallenge: coreClient__namespace.authorizeRequestOnClaimChallenge
+                    }
+                }));
+            }
+        }
         // Assigning values to Constant parameters
         this.host = options.host || "https://dc.services.visualstudio.com";
     }
-}
-
-/*
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * Code generated by Microsoft (R) AutoRest Code Generator.
- * Changes may cause incorrect behavior and will be lost if the code is regenerated.
- */
-class ApplicationInsightsClient extends ApplicationInsightsClientContext {
-    /**
-     * Initializes a new instance of the ApplicationInsightsClient class.
-     * @param options The parameter options
-     */
-    constructor(options) {
-        super(options);
-    }
     /**
      * This operation sends a sequence of telemetry events that will be monitored by Azure Monitor.
      * @param body The list of telemetry events to track.
@@ -1668,19 +1810,16 @@ const applicationInsightsResource = "https://monitor.azure.com//.default";
  * @internal
  */
 class HttpSender {
-    constructor(_exporterOptions) {
-        this._exporterOptions = _exporterOptions;
+    constructor(endpointUrl, options) {
         // Build endpoint using provided configuration or default values
-        this._appInsightsClientOptions = {
-            host: this._exporterOptions.endpointUrl,
-        };
-        this._appInsightsClient = new ApplicationInsightsClient(Object.assign({}, this._appInsightsClientOptions));
+        this._appInsightsClientOptions = Object.assign({ host: endpointUrl }, options);
+        this._appInsightsClient = new ApplicationInsightsClient(this._appInsightsClientOptions);
         // Handle redirects in HTTP Sender
         this._appInsightsClient.pipeline.removePolicy({ name: coreRestPipeline.redirectPolicyName });
-        if (this._exporterOptions.aadTokenCredential) {
+        if (options === null || options === void 0 ? void 0 : options.aadTokenCredential) {
             let scopes = [applicationInsightsResource];
             this._appInsightsClient.pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
-                credential: this._exporterOptions.aadTokenCredential,
+                credential: options === null || options === void 0 ? void 0 : options.aadTokenCredential,
                 scopes: scopes,
             }));
         }
@@ -1724,37 +1863,6 @@ class HttpSender {
     }
 }
 
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * AI MS Links.
- * @internal
- */
-const MS_LINKS = "_MS.links";
-/**
- * AI enqueued time attribute.
- * @internal
- */
-const ENQUEUED_TIME = "enqueuedTime";
-/**
- * AI time since enqueued attribute.
- * @internal
- */
-const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
-/**
- * AzureMonitorTraceExporter version.
- * @internal
- */
-const packageVersion = "1.0.0-beta.7";
-var DependencyTypes;
-(function (DependencyTypes) {
-    DependencyTypes["InProc"] = "InProc";
-    DependencyTypes["QueueMessage"] = "Queue Message";
-    DependencyTypes["Sql"] = "SQL";
-    DependencyTypes["Http"] = "Http";
-    DependencyTypes["Grpc"] = "GRPC";
-})(DependencyTypes || (DependencyTypes = {}));
-
 // Copyright (c) Microsoft Corporation.
 let instance = null;
 /**
@@ -1805,7 +1913,9 @@ function isRetriable(statusCode) {
         statusCode === 408 || // Timeout
         statusCode === 429 || // Too many requests
         statusCode === 500 || // Server Error
-        statusCode === 503 // Server Unavailable
+        statusCode === 502 || // Bad Gateway
+        statusCode === 503 || // Server Unavailable
+        statusCode === 504 // Gateway Timeout
     );
 }
 /**
@@ -1828,6 +1938,203 @@ function msToTimeSpan(ms) {
     return `${daysText + hour}:${min}:${sec}`;
 }
 
+// Copyright (c) Microsoft Corporation.
+const DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS = 60000;
+/**
+ * Azure Monitor OpenTelemetry Trace Exporter.
+ */
+class AzureMonitorBaseExporter {
+    /**
+     * Initializes a new instance of the AzureMonitorBaseExporter class.
+     * @param AzureMonitorExporterOptions - Exporter configuration.
+     */
+    constructor(options = {}) {
+        var _a;
+        this._batchSendRetryIntervalMs = DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS;
+        this._options = options;
+        this._numConsecutiveRedirects = 0;
+        this._instrumentationKey = "";
+        this._endpointUrl = DEFAULT_BREEZE_ENDPOINT;
+        const connectionString = this._options.connectionString || process.env[ENV_CONNECTION_STRING];
+        if (connectionString) {
+            const parsedConnectionString = ConnectionStringParser.parse(connectionString);
+            this._instrumentationKey =
+                parsedConnectionString.instrumentationkey || this._instrumentationKey;
+            this._endpointUrl = ((_a = parsedConnectionString.ingestionendpoint) === null || _a === void 0 ? void 0 : _a.trim()) || this._endpointUrl;
+        }
+        // Instrumentation key is required
+        if (!this._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._endpointUrl, this._options);
+        this._persister = new FileSystemPersist(this._instrumentationKey, this._options);
+        this._retryTimer = null;
+        api.diag.debug("AzureMonitorExporter 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)`);
+        if (envelopes.length < 1) {
+            return { code: core.ExportResultCode.SUCCESS };
+        }
+        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._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.
 /**
@@ -1894,34 +2201,15 @@ const parseEventHubSpan = (span, baseData) => {
 
 // Copyright (c) Microsoft Corporation.
 function createTagsFromSpan(span) {
-    const context = getInstance();
-    const tags = Object.assign({}, context.tags);
+    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);
     }
     if (span.kind === api.SpanKind.SERVER) {
         const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
@@ -1956,25 +2244,34 @@ 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.") ||
+                key.startsWith("_MS."))) {
+                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 +2400,7 @@ function createDependencyData(span) {
                     }
                 }
             }
-            catch (error) { }
+            catch (ex) { }
             remoteDependencyData.target = `${target}`;
         }
     }
@@ -2192,7 +2489,6 @@ function createRequestData(span) {
 function readableSpanToEnvelope(span, ikey) {
     let name;
     let baseType;
-    const sampleRate = 100;
     let baseData;
     const time = new Date(core.hrTimeToMilliseconds(span.startTime));
     const instrumentationKey = ikey;
@@ -2218,6 +2514,10 @@ function readableSpanToEnvelope(span, ikey) {
             api.diag.error(`Unsupported span kind ${span.kind}`);
             throw new Error(`Unsupported span kind ${span.kind}`);
     }
+    let sampleRate = 100;
+    if (span.attributes[AzureMonitorSampleRate]) {
+        sampleRate = Number(span.attributes[AzureMonitorSampleRate]);
+    }
     // Azure SDK
     if (span.attributes[AzNamespace]) {
         if (span.kind === api.SpanKind.INTERNAL) {
@@ -2241,172 +2541,267 @@ function readableSpanToEnvelope(span, ikey) {
         },
     };
 }
+/**
+ * Span Events to Azure envelopes parsing.
+ * @internal
+ */
+function spanEventsToEnvelopes(span, ikey) {
+    let envelopes = [];
+    if (span.events) {
+        span.events.forEach((event) => {
+            var _a;
+            let baseType;
+            let time = new Date(core.hrTimeToMilliseconds(event.time));
+            let name = "";
+            let baseData;
+            const properties = createPropertiesFromSpanAttributes(event.attributes);
+            let tags = createTagsFromResource(span.resource);
+            tags[KnownContextTagKeys.AiOperationId] = span.spanContext().traceId;
+            let spanId = (_a = span.spanContext()) === null || _a === void 0 ? void 0 : _a.spanId;
+            if (spanId) {
+                tags[KnownContextTagKeys.AiOperationParentId] = spanId;
+            }
+            // Only generate exception telemetry for incoming requests
+            if (event.name == "exception" && span.kind == api.SpanKind.SERVER) {
+                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 sampleRate = 100;
+            if (span.attributes[AzureMonitorSampleRate]) {
+                sampleRate = Number(span.attributes[AzureMonitorSampleRate]);
+            }
+            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);
+        /**
+         * Flag to determine if Exporter is shutdown.
+         */
+        this._isShutdown = false;
         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."),
-                };
+    /**
+     * Export OpenTelemetry spans.
+     * @param spans - Spans to export.
+     * @param resultCallback - Result callback.
+     */
+    async export(spans, resultCallback) {
+        if (this._isShutdown) {
+            api.diag.info("Exporter shut down. Failed to export spans.");
+            setTimeout(() => resultCallback({ code: core.ExportResultCode.FAILED }), 0);
+            return;
         }
-        catch (ex) {
-            return { code: core.ExportResultCode.FAILED, error: ex };
+        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);
+            }
+        });
+        resultCallback(await this._exportEnvelopes(envelopes));
+    }
+    /**
+     * Shutdown AzureMonitorTraceExporter.
+     */
+    async shutdown() {
+        this._isShutdown = true;
+        api.diag.info("AzureMonitorTraceExporter shutting down");
+        return this._shutdown();
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+function createPropertiesFromMetricAttributes(attributes) {
+    const properties = {};
+    if (attributes) {
+        for (const key of Object.keys(attributes)) {
+            properties[key] = attributes[key];
         }
     }
-    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,
+    return properties;
+}
+/**
+ * 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) => {
+        scopeMetric.metrics.forEach((metric) => {
+            metric.dataPoints.forEach((dataPoint) => {
+                let baseData = {
+                    metrics: [],
+                    version: 2,
+                    properties: {},
                 };
-            }
-        }
-        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);
-                        }
-                    }
+                baseData.properties = createPropertiesFromMetricAttributes(dataPoint.attributes);
+                var metricDataPoint = {
+                    name: metric.descriptor.name,
+                    value: 0,
+                    dataPointType: "Aggregation",
+                };
+                if (metric.dataPointType == sdkMetrics.DataPointType.SUM ||
+                    metric.dataPointType == sdkMetrics.DataPointType.GAUGE) {
+                    metricDataPoint.value = dataPoint.value;
+                    metricDataPoint.count = 1;
                 }
                 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 };
-        }
+                    metricDataPoint.value = dataPoint.value.sum || 0;
+                    metricDataPoint.count = dataPoint.value.count;
+                    metricDataPoint.max = dataPoint.value.max;
+                    metricDataPoint.min = dataPoint.value.min;
+                }
+                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);
+        /**
+         * Flag to determine if Exporter is shutdown.
+         */
+        this._isShutdown = false;
+        this._aggregationTemporality = sdkMetrics.AggregationTemporality.CUMULATIVE;
+        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) {
+        if (this._isShutdown) {
+            api.diag.info("Exporter shut down. Failed to export spans.");
+            setTimeout(() => resultCallback({ code: core.ExportResultCode.FAILED }), 0);
+            return;
+        }
+        api.diag.info(`Exporting ${metrics.scopeMetrics.length} metrics(s). Converting to envelopes...`);
+        let envelopes = resourceMetricsToEnvelope(metrics, this._instrumentationKey);
+        // Supress tracing until OpenTelemetry Metrics SDK support it
+        api.context.with(core.suppressTracing(api.context.active()), async () => {
+            resultCallback(await this._exportEnvelopes(envelopes));
+        });
     }
     /**
-     * Shutdown AzureMonitorTraceExporter.
+     * Shutdown AzureMonitorMetricExporter.
      */
     async shutdown() {
-        api.diag.info("Azure Monitor Trace Exporter shutting down");
-        return this._sender.shutdown();
+        this._isShutdown = true;
+        api.diag.info("AzureMonitorMetricExporter shutting down");
+        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(_instrumentType) {
+        return this._aggregationTemporality;
     }
-    _isNetworkError(error) {
-        if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
-            return true;
-        }
-        return false;
+    /**
+     * Force flush
+     */
+    async forceFlush() {
+        return Promise.resolve();
     }
 }
 
+exports.ApplicationInsightsSampler = ApplicationInsightsSampler;
+exports.AzureMonitorBaseExporter = AzureMonitorBaseExporter;
+exports.AzureMonitorMetricExporter = AzureMonitorMetricExporter;
 exports.AzureMonitorTraceExporter = AzureMonitorTraceExporter;
 //# sourceMappingURL=index.js.map