{"version":3,"file":"static/chunks/645.8937cd053345bcf1.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context/context.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/platform/browser/globalThis.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/version.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/internal/semver.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/internal/global-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/types.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/diag.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/context.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/metrics.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/propagation.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/context-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/trace.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/index.js","webpack://_N_E/<anon>"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/** Get a key to uniquely identify a context value */\nexport function createContextKey(description) {\n    // The specification states that for the same input, multiple calls should\n    // return different keys. Due to the nature of the JS dependency management\n    // system, this creates problems where multiple versions of some package\n    // could hold different keys for the same property.\n    //\n    // Therefore, we use Symbol.for which returns the same key for the same input.\n    return Symbol.for(description);\n}\nvar BaseContext = /** @class */ (function () {\n    /**\n     * Construct a new context which inherits values from an optional parent context.\n     *\n     * @param parentContext a context from which to inherit values\n     */\n    function BaseContext(parentContext) {\n        // for minification\n        var self = this;\n        self._currentContext = parentContext ? new Map(parentContext) : new Map();\n        self.getValue = function (key) { return self._currentContext.get(key); };\n        self.setValue = function (key, value) {\n            var context = new BaseContext(self._currentContext);\n            context._currentContext.set(key, value);\n            return context;\n        };\n        self.deleteValue = function (key) {\n            var context = new BaseContext(self._currentContext);\n            context._currentContext.delete(key);\n            return context;\n        };\n    }\n    return BaseContext;\n}());\n/** The root context is used as the default parent context when there is no active context */\nexport var ROOT_CONTEXT = new BaseContext();\n//# sourceMappingURL=context.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { ROOT_CONTEXT } from './context';\nvar NoopContextManager = /** @class */ (function () {\n    function NoopContextManager() {\n    }\n    NoopContextManager.prototype.active = function () {\n        return ROOT_CONTEXT;\n    };\n    NoopContextManager.prototype.with = function (_context, fn, thisArg) {\n        var args = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            args[_i - 3] = arguments[_i];\n        }\n        return fn.call.apply(fn, __spreadArray([thisArg], __read(args), false));\n    };\n    NoopContextManager.prototype.bind = function (_context, target) {\n        return target;\n    };\n    NoopContextManager.prototype.enable = function () {\n        return this;\n    };\n    NoopContextManager.prototype.disable = function () {\n        return this;\n    };\n    return NoopContextManager;\n}());\nexport { NoopContextManager };\n//# sourceMappingURL=NoopContextManager.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Updates to this file should also be replicated to @opentelemetry/core too.\n/**\n * - globalThis (New standard)\n * - self (Will return the current window instance for supported browsers)\n * - window (fallback for older browser implementations)\n * - global (NodeJS implementation)\n * - <object> (When all else fails)\n */\n/** only globals that common to node and browsers are allowed */\n// eslint-disable-next-line node/no-unsupported-features/es-builtins, no-undef\nexport var _globalThis = typeof globalThis === 'object'\n    ? globalThis\n    : typeof self === 'object'\n        ? self\n        : typeof window === 'object'\n            ? window\n            : typeof global === 'object'\n                ? global\n                : {};\n//# sourceMappingURL=globalThis.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// this is autogenerated file, see scripts/version-update.js\nexport var VERSION = '1.4.1';\n//# sourceMappingURL=version.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { VERSION } from '../version';\nvar re = /^(\\d+)\\.(\\d+)\\.(\\d+)(-(.+))?$/;\n/**\n * Create a function to test an API version to see if it is compatible with the provided ownVersion.\n *\n * The returned function has the following semantics:\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param ownVersion version which should be checked against\n */\nexport function _makeCompatibilityCheck(ownVersion) {\n    var acceptedVersions = new Set([ownVersion]);\n    var rejectedVersions = new Set();\n    var myVersionMatch = ownVersion.match(re);\n    if (!myVersionMatch) {\n        // we cannot guarantee compatibility so we always return noop\n        return function () { return false; };\n    }\n    var ownVersionParsed = {\n        major: +myVersionMatch[1],\n        minor: +myVersionMatch[2],\n        patch: +myVersionMatch[3],\n        prerelease: myVersionMatch[4],\n    };\n    // if ownVersion has a prerelease tag, versions must match exactly\n    if (ownVersionParsed.prerelease != null) {\n        return function isExactmatch(globalVersion) {\n            return globalVersion === ownVersion;\n        };\n    }\n    function _reject(v) {\n        rejectedVersions.add(v);\n        return false;\n    }\n    function _accept(v) {\n        acceptedVersions.add(v);\n        return true;\n    }\n    return function isCompatible(globalVersion) {\n        if (acceptedVersions.has(globalVersion)) {\n            return true;\n        }\n        if (rejectedVersions.has(globalVersion)) {\n            return false;\n        }\n        var globalVersionMatch = globalVersion.match(re);\n        if (!globalVersionMatch) {\n            // cannot parse other version\n            // we cannot guarantee compatibility so we always noop\n            return _reject(globalVersion);\n        }\n        var globalVersionParsed = {\n            major: +globalVersionMatch[1],\n            minor: +globalVersionMatch[2],\n            patch: +globalVersionMatch[3],\n            prerelease: globalVersionMatch[4],\n        };\n        // if globalVersion has a prerelease tag, versions must match exactly\n        if (globalVersionParsed.prerelease != null) {\n            return _reject(globalVersion);\n        }\n        // major versions must match\n        if (ownVersionParsed.major !== globalVersionParsed.major) {\n            return _reject(globalVersion);\n        }\n        if (ownVersionParsed.major === 0) {\n            if (ownVersionParsed.minor === globalVersionParsed.minor &&\n                ownVersionParsed.patch <= globalVersionParsed.patch) {\n                return _accept(globalVersion);\n            }\n            return _reject(globalVersion);\n        }\n        if (ownVersionParsed.minor <= globalVersionParsed.minor) {\n            return _accept(globalVersion);\n        }\n        return _reject(globalVersion);\n    };\n}\n/**\n * Test an API version to see if it is compatible with this API.\n *\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param version version of the API requesting an instance of the global API\n */\nexport var isCompatible = _makeCompatibilityCheck(VERSION);\n//# sourceMappingURL=semver.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { _globalThis } from '../platform';\nimport { VERSION } from '../version';\nimport { isCompatible } from './semver';\nvar major = VERSION.split('.')[0];\nvar GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(\"opentelemetry.js.api.\" + major);\nvar _global = _globalThis;\nexport function registerGlobal(type, instance, diag, allowOverride) {\n    var _a;\n    if (allowOverride === void 0) { allowOverride = false; }\n    var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {\n        version: VERSION,\n    });\n    if (!allowOverride && api[type]) {\n        // already registered an API of this type\n        var err = new Error(\"@opentelemetry/api: Attempted duplicate registration of API: \" + type);\n        diag.error(err.stack || err.message);\n        return false;\n    }\n    if (api.version !== VERSION) {\n        // All registered APIs must be of the same version exactly\n        var err = new Error(\"@opentelemetry/api: Registration of version v\" + api.version + \" for \" + type + \" does not match previously registered API v\" + VERSION);\n        diag.error(err.stack || err.message);\n        return false;\n    }\n    api[type] = instance;\n    diag.debug(\"@opentelemetry/api: Registered a global for \" + type + \" v\" + VERSION + \".\");\n    return true;\n}\nexport function getGlobal(type) {\n    var _a, _b;\n    var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;\n    if (!globalVersion || !isCompatible(globalVersion)) {\n        return;\n    }\n    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];\n}\nexport function unregisterGlobal(type, diag) {\n    diag.debug(\"@opentelemetry/api: Unregistering a global for \" + type + \" v\" + VERSION + \".\");\n    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];\n    if (api) {\n        delete api[type];\n    }\n}\n//# sourceMappingURL=global-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { getGlobal } from '../internal/global-utils';\n/**\n * Component Logger which is meant to be used as part of any component which\n * will add automatically additional namespace in front of the log message.\n * It will then forward all message to global diag logger\n * @example\n * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });\n * cLogger.debug('test');\n * // @opentelemetry/instrumentation-http test\n */\nvar DiagComponentLogger = /** @class */ (function () {\n    function DiagComponentLogger(props) {\n        this._namespace = props.namespace || 'DiagComponentLogger';\n    }\n    DiagComponentLogger.prototype.debug = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('debug', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('error', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.info = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('info', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('warn', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.verbose = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('verbose', this._namespace, args);\n    };\n    return DiagComponentLogger;\n}());\nexport { DiagComponentLogger };\nfunction logProxy(funcName, namespace, args) {\n    var logger = getGlobal('diag');\n    // shortcut if logger not set\n    if (!logger) {\n        return;\n    }\n    args.unshift(namespace);\n    return logger[funcName].apply(logger, __spreadArray([], __read(args), false));\n}\n//# sourceMappingURL=ComponentLogger.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Defines the available internal logging levels for the diagnostic logger, the numeric values\n * of the levels are defined to match the original values from the initial LogLevel to avoid\n * compatibility/migration issues for any implementation that assume the numeric ordering.\n */\nexport var DiagLogLevel;\n(function (DiagLogLevel) {\n    /** Diagnostic Logging level setting to disable all logging (except and forced logs) */\n    DiagLogLevel[DiagLogLevel[\"NONE\"] = 0] = \"NONE\";\n    /** Identifies an error scenario */\n    DiagLogLevel[DiagLogLevel[\"ERROR\"] = 30] = \"ERROR\";\n    /** Identifies a warning scenario */\n    DiagLogLevel[DiagLogLevel[\"WARN\"] = 50] = \"WARN\";\n    /** General informational log message */\n    DiagLogLevel[DiagLogLevel[\"INFO\"] = 60] = \"INFO\";\n    /** General debug log message */\n    DiagLogLevel[DiagLogLevel[\"DEBUG\"] = 70] = \"DEBUG\";\n    /**\n     * Detailed trace level logging should only be used for development, should only be set\n     * in a development environment.\n     */\n    DiagLogLevel[DiagLogLevel[\"VERBOSE\"] = 80] = \"VERBOSE\";\n    /** Used to set the logging level to include all logging */\n    DiagLogLevel[DiagLogLevel[\"ALL\"] = 9999] = \"ALL\";\n})(DiagLogLevel || (DiagLogLevel = {}));\n//# sourceMappingURL=types.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DiagLogLevel } from '../types';\nexport function createLogLevelDiagLogger(maxLevel, logger) {\n    if (maxLevel < DiagLogLevel.NONE) {\n        maxLevel = DiagLogLevel.NONE;\n    }\n    else if (maxLevel > DiagLogLevel.ALL) {\n        maxLevel = DiagLogLevel.ALL;\n    }\n    // In case the logger is null or undefined\n    logger = logger || {};\n    function _filterFunc(funcName, theLevel) {\n        var theFunc = logger[funcName];\n        if (typeof theFunc === 'function' && maxLevel >= theLevel) {\n            return theFunc.bind(logger);\n        }\n        return function () { };\n    }\n    return {\n        error: _filterFunc('error', DiagLogLevel.ERROR),\n        warn: _filterFunc('warn', DiagLogLevel.WARN),\n        info: _filterFunc('info', DiagLogLevel.INFO),\n        debug: _filterFunc('debug', DiagLogLevel.DEBUG),\n        verbose: _filterFunc('verbose', DiagLogLevel.VERBOSE),\n    };\n}\n//# sourceMappingURL=logLevelLogger.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { DiagComponentLogger } from '../diag/ComponentLogger';\nimport { createLogLevelDiagLogger } from '../diag/internal/logLevelLogger';\nimport { DiagLogLevel, } from '../diag/types';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nvar API_NAME = 'diag';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry internal\n * diagnostic API\n */\nvar DiagAPI = /** @class */ (function () {\n    /**\n     * Private internal constructor\n     * @private\n     */\n    function DiagAPI() {\n        function _logProxy(funcName) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                var logger = getGlobal('diag');\n                // shortcut if logger not set\n                if (!logger)\n                    return;\n                return logger[funcName].apply(logger, __spreadArray([], __read(args), false));\n            };\n        }\n        // Using self local variable for minification purposes as 'this' cannot be minified\n        var self = this;\n        // DiagAPI specific functions\n        var setLogger = function (logger, optionsOrLogLevel) {\n            var _a, _b, _c;\n            if (optionsOrLogLevel === void 0) { optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }; }\n            if (logger === self) {\n                // There isn't much we can do here.\n                // Logging to the console might break the user application.\n                // Try to log to self. If a logger was previously registered it will receive the log.\n                var err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');\n                self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);\n                return false;\n            }\n            if (typeof optionsOrLogLevel === 'number') {\n                optionsOrLogLevel = {\n                    logLevel: optionsOrLogLevel,\n                };\n            }\n            var oldLogger = getGlobal('diag');\n            var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);\n            // There already is an logger registered. We'll let it know before overwriting it.\n            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {\n                var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : '<failed to generate stacktrace>';\n                oldLogger.warn(\"Current logger will be overwritten from \" + stack);\n                newLogger.warn(\"Current logger will overwrite one already registered from \" + stack);\n            }\n            return registerGlobal('diag', newLogger, self, true);\n        };\n        self.setLogger = setLogger;\n        self.disable = function () {\n            unregisterGlobal(API_NAME, self);\n        };\n        self.createComponentLogger = function (options) {\n            return new DiagComponentLogger(options);\n        };\n        self.verbose = _logProxy('verbose');\n        self.debug = _logProxy('debug');\n        self.info = _logProxy('info');\n        self.warn = _logProxy('warn');\n        self.error = _logProxy('error');\n    }\n    /** Get the singleton instance of the DiagAPI API */\n    DiagAPI.instance = function () {\n        if (!this._instance) {\n            this._instance = new DiagAPI();\n        }\n        return this._instance;\n    };\n    return DiagAPI;\n}());\nexport { DiagAPI };\n//# sourceMappingURL=diag.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { NoopContextManager } from '../context/NoopContextManager';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'context';\nvar NOOP_CONTEXT_MANAGER = new NoopContextManager();\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Context API\n */\nvar ContextAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function ContextAPI() {\n    }\n    /** Get the singleton instance of the Context API */\n    ContextAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new ContextAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current context manager.\n     *\n     * @returns true if the context manager was successfully registered, else false\n     */\n    ContextAPI.prototype.setGlobalContextManager = function (contextManager) {\n        return registerGlobal(API_NAME, contextManager, DiagAPI.instance());\n    };\n    /**\n     * Get the currently active context\n     */\n    ContextAPI.prototype.active = function () {\n        return this._getContextManager().active();\n    };\n    /**\n     * Execute a function with an active context\n     *\n     * @param context context to be active during function execution\n     * @param fn function to execute in a context\n     * @param thisArg optional receiver to be used for calling fn\n     * @param args optional arguments forwarded to fn\n     */\n    ContextAPI.prototype.with = function (context, fn, thisArg) {\n        var _a;\n        var args = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            args[_i - 3] = arguments[_i];\n        }\n        return (_a = this._getContextManager()).with.apply(_a, __spreadArray([context, fn, thisArg], __read(args), false));\n    };\n    /**\n     * Bind a context to a target function or event emitter\n     *\n     * @param context context to bind to the event emitter or function. Defaults to the currently active context\n     * @param target function or event emitter to bind\n     */\n    ContextAPI.prototype.bind = function (context, target) {\n        return this._getContextManager().bind(context, target);\n    };\n    ContextAPI.prototype._getContextManager = function () {\n        return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;\n    };\n    /** Disable and remove the global context manager */\n    ContextAPI.prototype.disable = function () {\n        this._getContextManager().disable();\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    return ContextAPI;\n}());\nexport { ContextAPI };\n//# sourceMappingURL=context.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { ContextAPI } from './api/context';\n/** Entrypoint for context API */\nexport var context = ContextAPI.getInstance();\n//# sourceMappingURL=context-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { DiagAPI } from './api/diag';\n/**\n * Entrypoint for Diag API.\n * Defines Diagnostic handler used for internal diagnostic logging operations.\n * The default provides a Noop DiagLogger implementation which may be changed via the\n * diag.setLogger(logger: DiagLogger) function.\n */\nexport var diag = DiagAPI.instance();\n//# sourceMappingURL=diag-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses\n * constant NoopMetrics for all of its methods.\n */\nvar NoopMeter = /** @class */ (function () {\n    function NoopMeter() {\n    }\n    /**\n     * @see {@link Meter.createHistogram}\n     */\n    NoopMeter.prototype.createHistogram = function (_name, _options) {\n        return NOOP_HISTOGRAM_METRIC;\n    };\n    /**\n     * @see {@link Meter.createCounter}\n     */\n    NoopMeter.prototype.createCounter = function (_name, _options) {\n        return NOOP_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createUpDownCounter}\n     */\n    NoopMeter.prototype.createUpDownCounter = function (_name, _options) {\n        return NOOP_UP_DOWN_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableGauge}\n     */\n    NoopMeter.prototype.createObservableGauge = function (_name, _options) {\n        return NOOP_OBSERVABLE_GAUGE_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableCounter}\n     */\n    NoopMeter.prototype.createObservableCounter = function (_name, _options) {\n        return NOOP_OBSERVABLE_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableUpDownCounter}\n     */\n    NoopMeter.prototype.createObservableUpDownCounter = function (_name, _options) {\n        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.addBatchObservableCallback}\n     */\n    NoopMeter.prototype.addBatchObservableCallback = function (_callback, _observables) { };\n    /**\n     * @see {@link Meter.removeBatchObservableCallback}\n     */\n    NoopMeter.prototype.removeBatchObservableCallback = function (_callback) { };\n    return NoopMeter;\n}());\nexport { NoopMeter };\nvar NoopMetric = /** @class */ (function () {\n    function NoopMetric() {\n    }\n    return NoopMetric;\n}());\nexport { NoopMetric };\nvar NoopCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopCounterMetric, _super);\n    function NoopCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopCounterMetric.prototype.add = function (_value, _attributes) { };\n    return NoopCounterMetric;\n}(NoopMetric));\nexport { NoopCounterMetric };\nvar NoopUpDownCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopUpDownCounterMetric, _super);\n    function NoopUpDownCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopUpDownCounterMetric.prototype.add = function (_value, _attributes) { };\n    return NoopUpDownCounterMetric;\n}(NoopMetric));\nexport { NoopUpDownCounterMetric };\nvar NoopHistogramMetric = /** @class */ (function (_super) {\n    __extends(NoopHistogramMetric, _super);\n    function NoopHistogramMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopHistogramMetric.prototype.record = function (_value, _attributes) { };\n    return NoopHistogramMetric;\n}(NoopMetric));\nexport { NoopHistogramMetric };\nvar NoopObservableMetric = /** @class */ (function () {\n    function NoopObservableMetric() {\n    }\n    NoopObservableMetric.prototype.addCallback = function (_callback) { };\n    NoopObservableMetric.prototype.removeCallback = function (_callback) { };\n    return NoopObservableMetric;\n}());\nexport { NoopObservableMetric };\nvar NoopObservableCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableCounterMetric, _super);\n    function NoopObservableCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableCounterMetric;\n}(NoopObservableMetric));\nexport { NoopObservableCounterMetric };\nvar NoopObservableGaugeMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableGaugeMetric, _super);\n    function NoopObservableGaugeMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableGaugeMetric;\n}(NoopObservableMetric));\nexport { NoopObservableGaugeMetric };\nvar NoopObservableUpDownCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableUpDownCounterMetric, _super);\n    function NoopObservableUpDownCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableUpDownCounterMetric;\n}(NoopObservableMetric));\nexport { NoopObservableUpDownCounterMetric };\nexport var NOOP_METER = new NoopMeter();\n// Synchronous instruments\nexport var NOOP_COUNTER_METRIC = new NoopCounterMetric();\nexport var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();\nexport var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();\n// Asynchronous instruments\nexport var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();\nexport var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();\nexport var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();\n/**\n * Create a no-op Meter\n */\nexport function createNoopMeter() {\n    return NOOP_METER;\n}\n//# sourceMappingURL=NoopMeter.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NOOP_METER } from './NoopMeter';\n/**\n * An implementation of the {@link MeterProvider} which returns an impotent Meter\n * for all calls to `getMeter`\n */\nvar NoopMeterProvider = /** @class */ (function () {\n    function NoopMeterProvider() {\n    }\n    NoopMeterProvider.prototype.getMeter = function (_name, _version, _options) {\n        return NOOP_METER;\n    };\n    return NoopMeterProvider;\n}());\nexport { NoopMeterProvider };\nexport var NOOP_METER_PROVIDER = new NoopMeterProvider();\n//# sourceMappingURL=NoopMeterProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NOOP_METER_PROVIDER } from '../metrics/NoopMeterProvider';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'metrics';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Metrics API\n */\nvar MetricsAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function MetricsAPI() {\n    }\n    /** Get the singleton instance of the Metrics API */\n    MetricsAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new MetricsAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current global meter provider.\n     * Returns true if the meter provider was successfully registered, else false.\n     */\n    MetricsAPI.prototype.setGlobalMeterProvider = function (provider) {\n        return registerGlobal(API_NAME, provider, DiagAPI.instance());\n    };\n    /**\n     * Returns the global meter provider.\n     */\n    MetricsAPI.prototype.getMeterProvider = function () {\n        return getGlobal(API_NAME) || NOOP_METER_PROVIDER;\n    };\n    /**\n     * Returns a meter from the global meter provider.\n     */\n    MetricsAPI.prototype.getMeter = function (name, version, options) {\n        return this.getMeterProvider().getMeter(name, version, options);\n    };\n    /** Remove the global meter provider */\n    MetricsAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    return MetricsAPI;\n}());\nexport { MetricsAPI };\n//# sourceMappingURL=metrics.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { MetricsAPI } from './api/metrics';\n/** Entrypoint for metrics API */\nexport var metrics = MetricsAPI.getInstance();\n//# sourceMappingURL=metrics-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * No-op implementations of {@link TextMapPropagator}.\n */\nvar NoopTextMapPropagator = /** @class */ (function () {\n    function NoopTextMapPropagator() {\n    }\n    /** Noop inject function does nothing */\n    NoopTextMapPropagator.prototype.inject = function (_context, _carrier) { };\n    /** Noop extract function does nothing and returns the input context */\n    NoopTextMapPropagator.prototype.extract = function (context, _carrier) {\n        return context;\n    };\n    NoopTextMapPropagator.prototype.fields = function () {\n        return [];\n    };\n    return NoopTextMapPropagator;\n}());\nexport { NoopTextMapPropagator };\n//# sourceMappingURL=NoopTextMapPropagator.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var defaultTextMapGetter = {\n    get: function (carrier, key) {\n        if (carrier == null) {\n            return undefined;\n        }\n        return carrier[key];\n    },\n    keys: function (carrier) {\n        if (carrier == null) {\n            return [];\n        }\n        return Object.keys(carrier);\n    },\n};\nexport var defaultTextMapSetter = {\n    set: function (carrier, key, value) {\n        if (carrier == null) {\n            return;\n        }\n        carrier[key] = value;\n    },\n};\n//# sourceMappingURL=TextMapPropagator.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ContextAPI } from '../api/context';\nimport { createContextKey } from '../context/context';\n/**\n * Baggage key\n */\nvar BAGGAGE_KEY = createContextKey('OpenTelemetry Baggage Key');\n/**\n * Retrieve the current baggage from the given context\n *\n * @param {Context} Context that manage all context values\n * @returns {Baggage} Extracted baggage from the context\n */\nexport function getBaggage(context) {\n    return context.getValue(BAGGAGE_KEY) || undefined;\n}\n/**\n * Retrieve the current baggage from the active/current context\n *\n * @returns {Baggage} Extracted baggage from the context\n */\nexport function getActiveBaggage() {\n    return getBaggage(ContextAPI.getInstance().active());\n}\n/**\n * Store a baggage in the given context\n *\n * @param {Context} Context that manage all context values\n * @param {Baggage} baggage that will be set in the actual context\n */\nexport function setBaggage(context, baggage) {\n    return context.setValue(BAGGAGE_KEY, baggage);\n}\n/**\n * Delete the baggage stored in the given context\n *\n * @param {Context} Context that manage all context values\n */\nexport function deleteBaggage(context) {\n    return context.deleteValue(BAGGAGE_KEY);\n}\n//# sourceMappingURL=context-helpers.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar BaggageImpl = /** @class */ (function () {\n    function BaggageImpl(entries) {\n        this._entries = entries ? new Map(entries) : new Map();\n    }\n    BaggageImpl.prototype.getEntry = function (key) {\n        var entry = this._entries.get(key);\n        if (!entry) {\n            return undefined;\n        }\n        return Object.assign({}, entry);\n    };\n    BaggageImpl.prototype.getAllEntries = function () {\n        return Array.from(this._entries.entries()).map(function (_a) {\n            var _b = __read(_a, 2), k = _b[0], v = _b[1];\n            return [k, v];\n        });\n    };\n    BaggageImpl.prototype.setEntry = function (key, entry) {\n        var newBaggage = new BaggageImpl(this._entries);\n        newBaggage._entries.set(key, entry);\n        return newBaggage;\n    };\n    BaggageImpl.prototype.removeEntry = function (key) {\n        var newBaggage = new BaggageImpl(this._entries);\n        newBaggage._entries.delete(key);\n        return newBaggage;\n    };\n    BaggageImpl.prototype.removeEntries = function () {\n        var e_1, _a;\n        var keys = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            keys[_i] = arguments[_i];\n        }\n        var newBaggage = new BaggageImpl(this._entries);\n        try {\n            for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {\n                var key = keys_1_1.value;\n                newBaggage._entries.delete(key);\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return newBaggage;\n    };\n    BaggageImpl.prototype.clear = function () {\n        return new BaggageImpl();\n    };\n    return BaggageImpl;\n}());\nexport { BaggageImpl };\n//# sourceMappingURL=baggage-impl.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DiagAPI } from '../api/diag';\nimport { BaggageImpl } from './internal/baggage-impl';\nimport { baggageEntryMetadataSymbol } from './internal/symbol';\nvar diag = DiagAPI.instance();\n/**\n * Create a new Baggage with optional entries\n *\n * @param entries An array of baggage entries the new baggage should contain\n */\nexport function createBaggage(entries) {\n    if (entries === void 0) { entries = {}; }\n    return new BaggageImpl(new Map(Object.entries(entries)));\n}\n/**\n * Create a serializable BaggageEntryMetadata object from a string.\n *\n * @param str string metadata. Format is currently not defined by the spec and has no special meaning.\n *\n */\nexport function baggageEntryMetadataFromString(str) {\n    if (typeof str !== 'string') {\n        diag.error(\"Cannot create baggage metadata from unknown type: \" + typeof str);\n        str = '';\n    }\n    return {\n        __TYPE__: baggageEntryMetadataSymbol,\n        toString: function () {\n            return str;\n        },\n    };\n}\n//# sourceMappingURL=utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { NoopTextMapPropagator } from '../propagation/NoopTextMapPropagator';\nimport { defaultTextMapGetter, defaultTextMapSetter, } from '../propagation/TextMapPropagator';\nimport { getBaggage, getActiveBaggage, setBaggage, deleteBaggage, } from '../baggage/context-helpers';\nimport { createBaggage } from '../baggage/utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'propagation';\nvar NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Propagation API\n */\nvar PropagationAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function PropagationAPI() {\n        this.createBaggage = createBaggage;\n        this.getBaggage = getBaggage;\n        this.getActiveBaggage = getActiveBaggage;\n        this.setBaggage = setBaggage;\n        this.deleteBaggage = deleteBaggage;\n    }\n    /** Get the singleton instance of the Propagator API */\n    PropagationAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new PropagationAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current propagator.\n     *\n     * @returns true if the propagator was successfully registered, else false\n     */\n    PropagationAPI.prototype.setGlobalPropagator = function (propagator) {\n        return registerGlobal(API_NAME, propagator, DiagAPI.instance());\n    };\n    /**\n     * Inject context into a carrier to be propagated inter-process\n     *\n     * @param context Context carrying tracing data to inject\n     * @param carrier carrier to inject context into\n     * @param setter Function used to set values on the carrier\n     */\n    PropagationAPI.prototype.inject = function (context, carrier, setter) {\n        if (setter === void 0) { setter = defaultTextMapSetter; }\n        return this._getGlobalPropagator().inject(context, carrier, setter);\n    };\n    /**\n     * Extract context from a carrier\n     *\n     * @param context Context which the newly created context will inherit from\n     * @param carrier Carrier to extract context from\n     * @param getter Function used to extract keys from a carrier\n     */\n    PropagationAPI.prototype.extract = function (context, carrier, getter) {\n        if (getter === void 0) { getter = defaultTextMapGetter; }\n        return this._getGlobalPropagator().extract(context, carrier, getter);\n    };\n    /**\n     * Return a list of all fields which may be used by the propagator.\n     */\n    PropagationAPI.prototype.fields = function () {\n        return this._getGlobalPropagator().fields();\n    };\n    /** Remove the global propagator */\n    PropagationAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    PropagationAPI.prototype._getGlobalPropagator = function () {\n        return getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;\n    };\n    return PropagationAPI;\n}());\nexport { PropagationAPI };\n//# sourceMappingURL=propagation.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { PropagationAPI } from './api/propagation';\n/** Entrypoint for propagation API */\nexport var propagation = PropagationAPI.getInstance();\n//# sourceMappingURL=propagation-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var TraceFlags;\n(function (TraceFlags) {\n    /** Represents no flag set. */\n    TraceFlags[TraceFlags[\"NONE\"] = 0] = \"NONE\";\n    /** Bit to represent whether trace is sampled in trace flags. */\n    TraceFlags[TraceFlags[\"SAMPLED\"] = 1] = \"SAMPLED\";\n})(TraceFlags || (TraceFlags = {}));\n//# sourceMappingURL=trace_flags.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { TraceFlags } from './trace_flags';\nexport var INVALID_SPANID = '0000000000000000';\nexport var INVALID_TRACEID = '00000000000000000000000000000000';\nexport var INVALID_SPAN_CONTEXT = {\n    traceId: INVALID_TRACEID,\n    spanId: INVALID_SPANID,\n    traceFlags: TraceFlags.NONE,\n};\n//# sourceMappingURL=invalid-span-constants.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { INVALID_SPAN_CONTEXT } from './invalid-span-constants';\n/**\n * The NonRecordingSpan is the default {@link Span} that is used when no Span\n * implementation is available. All operations are no-op including context\n * propagation.\n */\nvar NonRecordingSpan = /** @class */ (function () {\n    function NonRecordingSpan(_spanContext) {\n        if (_spanContext === void 0) { _spanContext = INVALID_SPAN_CONTEXT; }\n        this._spanContext = _spanContext;\n    }\n    // Returns a SpanContext.\n    NonRecordingSpan.prototype.spanContext = function () {\n        return this._spanContext;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setAttribute = function (_key, _value) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setAttributes = function (_attributes) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.addEvent = function (_name, _attributes) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setStatus = function (_status) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.updateName = function (_name) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.end = function (_endTime) { };\n    // isRecording always returns false for NonRecordingSpan.\n    NonRecordingSpan.prototype.isRecording = function () {\n        return false;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.recordException = function (_exception, _time) { };\n    return NonRecordingSpan;\n}());\nexport { NonRecordingSpan };\n//# sourceMappingURL=NonRecordingSpan.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { createContextKey } from '../context/context';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nimport { ContextAPI } from '../api/context';\n/**\n * span key\n */\nvar SPAN_KEY = createContextKey('OpenTelemetry Context Key SPAN');\n/**\n * Return the span if one exists\n *\n * @param context context to get span from\n */\nexport function getSpan(context) {\n    return context.getValue(SPAN_KEY) || undefined;\n}\n/**\n * Gets the span from the current context, if one exists.\n */\nexport function getActiveSpan() {\n    return getSpan(ContextAPI.getInstance().active());\n}\n/**\n * Set the span on a context\n *\n * @param context context to use as parent\n * @param span span to set active\n */\nexport function setSpan(context, span) {\n    return context.setValue(SPAN_KEY, span);\n}\n/**\n * Remove current span stored in the context\n *\n * @param context context to delete span from\n */\nexport function deleteSpan(context) {\n    return context.deleteValue(SPAN_KEY);\n}\n/**\n * Wrap span context in a NoopSpan and set as span in a new\n * context\n *\n * @param context context to set active span on\n * @param spanContext span context to be wrapped\n */\nexport function setSpanContext(context, spanContext) {\n    return setSpan(context, new NonRecordingSpan(spanContext));\n}\n/**\n * Get the span context of the span if it exists.\n *\n * @param context context to get values from\n */\nexport function getSpanContext(context) {\n    var _a;\n    return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();\n}\n//# sourceMappingURL=context-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { INVALID_SPANID, INVALID_TRACEID } from './invalid-span-constants';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nvar VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;\nvar VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;\nexport function isValidTraceId(traceId) {\n    return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;\n}\nexport function isValidSpanId(spanId) {\n    return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;\n}\n/**\n * Returns true if this {@link SpanContext} is valid.\n * @return true if this {@link SpanContext} is valid.\n */\nexport function isSpanContextValid(spanContext) {\n    return (isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId));\n}\n/**\n * Wrap the given {@link SpanContext} in a new non-recording {@link Span}\n *\n * @param spanContext span context to be wrapped\n * @returns a new non-recording {@link Span} with the provided context\n */\nexport function wrapSpanContext(spanContext) {\n    return new NonRecordingSpan(spanContext);\n}\n//# sourceMappingURL=spancontext-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ContextAPI } from '../api/context';\nimport { getSpanContext, setSpan } from '../trace/context-utils';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nimport { isSpanContextValid } from './spancontext-utils';\nvar contextApi = ContextAPI.getInstance();\n/**\n * No-op implementations of {@link Tracer}.\n */\nvar NoopTracer = /** @class */ (function () {\n    function NoopTracer() {\n    }\n    // startSpan starts a noop span.\n    NoopTracer.prototype.startSpan = function (name, options, context) {\n        if (context === void 0) { context = contextApi.active(); }\n        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);\n        if (root) {\n            return new NonRecordingSpan();\n        }\n        var parentFromContext = context && getSpanContext(context);\n        if (isSpanContext(parentFromContext) &&\n            isSpanContextValid(parentFromContext)) {\n            return new NonRecordingSpan(parentFromContext);\n        }\n        else {\n            return new NonRecordingSpan();\n        }\n    };\n    NoopTracer.prototype.startActiveSpan = function (name, arg2, arg3, arg4) {\n        var opts;\n        var ctx;\n        var fn;\n        if (arguments.length < 2) {\n            return;\n        }\n        else if (arguments.length === 2) {\n            fn = arg2;\n        }\n        else if (arguments.length === 3) {\n            opts = arg2;\n            fn = arg3;\n        }\n        else {\n            opts = arg2;\n            ctx = arg3;\n            fn = arg4;\n        }\n        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();\n        var span = this.startSpan(name, opts, parentContext);\n        var contextWithSpanSet = setSpan(parentContext, span);\n        return contextApi.with(contextWithSpanSet, fn, undefined, span);\n    };\n    return NoopTracer;\n}());\nexport { NoopTracer };\nfunction isSpanContext(spanContext) {\n    return (typeof spanContext === 'object' &&\n        typeof spanContext['spanId'] === 'string' &&\n        typeof spanContext['traceId'] === 'string' &&\n        typeof spanContext['traceFlags'] === 'number');\n}\n//# sourceMappingURL=NoopTracer.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NoopTracer } from './NoopTracer';\nvar NOOP_TRACER = new NoopTracer();\n/**\n * Proxy tracer provided by the proxy tracer provider\n */\nvar ProxyTracer = /** @class */ (function () {\n    function ProxyTracer(_provider, name, version, options) {\n        this._provider = _provider;\n        this.name = name;\n        this.version = version;\n        this.options = options;\n    }\n    ProxyTracer.prototype.startSpan = function (name, options, context) {\n        return this._getTracer().startSpan(name, options, context);\n    };\n    ProxyTracer.prototype.startActiveSpan = function (_name, _options, _context, _fn) {\n        var tracer = this._getTracer();\n        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);\n    };\n    /**\n     * Try to get a tracer from the proxy tracer provider.\n     * If the proxy tracer provider has no delegate, return a noop tracer.\n     */\n    ProxyTracer.prototype._getTracer = function () {\n        if (this._delegate) {\n            return this._delegate;\n        }\n        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);\n        if (!tracer) {\n            return NOOP_TRACER;\n        }\n        this._delegate = tracer;\n        return this._delegate;\n    };\n    return ProxyTracer;\n}());\nexport { ProxyTracer };\n//# sourceMappingURL=ProxyTracer.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NoopTracer } from './NoopTracer';\n/**\n * An implementation of the {@link TracerProvider} which returns an impotent\n * Tracer for all calls to `getTracer`.\n *\n * All operations are no-op.\n */\nvar NoopTracerProvider = /** @class */ (function () {\n    function NoopTracerProvider() {\n    }\n    NoopTracerProvider.prototype.getTracer = function (_name, _version, _options) {\n        return new NoopTracer();\n    };\n    return NoopTracerProvider;\n}());\nexport { NoopTracerProvider };\n//# sourceMappingURL=NoopTracerProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ProxyTracer } from './ProxyTracer';\nimport { NoopTracerProvider } from './NoopTracerProvider';\nvar NOOP_TRACER_PROVIDER = new NoopTracerProvider();\n/**\n * Tracer provider which provides {@link ProxyTracer}s.\n *\n * Before a delegate is set, tracers provided are NoOp.\n *   When a delegate is set, traces are provided from the delegate.\n *   When a delegate is set after tracers have already been provided,\n *   all tracers already provided will use the provided delegate implementation.\n */\nvar ProxyTracerProvider = /** @class */ (function () {\n    function ProxyTracerProvider() {\n    }\n    /**\n     * Get a {@link ProxyTracer}\n     */\n    ProxyTracerProvider.prototype.getTracer = function (name, version, options) {\n        var _a;\n        return ((_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options));\n    };\n    ProxyTracerProvider.prototype.getDelegate = function () {\n        var _a;\n        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;\n    };\n    /**\n     * Set the delegate tracer provider\n     */\n    ProxyTracerProvider.prototype.setDelegate = function (delegate) {\n        this._delegate = delegate;\n    };\n    ProxyTracerProvider.prototype.getDelegateTracer = function (name, version, options) {\n        var _a;\n        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);\n    };\n    return ProxyTracerProvider;\n}());\nexport { ProxyTracerProvider };\n//# sourceMappingURL=ProxyTracerProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { ProxyTracerProvider } from '../trace/ProxyTracerProvider';\nimport { isSpanContextValid, wrapSpanContext, } from '../trace/spancontext-utils';\nimport { deleteSpan, getActiveSpan, getSpan, getSpanContext, setSpan, setSpanContext, } from '../trace/context-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'trace';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Tracing API\n */\nvar TraceAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function TraceAPI() {\n        this._proxyTracerProvider = new ProxyTracerProvider();\n        this.wrapSpanContext = wrapSpanContext;\n        this.isSpanContextValid = isSpanContextValid;\n        this.deleteSpan = deleteSpan;\n        this.getSpan = getSpan;\n        this.getActiveSpan = getActiveSpan;\n        this.getSpanContext = getSpanContext;\n        this.setSpan = setSpan;\n        this.setSpanContext = setSpanContext;\n    }\n    /** Get the singleton instance of the Trace API */\n    TraceAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new TraceAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current global tracer.\n     *\n     * @returns true if the tracer provider was successfully registered, else false\n     */\n    TraceAPI.prototype.setGlobalTracerProvider = function (provider) {\n        var success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());\n        if (success) {\n            this._proxyTracerProvider.setDelegate(provider);\n        }\n        return success;\n    };\n    /**\n     * Returns the global tracer provider.\n     */\n    TraceAPI.prototype.getTracerProvider = function () {\n        return getGlobal(API_NAME) || this._proxyTracerProvider;\n    };\n    /**\n     * Returns a tracer from the global tracer provider.\n     */\n    TraceAPI.prototype.getTracer = function (name, version) {\n        return this.getTracerProvider().getTracer(name, version);\n    };\n    /** Remove the global tracer provider */\n    TraceAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n        this._proxyTracerProvider = new ProxyTracerProvider();\n    };\n    return TraceAPI;\n}());\nexport { TraceAPI };\n//# sourceMappingURL=trace.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { TraceAPI } from './api/trace';\n/** Entrypoint for trace API */\nexport var trace = TraceAPI.getInstance();\n//# sourceMappingURL=trace-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport { baggageEntryMetadataFromString } from './baggage/utils';\n// Context APIs\nexport { createContextKey, ROOT_CONTEXT } from './context/context';\n// Diag APIs\nexport { DiagConsoleLogger } from './diag/consoleLogger';\nexport { DiagLogLevel, } from './diag/types';\n// Metrics APIs\nexport { createNoopMeter } from './metrics/NoopMeter';\nexport { ValueType, } from './metrics/Metric';\n// Propagation APIs\nexport { defaultTextMapGetter, defaultTextMapSetter, } from './propagation/TextMapPropagator';\nexport { ProxyTracer } from './trace/ProxyTracer';\nexport { ProxyTracerProvider } from './trace/ProxyTracerProvider';\nexport { SamplingDecision } from './trace/SamplingResult';\nexport { SpanKind } from './trace/span_kind';\nexport { SpanStatusCode } from './trace/status';\nexport { TraceFlags } from './trace/trace_flags';\nexport { createTraceState } from './trace/internal/utils';\nexport { isSpanContextValid, isValidTraceId, isValidSpanId, } from './trace/spancontext-utils';\nexport { INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT, } from './trace/invalid-span-constants';\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { context } from './context-api';\nimport { diag } from './diag-api';\nimport { metrics } from './metrics-api';\nimport { propagation } from './propagation-api';\nimport { trace } from './trace-api';\n// Named export.\nexport { context, diag, metrics, propagation, trace };\n// Default export.\nexport default {\n    context: context,\n    diag: diag,\n    metrics: metrics,\n    propagation: propagation,\n    trace: trace,\n};\n//# sourceMappingURL=index.js.map"],"names":["createContextKey","description","Symbol","for","DiagLogLevel","TraceFlags","extendStatics","ROOT_CONTEXT","BaseContext","parentContext","self","_currentContext","Map","getValue","key","get","setValue","value","context","set","deleteValue","delete","__read","o","n","m","iterator","r","e","i","call","ar","next","done","push","error","__spreadArray","to","from","pack","arguments","length","l","Array","prototype","slice","concat","NoopContextManager","active","with","_context","fn","thisArg","args","_i","apply","bind","target","enable","disable","_globalThis","globalThis","window","__webpack_require__","g","VERSION","re","isCompatible","_makeCompatibilityCheck","ownVersion","acceptedVersions","Set","rejectedVersions","myVersionMatch","match","ownVersionParsed","major","minor","patch","prerelease","globalVersion","_reject","v","add","has","globalVersionMatch","globalVersionParsed","GLOBAL_OPENTELEMETRY_API_KEY","split","registerGlobal","type","instance","diag","allowOverride","_a","api","_global","version","err","stack","message","debug","getGlobal","_b","unregisterGlobal","ComponentLogger_read","ComponentLogger_spreadArray","DiagComponentLogger","props","_namespace","namespace","logProxy","info","warn","verbose","funcName","logger","unshift","diag_read","diag_spreadArray","DiagAPI","_logProxy","setLogger","optionsOrLogLevel","logLevel","INFO","_c","oldLogger","newLogger","createLogLevelDiagLogger","maxLevel","_filterFunc","theLevel","theFunc","NONE","ALL","ERROR","WARN","DEBUG","VERBOSE","suppressOverrideMessage","createComponentLogger","options","_instance","context_read","context_spreadArray","context_API_NAME","NOOP_CONTEXT_MANAGER","ContextAPI","getInstance","setGlobalContextManager","contextManager","_getContextManager","__extends","d","b","Object","setPrototypeOf","__proto__","p","hasOwnProperty","String","__","constructor","create","NoopMeter","createHistogram","_name","_options","NOOP_HISTOGRAM_METRIC","createCounter","NOOP_COUNTER_METRIC","createUpDownCounter","NOOP_UP_DOWN_COUNTER_METRIC","createObservableGauge","NOOP_OBSERVABLE_GAUGE_METRIC","createObservableCounter","NOOP_OBSERVABLE_COUNTER_METRIC","createObservableUpDownCounter","NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC","addBatchObservableCallback","_callback","_observables","removeBatchObservableCallback","NoopMetric","NoopCounterMetric","_super","_value","_attributes","NoopUpDownCounterMetric","NoopHistogramMetric","record","NoopObservableMetric","addCallback","removeCallback","NoopObservableCounterMetric","NoopObservableGaugeMetric","NoopObservableUpDownCounterMetric","NOOP_METER","NOOP_METER_PROVIDER","NoopMeterProvider","getMeter","_version","metrics_API_NAME","MetricsAPI","setGlobalMeterProvider","provider","getMeterProvider","name","NoopTextMapPropagator","inject","_carrier","extract","fields","defaultTextMapGetter","carrier","keys","defaultTextMapSetter","BAGGAGE_KEY","getBaggage","undefined","getActiveBaggage","setBaggage","baggage","deleteBaggage","baggage_impl_read","__values","s","BaggageImpl","entries","_entries","getEntry","entry","assign","getAllEntries","map","setEntry","newBaggage","removeEntry","removeEntries","e_1","keys_1","keys_1_1","e_1_1","return","clear","createBaggage","propagation_API_NAME","NOOP_TEXT_MAP_PROPAGATOR","PropagationAPI","setGlobalPropagator","propagator","setter","_getGlobalPropagator","getter","INVALID_SPANID","INVALID_TRACEID","INVALID_SPAN_CONTEXT","traceId","spanId","traceFlags","NonRecordingSpan","_spanContext","spanContext","setAttribute","_key","setAttributes","addEvent","setStatus","_status","updateName","end","_endTime","isRecording","recordException","_exception","_time","SPAN_KEY","getSpan","getActiveSpan","setSpan","span","deleteSpan","setSpanContext","getSpanContext","VALID_TRACEID_REGEX","VALID_SPANID_REGEX","isSpanContextValid","isValidTraceId","test","wrapSpanContext","contextApi","NoopTracer","startSpan","root","parentFromContext","startActiveSpan","arg2","arg3","arg4","opts","ctx","contextWithSpanSet","NOOP_TRACER","ProxyTracer","_provider","_getTracer","_fn","tracer","Reflect","_delegate","getDelegateTracer","NOOP_TRACER_PROVIDER","NoopTracerProvider","getTracer","ProxyTracerProvider","getDelegate","setDelegate","delegate","trace_API_NAME","trace","TraceAPI","_proxyTracerProvider","setGlobalTracerProvider","success","getTracerProvider"],"sourceRoot":""}