@moostjs/otel 0.4.7 → 0.4.8

package/dist/index.mjs

@@ -1,9 +1,10 @@
-import { trace, context, SpanStatusCode } from '@opentelemetry/api';
-import { useAsyncEventContext as useAsyncEventContext$1, eventContextHooks as eventContextHooks$1, useControllerContext, getConstructor as getConstructor$2 } from 'moost';
+import { trace, context, metrics } from '@opentelemetry/api';
+import { useAsyncEventContext as useAsyncEventContext$1, ContextInjector, useControllerContext, getConstructor as getConstructor$2, replaceContextInjector } from 'moost';
 import { randomUUID } from 'crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
 
+const spanStack = [];
 function useOtelContext() {
     const store = useAsyncEventContext$1().store('otel');
     const getSpan = () => store.get('span');
@@ -23,23 +24,42 @@ function useOtelContext() {
         }
         return {};
     };
+    const pushSpan = (span) => {
+        const activeSpan = 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);
+        }
+        trace.setSpan(context.active(), span);
+    };
+    const popSpan = () => {
+        const span = spanStack.pop();
+        if (span) {
+            trace.setSpan(context.active(), span);
+        }
+    };
     return {
         trace,
         withChildSpan: (name, cb, opts) => {
-            const parentSpan = getSpan();
-            if (parentSpan) {
-                const tracer = trace.getTracer('moost-tracer');
-                const span = tracer.startSpan(name, opts);
-                return () => context.with(trace.setSpan(context.active(), span), () => cb());
-            }
-            else {
-                return cb();
-            }
+            const tracer = trace.getTracer('moost-tracer');
+            const span = tracer.startSpan(name, opts);
+            return () => context.with(trace.setSpan(context.active(), span), cb);
         },
         getSpan,
         getSpanContext,
         getPropagationHeaders,
         registerSpan: (span) => store.set('span', span),
+        pushSpan,
     };
 }
 function useTrace() {
@@ -56,60 +76,468 @@ function useOtelPropagation() {
     };
 }
 
-function enableOtelForMoost() {
-    eventContextHooks$1.onStartEvent((eventType) => {
-        if (eventType === 'init') {
-            return;
+const meter = 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 = trace.getTracer('moost-tracer');
+class SpanInjector extends 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 = trace.getActiveSpan();
         if (eventType === 'HTTP') {
-            span = trace.getSpan(context.active());
+            this.patchRsponse();
         }
         else {
-            const tracer = trace.getTracer('moost-tracer');
             span = tracer.startSpan(`${eventType} Event`);
         }
         if (span) {
             registerSpan(span);
+            return this.withSpan(span, cb, {
+                rootSpan: true,
+                endSpan: eventType !== 'HTTP',
+            });
         }
-    });
-    eventContextHooks$1.onEndEvent((eventType, abortReason) => {
-        if (eventType === 'init') {
-            return;
+        return cb();
+    }
+    getEventType() {
+        return useAsyncEventContext$1().getCtx().event.type;
+    }
+    getIgnoreSpan() {
+        const { getMethodMeta, getControllerMeta } = useControllerContext();
+        const cMeta = getControllerMeta();
+        const mMeta = getMethodMeta();
+        return cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan;
+    }
+    getControllerHandlerMeta() {
+        const { getMethod, getMethodMeta, getController, getControllerMeta, getRoute } = useControllerContext();
+        const methodName = getMethod();
+        const cMeta = getControllerMeta();
+        const mMeta = getMethodMeta();
+        return {
+            ignoreMeter: cMeta?.otelIgnoreMeter || mMeta?.otelIgnoreMeter,
+            ignoreSpan: cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
+            attrs: {
+                'moost.controller': getConstructor$2(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) {
+        useAsyncEventContext$1().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, getControllerMeta } = useControllerContext();
-            const methodName = getMethod();
-            const methodMeta = getMethodMeta();
-            const cMeta = getControllerMeta();
-            span.setAttributes({
-                'custom.event_type': eventType,
-                'custom.event_description': methodMeta?.description || methodMeta?.label || methodName,
-                'moost.controller': getConstructor$2(getController()).name,
-                'moost.handler': methodName,
-                'moost.ignore': cMeta?.otelIgnoreSpan || methodMeta?.otelIgnoreSpan,
-            });
-            if (abortReason) {
-                span.recordException(new Error(abortReason));
-                span.setStatus({ code: SpanStatusCode.ERROR, message: abortReason });
-            }
-            if (eventType === 'HTTP') {
-                const req = useAsyncEventContext$1()
-                    .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();
             }
+        };
+        context.with(trace.setSpan(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 = useAsyncEventContext$1().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 useAsyncEventContext$1().store('event').get('req');
+    }
+    getResponse() {
+        return useAsyncEventContext$1()
+            .store('event')
+            .get('res');
+    }
+}
+
+function enableOtelForMoost() {
+    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',
@@ -122,54 +550,6 @@ const defaultLevels = [
 const defaultMappedLevels = new Map();
 defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
 
-class Hookable {
-    constructor() {
-        this.hooks = {};
-    }
-    hook(name, cb) {
-        if (!this.hooks[name]) {
-            this.hooks[name] = [];
-        }
-        this.hooks[name].push(cb);
-        return () => {
-            this.unhook(name, cb);
-        };
-    }
-    callHook(name, ...args) {
-        if (this.hooks[name]) {
-            for (const cb of this.hooks[name]) {
-                try {
-                    cb(...args);
-                }
-                catch (error) {
-                    console.error(`Error in hook ${name}:`, error);
-                }
-            }
-        }
-    }
-    unhook(name, cb) {
-        if (this.hooks[name]) {
-            this.hooks[name] = this.hooks[name].filter(hookCb => hookCb !== cb);
-        }
-    }
-}
-
-class EventContextHooks extends Hookable {
-    fireStartEvent(eventType) {
-        this.callHook('start-event', eventType);
-    }
-    fireEndEvent(eventType, abortReason) {
-        this.callHook('end-event', eventType, abortReason);
-    }
-    onStartEvent(cb) {
-        return this.hook('start-event', cb);
-    }
-    onEndEvent(cb) {
-        return this.hook('end-event', cb);
-    }
-}
-const eventContextHooks = new EventContextHooks();
-
 function attachHook(target, opts, name) {
     Object.defineProperty(target, name || 'value', {
         get: opts.get,
@@ -275,12 +655,6 @@ function _getCtxHelpers(cc) {
     const hasParentCtx = () => !!cc.parentCtx;
     return {
         getCtx,
-        endEvent: (abortReason) => {
-            if (cc && !cc._ended) {
-                cc._ended = true;
-                eventContextHooks.fireEndEvent(cc.event.type, abortReason);
-            }
-        },
         store,
         getStore: get,
         setStore: set,
@@ -304,7 +678,7 @@ function useEventId() {
     return { getId };
 }
 
-function getConstructor$1(instance) {
+function getConstructor(instance) {
     return Object.getPrototypeOf(instance).constructor;
 }
 
@@ -592,8 +966,8 @@ class Infact {
                         case 'string':
                             return `"${''}...${''}"`;
                         case 'object':
-                            if (getConstructor$1(p))
-                                return getConstructor$1(p).name;
+                            if (getConstructor(p))
+                                return getConstructor(p).name;
                             return '{}';
                         default:
                             return '*';
@@ -649,231 +1023,6 @@ async function runPipes(pipes, initialValue, metas, level) {
     return v;
 }
 
-function getConstructor(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(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(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 METADATA_WORKSPACE = 'moost';
 const moostMate = new Mate(METADATA_WORKSPACE, {
     readType: true,
@@ -996,6 +1145,7 @@ function getOtelMate() {
 
 const mate = getOtelMate();
 const OtelIgnoreSpan = () => mate.decorate('otelIgnoreSpan', true);
+const OtelIgnoreMeter = () => mate.decorate('otelIgnoreMeter', true);
 
 function shouldSpanBeIgnored(span) {
     return span.attributes['moost.ignore'] === true;
@@ -1019,4 +1169,4 @@ class MoostSimpleSpanProcessor extends SimpleSpanProcessor {
     }
 }
 
-export { MoostBatchSpanProcessor, MoostSimpleSpanProcessor, OtelIgnoreSpan, enableOtelForMoost, getOtelMate, shouldSpanBeIgnored, useOtelContext, useOtelPropagation, useSpan, useTrace };
+export { MoostBatchSpanProcessor, MoostSimpleSpanProcessor, OtelIgnoreMeter, OtelIgnoreSpan, SpanInjector, enableOtelForMoost, getOtelMate, shouldSpanBeIgnored, useOtelContext, useOtelPropagation, useSpan, useTrace };