@moostjs/otel 0.4.6 → 0.4.8

package/dist/index.cjs

@@ -2,7 +2,11 @@
 
 var api = require('@opentelemetry/api');
 var moost = require('moost');
+var crypto = require('crypto');
+var node_async_hooks = require('node:async_hooks');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 
+const spanStack = [];
 function useOtelContext() {
     const store = moost.useAsyncEventContext().store('otel');
     const getSpan = () => store.get('span');
@@ -22,23 +26,42 @@ function useOtelContext() {
         }
         return {};
     };
+    const pushSpan = (span) => {
+        const activeSpan = api.trace.getActiveSpan();
+        if (activeSpan) {
+            const origEnd = activeSpan.end;
+            Object.assign(activeSpan, {
+                end: (t) => {
+                    popSpan();
+                    const i = spanStack.indexOf(activeSpan);
+                    if (i >= 0) {
+                        spanStack.splice(i, 1);
+                    }
+                    origEnd.apply(span, [t]);
+                },
+            });
+            spanStack.push(activeSpan);
+        }
+        api.trace.setSpan(api.context.active(), span);
+    };
+    const popSpan = () => {
+        const span = spanStack.pop();
+        if (span) {
+            api.trace.setSpan(api.context.active(), span);
+        }
+    };
     return {
         trace: api.trace,
         withChildSpan: (name, cb, opts) => {
-            const parentSpan = getSpan();
-            if (parentSpan) {
-                const tracer = api.trace.getTracer('moost-tracer');
-                const span = tracer.startSpan(name, opts);
-                return () => api.context.with(api.trace.setSpan(api.context.active(), span), () => cb());
-            }
-            else {
-                return cb();
-            }
+            const tracer = api.trace.getTracer('moost-tracer');
+            const span = tracer.startSpan(name, opts);
+            return () => api.context.with(api.trace.setSpan(api.context.active(), span), cb);
         },
         getSpan,
         getSpanContext,
         getPropagationHeaders,
         registerSpan: (span) => store.set('span', span),
+        pushSpan,
     };
 }
 function useTrace() {
@@ -55,59 +78,1107 @@ function useOtelPropagation() {
     };
 }
 
-function enableOtelForMoost() {
-    moost.eventContextHooks.onStartEvent((eventType) => {
-        if (eventType === 'init') {
-            return;
+const meter = api.metrics.getMeter('moost-meter');
+const moostMetrics = {
+    httpRequestCount: meter.createCounter('http.server.requests', {
+        description: 'The number of HTTP requests received',
+    }),
+    httpResponseCount: meter.createCounter('http.server.responses', {
+        description: 'The number of HTTP responses sent',
+    }),
+    httpActiveRequests: meter.createUpDownCounter('http.server.active_requests', {
+        description: 'The number of active HTTP requests',
+    }),
+    httpRequestSize: meter.createHistogram('http.server.request.size', {
+        description: 'The size of HTTP request bodies',
+    }),
+    httpResponseSize: meter.createHistogram('http.server.response.size', {
+        description: 'The size of HTTP response bodies',
+    }),
+    httpErrorCount: meter.createCounter('http.server.errors', {
+        description: 'The number of HTTP requests that resulted in an error',
+    }),
+    moostEventCount: meter.createCounter('moost.events.count', {
+        description: 'The number of HTTP requests received',
+    }),
+    moostActiveEvents: meter.createUpDownCounter('moost.events.active', {
+        description: 'The number of active HTTP requests',
+    }),
+    moostErrorCount: meter.createCounter('moost.events.errors', {
+        description: 'The number of HTTP requests that resulted in an error',
+    }),
+};
+
+const tracer = api.trace.getTracer('moost-tracer');
+class SpanInjector extends moost.ContextInjector {
+    with(name, attributes, cb) {
+        const fn = typeof attributes === 'function' ? attributes : cb;
+        const attrs = typeof attributes === 'object' ? attributes : undefined;
+        if (name === 'Event:start' && attrs?.eventType) {
+            return this.startEvent(name, attrs.eventType, fn);
         }
+        else if (name !== 'Event:start') {
+            if (this.getIgnoreSpan()) {
+                return fn();
+            }
+            else {
+                const span = tracer.startSpan(name, {
+                    attributes: attrs,
+                });
+                return this.withSpan(span, fn, {
+                    rootSpan: false,
+                    endSpan: true,
+                });
+            }
+        }
+        return fn();
+    }
+    patchRsponse() {
+        const res = this.getResponse();
+        if (res) {
+            const originalWriteHead = res.writeHead;
+            Object.assign(res, {
+                writeHead: (arg0, arg1, arg2) => {
+                    res._statusCode = arg0;
+                    const headers = typeof arg2 === 'object' ? arg2 : typeof arg1 === 'object' ? arg1 : undefined;
+                    res._contentLength = headers?.['content-length'] ? Number(headers['content-length']) : 0;
+                    return originalWriteHead.apply(res, [arg0, arg1, arg2]);
+                },
+            });
+        }
+    }
+    startEvent(name, eventType, cb) {
         const { registerSpan } = useOtelContext();
-        let span;
+        let span = api.trace.getActiveSpan();
         if (eventType === 'HTTP') {
-            span = api.trace.getSpan(api.context.active());
+            this.patchRsponse();
         }
         else {
-            const tracer = api.trace.getTracer('moost-tracer');
             span = tracer.startSpan(`${eventType} Event`);
         }
         if (span) {
             registerSpan(span);
+            return this.withSpan(span, cb, {
+                rootSpan: true,
+                endSpan: eventType !== 'HTTP',
+            });
         }
-    });
-    moost.eventContextHooks.onEndEvent((eventType, abortReason) => {
-        if (eventType === 'init') {
-            return;
+        return cb();
+    }
+    getEventType() {
+        return moost.useAsyncEventContext().getCtx().event.type;
+    }
+    getIgnoreSpan() {
+        const { getMethodMeta, getControllerMeta } = moost.useControllerContext();
+        const cMeta = getControllerMeta();
+        const mMeta = getMethodMeta();
+        return cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan;
+    }
+    getControllerHandlerMeta() {
+        const { getMethod, getMethodMeta, getController, getControllerMeta, getRoute } = moost.useControllerContext();
+        const methodName = getMethod();
+        const cMeta = getControllerMeta();
+        const mMeta = getMethodMeta();
+        return {
+            ignoreMeter: cMeta?.otelIgnoreMeter || mMeta?.otelIgnoreMeter,
+            ignoreSpan: cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
+            attrs: {
+                'moost.controller': moost.getConstructor(getController()).name,
+                'moost.handler': methodName,
+                'moost.handler_description': mMeta?.description,
+                'moost.handler_label': mMeta?.label,
+                'moost.handler_id': mMeta?.id,
+                'moost.ignore': cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
+                'moost.route': getRoute(),
+                'moost.event_type': this.getEventType(),
+            },
+        };
+    }
+    hook(name, route) {
+        moost.useAsyncEventContext().store('otel').set('route', route);
+        const chm = this.getControllerHandlerMeta();
+        if (!chm.ignoreMeter) {
+            this.startEventMetrics(chm.attrs, route);
         }
         const { getSpan } = useOtelContext();
         const span = getSpan();
         if (span) {
-            const { getMethod, getMethodMeta, getController } = moost.useControllerContext();
-            const methodName = getMethod();
-            const methodMeta = getMethodMeta();
-            span.setAttributes({
-                'custom.event_type': eventType,
-                'custom.event_description': methodMeta?.description || methodMeta?.label || methodName,
-                'moost.controller': moost.getConstructor(getController()).name,
-                'moost.handler': methodName,
-            });
-            if (abortReason) {
-                span.recordException(new Error(abortReason));
-                span.setStatus({ code: api.SpanStatusCode.ERROR, message: abortReason });
-            }
-            if (eventType === 'HTTP') {
-                const req = moost.useAsyncEventContext()
-                    .store('event')
-                    .get('req');
-                span.updateName(`${req?.method || ''} ${methodMeta?.id || methodMeta?.label || methodName}`);
+            span.setAttributes(chm.attrs);
+            if (chm.attrs['moost.event_type'] === 'HTTP') {
+                span.updateName(`${this.getRequest()?.method || ''} ${route || '<unresolved>'}`);
             }
             else {
-                span.updateName(`${methodMeta?.label || methodName}`);
+                span.updateName(`${chm.attrs['moost.event_type']} ${route || '<unresolved>'}`);
+            }
+        }
+    }
+    withSpan(span, cb, opts) {
+        let result;
+        let exception;
+        const endSpan = (error) => {
+            if (error) {
+                span.recordException(error);
+            }
+            if (opts.rootSpan) {
+                const chm = this.getControllerHandlerMeta();
+                if (!chm.ignoreMeter) {
+                    this.endEventMetrics(chm.attrs, error);
+                }
+            }
+            if (opts.endSpan) {
                 span.end();
             }
+        };
+        api.context.with(api.trace.setSpan(api.context.active(), span), () => {
+            try {
+                result = cb();
+            }
+            catch (error) {
+                exception = error;
+                endSpan(exception);
+            }
+        });
+        const ret = result;
+        if (!exception) {
+            if (ret && ret instanceof Promise) {
+                ret
+                    .then(r => {
+                    endSpan();
+                    return r;
+                })
+                    .catch(error => {
+                    endSpan(error);
+                });
+            }
+            else {
+                endSpan();
+            }
         }
+        return ret;
+    }
+    startEventMetrics(a, route) {
+        if (a['moost.event_type'] === 'HTTP') {
+            const req = this.getRequest();
+            const attrs = {
+                ...a,
+                route,
+                url: req?.url,
+            };
+            moostMetrics.httpRequestCount.add(1, attrs);
+            moostMetrics.httpActiveRequests.add(1, attrs);
+        }
+        const attrs = {
+            ...a,
+            route,
+        };
+        moostMetrics.moostEventCount.add(1, attrs);
+        moostMetrics.moostActiveEvents.add(1, attrs);
+    }
+    endEventMetrics(a, error) {
+        const route = moost.useAsyncEventContext().store('otel').get('route');
+        if (a['moost.event_type'] === 'HTTP') {
+            const req = this.getRequest();
+            const res = this.getResponse();
+            const attrs = {
+                ...a,
+                route,
+                url: req?.url,
+            };
+            moostMetrics.httpActiveRequests.add(-1, attrs);
+            if (error) {
+                moostMetrics.httpErrorCount.add(1, attrs);
+            }
+            moostMetrics.httpRequestSize.record(req?.socket.bytesRead || 0, attrs);
+            moostMetrics.httpResponseSize.record(res?._contentLength || 0, attrs);
+            moostMetrics.httpResponseCount.add(1, { ...attrs, status: res?._statusCode });
+        }
+        const attrs = {
+            ...a,
+            route,
+        };
+        moostMetrics.moostActiveEvents.add(-1, attrs);
+        if (error) {
+            moostMetrics.moostErrorCount.add(1, attrs);
+        }
+    }
+    getRequest() {
+        return moost.useAsyncEventContext().store('event').get('req');
+    }
+    getResponse() {
+        return moost.useAsyncEventContext()
+            .store('event')
+            .get('res');
+    }
+}
+
+function enableOtelForMoost() {
+    moost.replaceContextInjector(new SpanInjector());
+}
+
+function getConstructor$1(instance) {
+    return isConstructor(instance) ?
+        instance : instance.constructor ?
+        instance.constructor : Object.getPrototypeOf(instance).constructor;
+}
+function isConstructor(v) {
+    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
+}
+
+const classMetadata = new WeakMap();
+const paramMetadata = new WeakMap();
+const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
+function getMetaObject(target, prop) {
+    const isParam = typeof prop !== 'undefined';
+    const metadata = isParam ? paramMetadata : classMetadata;
+    const targetKey = getConstructor$1(target);
+    let meta = metadata.get(targetKey);
+    if (!meta) {
+        meta = {};
+        metadata.set(targetKey, meta);
+    }
+    if (isParam) {
+        meta = (meta[prop] =
+            meta[prop] || {});
+    }
+    return meta;
+}
+const _reflect = {
+    getOwnMetadata(key, target, prop) {
+        return getMetaObject(target, prop)[key];
+    },
+    defineMetadata(key, data, target, prop) {
+        const meta = getMetaObject(target, prop);
+        meta[key] = data;
+    },
+    metadata(key, data) {
+        return ((target, propKey) => {
+            Reflect$1.defineMetadata(key, data, target, propKey);
+        });
+    },
+};
+if (!root.Reflect) {
+    root.Reflect = _reflect;
+}
+else {
+    const funcs = [
+        'getOwnMetadata',
+        'defineMetadata',
+        'metadata',
+    ];
+    const target = root.Reflect;
+    for (const func of funcs) {
+        if (typeof target[func] !== 'function') {
+            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
+        }
+    }
+}
+const Reflect$1 = _reflect;
+
+const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
+class Mate {
+    constructor(workspace, options = {}) {
+        this.workspace = workspace;
+        this.options = options;
+        this.logger = options.logger || console;
+    }
+    set(args, key, value, isArray) {
+        var _a;
+        let level = 'CLASS';
+        const newArgs = args.level === 'CLASS' ? { target: args.target }
+            : args.level === 'PROP' ? { target: args.target, propKey: args.propKey }
+                : args;
+        let meta = (Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
+        if (newArgs.propKey && this.options.readReturnType && !meta.returnType && args.descriptor) {
+            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
+        }
+        if (newArgs.propKey && this.options.readType && !meta.type) {
+            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
+        }
+        const { index } = newArgs;
+        const cb = typeof key === 'function' ? key : undefined;
+        let data = meta;
+        if (!data.params) {
+            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
+        }
+        if (typeof index === 'number') {
+            level = 'PARAM';
+            data.params = data.params || [];
+            data.params[index] = data.params[index] || {
+                type: undefined,
+            };
+            if (cb) {
+                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
+            }
+            else {
+                data = data.params[index];
+            }
+        }
+        else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== 'CLASS') {
+            this.set({ ...args, level: 'CLASS' }, (meta) => {
+                if (!meta.properties) {
+                    meta.properties = [args.propKey];
+                }
+                else if (!meta.properties.includes(args.propKey)) {
+                    meta.properties.push(args.propKey);
+                }
+                return meta;
+            });
+        }
+        level = typeof index === 'number' ? 'PARAM' : newArgs.propKey && newArgs.descriptor ? 'METHOD' : newArgs.propKey ? 'PROP' : 'CLASS';
+        if (typeof key !== 'function') {
+            if (isArray) {
+                const newArray = (data[key] || []);
+                if (!Array.isArray(newArray)) {
+                    this.logger.error('Mate.add (isArray=true) called for non-array metadata');
+                }
+                newArray.unshift(value);
+                data[key] = newArray;
+            }
+            else {
+                data[key] = value;
+            }
+        }
+        else if (cb && typeof index !== 'number') {
+            meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
+        }
+        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
+    }
+    read(target, propKey) {
+        var _a;
+        const isConstr = isConstructor(target);
+        const constructor = isConstr ? target : getConstructor$1(target);
+        const proto = constructor.prototype;
+        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
+        if (ownMeta && propKey === undefined && ownMeta.params === undefined) {
+            const parent = Object.getPrototypeOf(constructor);
+            if (typeof parent === 'function' &&
+                parent !== fnProto &&
+                parent !== constructor) {
+                ownMeta.params = (_a = this.read(parent)) === null || _a === void 0 ? void 0 : _a.params;
+            }
+        }
+        if (this.options.inherit) {
+            const inheritFn = typeof this.options.inherit === 'function'
+                ? this.options.inherit
+                : undefined;
+            let shouldInherit = this.options.inherit;
+            if (inheritFn) {
+                if (typeof propKey === 'string') {
+                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
+                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
+                }
+                else {
+                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
+                }
+            }
+            if (shouldInherit) {
+                const parent = Object.getPrototypeOf(constructor);
+                if (typeof parent === 'function' &&
+                    parent !== fnProto &&
+                    parent !== constructor) {
+                    const inheritedMeta = (this.read(parent, propKey) ||
+                        {});
+                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
+                    ownMeta = { ...inheritedMeta, ...ownMeta };
+                    if (typeof propKey === 'string' &&
+                        ownParams &&
+                        (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
+                        for (let i = 0; i < ownParams.length; i++) {
+                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !==
+                                'undefined') {
+                                const ownParam = ownParams[i];
+                                if (ownMeta.params &&
+                                    inheritFn &&
+                                    inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string'
+                                        ? propKey
+                                        : undefined)) {
+                                    ownMeta.params[i] = {
+                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
+                                        ...ownParams[i],
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return ownMeta;
+    }
+    apply(...decorators) {
+        return ((target, propKey, descriptor) => {
+            for (const d of decorators) {
+                d(target, propKey, descriptor);
+            }
+        });
+    }
+    decorate(key, value, isArray, level) {
+        return ((target, propKey, descriptor) => {
+            const args = {
+                target,
+                propKey,
+                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
+                index: typeof descriptor === 'number' ? descriptor : undefined,
+                level,
+            };
+            this.set(args, key, value, isArray);
+        });
+    }
+    decorateConditional(ccb) {
+        return ((target, propKey, descriptor) => {
+            const hasIndex = typeof descriptor === 'number';
+            const decoratorLevel = hasIndex ? 'PARAM' : propKey && descriptor ? 'METHOD' : propKey ? 'PROP' : 'CLASS';
+            const d = ccb(decoratorLevel);
+            if (d) {
+                d(target, propKey, descriptor);
+            }
+        });
+    }
+    decorateClass(key, value, isArray) {
+        return this.decorate(key, value, isArray, 'CLASS');
+    }
+}
+const fnProto = Object.getPrototypeOf(Function);
+
+const defaultLevels = [
+    'fatal',
+    'error',
+    'warn',
+    'log',
+    'info',
+    'debug',
+    'trace',
+];
+const defaultMappedLevels = new Map();
+defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
+
+function attachHook(target, opts, name) {
+    Object.defineProperty(target, name || 'value', {
+        get: opts.get,
+        set: opts.set,
     });
+    return target;
+}
+
+const asyncStorage = new node_async_hooks.AsyncLocalStorage();
+function useAsyncEventContext(expectedTypes) {
+    let cc = asyncStorage.getStore();
+    if (!cc) {
+        throw new Error('Event context does not exist at this point.');
+    }
+    if (expectedTypes || typeof expectedTypes === 'string') {
+        const type = cc.event.type;
+        const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
+        if (!types.includes(type)) {
+            if (cc.parentCtx?.event.type && types.includes(cc.parentCtx.event.type)) {
+                cc = cc.parentCtx;
+            }
+            else {
+                throw new Error(`Event context type mismatch: expected ${types
+                    .map(t => `"${t}"`)
+                    .join(', ')}, received "${type}"`);
+            }
+        }
+    }
+    return _getCtxHelpers(cc);
+}
+function _getCtxHelpers(cc) {
+    function store(key) {
+        const obj = {
+            value: null,
+            hook,
+            init,
+            set: setNested,
+            get: getNested,
+            has: hasNested,
+            del: delNested,
+            entries,
+            clear,
+        };
+        attachHook(obj, {
+            set: v => {
+                set(key, v);
+            },
+            get: () => get(key),
+        });
+        function init(key2, getter) {
+            if (hasNested(key2)) {
+                return getNested(key2);
+            }
+            return setNested(key2, getter());
+        }
+        function hook(key2) {
+            const obj = {
+                value: null,
+                isDefined: null,
+            };
+            attachHook(obj, {
+                set: v => setNested(key2, v),
+                get: () => getNested(key2),
+            });
+            attachHook(obj, {
+                get: () => hasNested(key2),
+            }, 'isDefined');
+            return obj;
+        }
+        function setNested(key2, v) {
+            if (obj.value === undefined) {
+                obj.value = {};
+            }
+            obj.value[key2] = v;
+            return v;
+        }
+        function delNested(key2) {
+            setNested(key2, undefined);
+        }
+        function getNested(key2) {
+            return (obj.value || {})[key2];
+        }
+        function hasNested(key2) {
+            return (obj.value || {})[key2] !== undefined;
+        }
+        function entries() {
+            return Object.entries(obj.value || {});
+        }
+        function clear() {
+            obj.value = {};
+        }
+        return obj;
+    }
+    function getCtx() {
+        return cc;
+    }
+    function get(key) {
+        return getCtx()[key];
+    }
+    function set(key, v) {
+        getCtx()[key] = v;
+    }
+    const hasParentCtx = () => !!cc.parentCtx;
+    return {
+        getCtx,
+        store,
+        getStore: get,
+        setStore: set,
+        setParentCtx: (parentCtx) => {
+            cc.parentCtx = parentCtx;
+        },
+        hasParentCtx,
+        getParentCtx: () => {
+            if (!hasParentCtx()) {
+                throw new Error('Parent context is not available');
+            }
+            return _getCtxHelpers(cc.parentCtx);
+        },
+    };
+}
+
+function useEventId() {
+    const { store } = useAsyncEventContext();
+    const { init } = store('event');
+    const getId = () => init('id', () => crypto.randomUUID());
+    return { getId };
+}
+
+function getConstructor(instance) {
+    return Object.getPrototypeOf(instance).constructor;
+}
+
+const globalRegistry = {};
+const UNDEFINED = Symbol('undefined');
+class Infact {
+    constructor(options) {
+        this.options = options;
+        this.registry = {};
+        this.instanceRegistries = new WeakMap();
+        this.scopes = {};
+        this._silent = false;
+        this.logger = options.logger || console;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    silent(value = 'logs') {
+        this._silent = value;
+    }
+    registerScope(scopeId) {
+        if (!this.scopes[scopeId]) {
+            this.scopes[scopeId] = {};
+        }
+    }
+    unregisterScope(scopeId) {
+        delete this.scopes[scopeId];
+    }
+    getForInstance(instance, classConstructor, opts) {
+        const registries = this.getInstanceRegistries(instance);
+        return this.get(classConstructor, {
+            ...opts,
+            provide: registries.provide || {},
+            replace: registries.replace,
+            customData: registries.customData,
+        });
+    }
+    async get(classConstructor, opts, optional = false) {
+        const result = await this._get(classConstructor, opts, optional);
+        if (result) {
+            const { instance, mergedProvide, replace } = result;
+            if (this.options.storeProvideRegByInstance) {
+                this.setInstanceRegistries(instance, mergedProvide, replace, opts === null || opts === void 0 ? void 0 : opts.customData);
+            }
+            return instance;
+        }
+        return undefined;
+    }
+    setInstanceRegistries(instance, provide, replace, customData) {
+        this.instanceRegistries.set(instance, { provide, replace, customData });
+    }
+    getInstanceRegistries(instance) {
+        return this.instanceRegistries.get(instance) || {};
+    }
+    async _get(classConstructor, opts, optional) {
+        const hierarchy = (opts === null || opts === void 0 ? void 0 : opts.hierarchy) || [];
+        const provide = opts === null || opts === void 0 ? void 0 : opts.provide;
+        const replace = opts === null || opts === void 0 ? void 0 : opts.replace;
+        const syncContextFn = opts === null || opts === void 0 ? void 0 : opts.syncContextFn;
+        hierarchy.push(classConstructor.name);
+        let classMeta;
+        let instanceKey = Symbol.for(classConstructor);
+        if (replace && replace[instanceKey]) {
+            classConstructor = replace === null || replace === void 0 ? void 0 : replace[instanceKey];
+            instanceKey = Symbol.for(classConstructor);
+        }
+        try {
+            classMeta = this.options.describeClass(classConstructor);
+        }
+        catch (e) {
+            throw this.panicOwnError(`Could not instantiate "${classConstructor.name}". ` +
+                `An error occored on "describeClass" function.\n${e.message}`, hierarchy);
+        }
+        if (!classMeta || !classMeta.injectable) {
+            if (provide && provide[instanceKey]) {
+                syncContextFn && syncContextFn(classMeta);
+                return {
+                    instance: await getProvidedValue(provide[instanceKey]),
+                    mergedProvide: provide,
+                    replace,
+                };
+            }
+            if (!optional) {
+                throw this.panicOwnError(`Could not instantiate Injectable "${classConstructor.name}". ` +
+                    'Please check if the class is injectable or if you properly typed arguments.', hierarchy);
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (classMeta.scopeId && classMeta.global) {
+            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". ` +
+                'The scoped Injectable is not supported for Global scope.', hierarchy);
+        }
+        if (classMeta.scopeId && !this.scopes[classMeta.scopeId]) {
+            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". ` +
+                'The requested scope isn\'t registered.', hierarchy);
+        }
+        const scope = classMeta.scopeId
+            ? this.scopes[classMeta.scopeId]
+            : {};
+        const mergedProvide = {
+            ...(provide || {}),
+            ...(classMeta.provide || {}),
+        };
+        if (mergedProvide[instanceKey]) {
+            syncContextFn && syncContextFn(classMeta);
+            return {
+                instance: await getProvidedValue(mergedProvide[instanceKey]),
+                mergedProvide,
+                replace,
+            };
+        }
+        if (!this.registry[instanceKey] &&
+            !globalRegistry[instanceKey] &&
+            !scope[instanceKey]) {
+            const registry = classMeta.scopeId
+                ? scope
+                : classMeta.global
+                    ? globalRegistry
+                    : this.registry;
+            const params = classMeta.constructorParams || [];
+            const isCircular = !!params.find((p) => !!p.circular);
+            if (isCircular) {
+                registry[instanceKey] = Object.create(classConstructor.prototype);
+            }
+            const resolvedParams = [];
+            for (let i = 0; i < params.length; i++) {
+                const param = params[i];
+                if (param.inject) {
+                    if (mergedProvide && mergedProvide[param.inject]) {
+                        resolvedParams[i] = getProvidedValue(mergedProvide[param.inject]);
+                    }
+                    else if (param.nullable || param.optional) {
+                        resolvedParams[i] = UNDEFINED;
+                    }
+                    else {
+                        throw this.panicOwnError(`Could not inject ${JSON.stringify(param.inject)} to "${classConstructor.name}" to argument ${param.label
+                            ? `labeled as "${param.label}"`
+                            : `with index ${i}`}`, hierarchy);
+                    }
+                }
+                else if (this.options.resolveParam) {
+                    resolvedParams[i] = this.options.resolveParam({
+                        classMeta,
+                        classConstructor,
+                        index: i,
+                        paramMeta: param,
+                        customData: opts === null || opts === void 0 ? void 0 : opts.customData,
+                    });
+                }
+            }
+            for (let i = 0; i < resolvedParams.length; i++) {
+                const rp = resolvedParams[i];
+                if (rp &&
+                    rp !== UNDEFINED &&
+                    typeof rp.then === 'function') {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedParams[i] = await rp;
+                    }
+                    catch (e) {
+                        const param = params[i];
+                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" ` +
+                            `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
+                    }
+                }
+            }
+            for (let i = 0; i < params.length; i++) {
+                const param = params[i];
+                if (typeof resolvedParams[i] === 'undefined') {
+                    if (param.type === undefined && !param.circular) {
+                        if (this._silent === false) {
+                            this.logger.warn(`${classConstructor.name}.constructor() expects argument ${param.label
+                                ? `labeled as "${param.label}"`
+                                : `#${i}`} that is undefined. This might happen when Circular Dependency occurs. To handle Circular Dependencies please specify circular meta for param.`);
+                        }
+                    }
+                    else if (param.type === undefined && param.circular) {
+                        param.type = param.circular();
+                    }
+                    if (typeof param.type === 'function') {
+                        if ([String, Number, Date, Array].includes(param.type)) {
+                            if (!param.nullable && !param.optional) {
+                                throw this.panicOwnError(`Could not inject "${param.type
+                                    .name}" to "${classConstructor.name}" ` +
+                                    `constructor at index ${i}${param.label
+                                        ? ` (${param.label})`
+                                        : ''}. The param was not resolved to a value.`, hierarchy);
+                            }
+                        }
+                        resolvedParams[i] = this.get(param.type, {
+                            provide: mergedProvide,
+                            replace,
+                            hierarchy,
+                            syncContextFn,
+                            customData: opts === null || opts === void 0 ? void 0 : opts.customData,
+                        }, param.optional || param.nullable);
+                    }
+                }
+                if (resolvedParams[i] === UNDEFINED) {
+                    resolvedParams[i] = undefined;
+                }
+            }
+            for (let i = 0; i < resolvedParams.length; i++) {
+                const rp = resolvedParams[i];
+                if (rp && typeof rp.then === 'function') {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedParams[i] = await rp;
+                    }
+                    catch (e) {
+                        const param = params[i];
+                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" ` +
+                            `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
+                    }
+                }
+            }
+            const instance = new classConstructor(...resolvedParams);
+            if (isCircular) {
+                Object.assign(registry[instanceKey], instance);
+            }
+            else {
+                registry[instanceKey] = instance;
+            }
+            if (this.options.describeProp &&
+                this.options.resolveProp &&
+                classMeta.properties &&
+                classMeta.properties.length) {
+                const resolvedProps = {};
+                for (const prop of classMeta.properties) {
+                    const initialValue = instance[prop];
+                    let propMeta;
+                    try {
+                        propMeta = this.options.describeProp(classConstructor, prop);
+                    }
+                    catch (e) {
+                        throw this.panic(e, `Could not process prop "${prop}" of "${classConstructor.name}". ` +
+                            `An error occored on "describeProp" function.\n${e.message}`, hierarchy);
+                    }
+                    if (propMeta) {
+                        try {
+                            resolvedProps[prop] = this.options.resolveProp({
+                                classMeta,
+                                classConstructor,
+                                initialValue,
+                                key: prop,
+                                instance,
+                                propMeta,
+                                customData: opts === null || opts === void 0 ? void 0 : opts.customData,
+                            });
+                        }
+                        catch (e) {
+                            throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". ` +
+                                'An exception occured: ' +
+                                e.message, hierarchy);
+                        }
+                    }
+                }
+                for (const [prop, value] of Object.entries(resolvedProps)) {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedProps[prop] = value
+                            ? await value
+                            : value;
+                    }
+                    catch (e) {
+                        throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". ` +
+                            'An exception occured: ' +
+                            e.message, hierarchy);
+                    }
+                }
+                Object.assign(instance, resolvedProps);
+            }
+            if (this._silent === false) {
+                this.logger.info(`Class "${'' +
+                    classConstructor.name +
+                    '' +
+                    ''}" instantiated with: ${''}[${resolvedParams
+                    .map((p) => {
+                    switch (typeof p) {
+                        case 'number':
+                        case 'boolean':
+                            return p;
+                        case 'string':
+                            return `"${''}...${''}"`;
+                        case 'object':
+                            if (getConstructor(p))
+                                return getConstructor(p).name;
+                            return '{}';
+                        default:
+                            return '*';
+                    }
+                })
+                    .join(', ')}]`);
+            }
+        }
+        hierarchy.pop();
+        syncContextFn && syncContextFn(classMeta);
+        return {
+            instance: await (scope[instanceKey] ||
+                this.registry[instanceKey] ||
+                globalRegistry[instanceKey]),
+            mergedProvide,
+            replace,
+        };
+    }
+    panic(origError, text, hierarchy) {
+        if (this._silent === true) ;
+        else {
+            this.logger.error(text +
+                (hierarchy
+                    ? '\nHierarchy:\n' + hierarchy.join(' -> ')
+                    : ''));
+        }
+        return origError;
+    }
+    panicOwnError(text, hierarchy) {
+        const e = new Error(text + (hierarchy ? '\nHierarchy:\n' + hierarchy.join(' -> ') : ''));
+        if (this._silent === true) {
+            return e;
+        }
+        else {
+            this.logger.error(e);
+            return e;
+        }
+    }
+}
+function getProvidedValue(meta) {
+    if (!meta.resolved) {
+        meta.resolved = true;
+        meta.value = meta.fn();
+    }
+    return meta.value;
+}
+
+async function runPipes(pipes, initialValue, metas, level) {
+    let v = initialValue;
+    for (const pipe of pipes) {
+        v = await pipe.handler(v, metas, level);
+    }
+    return v;
+}
+
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+    collectPropKeys: true,
+    inherit(classMeta, targetMeta, level) {
+        if (level === 'CLASS') {
+            return !!classMeta?.inherit;
+        }
+        if (level === 'PROP') {
+            return !!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta);
+        }
+        return !!targetMeta?.inherit;
+    },
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+getNewMoostInfact();
+function getNewMoostInfact() {
+    return new Infact({
+        describeClass(classConstructor) {
+            const meta = getMoostMate().read(classConstructor);
+            return {
+                injectable: !!meta?.injectable,
+                global: false,
+                constructorParams: meta?.params || [],
+                provide: meta?.provide,
+                properties: meta?.properties || [],
+                scopeId: meta?.injectable === 'FOR_EVENT' ? useEventId().getId() : undefined,
+            };
+        },
+        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
+            if (paramMeta && customData?.pipes) {
+                return runPipes(customData.pipes, undefined, {
+                    paramMeta,
+                    type: classConstructor,
+                    key: 'constructor',
+                    classMeta: classMeta,
+                    index,
+                    targetMeta: paramMeta,
+                }, 'PARAM');
+            }
+        },
+        describeProp(classConstructor, key) {
+            const meta = getMoostMate().read(classConstructor, key);
+            return meta;
+        },
+        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
+            if (propMeta && customData?.pipes) {
+                return runPipes(customData.pipes, initialValue, {
+                    instance,
+                    type: classConstructor,
+                    key,
+                    propMeta,
+                    targetMeta: propMeta,
+                    classMeta: classMeta,
+                }, 'PROP');
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+getMoostMate().decorate(meta => {
+    if (!meta.injectable) {
+        meta.injectable = true;
+    }
+    return meta;
+});
+
+var TInterceptorPriority;
+(function (TInterceptorPriority) {
+    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
+    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
+    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
+    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
+    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
+    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
+    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
+})(TInterceptorPriority || (TInterceptorPriority = {}));
+
+var TPipePriority;
+(function (TPipePriority) {
+    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
+    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
+    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
+    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
+    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
+    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
+    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
+    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
+    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
+})(TPipePriority || (TPipePriority = {}));
+
+function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
+    fn.priority = priority;
+    return fn;
+}
+
+const resolvePipe = definePipeFn((_value, metas, level) => {
+    const resolver = metas.targetMeta?.resolver;
+    if (resolver) {
+        return resolver(metas, level);
+    }
+    return undefined;
+}, TPipePriority.RESOLVE);
+
+[
+    {
+        handler: resolvePipe,
+        priority: TPipePriority.RESOLVE,
+    },
+];
+
+function getOtelMate() {
+    return getMoostMate();
+}
+
+const mate = getOtelMate();
+const OtelIgnoreSpan = () => mate.decorate('otelIgnoreSpan', true);
+const OtelIgnoreMeter = () => mate.decorate('otelIgnoreMeter', true);
+
+function shouldSpanBeIgnored(span) {
+    return span.attributes['moost.ignore'] === true;
+}
+
+class MoostBatchSpanProcessor extends sdkTraceBase.BatchSpanProcessor {
+    onEnd(span) {
+        if (shouldSpanBeIgnored(span)) {
+            return;
+        }
+        super.onEnd(span);
+    }
+}
+
+class MoostSimpleSpanProcessor extends sdkTraceBase.SimpleSpanProcessor {
+    onEnd(span) {
+        if (shouldSpanBeIgnored(span)) {
+            return;
+        }
+        super.onEnd(span);
+    }
 }
 
+exports.MoostBatchSpanProcessor = MoostBatchSpanProcessor;
+exports.MoostSimpleSpanProcessor = MoostSimpleSpanProcessor;
+exports.OtelIgnoreMeter = OtelIgnoreMeter;
+exports.OtelIgnoreSpan = OtelIgnoreSpan;
+exports.SpanInjector = SpanInjector;
 exports.enableOtelForMoost = enableOtelForMoost;
+exports.getOtelMate = getOtelMate;
+exports.shouldSpanBeIgnored = shouldSpanBeIgnored;
 exports.useOtelContext = useOtelContext;
 exports.useOtelPropagation = useOtelPropagation;
 exports.useSpan = useSpan;