@moostjs/otel 0.4.5 → 0.4.7

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 import * as _opentelemetry_api from '@opentelemetry/api';
 import { Span, SpanOptions } from '@opentelemetry/api';
+import * as _prostojs_mate from '@prostojs/mate';
+import { TMateParamMeta } from '@prostojs/mate';
+import { TProvideRegistry, TReplaceRegistry } from '@prostojs/infact';
+import { BatchSpanProcessor, ReadableSpan, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
 
 interface TOtelContext {
     otel?: {
@@ -39,4 +43,145 @@ declare function useOtelPropagation(): {
 
 declare function enableOtelForMoost(): void;
 
-export { type TOtelContext, enableOtelForMoost, useOtelContext, useOtelPropagation, useSpan, useTrace };
+/**
+ * Annotate controller and/or handler to filter
+ * out the corresponding spans from transporting
+ *
+ * Requires use of MoostBatchSpanProcessor or MoostSimpleSpanProcessor
+ */
+declare const OtelIgnoreSpan: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+type TAny = any;
+type TAnyFn = (...a: TAny[]) => unknown;
+type TObject = object;
+type TFunction = Function;
+type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
+interface TEmpty {
+}
+
+interface TClassFunction<T extends TAnyFn = TAnyFn> {
+    handler: T;
+}
+type TClassFunctionConstructor<T extends TAnyFn = TAnyFn> = new (...a: TAny[]) => TClassFunction<T>;
+type TCallableClassFunction<T extends TAnyFn = TAnyFn> = T | TClassFunctionConstructor;
+
+type TInterceptorBefore = (reply: (response: TAny) => void) => void | Promise<void>;
+type TInterceptorAfter = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
+type TInterceptorOnError = (error: Error, reply: (response: TAny) => void) => void | Promise<void>;
+interface TInterceptorFn {
+    (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): unknown | Promise<unknown>;
+    priority?: TInterceptorPriority;
+}
+declare enum TInterceptorPriority {
+    BEFORE_ALL = 0,
+    BEFORE_GUARD = 1,
+    GUARD = 2,
+    AFTER_GUARD = 3,
+    INTERCEPTOR = 4,
+    CATCH_ERROR = 5,
+    AFTER_ALL = 6
+}
+
+type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
+
+interface TPipeMetas<T extends TObject = TEmpty> {
+    classMeta?: TMoostMetadata & T;
+    methodMeta?: TMoostMetadata & T;
+    propMeta?: TMoostMetadata & T;
+    paramMeta?: TMoostParamsMetadata & T;
+    targetMeta?: TMoostParamsMetadata & T;
+    instance?: TObject;
+    type: TFunction;
+    index?: number;
+    key: string | symbol;
+}
+interface TPipeFn<T extends TObject = TEmpty> {
+    (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
+    priority?: TPipePriority;
+}
+declare enum TPipePriority {
+    BEFORE_RESOLVE = 0,
+    RESOLVE = 1,
+    AFTER_RESOLVE = 2,
+    BEFORE_TRANSFORM = 3,
+    TRANSFORM = 4,
+    AFTER_TRANSFORM = 5,
+    BEFORE_VALIDATE = 6,
+    VALIDATE = 7,
+    AFTER_VALIDATE = 8
+}
+interface TPipeData {
+    handler: TPipeFn;
+    priority: TPipePriority;
+}
+
+interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
+    requiredProps?: Array<string | symbol>;
+    controller?: {
+        prefix?: string;
+    };
+    importController?: Array<{
+        prefix?: string;
+        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
+        provide?: TProvideRegistry;
+    }>;
+    properties?: Array<string | symbol>;
+    injectable?: true | TInjectableScope;
+    interceptors?: TInterceptorData[];
+    handlers?: Array<TMoostHandler<H>>;
+    returnType?: TFunction;
+    provide?: TProvideRegistry;
+    replace?: TReplaceRegistry;
+    params: Array<TMateParamMeta & TMoostParamsMetadata>;
+}
+interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
+    circular?: () => TAny;
+    inject?: string | symbol | TClassConstructor;
+    nullable?: boolean;
+    paramSource?: string;
+    paramName?: string;
+}
+type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
+type TMoostHandler<T> = {
+    type: string;
+    path?: string;
+} & T;
+interface TInterceptorData {
+    handler: TCallableClassFunction<TInterceptorFn>;
+    priority: TInterceptorPriority;
+}
+interface TCommonMetaFields {
+    id?: string;
+    label?: string;
+    value?: unknown;
+    description?: string;
+    optional?: boolean;
+    required?: boolean;
+}
+interface TCommonMoostMeta {
+    inherit?: boolean;
+    pipes?: TPipeData[];
+    resolver?: (metas: TPipeMetas<TAny>, level: TDecoratorLevel) => unknown;
+    type?: TFunction;
+}
+
+interface TOtelMate {
+    otelIgnoreSpan: boolean;
+}
+declare function getOtelMate(): _prostojs_mate.Mate<TMoostMetadata<TEmpty> & TOtelMate & {
+    params: (TOtelMate & _prostojs_mate.TMateParamMeta)[];
+}, TMoostMetadata<TEmpty> & TOtelMate & {
+    params: (TOtelMate & _prostojs_mate.TMateParamMeta)[];
+}>;
+
+declare class MoostBatchSpanProcessor extends BatchSpanProcessor {
+    onEnd(span: ReadableSpan): void;
+}
+
+declare class MoostSimpleSpanProcessor extends SimpleSpanProcessor {
+    onEnd(span: ReadableSpan): void;
+}
+
+declare function shouldSpanBeIgnored(span: ReadableSpan): boolean;
+
+export { MoostBatchSpanProcessor, MoostSimpleSpanProcessor, OtelIgnoreSpan, type TOtelContext, type TOtelMate, enableOtelForMoost, getOtelMate, shouldSpanBeIgnored, useOtelContext, useOtelPropagation, useSpan, useTrace };