@opentelemetry/sdk-trace-web 1.1.0 → 1.1.1

package/build/esm/StackContextManager.d.ts

@@ -0,0 +1,50 @@
+import { Context, ContextManager } from '@opentelemetry/api';
+/**
+ * Stack Context Manager for managing the state in web
+ * it doesn't fully support the async calls though
+ */
+export declare class StackContextManager implements ContextManager {
+    /**
+     * whether the context manager is enabled or not
+     */
+    private _enabled;
+    /**
+     * Keeps the reference to current context
+     */
+    _currentContext: Context;
+    /**
+     *
+     * @param context
+     * @param target Function to be executed within the context
+     */
+    private _bindFunction;
+    /**
+     * Returns the active context
+     */
+    active(): Context;
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function or event emitter. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind<T>(context: Context, target: T): T;
+    /**
+     * Disable the context manager (clears the current context)
+     */
+    disable(): this;
+    /**
+     * Enables the context manager and creates a default(root) context
+     */
+    enable(): this;
+    /**
+     * Calls the callback function [fn] with the provided [context]. If [context] is undefined then it will use the window.
+     * The context will be set as active
+     * @param context
+     * @param fn Callback function
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: Context | null, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+}
+//# sourceMappingURL=StackContextManager.d.ts.map

package/build/esm/StackContextManager.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { ROOT_CONTEXT } from '@opentelemetry/api';
+/**
+ * Stack Context Manager for managing the state in web
+ * it doesn't fully support the async calls though
+ */
+var StackContextManager = /** @class */ (function () {
+    function StackContextManager() {
+        /**
+         * whether the context manager is enabled or not
+         */
+        this._enabled = false;
+        /**
+         * Keeps the reference to current context
+         */
+        this._currentContext = ROOT_CONTEXT;
+    }
+    /**
+     *
+     * @param context
+     * @param target Function to be executed within the context
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    StackContextManager.prototype._bindFunction = function (context, target) {
+        if (context === void 0) { context = ROOT_CONTEXT; }
+        var manager = this;
+        var contextWrapper = function () {
+            var _this = this;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return manager.with(context, function () { return target.apply(_this, args); });
+        };
+        Object.defineProperty(contextWrapper, 'length', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: target.length,
+        });
+        return contextWrapper;
+    };
+    /**
+     * Returns the active context
+     */
+    StackContextManager.prototype.active = function () {
+        return this._currentContext;
+    };
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function or event emitter. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    StackContextManager.prototype.bind = function (context, target) {
+        // if no specific context to propagate is given, we use the current one
+        if (context === undefined) {
+            context = this.active();
+        }
+        if (typeof target === 'function') {
+            return this._bindFunction(context, target);
+        }
+        return target;
+    };
+    /**
+     * Disable the context manager (clears the current context)
+     */
+    StackContextManager.prototype.disable = function () {
+        this._currentContext = ROOT_CONTEXT;
+        this._enabled = false;
+        return this;
+    };
+    /**
+     * Enables the context manager and creates a default(root) context
+     */
+    StackContextManager.prototype.enable = function () {
+        if (this._enabled) {
+            return this;
+        }
+        this._enabled = true;
+        this._currentContext = ROOT_CONTEXT;
+        return this;
+    };
+    /**
+     * Calls the callback function [fn] with the provided [context]. If [context] is undefined then it will use the window.
+     * The context will be set as active
+     * @param context
+     * @param fn Callback function
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    StackContextManager.prototype.with = function (context, fn, thisArg) {
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            args[_i - 3] = arguments[_i];
+        }
+        var previousContext = this._currentContext;
+        this._currentContext = context || ROOT_CONTEXT;
+        try {
+            return fn.call.apply(fn, __spreadArray([thisArg], __read(args), false));
+        }
+        finally {
+            this._currentContext = previousContext;
+        }
+    };
+    return StackContextManager;
+}());
+export { StackContextManager };
+//# sourceMappingURL=StackContextManager.js.map

package/build/esm/StackContextManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StackContextManager.js","sourceRoot":"","sources":["../../src/StackContextManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,OAAO,EAA2B,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE3E;;;GAGG;AACH;IAAA;QACE;;WAEG;QACK,aAAQ,GAAG,KAAK,CAAC;QAEzB;;WAEG;QACI,oBAAe,GAAG,YAAY,CAAC;IA6FxC,CAAC;IA3FC;;;;OAIG;IACH,wDAAwD;IAChD,2CAAa,GAArB,UACE,OAAsB,EACtB,MAAS;QADT,wBAAA,EAAA,sBAAsB;QAGtB,IAAM,OAAO,GAAG,IAAI,CAAC;QACrB,IAAM,cAAc,GAAG;YAAA,iBAEtB;YAF+C,cAAkB;iBAAlB,UAAkB,EAAlB,qBAAkB,EAAlB,IAAkB;gBAAlB,yBAAkB;;YAChE,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,cAAM,OAAA,MAAM,CAAC,KAAK,CAAC,KAAI,EAAE,IAAI,CAAC,EAAxB,CAAwB,CAAC,CAAC;QAC/D,CAAC,CAAC;QACF,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,QAAQ,EAAE;YAC9C,UAAU,EAAE,KAAK;YACjB,YAAY,EAAE,IAAI;YAClB,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,MAAM,CAAC,MAAM;SACrB,CAAC,CAAC;QACH,OAAQ,cAA+B,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,oCAAM,GAAN;QACE,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACH,kCAAI,GAAJ,UAAQ,OAAgB,EAAE,MAAS;QACjC,uEAAuE;QACvE,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;SACzB;QACD,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE;YAChC,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;SAC5C;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,qCAAO,GAAP;QACE,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC;QACpC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,oCAAM,GAAN;QACE,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,OAAO,IAAI,CAAC;SACb;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,kCAAI,GAAJ,UACE,OAAuB,EACvB,EAAK,EACL,OAA8B;QAC9B,cAAU;aAAV,UAAU,EAAV,qBAAU,EAAV,IAAU;YAAV,6BAAU;;QAEV,IAAM,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC7C,IAAI,CAAC,eAAe,GAAG,OAAO,IAAI,YAAY,CAAC;QAE/C,IAAI;YACF,OAAO,EAAE,CAAC,IAAI,OAAP,EAAE,iBAAM,OAAO,UAAK,IAAI,WAAE;SAClC;gBAAS;YACR,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;SACxC;IACH,CAAC;IACH,0BAAC;AAAD,CAAC,AAtGD,IAsGC","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\nimport { Context, ContextManager, ROOT_CONTEXT } from '@opentelemetry/api';\n\n/**\n * Stack Context Manager for managing the state in web\n * it doesn't fully support the async calls though\n */\nexport class StackContextManager implements ContextManager {\n  /**\n   * whether the context manager is enabled or not\n   */\n  private _enabled = false;\n\n  /**\n   * Keeps the reference to current context\n   */\n  public _currentContext = ROOT_CONTEXT;\n\n  /**\n   *\n   * @param context\n   * @param target Function to be executed within the context\n   */\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  private _bindFunction<T extends Function>(\n    context = ROOT_CONTEXT,\n    target: T\n  ): T {\n    const manager = this;\n    const contextWrapper = function (this: unknown, ...args: unknown[]) {\n      return manager.with(context, () => target.apply(this, args));\n    };\n    Object.defineProperty(contextWrapper, 'length', {\n      enumerable: false,\n      configurable: true,\n      writable: false,\n      value: target.length,\n    });\n    return (contextWrapper as unknown) as T;\n  }\n\n  /**\n   * Returns the active context\n   */\n  active(): Context {\n    return this._currentContext;\n  }\n\n  /**\n   * Binds a the certain context or the active one to the target function and then returns the target\n   * @param context A context (span) to be bind to target\n   * @param target a function or event emitter. When target or one of its callbacks is called,\n   *  the provided context will be used as the active context for the duration of the call.\n   */\n  bind<T>(context: Context, target: T): T {\n    // if no specific context to propagate is given, we use the current one\n    if (context === undefined) {\n      context = this.active();\n    }\n    if (typeof target === 'function') {\n      return this._bindFunction(context, target);\n    }\n    return target;\n  }\n\n  /**\n   * Disable the context manager (clears the current context)\n   */\n  disable(): this {\n    this._currentContext = ROOT_CONTEXT;\n    this._enabled = false;\n    return this;\n  }\n\n  /**\n   * Enables the context manager and creates a default(root) context\n   */\n  enable(): this {\n    if (this._enabled) {\n      return this;\n    }\n    this._enabled = true;\n    this._currentContext = ROOT_CONTEXT;\n    return this;\n  }\n\n  /**\n   * Calls the callback function [fn] with the provided [context]. If [context] is undefined then it will use the window.\n   * The context will be set as active\n   * @param context\n   * @param fn Callback function\n   * @param thisArg optional receiver to be used for calling fn\n   * @param args optional arguments forwarded to fn\n   */\n  with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(\n    context: Context | null,\n    fn: F,\n    thisArg?: ThisParameterType<F>,\n    ...args: A\n  ): ReturnType<F> {\n    const previousContext = this._currentContext;\n    this._currentContext = context || ROOT_CONTEXT;\n\n    try {\n      return fn.call(thisArg, ...args);\n    } finally {\n      this._currentContext = previousContext;\n    }\n  }\n}\n"]}

package/build/esm/WebTracerProvider.d.ts

@@ -0,0 +1,24 @@
+import { BasicTracerProvider, SDKRegistrationConfig, TracerConfig } from '@opentelemetry/sdk-trace-base';
+/**
+ * WebTracerConfig provides an interface for configuring a Web Tracer.
+ */
+export declare type WebTracerConfig = TracerConfig;
+/**
+ * This class represents a web tracer with {@link StackContextManager}
+ */
+export declare class WebTracerProvider extends BasicTracerProvider {
+    /**
+     * Constructs a new Tracer instance.
+     * @param config Web Tracer config
+     */
+    constructor(config?: WebTracerConfig);
+    /**
+     * Register this TracerProvider for use with the OpenTelemetry API.
+     * Undefined values may be replaced with defaults, and
+     * null values will be skipped.
+     *
+     * @param config Configuration object for SDK registration
+     */
+    register(config?: SDKRegistrationConfig): void;
+}
+//# sourceMappingURL=WebTracerProvider.d.ts.map

package/build/esm/WebTracerProvider.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BasicTracerProvider, } from '@opentelemetry/sdk-trace-base';
+import { StackContextManager } from './StackContextManager';
+/**
+ * This class represents a web tracer with {@link StackContextManager}
+ */
+var WebTracerProvider = /** @class */ (function (_super) {
+    __extends(WebTracerProvider, _super);
+    /**
+     * Constructs a new Tracer instance.
+     * @param config Web Tracer config
+     */
+    function WebTracerProvider(config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this, config) || this;
+        if (config.contextManager) {
+            throw ('contextManager should be defined in register method not in' +
+                ' constructor');
+        }
+        if (config.propagator) {
+            throw 'propagator should be defined in register method not in constructor';
+        }
+        return _this;
+    }
+    /**
+     * Register this TracerProvider for use with the OpenTelemetry API.
+     * Undefined values may be replaced with defaults, and
+     * null values will be skipped.
+     *
+     * @param config Configuration object for SDK registration
+     */
+    WebTracerProvider.prototype.register = function (config) {
+        if (config === void 0) { config = {}; }
+        if (config.contextManager === undefined) {
+            config.contextManager = new StackContextManager();
+        }
+        if (config.contextManager) {
+            config.contextManager.enable();
+        }
+        _super.prototype.register.call(this, config);
+    };
+    return WebTracerProvider;
+}(BasicTracerProvider));
+export { WebTracerProvider };
+//# sourceMappingURL=WebTracerProvider.js.map

package/build/esm/WebTracerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebTracerProvider.js","sourceRoot":"","sources":["../../src/WebTracerProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;AAEH,OAAO,EACL,mBAAmB,GAGpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAO5D;;GAEG;AACH;IAAuC,qCAAmB;IACxD;;;OAGG;IACH,2BAAY,MAA4B;QAA5B,uBAAA,EAAA,WAA4B;QAAxC,YACE,kBAAM,MAAM,CAAC,SAWd;QATC,IAAK,MAAgC,CAAC,cAAc,EAAE;YACpD,MAAM,CACJ,4DAA4D;gBAC5D,cAAc,CACf,CAAC;SACH;QACD,IAAK,MAAgC,CAAC,UAAU,EAAE;YAChD,MAAM,oEAAoE,CAAC;SAC5E;;IACH,CAAC;IAED;;;;;;OAMG;IACM,oCAAQ,GAAjB,UAAkB,MAAkC;QAAlC,uBAAA,EAAA,WAAkC;QAClD,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE;YACvC,MAAM,CAAC,cAAc,GAAG,IAAI,mBAAmB,EAAE,CAAC;SACnD;QACD,IAAI,MAAM,CAAC,cAAc,EAAE;YACzB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;SAChC;QAED,iBAAM,QAAQ,YAAC,MAAM,CAAC,CAAC;IACzB,CAAC;IACH,wBAAC;AAAD,CAAC,AApCD,CAAuC,mBAAmB,GAoCzD","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\nimport {\n  BasicTracerProvider,\n  SDKRegistrationConfig,\n  TracerConfig,\n} from '@opentelemetry/sdk-trace-base';\nimport { StackContextManager } from './StackContextManager';\n\n/**\n * WebTracerConfig provides an interface for configuring a Web Tracer.\n */\nexport type WebTracerConfig = TracerConfig;\n\n/**\n * This class represents a web tracer with {@link StackContextManager}\n */\nexport class WebTracerProvider extends BasicTracerProvider {\n  /**\n   * Constructs a new Tracer instance.\n   * @param config Web Tracer config\n   */\n  constructor(config: WebTracerConfig = {}) {\n    super(config);\n\n    if ((config as SDKRegistrationConfig).contextManager) {\n      throw (\n        'contextManager should be defined in register method not in' +\n        ' constructor'\n      );\n    }\n    if ((config as SDKRegistrationConfig).propagator) {\n      throw 'propagator should be defined in register method not in constructor';\n    }\n  }\n\n  /**\n   * Register this TracerProvider for use with the OpenTelemetry API.\n   * Undefined values may be replaced with defaults, and\n   * null values will be skipped.\n   *\n   * @param config Configuration object for SDK registration\n   */\n  override register(config: SDKRegistrationConfig = {}): void {\n    if (config.contextManager === undefined) {\n      config.contextManager = new StackContextManager();\n    }\n    if (config.contextManager) {\n      config.contextManager.enable();\n    }\n\n    super.register(config);\n  }\n}\n"]}

package/build/esm/enums/PerformanceTimingNames.d.ts

@@ -0,0 +1,25 @@
+export declare enum PerformanceTimingNames {
+    CONNECT_END = "connectEnd",
+    CONNECT_START = "connectStart",
+    DECODED_BODY_SIZE = "decodedBodySize",
+    DOM_COMPLETE = "domComplete",
+    DOM_CONTENT_LOADED_EVENT_END = "domContentLoadedEventEnd",
+    DOM_CONTENT_LOADED_EVENT_START = "domContentLoadedEventStart",
+    DOM_INTERACTIVE = "domInteractive",
+    DOMAIN_LOOKUP_END = "domainLookupEnd",
+    DOMAIN_LOOKUP_START = "domainLookupStart",
+    ENCODED_BODY_SIZE = "encodedBodySize",
+    FETCH_START = "fetchStart",
+    LOAD_EVENT_END = "loadEventEnd",
+    LOAD_EVENT_START = "loadEventStart",
+    NAVIGATION_START = "navigationStart",
+    REDIRECT_END = "redirectEnd",
+    REDIRECT_START = "redirectStart",
+    REQUEST_START = "requestStart",
+    RESPONSE_END = "responseEnd",
+    RESPONSE_START = "responseStart",
+    SECURE_CONNECTION_START = "secureConnectionStart",
+    UNLOAD_EVENT_END = "unloadEventEnd",
+    UNLOAD_EVENT_START = "unloadEventStart"
+}
+//# sourceMappingURL=PerformanceTimingNames.d.ts.map

package/build/esm/enums/PerformanceTimingNames.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export var PerformanceTimingNames;
+(function (PerformanceTimingNames) {
+    PerformanceTimingNames["CONNECT_END"] = "connectEnd";
+    PerformanceTimingNames["CONNECT_START"] = "connectStart";
+    PerformanceTimingNames["DECODED_BODY_SIZE"] = "decodedBodySize";
+    PerformanceTimingNames["DOM_COMPLETE"] = "domComplete";
+    PerformanceTimingNames["DOM_CONTENT_LOADED_EVENT_END"] = "domContentLoadedEventEnd";
+    PerformanceTimingNames["DOM_CONTENT_LOADED_EVENT_START"] = "domContentLoadedEventStart";
+    PerformanceTimingNames["DOM_INTERACTIVE"] = "domInteractive";
+    PerformanceTimingNames["DOMAIN_LOOKUP_END"] = "domainLookupEnd";
+    PerformanceTimingNames["DOMAIN_LOOKUP_START"] = "domainLookupStart";
+    PerformanceTimingNames["ENCODED_BODY_SIZE"] = "encodedBodySize";
+    PerformanceTimingNames["FETCH_START"] = "fetchStart";
+    PerformanceTimingNames["LOAD_EVENT_END"] = "loadEventEnd";
+    PerformanceTimingNames["LOAD_EVENT_START"] = "loadEventStart";
+    PerformanceTimingNames["NAVIGATION_START"] = "navigationStart";
+    PerformanceTimingNames["REDIRECT_END"] = "redirectEnd";
+    PerformanceTimingNames["REDIRECT_START"] = "redirectStart";
+    PerformanceTimingNames["REQUEST_START"] = "requestStart";
+    PerformanceTimingNames["RESPONSE_END"] = "responseEnd";
+    PerformanceTimingNames["RESPONSE_START"] = "responseStart";
+    PerformanceTimingNames["SECURE_CONNECTION_START"] = "secureConnectionStart";
+    PerformanceTimingNames["UNLOAD_EVENT_END"] = "unloadEventEnd";
+    PerformanceTimingNames["UNLOAD_EVENT_START"] = "unloadEventStart";
+})(PerformanceTimingNames || (PerformanceTimingNames = {}));
+//# sourceMappingURL=PerformanceTimingNames.js.map

package/build/esm/enums/PerformanceTimingNames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceTimingNames.js","sourceRoot":"","sources":["../../../src/enums/PerformanceTimingNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,CAAN,IAAY,sBAuBX;AAvBD,WAAY,sBAAsB;IAChC,oDAA0B,CAAA;IAC1B,wDAA8B,CAAA;IAC9B,+DAAqC,CAAA;IACrC,sDAA4B,CAAA;IAC5B,mFAAyD,CAAA;IACzD,uFAA6D,CAAA;IAC7D,4DAAkC,CAAA;IAClC,+DAAqC,CAAA;IACrC,mEAAyC,CAAA;IACzC,+DAAqC,CAAA;IACrC,oDAA0B,CAAA;IAC1B,yDAA+B,CAAA;IAC/B,6DAAmC,CAAA;IACnC,8DAAoC,CAAA;IACpC,sDAA4B,CAAA;IAC5B,0DAAgC,CAAA;IAChC,wDAA8B,CAAA;IAC9B,sDAA4B,CAAA;IAC5B,0DAAgC,CAAA;IAChC,2EAAiD,CAAA;IACjD,6DAAmC,CAAA;IACnC,iEAAuC,CAAA;AACzC,CAAC,EAvBW,sBAAsB,KAAtB,sBAAsB,QAuBjC","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\nexport enum PerformanceTimingNames {\n  CONNECT_END = 'connectEnd',\n  CONNECT_START = 'connectStart',\n  DECODED_BODY_SIZE = 'decodedBodySize',\n  DOM_COMPLETE = 'domComplete',\n  DOM_CONTENT_LOADED_EVENT_END = 'domContentLoadedEventEnd',\n  DOM_CONTENT_LOADED_EVENT_START = 'domContentLoadedEventStart',\n  DOM_INTERACTIVE = 'domInteractive',\n  DOMAIN_LOOKUP_END = 'domainLookupEnd',\n  DOMAIN_LOOKUP_START = 'domainLookupStart',\n  ENCODED_BODY_SIZE = 'encodedBodySize',\n  FETCH_START = 'fetchStart',\n  LOAD_EVENT_END = 'loadEventEnd',\n  LOAD_EVENT_START = 'loadEventStart',\n  NAVIGATION_START = 'navigationStart',\n  REDIRECT_END = 'redirectEnd',\n  REDIRECT_START = 'redirectStart',\n  REQUEST_START = 'requestStart',\n  RESPONSE_END = 'responseEnd',\n  RESPONSE_START = 'responseStart',\n  SECURE_CONNECTION_START = 'secureConnectionStart',\n  UNLOAD_EVENT_END = 'unloadEventEnd',\n  UNLOAD_EVENT_START = 'unloadEventStart',\n}\n"]}

package/build/esm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './WebTracerProvider';
+export * from './StackContextManager';
+export * from './enums/PerformanceTimingNames';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/build/esm/index.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './WebTracerProvider';
+export * from './StackContextManager';
+export * from './enums/PerformanceTimingNames';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.js.map

package/build/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC","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\nexport * from './WebTracerProvider';\nexport * from './StackContextManager';\nexport * from './enums/PerformanceTimingNames';\nexport * from './types';\nexport * from './utils';\n"]}

package/build/esm/types.d.ts

@@ -0,0 +1,46 @@
+import { PerformanceTimingNames } from './enums/PerformanceTimingNames';
+export declare type PerformanceEntries = {
+    [PerformanceTimingNames.CONNECT_END]?: number;
+    [PerformanceTimingNames.CONNECT_START]?: number;
+    [PerformanceTimingNames.DECODED_BODY_SIZE]?: number;
+    [PerformanceTimingNames.DOM_COMPLETE]?: number;
+    [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_END]?: number;
+    [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_START]?: number;
+    [PerformanceTimingNames.DOM_INTERACTIVE]?: number;
+    [PerformanceTimingNames.DOMAIN_LOOKUP_END]?: number;
+    [PerformanceTimingNames.DOMAIN_LOOKUP_START]?: number;
+    [PerformanceTimingNames.ENCODED_BODY_SIZE]?: number;
+    [PerformanceTimingNames.FETCH_START]?: number;
+    [PerformanceTimingNames.LOAD_EVENT_END]?: number;
+    [PerformanceTimingNames.LOAD_EVENT_START]?: number;
+    [PerformanceTimingNames.REDIRECT_END]?: number;
+    [PerformanceTimingNames.REDIRECT_START]?: number;
+    [PerformanceTimingNames.REQUEST_START]?: number;
+    [PerformanceTimingNames.RESPONSE_END]?: number;
+    [PerformanceTimingNames.RESPONSE_START]?: number;
+    [PerformanceTimingNames.SECURE_CONNECTION_START]?: number;
+    [PerformanceTimingNames.UNLOAD_EVENT_END]?: number;
+    [PerformanceTimingNames.UNLOAD_EVENT_START]?: number;
+};
+/**
+ * This interface defines a fallback to read performance metrics,
+ * this happens for example on Safari Mac
+ */
+export interface PerformanceLegacy {
+    timing?: PerformanceEntries;
+}
+/**
+ * This interface is used in {@link getResource} function to return
+ *     main request and it's corresponding PreFlight request
+ */
+export interface PerformanceResourceTimingInfo {
+    corsPreFlightRequest?: PerformanceResourceTiming;
+    mainRequest?: PerformanceResourceTiming;
+}
+declare type PropagateTraceHeaderCorsUrl = string | RegExp;
+/**
+ * urls which should include trace headers when origin doesn't match
+ */
+export declare type PropagateTraceHeaderCorsUrls = PropagateTraceHeaderCorsUrl | PropagateTraceHeaderCorsUrl[];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/build/esm/types.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PerformanceTimingNames } from './enums/PerformanceTimingNames';
+//# sourceMappingURL=types.js.map

package/build/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC","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 */\nimport { PerformanceTimingNames } from './enums/PerformanceTimingNames';\n\nexport type PerformanceEntries = {\n  [PerformanceTimingNames.CONNECT_END]?: number;\n  [PerformanceTimingNames.CONNECT_START]?: number;\n  [PerformanceTimingNames.DECODED_BODY_SIZE]?: number;\n  [PerformanceTimingNames.DOM_COMPLETE]?: number;\n  [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_END]?: number;\n  [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_START]?: number;\n  [PerformanceTimingNames.DOM_INTERACTIVE]?: number;\n  [PerformanceTimingNames.DOMAIN_LOOKUP_END]?: number;\n  [PerformanceTimingNames.DOMAIN_LOOKUP_START]?: number;\n  [PerformanceTimingNames.ENCODED_BODY_SIZE]?: number;\n  [PerformanceTimingNames.FETCH_START]?: number;\n  [PerformanceTimingNames.LOAD_EVENT_END]?: number;\n  [PerformanceTimingNames.LOAD_EVENT_START]?: number;\n  [PerformanceTimingNames.REDIRECT_END]?: number;\n  [PerformanceTimingNames.REDIRECT_START]?: number;\n  [PerformanceTimingNames.REQUEST_START]?: number;\n  [PerformanceTimingNames.RESPONSE_END]?: number;\n  [PerformanceTimingNames.RESPONSE_START]?: number;\n  [PerformanceTimingNames.SECURE_CONNECTION_START]?: number;\n  [PerformanceTimingNames.UNLOAD_EVENT_END]?: number;\n  [PerformanceTimingNames.UNLOAD_EVENT_START]?: number;\n};\n\n/**\n * This interface defines a fallback to read performance metrics,\n * this happens for example on Safari Mac\n */\nexport interface PerformanceLegacy {\n  timing?: PerformanceEntries;\n}\n\n/**\n * This interface is used in {@link getResource} function to return\n *     main request and it's corresponding PreFlight request\n */\nexport interface PerformanceResourceTimingInfo {\n  corsPreFlightRequest?: PerformanceResourceTiming;\n  mainRequest?: PerformanceResourceTiming;\n}\n\ntype PropagateTraceHeaderCorsUrl = string | RegExp;\n\n/**\n * urls which should include trace headers when origin doesn't match\n */\nexport type PropagateTraceHeaderCorsUrls =\n  | PropagateTraceHeaderCorsUrl\n  | PropagateTraceHeaderCorsUrl[];\n"]}

package/build/esm/utils.d.ts

@@ -0,0 +1,81 @@
+import { PerformanceEntries, PerformanceResourceTimingInfo, PropagateTraceHeaderCorsUrls } from './types';
+import * as api from '@opentelemetry/api';
+/**
+ * Helper function to be able to use enum as typed key in type and in interface when using forEach
+ * @param obj
+ * @param key
+ */
+export declare function hasKey<O>(obj: O, key: keyof any): key is keyof O;
+/**
+ * Helper function for starting an event on span based on {@link PerformanceEntries}
+ * @param span
+ * @param performanceName name of performance entry for time start
+ * @param entries
+ */
+export declare function addSpanNetworkEvent(span: api.Span, performanceName: string, entries: PerformanceEntries): api.Span | undefined;
+/**
+ * Helper function for adding network events
+ * @param span
+ * @param resource
+ */
+export declare function addSpanNetworkEvents(span: api.Span, resource: PerformanceEntries): void;
+/**
+ * sort resources by startTime
+ * @param filteredResources
+ */
+export declare function sortResources(filteredResources: PerformanceResourceTiming[]): PerformanceResourceTiming[];
+/**
+ * Get closest performance resource ignoring the resources that have been
+ * already used.
+ * @param spanUrl
+ * @param startTimeHR
+ * @param endTimeHR
+ * @param resources
+ * @param ignoredResources
+ * @param initiatorType
+ */
+export declare function getResource(spanUrl: string, startTimeHR: api.HrTime, endTimeHR: api.HrTime, resources: PerformanceResourceTiming[], ignoredResources?: WeakSet<PerformanceResourceTiming>, initiatorType?: string): PerformanceResourceTimingInfo;
+/**
+ * The URLLike interface represents an URL and HTMLAnchorElement compatible fields.
+ */
+export interface URLLike {
+    hash: string;
+    host: string;
+    hostname: string;
+    href: string;
+    readonly origin: string;
+    password: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    username: string;
+}
+/**
+ * Parses url using URL constructor or fallback to anchor element.
+ * @param url
+ */
+export declare function parseUrl(url: string): URLLike;
+/**
+ * Parses url using URL constructor or fallback to anchor element and serialize
+ * it to a string.
+ *
+ * Performs the steps described in https://html.spec.whatwg.org/multipage/urls-and-fetching.html#parse-a-url
+ *
+ * @param url
+ */
+export declare function normalizeUrl(url: string): string;
+/**
+ * Get element XPath
+ * @param target - target element
+ * @param optimised - when id attribute of element is present the xpath can be
+ * simplified to contain id
+ */
+export declare function getElementXPath(target: any, optimised?: boolean): string;
+/**
+ * Checks if trace headers should be propagated
+ * @param spanUrl
+ * @private
+ */
+export declare function shouldPropagateTraceHeaders(spanUrl: string, propagateTraceHeaderCorsUrls?: PropagateTraceHeaderCorsUrls): boolean;
+//# sourceMappingURL=utils.d.ts.map