@opentelemetry/sdk-trace-web
Version:
113 lines • 3.81 kB
JavaScript
"use strict";
/*
* 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.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.StackContextManager = void 0;
const api_1 = require("@opentelemetry/api");
/**
* Stack Context Manager for managing the state in web
* it doesn't fully support the async calls though
*/
class StackContextManager {
/**
* whether the context manager is enabled or not
*/
_enabled = false;
/**
* Keeps the reference to current context
*/
_currentContext = api_1.ROOT_CONTEXT;
/**
*
* @param context
* @param target Function to be executed within the context
*/
// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
_bindFunction(context = api_1.ROOT_CONTEXT, target) {
const manager = this;
const contextWrapper = function (...args) {
return manager.with(context, () => target.apply(this, args));
};
Object.defineProperty(contextWrapper, 'length', {
enumerable: false,
configurable: true,
writable: false,
value: target.length,
});
return contextWrapper;
}
/**
* Returns the active context
*/
active() {
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.
*/
bind(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)
*/
disable() {
this._currentContext = api_1.ROOT_CONTEXT;
this._enabled = false;
return this;
}
/**
* Enables the context manager and creates a default(root) context
*/
enable() {
if (this._enabled) {
return this;
}
this._enabled = true;
this._currentContext = api_1.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
*/
with(context, fn, thisArg, ...args) {
const previousContext = this._currentContext;
this._currentContext = context || api_1.ROOT_CONTEXT;
try {
return fn.call(thisArg, ...args);
}
finally {
this._currentContext = previousContext;
}
}
}
exports.StackContextManager = StackContextManager;
//# sourceMappingURL=StackContextManager.js.map