@azure/monitor-opentelemetry-exporter 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/index.js

@@ -1,1855 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var core = require('@opentelemetry/core');
-var coreHttp = require('@azure/core-http');
-var api = require('@opentelemetry/api');
-var fs = require('fs');
-var os = require('os');
-var path = require('path');
-var util = require('util');
-var url = require('url');
-var resources = require('@opentelemetry/resources');
-var conventions = require('@opentelemetry/semantic-conventions');
-
-// Copyright (c) Microsoft Corporation.
-(function (ServiceApiVersion) {
-    ServiceApiVersion["V2"] = "2020-09-15_Preview";
-})(exports.ServiceApiVersion || (exports.ServiceApiVersion = {}));
-const DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
-const DEFAULT_BREEZE_API_VERSION = exports.ServiceApiVersion.V2;
-const DEFAULT_LIVEMETRICS_ENDPOINT = "https://rt.services.visualstudio.com";
-const ENV_CONNECTION_STRING = "APPLICATIONINSIGHTS_CONNECTION_STRING";
-var QuickPulseCounter;
-(function (QuickPulseCounter) {
-    // Memory
-    QuickPulseCounter["COMMITTED_BYTES"] = "\\Memory\\Committed Bytes";
-    // CPU
-    QuickPulseCounter["PROCESSOR_TIME"] = "\\Processor(_Total)\\% Processor Time";
-    // Request
-    QuickPulseCounter["REQUEST_RATE"] = "\\ApplicationInsights\\Requests/Sec";
-    QuickPulseCounter["REQUEST_FAILURE_RATE"] = "\\ApplicationInsights\\Requests Failed/Sec";
-    QuickPulseCounter["REQUEST_DURATION"] = "\\ApplicationInsights\\Request Duration";
-    // Dependency
-    QuickPulseCounter["DEPENDENCY_RATE"] = "\\ApplicationInsights\\Dependency Calls/Sec";
-    QuickPulseCounter["DEPENDENCY_FAILURE_RATE"] = "\\ApplicationInsights\\Dependency Calls Failed/Sec";
-    QuickPulseCounter["DEPENDENCY_DURATION"] = "\\ApplicationInsights\\Dependency Call Duration";
-    // Exception
-    QuickPulseCounter["EXCEPTION_RATE"] = "\\ApplicationInsights\\Exceptions/Sec";
-})(QuickPulseCounter || (QuickPulseCounter = {}));
-var PerformanceCounter;
-(function (PerformanceCounter) {
-    // Memory
-    PerformanceCounter["PRIVATE_BYTES"] = "\\Process(??APP_WIN32_PROC??)\\Private Bytes";
-    PerformanceCounter["AVAILABLE_BYTES"] = "\\Memory\\Available Bytes";
-    // CPU
-    PerformanceCounter["PROCESSOR_TIME"] = "\\Processor(_Total)\\% Processor Time";
-    PerformanceCounter["PROCESS_TIME"] = "\\Process(??APP_WIN32_PROC??)\\% Processor Time";
-    // Requests
-    PerformanceCounter["REQUEST_RATE"] = "\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Requests/Sec";
-    PerformanceCounter["REQUEST_DURATION"] = "\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Request Execution Time";
-})(PerformanceCounter || (PerformanceCounter = {}));
-/**
- * Map a PerformanceCounter/QuickPulseCounter to a QuickPulseCounter. If no mapping exists, mapping is *undefined*
- */
-const PerformanceToQuickPulseCounter = {
-    [PerformanceCounter.PROCESSOR_TIME]: QuickPulseCounter.PROCESSOR_TIME,
-    [PerformanceCounter.REQUEST_RATE]: QuickPulseCounter.REQUEST_RATE,
-    [PerformanceCounter.REQUEST_DURATION]: QuickPulseCounter.REQUEST_DURATION,
-    // Remap quick pulse only counters
-    [QuickPulseCounter.COMMITTED_BYTES]: QuickPulseCounter.COMMITTED_BYTES,
-    [QuickPulseCounter.REQUEST_FAILURE_RATE]: QuickPulseCounter.REQUEST_FAILURE_RATE,
-    [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
-};
-
-// Copyright (c) Microsoft Corporation.
-class ConnectionStringParser {
-    static parse(connectionString, logger = new api.NoopLogger()) {
-        if (!connectionString) {
-            return {};
-        }
-        const kvPairs = connectionString.split(ConnectionStringParser.FIELDS_SEPARATOR);
-        let isValid = true;
-        const result = kvPairs.reduce((fields, kv) => {
-            const kvParts = kv.split(ConnectionStringParser.FIELD_KEY_VALUE_SEPARATOR);
-            if (kvParts.length === 2) {
-                // only save fields with valid formats
-                const key = kvParts[0].toLowerCase();
-                const value = kvParts[1];
-                return Object.assign(Object.assign({}, fields), { [key]: value });
-            }
-            logger.error(`Connection string key-value pair is invalid: ${kv}`, `Entire connection string will be discarded`, connectionString);
-            isValid = false;
-            return fields;
-        }, {});
-        if (isValid && Object.keys(result).length > 0) {
-            // this is a valid connection string, so parse the results
-            if (result.endpointsuffix) {
-                // use endpoint suffix where overrides are not provided
-                const locationPrefix = result.location ? `${result.location}.` : "";
-                result.ingestionendpoint =
-                    result.ingestionendpoint || `https://${locationPrefix}dc.${result.endpointsuffix}`;
-                result.liveendpoint =
-                    result.liveendpoint || `https://${locationPrefix}live.${result.endpointsuffix}`;
-            }
-            result.ingestionendpoint = result.ingestionendpoint
-                ? ConnectionStringParser.sanitizeUrl(result.ingestionendpoint)
-                : DEFAULT_BREEZE_ENDPOINT;
-            result.liveendpoint = result.liveendpoint
-                ? ConnectionStringParser.sanitizeUrl(result.liveendpoint)
-                : DEFAULT_LIVEMETRICS_ENDPOINT;
-            if (result.authorization && result.authorization.toLowerCase() !== "ikey") {
-                logger.warn(`Connection String contains an unsupported 'Authorization' value: ${result.authorization}. Defaulting to 'Authorization=ikey'. Instrumentation Key ${result.instrumentationkey}`);
-            }
-        }
-        else {
-            logger.error("An invalid connection string was passed in. There may be telemetry loss", connectionString);
-        }
-        return result;
-    }
-    static sanitizeUrl(url) {
-        let newUrl = url.trim();
-        if (newUrl.indexOf("https://") < 0) {
-            // Try to update http to https
-            newUrl = newUrl.replace("http://", "https://");
-        }
-        // Remove final slash if present
-        if (newUrl[newUrl.length - 1] == "/") {
-            newUrl = newUrl.slice(0, -1);
-        }
-        return newUrl;
-    }
-}
-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;
-const DEFAULT_EXPORTER_CONFIG = {
-    instrumentationKey: "",
-    endpointUrl: DEFAULT_BREEZE_ENDPOINT,
-    batchSendRetryIntervalMs: DEFAULT_BATCH_SEND_RETRY_INTERVAL_MS,
-    maxConsecutiveFailuresBeforeWarning: DEFAULT_MAX_CONSECUTIVE_FAILURES_BEFORE_WARNING,
-    serviceApiVersion: 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);
-/**
- * Computes the size (in bytes) of all files in a directory at the root level. Asynchronously.
- */
-const getShallowDirectorySize = (directory) => tslib.__awaiter(void 0, void 0, void 0, function* () {
-    // Get the directory listing
-    const files = yield readdirAsync(directory);
-    let totalSize = 0;
-    // Query all file sizes
-    for (const file of files) {
-        const fileStats = yield statAsync(path.join(directory, file));
-        if (fileStats.isFile()) {
-            totalSize += fileStats.size;
-        }
-    }
-    return totalSize;
-});
-const confirmDirExists = (directory) => tslib.__awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const stats = yield lstatAsync(directory);
-        if (!stats.isDirectory()) {
-            throw new Error("Path existed but was not a directory");
-        }
-    }
-    catch (err) {
-        if (err && err.code === "ENOENT") {
-            try {
-                yield mkdirAsync(directory);
-            }
-            catch (mkdirErr) {
-                if (mkdirErr && mkdirErr.code !== "EEXIST") {
-                    // Handle race condition by ignoring EEXIST
-                    throw mkdirErr;
-                }
-            }
-        }
-    }
-});
-
-// 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);
-class FileSystemPersist {
-    constructor(options = {}) {
-        this.maxBytesOnDisk = 50000000; // ~50MB
-        this._options = Object.assign(Object.assign({}, DEFAULT_EXPORTER_CONFIG), options);
-        this._logger = options.logger || new api.NoopLogger();
-        if (!this._options.instrumentationKey) {
-            this._logger.error(`No instrumentation key was provided to FileSystemPersister. Files may not be properly persisted`);
-        }
-    }
-    push(value) {
-        this._logger.debug("Pushing value to persistent storage", value.toString());
-        return this._storeToDisk(JSON.stringify(value));
-    }
-    shift() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            this._logger.debug("Searching for filesystem persisted files");
-            try {
-                const buffer = yield this._getFirstFileOnDisk();
-                if (buffer) {
-                    return JSON.parse(buffer.toString("utf8"));
-                }
-            }
-            catch (e) {
-                this._logger.debug("Failed to read persisted file", e);
-            }
-            return null;
-        });
-    }
-    /**
-     * Check for temp telemetry files
-     * reads the first file if exist, deletes it and tries to send its load
-     */
-    _getFirstFileOnDisk() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const tempDir = path.join(os.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
-            try {
-                const stats = yield statAsync$1(tempDir);
-                if (stats.isDirectory()) {
-                    const origFiles = yield readdirAsync$1(tempDir);
-                    const files = origFiles.filter((f) => path.basename(f).includes(FileSystemPersist.FILENAME_SUFFIX));
-                    if (files.length === 0) {
-                        return null;
-                    }
-                    else {
-                        const firstFile = files[0];
-                        const filePath = path.join(tempDir, firstFile);
-                        const payload = yield readFileAsync(filePath);
-                        // delete the file first to prevent double sending
-                        yield unlinkAsync(filePath);
-                        return payload;
-                    }
-                }
-                return null;
-            }
-            catch (e) {
-                if (e.code === "ENOENT") {
-                    // File does not exist -- return null instead of throwing
-                    return null;
-                }
-                else {
-                    throw e;
-                }
-            }
-        });
-    }
-    _storeToDisk(payload) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const directory = path.join(os.tmpdir(), FileSystemPersist.TEMPDIR_PREFIX + this._options.instrumentationKey);
-            try {
-                yield confirmDirExists(directory);
-            }
-            catch (error) {
-                this._logger.warn(`Error while checking/creating directory: `, error && error.message);
-                return false;
-            }
-            try {
-                const size = yield getShallowDirectorySize(directory);
-                if (size > this.maxBytesOnDisk) {
-                    this._logger.warn(`Not saving data due to max size limit being met. Directory size in bytes is: ${size}`);
-                    return false;
-                }
-            }
-            catch (error) {
-                this._logger.warn(`Error while checking size of persistence directory: `, error && error.message);
-                return false;
-            }
-            // create file - file name for now is the timestamp, @todo: a better approach would be a UUID but that
-            // would require an external dependency
-            const fileName = `${new Date().getTime()}${FileSystemPersist.FILENAME_SUFFIX}`;
-            const fileFullPath = path.join(directory, fileName);
-            // Mode 600 is w/r for creator and no read access for others
-            this._logger.info(`saving data to disk at: ${fileFullPath}`);
-            try {
-                yield writeFileAsync(fileFullPath, payload, { mode: 0o600 });
-            }
-            catch (writeError) {
-                this._logger.warn(`Error writing file to persistent file storage`, writeError);
-                return false;
-            }
-            return true;
-        });
-    }
-}
-FileSystemPersist.TEMPDIR_PREFIX = "ot-azure-exporter-";
-FileSystemPersist.FILENAME_SUFFIX = ".ai.json";
-
-/*
- * 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.
- */
-const contentType = {
-    parameterPath: ["options", "contentType"],
-    mapper: {
-        defaultValue: "application/json",
-        isConstant: true,
-        serializedName: "Content-Type",
-        type: {
-            name: "String"
-        }
-    }
-};
-const body = {
-    parameterPath: "body",
-    mapper: {
-        serializedName: "body",
-        required: true,
-        type: {
-            name: "Sequence",
-            element: { type: { name: "Composite", className: "TelemetryItem" } }
-        }
-    }
-};
-const accept = {
-    parameterPath: "accept",
-    mapper: {
-        defaultValue: "application/json",
-        isConstant: true,
-        serializedName: "Accept",
-        type: {
-            name: "String"
-        }
-    }
-};
-const host = {
-    parameterPath: "host",
-    mapper: {
-        serializedName: "Host",
-        required: true,
-        type: {
-            name: "String"
-        }
-    },
-    skipEncoding: true
-};
-
-/*
- * 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.
- */
-const TelemetryItem = {
-    type: {
-        name: "Composite",
-        className: "TelemetryItem",
-        modelProperties: {
-            version: {
-                defaultValue: 1,
-                serializedName: "ver",
-                type: {
-                    name: "Number"
-                }
-            },
-            name: {
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            },
-            time: {
-                serializedName: "time",
-                required: true,
-                type: {
-                    name: "DateTime"
-                }
-            },
-            sampleRate: {
-                defaultValue: 100,
-                serializedName: "sampleRate",
-                type: {
-                    name: "Number"
-                }
-            },
-            sequence: {
-                constraints: {
-                    MaxLength: 64
-                },
-                serializedName: "seq",
-                type: {
-                    name: "String"
-                }
-            },
-            instrumentationKey: {
-                serializedName: "iKey",
-                type: {
-                    name: "String"
-                }
-            },
-            tags: {
-                serializedName: "tags",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" } }
-                }
-            },
-            data: {
-                serializedName: "data",
-                type: {
-                    name: "Composite",
-                    className: "MonitorBase"
-                }
-            }
-        }
-    }
-};
-const MonitorBase = {
-    type: {
-        name: "Composite",
-        className: "MonitorBase",
-        modelProperties: {
-            baseType: {
-                serializedName: "baseType",
-                type: {
-                    name: "String"
-                }
-            },
-            baseData: {
-                serializedName: "baseData",
-                type: {
-                    name: "Composite",
-                    className: "MonitorDomain"
-                }
-            }
-        }
-    }
-};
-const MonitorDomain = {
-    type: {
-        name: "Composite",
-        className: "MonitorDomain",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: {
-            version: {
-                defaultValue: 2,
-                serializedName: "ver",
-                required: true,
-                type: {
-                    name: "Number"
-                }
-            }
-        }
-    }
-};
-const TrackResponse = {
-    type: {
-        name: "Composite",
-        className: "TrackResponse",
-        modelProperties: {
-            itemsReceived: {
-                serializedName: "itemsReceived",
-                type: {
-                    name: "Number"
-                }
-            },
-            itemsAccepted: {
-                serializedName: "itemsAccepted",
-                type: {
-                    name: "Number"
-                }
-            },
-            errors: {
-                serializedName: "errors",
-                type: {
-                    name: "Sequence",
-                    element: {
-                        type: { name: "Composite", className: "TelemetryErrorDetails" }
-                    }
-                }
-            }
-        }
-    }
-};
-const TelemetryErrorDetails = {
-    type: {
-        name: "Composite",
-        className: "TelemetryErrorDetails",
-        modelProperties: {
-            index: {
-                serializedName: "index",
-                type: {
-                    name: "Number"
-                }
-            },
-            statusCode: {
-                serializedName: "statusCode",
-                type: {
-                    name: "Number"
-                }
-            },
-            message: {
-                serializedName: "message",
-                type: {
-                    name: "String"
-                }
-            }
-        }
-    }
-};
-const MetricDataPoint = {
-    type: {
-        name: "Composite",
-        className: "MetricDataPoint",
-        modelProperties: {
-            namespace: {
-                constraints: {
-                    MaxLength: 256
-                },
-                serializedName: "ns",
-                type: {
-                    name: "String"
-                }
-            },
-            name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            },
-            dataPointType: {
-                serializedName: "kind",
-                type: {
-                    name: "String"
-                }
-            },
-            value: {
-                serializedName: "value",
-                required: true,
-                type: {
-                    name: "Number"
-                }
-            },
-            count: {
-                serializedName: "count",
-                type: {
-                    name: "Number"
-                }
-            },
-            min: {
-                serializedName: "min",
-                type: {
-                    name: "Number"
-                }
-            },
-            max: {
-                serializedName: "max",
-                type: {
-                    name: "Number"
-                }
-            },
-            stdDev: {
-                serializedName: "stdDev",
-                type: {
-                    name: "Number"
-                }
-            }
-        }
-    }
-};
-const TelemetryExceptionDetails = {
-    type: {
-        name: "Composite",
-        className: "TelemetryExceptionDetails",
-        modelProperties: {
-            id: {
-                serializedName: "id",
-                type: {
-                    name: "Number"
-                }
-            },
-            outerId: {
-                serializedName: "outerId",
-                type: {
-                    name: "Number"
-                }
-            },
-            typeName: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "typeName",
-                type: {
-                    name: "String"
-                }
-            },
-            message: {
-                constraints: {
-                    MaxLength: 32768
-                },
-                serializedName: "message",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            },
-            hasFullStack: {
-                defaultValue: true,
-                serializedName: "hasFullStack",
-                type: {
-                    name: "Boolean"
-                }
-            },
-            stack: {
-                constraints: {
-                    MaxLength: 32768
-                },
-                serializedName: "stack",
-                type: {
-                    name: "String"
-                }
-            },
-            parsedStack: {
-                serializedName: "parsedStack",
-                type: {
-                    name: "Sequence",
-                    element: { type: { name: "Composite", className: "StackFrame" } }
-                }
-            }
-        }
-    }
-};
-const StackFrame = {
-    type: {
-        name: "Composite",
-        className: "StackFrame",
-        modelProperties: {
-            level: {
-                serializedName: "level",
-                required: true,
-                type: {
-                    name: "Number"
-                }
-            },
-            method: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "method",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            },
-            assembly: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "assembly",
-                type: {
-                    name: "String"
-                }
-            },
-            fileName: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "fileName",
-                type: {
-                    name: "String"
-                }
-            },
-            line: {
-                serializedName: "line",
-                type: {
-                    name: "Number"
-                }
-            }
-        }
-    }
-};
-const AvailabilityData = {
-    type: {
-        name: "Composite",
-        className: "AvailabilityData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { id: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "id",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, duration: {
-                serializedName: "duration",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, success: {
-                serializedName: "success",
-                required: true,
-                type: {
-                    name: "Boolean"
-                }
-            }, runLocation: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "runLocation",
-                type: {
-                    name: "String"
-                }
-            }, message: {
-                constraints: {
-                    MaxLength: 8192
-                },
-                serializedName: "message",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const TelemetryEventData = {
-    type: {
-        name: "Composite",
-        className: "TelemetryEventData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { name: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const TelemetryExceptionData = {
-    type: {
-        name: "Composite",
-        className: "TelemetryExceptionData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { exceptions: {
-                serializedName: "exceptions",
-                required: true,
-                type: {
-                    name: "Sequence",
-                    element: {
-                        type: { name: "Composite", className: "TelemetryExceptionDetails" }
-                    }
-                }
-            }, severityLevel: {
-                serializedName: "severityLevel",
-                type: {
-                    name: "String"
-                }
-            }, problemId: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "problemId",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const MessageData = {
-    type: {
-        name: "Composite",
-        className: "MessageData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { message: {
-                constraints: {
-                    MaxLength: 32768
-                },
-                serializedName: "message",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, severityLevel: {
-                serializedName: "severityLevel",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const MetricsData = {
-    type: {
-        name: "Composite",
-        className: "MetricsData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { metrics: {
-                serializedName: "metrics",
-                required: true,
-                type: {
-                    name: "Sequence",
-                    element: { type: { name: "Composite", className: "MetricDataPoint" } }
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            } })
-    }
-};
-const PageViewData = {
-    type: {
-        name: "Composite",
-        className: "PageViewData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { id: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "id",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, url: {
-                constraints: {
-                    MaxLength: 2048
-                },
-                serializedName: "url",
-                type: {
-                    name: "String"
-                }
-            }, duration: {
-                serializedName: "duration",
-                type: {
-                    name: "String"
-                }
-            }, referredUri: {
-                constraints: {
-                    MaxLength: 2048
-                },
-                serializedName: "referredUri",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const PageViewPerfData = {
-    type: {
-        name: "Composite",
-        className: "PageViewPerfData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { id: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "id",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, url: {
-                constraints: {
-                    MaxLength: 2048
-                },
-                serializedName: "url",
-                type: {
-                    name: "String"
-                }
-            }, duration: {
-                serializedName: "duration",
-                type: {
-                    name: "String"
-                }
-            }, perfTotal: {
-                serializedName: "perfTotal",
-                type: {
-                    name: "String"
-                }
-            }, networkConnect: {
-                serializedName: "networkConnect",
-                type: {
-                    name: "String"
-                }
-            }, sentRequest: {
-                serializedName: "sentRequest",
-                type: {
-                    name: "String"
-                }
-            }, receivedResponse: {
-                serializedName: "receivedResponse",
-                type: {
-                    name: "String"
-                }
-            }, domProcessing: {
-                serializedName: "domProcessing",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const RemoteDependencyData = {
-    type: {
-        name: "Composite",
-        className: "RemoteDependencyData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { id: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "id",
-                type: {
-                    name: "String"
-                }
-            }, name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, resultCode: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "resultCode",
-                type: {
-                    name: "String"
-                }
-            }, data: {
-                constraints: {
-                    MaxLength: 8192
-                },
-                serializedName: "data",
-                type: {
-                    name: "String"
-                }
-            }, type: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "type",
-                type: {
-                    name: "String"
-                }
-            }, target: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "target",
-                type: {
-                    name: "String"
-                }
-            }, duration: {
-                serializedName: "duration",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, success: {
-                defaultValue: true,
-                serializedName: "success",
-                type: {
-                    name: "Boolean"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-const RequestData = {
-    type: {
-        name: "Composite",
-        className: "RequestData",
-        additionalProperties: { type: { name: "Object" } },
-        modelProperties: Object.assign(Object.assign({}, MonitorDomain.type.modelProperties), { id: {
-                constraints: {
-                    MaxLength: 512
-                },
-                serializedName: "id",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, name: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "name",
-                type: {
-                    name: "String"
-                }
-            }, duration: {
-                serializedName: "duration",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, success: {
-                defaultValue: true,
-                serializedName: "success",
-                required: true,
-                type: {
-                    name: "Boolean"
-                }
-            }, responseCode: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "responseCode",
-                required: true,
-                type: {
-                    name: "String"
-                }
-            }, source: {
-                constraints: {
-                    MaxLength: 1024
-                },
-                serializedName: "source",
-                type: {
-                    name: "String"
-                }
-            }, url: {
-                constraints: {
-                    MaxLength: 2048
-                },
-                serializedName: "url",
-                type: {
-                    name: "String"
-                }
-            }, properties: {
-                serializedName: "properties",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "String" }, constraints: { MaxLength: 8192 } }
-                }
-            }, measurements: {
-                serializedName: "measurements",
-                type: {
-                    name: "Dictionary",
-                    value: { type: { name: "Number" } }
-                }
-            } })
-    }
-};
-
-var Mappers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    TelemetryItem: TelemetryItem,
-    MonitorBase: MonitorBase,
-    MonitorDomain: MonitorDomain,
-    TrackResponse: TrackResponse,
-    TelemetryErrorDetails: TelemetryErrorDetails,
-    MetricDataPoint: MetricDataPoint,
-    TelemetryExceptionDetails: TelemetryExceptionDetails,
-    StackFrame: StackFrame,
-    AvailabilityData: AvailabilityData,
-    TelemetryEventData: TelemetryEventData,
-    TelemetryExceptionData: TelemetryExceptionData,
-    MessageData: MessageData,
-    MetricsData: MetricsData,
-    PageViewData: PageViewData,
-    PageViewPerfData: PageViewPerfData,
-    RemoteDependencyData: RemoteDependencyData,
-    RequestData: RequestData
-});
-
-/*
- * 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.
- */
-const packageName = "@azure/monitor-opentelemetry-exporter";
-const packageVersion = "1.0.0-beta.2";
-class ApplicationInsightsClientContext extends coreHttp.ServiceClient {
-    /**
-     * Initializes a new instance of the ApplicationInsightsClientContext class.
-     * @param options The parameter options
-     */
-    constructor(options) {
-        // Initializing default values for options
-        if (!options) {
-            options = {};
-        }
-        if (!options.userAgent) {
-            const defaultUserAgent = coreHttp.getDefaultUserAgentValue();
-            options.userAgent = `${packageName}/${packageVersion} ${defaultUserAgent}`;
-        }
-        super(undefined, options);
-        this.requestContentType = "application/json; charset=utf-8";
-        this.baseUri = options.endpoint || "{Host}/v2";
-        // 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.
-     * @param options The options parameters.
-     */
-    track(body, options) {
-        const operationOptions = coreHttp.operationOptionsToRequestOptionsBase(options || {});
-        return this.sendOperationRequest({ body, options: operationOptions }, trackOperationSpec);
-    }
-}
-// Operation Specifications
-const serializer = new coreHttp.Serializer(Mappers, /* isXml */ false);
-const trackOperationSpec = {
-    path: "/track",
-    httpMethod: "POST",
-    responses: {
-        200: {
-            bodyMapper: TrackResponse
-        },
-        206: {
-            bodyMapper: TrackResponse
-        },
-        400: {
-            bodyMapper: TrackResponse
-        },
-        402: {
-            bodyMapper: TrackResponse
-        },
-        429: {
-            bodyMapper: TrackResponse
-        },
-        500: {
-            bodyMapper: TrackResponse
-        },
-        503: {
-            bodyMapper: TrackResponse
-        }
-    },
-    requestBody: body,
-    urlParameters: [host],
-    headerParameters: [contentType, accept],
-    mediaType: "json",
-    serializer
-};
-
-// Copyright (c) Microsoft Corporation.
-class HttpSender {
-    constructor(_exporterOptions) {
-        this._exporterOptions = _exporterOptions;
-        this._logger = this._exporterOptions.logger || new core.ConsoleLogger(core.LogLevel.ERROR);
-        // Build endpoint using provided configuration or default values
-        this._appInsightsClientOptions = {
-            host: this._exporterOptions.endpointUrl
-        };
-        this._appInsightsClient = new ApplicationInsightsClient(Object.assign({}, this._appInsightsClientOptions));
-    }
-    send(envelopes) {
-        var _a;
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const { _response: res } = yield this._appInsightsClient.track(envelopes);
-                return { statusCode: res.status, result: (_a = res.bodyAsText) !== null && _a !== void 0 ? _a : "" };
-            }
-            catch (e) {
-                throw e;
-            }
-        });
-    }
-    shutdown() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            this._logger.info("HttpSender shutting down");
-        });
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-let instance = null;
-class Context {
-    constructor(_logger = new core.ConsoleLogger(core.LogLevel.WARN), 
-    /**
-     * Path to this module's `package.json` relative to
-     * `Context.ROOT_PATH`
-     */
-    _exporterPrefix = "./", 
-    /**
-     * Path to end user application folder which contains `package.json`
-     * relative to `Context.ROOT_PATH`
-     */
-    _appPrefix = "../../../") {
-        this._logger = _logger;
-        this._exporterPrefix = _exporterPrefix;
-        this._appPrefix = _appPrefix;
-        this.tags = {};
-        this._loadApplicationContext();
-        this._loadDeviceContext();
-        this._loadInternalContext();
-    }
-    _loadApplicationContext() {
-        if (Object.keys(Context.appVersion).length === 0) {
-            // note: this should return the host package.json
-            let packageJson = null;
-            const packageJsonPath = path.resolve(__dirname, Context.JS_NODE_PREFIX, this._appPrefix, Context.ROOT_PATH, "./package.json");
-            const packageJsonPathTsNode = path.resolve(__dirname, this._appPrefix, Context.ROOT_PATH, "./package.json");
-            Context.appVersion[packageJsonPath] = "unknown";
-            try {
-                packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-            }
-            catch (_) {
-                try {
-                    packageJson = JSON.parse(fs.readFileSync(packageJsonPathTsNode, "utf8"));
-                }
-                catch (exception) {
-                    this._logger.warn("Failed to load Application version", exception);
-                }
-            }
-            if (packageJson && typeof packageJson.version === "string") {
-                Context.appVersion[packageJsonPath] = packageJson.version;
-            }
-            this.tags["ai.application.ver"] = Context.appVersion[packageJsonPath];
-        }
-    }
-    _loadDeviceContext() {
-        this.tags["ai.device.id"] = "";
-        this.tags["ai.device.osVersion"] = os && `${os.type()} ${os.release()}`;
-        // not yet supported tags
-        this.tags["ai.device.osArchitecture"] = os && os.arch();
-        this.tags["ai.device.osPlatform"] = os && os.platform();
-    }
-    _loadInternalContext() {
-        if (!Context.sdkVersion) {
-            let packageJson = null;
-            const { node } = process.versions;
-            [Context.nodeVersion] = node.split(".");
-            // note: this should return the sdk package.json
-            const packageJsonPath = path.resolve(__dirname, Context.JS_NODE_PREFIX, this._exporterPrefix, Context.ROOT_PATH, "./package.json");
-            const packageJsonPathTsNode = path.resolve(__dirname, this._exporterPrefix, Context.ROOT_PATH, "./package.json");
-            Context.sdkVersion = "unknown";
-            try {
-                packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-            }
-            catch (_) {
-                try {
-                    packageJson = JSON.parse(fs.readFileSync(packageJsonPathTsNode, "utf8"));
-                }
-                catch (exception) {
-                    this._logger.warn("Failed to load Exporter version", exception);
-                    throw exception;
-                }
-            }
-            if (packageJson && typeof packageJson.version === "string") {
-                Context.sdkVersion = packageJson.version;
-            }
-        }
-        this.tags["ai.internal.sdkVersion"] = `node${Context.nodeVersion}:ot${core.SDK_INFO.VERSION}:ext${Context.sdkVersion}`;
-    }
-}
-Context.appVersion = {};
-Context.sdkVersion = null;
-Context.opentelemetryVersion = null;
-Context.nodeVersion = "";
-/**
- * Add extra ../ to access on environments not using ts-node
- */
-Context.JS_NODE_PREFIX = "../";
-/**
- * Path to azure-opentelemetry-exporter
- */
-Context.ROOT_PATH = "../../../../";
-function getInstance(logger, exporterPrefix, appPrefix) {
-    if (!instance) {
-        instance = new Context(logger, exporterPrefix, appPrefix);
-    }
-    return instance;
-}
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-function isRetriable(statusCode) {
-    return (statusCode === 206 || // Retriable
-        statusCode === 408 || // Timeout
-        statusCode === 429 || // Throttle
-        statusCode === 439 || // Quota
-        statusCode === 500 || // Server Error
-        statusCode === 503 // Server Unavilable
-    );
-}
-function msToTimeSpan(ms) {
-    let totalms = ms;
-    if (Number.isNaN(totalms) || totalms < 0 || !Number.isFinite(ms)) {
-        totalms = 0;
-    }
-    let sec = ((totalms / 1000) % 60).toFixed(7).replace(/0{0,4}$/, "");
-    let min = `${Math.floor(totalms / (1000 * 60)) % 60}`;
-    let hour = `${Math.floor(totalms / (1000 * 60 * 60)) % 24}`;
-    const days = Math.floor(totalms / (1000 * 60 * 60 * 24));
-    sec = sec.indexOf(".") < 2 ? `0${sec}` : sec;
-    min = min.length < 2 ? `0${min}` : min;
-    hour = hour.length < 2 ? `0${hour}` : hour;
-    const daysText = days > 0 ? `${days}.` : "";
-    return `${daysText + hour}:${min}:${sec}`;
-}
-
-// Copyright (c) Microsoft Corporation.
-const { HTTP_METHOD } = conventions.HttpAttribute;
-const { HTTP_URL } = conventions.HttpAttribute;
-const { HTTP_ROUTE } = conventions.HttpAttribute;
-const { HTTP_STATUS_CODE } = conventions.HttpAttribute;
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-const AI_CLOUD_ROLE = "ai.cloud.role";
-const AI_CLOUD_ROLE_INSTACE = "ai.cloud.roleInstance";
-const AI_OPERATION_ID = "ai.operation.id";
-const AI_OPERATION_PARENT_ID = "ai.operation.parentId";
-const AI_OPERATION_NAME = "ai.operation.name";
-const MS_LINKS = "_MS.links";
-const INPROC = "InProc";
-const ENQUEUED_TIME = "enqueuedTime";
-const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
-
-// Copyright (c) Microsoft Corporation.
-const { GRPC_METHOD } = conventions.RpcAttribute;
-const { GRPC_STATUS_CODE } = conventions.RpcAttribute;
-const { GRPC_ERROR_NAME } = conventions.RpcAttribute;
-const { GRPC_ERROR_MESSAGE } = conventions.RpcAttribute;
-
-// Copyright (c) Microsoft Corporation.
-const { DB_TYPE } = conventions.DatabaseAttribute;
-const { DB_INSTANCE } = conventions.DatabaseAttribute;
-const { DB_STATEMENT } = conventions.DatabaseAttribute;
-const PEER_ADDRESS = conventions.GeneralAttribute.NET_PEER_ADDRESS;
-const PEER_HOSTNAME = conventions.GeneralAttribute.NET_PEER_HOSTNAME;
-// Optionals
-const PEER_PORT = conventions.GeneralAttribute.NET_PEER_PORT;
-const PEER_IPV4 = conventions.GeneralAttribute.NET_PEER_IPV4;
-const PEER_IPV6 = conventions.GeneralAttribute.NET_PEER_IPV6;
-const PEER_SERVICE = conventions.GeneralAttribute.NET_PEER_SERVICE;
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-const AzNamespace = "az.namespace";
-const MicrosoftEventHub = "Microsoft.EventHub";
-const MessageBusDestination = "message_bus.destination";
-
-// Copyright (c) Microsoft Corporation.
-/**
- * Average span.links[].attributes.enqueuedTime
- */
-const getTimeSinceEnqueued = (span) => {
-    let countEnqueueDiffs = 0;
-    let sumEnqueueDiffs = 0;
-    const startTimeMs = core.hrTimeToMilliseconds(span.startTime);
-    span.links.forEach(({ attributes }) => {
-        const enqueuedTime = attributes === null || attributes === void 0 ? void 0 : attributes[ENQUEUED_TIME];
-        if (enqueuedTime) {
-            countEnqueueDiffs += 1;
-            sumEnqueueDiffs += startTimeMs - (parseFloat(enqueuedTime.toString()) || 0);
-        }
-    });
-    return Math.max(sumEnqueueDiffs / (countEnqueueDiffs || 1), 0);
-};
-/**
- * Implementation of Mapping to Azure Monitor
- *
- * https://gist.github.com/lmolkova/e4215c0f44a49ef824983382762e6b92#mapping-to-azure-monitor-application-insights-telemetry
- */
-const parseEventHubSpan = (span, baseData) => {
-    const namespace = span.attributes[AzNamespace];
-    const peerAddress = (span.attributes[conventions.GeneralAttribute.NET_PEER_ADDRESS] ||
-        span.attributes["peer.address"] ||
-        "unknown").replace(/\/$/g, ""); // remove trailing "/"
-    const messageBusDestination = (span.attributes[MessageBusDestination] || "unknown");
-    switch (span.kind) {
-        case api.SpanKind.CLIENT:
-            baseData.type = namespace;
-            baseData.target = `${peerAddress}/${messageBusDestination}`;
-            break;
-        case api.SpanKind.PRODUCER:
-            baseData.type = `Queue Message | ${namespace}`;
-            baseData.target = `${peerAddress}/${messageBusDestination}`;
-            break;
-        case api.SpanKind.CONSUMER:
-            baseData.type = `Queue Message | ${namespace}`;
-            baseData.source = `${peerAddress}/${messageBusDestination}`;
-            baseData.measurements = Object.assign(Object.assign({}, baseData.measurements), { [TIME_SINCE_ENQUEUED]: getTimeSinceEnqueued(span) });
-            break;
-    }
-};
-
-// Copyright (c) Microsoft Corporation.
-function createTagsFromSpan(span) {
-    const context = getInstance();
-    const tags = Object.assign({}, context.tags);
-    tags[AI_OPERATION_ID] = span.spanContext.traceId;
-    if (span.parentSpanId) {
-        tags[AI_OPERATION_PARENT_ID] = span.parentSpanId;
-    }
-    if (span.resource && span.resource.attributes) {
-        const serviceName = span.resource.attributes[resources.SERVICE_RESOURCE.NAME];
-        const serviceNamespace = span.resource.attributes[resources.SERVICE_RESOURCE.NAMESPACE];
-        const serviceInstanceId = span.resource.attributes[resources.SERVICE_RESOURCE.INSTANCE_ID];
-        if (serviceName) {
-            if (serviceNamespace) {
-                tags[AI_CLOUD_ROLE] = `${serviceNamespace}.${serviceName}`;
-            }
-            else {
-                tags[AI_CLOUD_ROLE] = String(serviceName);
-            }
-        }
-        if (serviceInstanceId) {
-            tags[AI_CLOUD_ROLE_INSTACE] = String(serviceInstanceId);
-        }
-    }
-    // @todo: is this for RequestData only?
-    if ((span.kind === api.SpanKind.SERVER || span.kind === api.SpanKind.CONSUMER) &&
-        span.attributes[GRPC_METHOD]) {
-        tags[AI_OPERATION_NAME] = String(span.attributes[GRPC_METHOD]);
-    }
-    if ((span.kind === api.SpanKind.SERVER || span.kind === api.SpanKind.CONSUMER) &&
-        span.attributes[HTTP_METHOD] &&
-        span.attributes[HTTP_ROUTE]) {
-        tags[AI_OPERATION_NAME] = `${span.attributes[HTTP_METHOD]} ${span.attributes[HTTP_ROUTE]}`;
-    }
-    return tags;
-}
-function createPropertiesFromSpan(span) {
-    const properties = {};
-    const measurements = {};
-    for (const key of Object.keys(span.attributes)) {
-        if (key === GRPC_ERROR_MESSAGE ||
-            key === GRPC_ERROR_NAME ||
-            !(key.startsWith("http.") || key.startsWith("grpc.") || key.startsWith("db."))) {
-            properties[key] = span.attributes[key];
-        }
-    }
-    const links = span.links.map((link) => ({
-        operation_Id: link.context.traceId,
-        id: link.context.spanId
-    }));
-    if (links.length > 0) {
-        properties[MS_LINKS] = JSON.stringify(links);
-    }
-    return [properties, measurements];
-}
-function createDependencyData(span) {
-    const data = {
-        name: span.name,
-        id: `|${span.spanContext.traceId}.${span.spanContext.spanId}.`,
-        success: span.status.code === api.StatusCode.OK,
-        resultCode: String(span.status.code),
-        target: span.attributes[HTTP_URL],
-        type: "Dependency",
-        duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
-        version: 1
-    };
-    if (span.attributes[HTTP_STATUS_CODE]) {
-        data.type = "HTTP";
-        data.resultCode = String(span.attributes[HTTP_STATUS_CODE]);
-    }
-    if (span.attributes[GRPC_STATUS_CODE] !== undefined) {
-        data.type = "GRPC";
-        data.resultCode = String(span.attributes[GRPC_STATUS_CODE]);
-    }
-    if (span.attributes[GRPC_METHOD]) {
-        data.target = String(span.attributes[GRPC_METHOD]);
-        data.data = String(span.attributes[GRPC_METHOD]);
-    }
-    if (span.attributes[HTTP_URL]) {
-        const url$1 = new url.URL(span.attributes[HTTP_URL]);
-        data.target = url$1.hostname;
-        data.data = url$1.href;
-        if (span.attributes[HTTP_METHOD]) {
-            data.name = `${span.attributes[HTTP_METHOD]} ${url$1.pathname}`;
-        }
-    }
-    if (span.attributes[DB_STATEMENT]) {
-        data.name = String(span.attributes[DB_STATEMENT]);
-        data.data = String(span.attributes[DB_STATEMENT]);
-        if (span.attributes[DB_TYPE]) {
-            data.type = String(span.attributes[DB_TYPE]);
-        }
-        else {
-            data.type = "DB";
-        }
-        if (span.attributes[DB_INSTANCE]) {
-            data.target = String(span.attributes[DB_INSTANCE]);
-        }
-    }
-    return data;
-}
-function createRequestData(span) {
-    const data = {
-        name: span.name,
-        id: `|${span.spanContext.traceId}.${span.spanContext.spanId}.`,
-        success: span.status.code === api.StatusCode.OK,
-        responseCode: String(span.status.code),
-        duration: msToTimeSpan(core.hrTimeToMilliseconds(span.duration)),
-        version: 1,
-        source: undefined
-    };
-    if (span.attributes[HTTP_METHOD]) {
-        data.name = span.attributes[HTTP_METHOD];
-        if (span.attributes[HTTP_STATUS_CODE]) {
-            data.responseCode = String(span.attributes[HTTP_STATUS_CODE]);
-        }
-        if (span.attributes[HTTP_URL]) {
-            data.url = span.attributes[HTTP_URL];
-        }
-        if (span.attributes[HTTP_ROUTE]) {
-            data.name = `${span.attributes[HTTP_METHOD]} ${span.attributes[HTTP_ROUTE]}`;
-        }
-        else if (span.attributes[HTTP_URL]) {
-            const url$1 = new url.URL(span.attributes[HTTP_URL]);
-            data.name = `${span.attributes[HTTP_METHOD]} ${url$1.pathname}`;
-        }
-    }
-    if (span.attributes[GRPC_STATUS_CODE]) {
-        data.responseCode = String(span.attributes[GRPC_STATUS_CODE]);
-    }
-    if (span.attributes[GRPC_METHOD]) {
-        data.url = String(span.attributes[GRPC_METHOD]);
-    }
-    return data;
-}
-function createInProcData(span) {
-    const data = createDependencyData(span);
-    data.type = INPROC;
-    data.success = true;
-    return data;
-}
-function readableSpanToEnvelope(span, ikey, logger) {
-    let name;
-    let baseType;
-    const sampleRate = 100;
-    let baseData;
-    const time = new Date(core.hrTimeToMilliseconds(span.startTime));
-    const instrumentationKey = ikey;
-    const tags = createTagsFromSpan(span);
-    const [properties, measurements] = createPropertiesFromSpan(span);
-    switch (span.kind) {
-        case api.SpanKind.CLIENT:
-        case api.SpanKind.PRODUCER:
-            name = "Microsoft.ApplicationInsights.RemoteDependency";
-            baseType = "RemoteDependencyData";
-            baseData = createDependencyData(span);
-            break;
-        case api.SpanKind.SERVER:
-        case api.SpanKind.CONSUMER:
-            name = "Microsoft.ApplicationInsights.Request";
-            baseType = "RequestData";
-            baseData = createRequestData(span);
-            break;
-        case api.SpanKind.INTERNAL:
-            baseType = "RemoteDependencyData";
-            name = "Microsoft.ApplicationInsights.RemoteDependency";
-            baseData = createInProcData(span);
-            break;
-        default:
-            // never
-            if (logger) {
-                logger.error(`Unsupported span kind ${span.kind}`);
-            }
-            throw new Error(`Unsupported span kind ${span.kind}`);
-    }
-    if (span.attributes[AzNamespace] === MicrosoftEventHub) {
-        parseEventHubSpan(span, baseData);
-    }
-    else if (span.attributes[AzNamespace]) {
-        switch (span.kind) {
-            case api.SpanKind.INTERNAL:
-                baseData.type = `${INPROC} | ${span.attributes[AzNamespace]}`;
-                break;
-        }
-    }
-    return {
-        name,
-        sampleRate,
-        time,
-        instrumentationKey,
-        tags,
-        version: 1,
-        data: {
-            baseType,
-            baseData: Object.assign(Object.assign({}, baseData), { properties,
-                measurements })
-        }
-    };
-}
-
-// Copyright (c) Microsoft Corporation.
-class AzureMonitorTraceExporter {
-    constructor(options = {}) {
-        var _a, _b, _c, _d;
-        const connectionString = options.connectionString || process.env[ENV_CONNECTION_STRING];
-        this._logger = new core.ConsoleLogger(core.LogLevel.ERROR);
-        this._options = Object.assign({}, DEFAULT_EXPORTER_CONFIG);
-        this._options.serviceApiVersion = (_a = options.serviceApiVersion) !== null && _a !== void 0 ? _a : this._options.serviceApiVersion;
-        if (connectionString) {
-            const parsedConnectionString = ConnectionStringParser.parse(connectionString, this._logger);
-            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";
-            this._logger.error(message);
-            throw new Error(message);
-        }
-        this._sender = new HttpSender(this._options);
-        this._persister = new FileSystemPersist(this._options);
-        this._retryTimer = null;
-        this._logger.debug("AzureMonitorTraceExporter was successfully setup");
-    }
-    _persist(envelopes) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const success = yield 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 };
-            }
-        });
-    }
-    exportEnvelopes(envelopes) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            this._logger.info(`Exporting ${envelopes.length} envelope(s)`);
-            try {
-                const { result, statusCode } = yield this._sender.send(envelopes);
-                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) {
-                        this._logger.info(result);
-                        const breezeResponse = JSON.parse(result);
-                        const filteredEnvelopes = breezeResponse.errors.reduce((acc, v) => [...acc, envelopes[v.index]], []);
-                        // calls resultCallback(ExportResult) based on result of persister.push
-                        return yield this._persist(filteredEnvelopes);
-                    }
-                    else {
-                        // calls resultCallback(ExportResult) based on result of persister.push
-                        return yield this._persist(envelopes);
-                    }
-                }
-                else {
-                    // Failed -- not retriable
-                    return {
-                        code: core.ExportResultCode.FAILED
-                    };
-                }
-            }
-            catch (senderErr) {
-                if (this._isNetworkError(senderErr)) {
-                    this._logger.error("Retrying due to transient client side error. Error message:", senderErr.message);
-                    return yield this._persist(envelopes);
-                }
-                else {
-                    this._logger.error("Envelopes could not be exported and are not retriable. Error message:", senderErr.message);
-                    return { code: core.ExportResultCode.FAILED, error: senderErr };
-                }
-            }
-        });
-    }
-    export(spans, resultCallback) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            this._logger.info(`Exporting ${spans.length} span(s). Converting to envelopes...`);
-            const envelopes = spans.map((span) => readableSpanToEnvelope(span, this._options.instrumentationKey, this._logger));
-            resultCallback(yield this.exportEnvelopes(envelopes));
-        });
-    }
-    shutdown() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            this._logger.info("Azure Monitor Trace Exporter shutting down");
-            return this._sender.shutdown();
-        });
-    }
-    _sendFirstPersistedFile() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const envelopes = (yield this._persister.shift());
-                if (envelopes) {
-                    yield this._sender.send(envelopes);
-                }
-            }
-            catch (err) {
-                this._logger.warn(`Failed to fetch persisted file`, err);
-            }
-        });
-    }
-    _isNetworkError(error) {
-        if (error instanceof coreHttp.RestError) {
-            if (error && error.code && error.code === "REQUEST_SEND_ERROR") {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-exports.AzureMonitorTraceExporter = AzureMonitorTraceExporter;
-//# sourceMappingURL=index.js.map