@moostjs/otel 0.4.6 → 0.4.8

package/dist/index.d.ts

@@ -1,14 +1,21 @@
 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';
+import { IncomingMessage, ServerResponse } from 'http';
+import { ContextInjector, TContextInjectorHook } from 'moost';
 
 interface TOtelContext {
     otel?: {
         span?: Span;
+        route?: string;
     };
 }
 declare function useOtelContext(): {
     trace: _opentelemetry_api.TraceAPI;
-    withChildSpan: <T>(name: string, cb: (...a: any[]) => T, opts?: SpanOptions) => T | (() => T);
+    withChildSpan: <T>(name: string, cb: (...a: any[]) => T, opts?: SpanOptions) => () => T;
     getSpan: () => Span | undefined;
     getSpanContext: () => _opentelemetry_api.SpanContext | undefined;
     getPropagationHeaders: () => {
@@ -19,6 +26,7 @@ declare function useOtelContext(): {
         tracestate?: undefined;
     };
     registerSpan: (span: Span) => unknown;
+    pushSpan: (span: Span) => void;
 };
 declare function useTrace(): _opentelemetry_api.TraceAPI;
 declare function useSpan(): Span | undefined;
@@ -39,4 +47,186 @@ 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;
+/**
+ * Annotate controller and/or handler to suppress metrics
+ */
+declare const OtelIgnoreMeter: () => 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;
+    otelIgnoreMeter: 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;
+
+type TAttributes = Record<string, string | number | boolean>;
+declare class SpanInjector extends ContextInjector<TContextInjectorHook> {
+    with<T>(name: TContextInjectorHook, attributes: TAttributes, cb: () => T): T;
+    with<T>(name: TContextInjectorHook, cb: () => T): T;
+    patchRsponse(): void;
+    startEvent<T>(name: string, eventType: string, cb: () => T): T;
+    getEventType(): string;
+    getIgnoreSpan(): boolean | undefined;
+    getControllerHandlerMeta(): {
+        ignoreMeter: boolean | undefined;
+        ignoreSpan: boolean | undefined;
+        attrs: {
+            'moost.controller': string;
+            'moost.handler': string | undefined;
+            'moost.handler_description': string | undefined;
+            'moost.handler_label': string | undefined;
+            'moost.handler_id': string | undefined;
+            'moost.ignore': boolean | undefined;
+            'moost.route': string | undefined;
+            'moost.event_type': string;
+        };
+    };
+    hook(name: 'Handler:not_found' | 'Handler:routed' | 'C', route?: string): void;
+    withSpan<T>(span: Span, cb: () => T, opts: {
+        rootSpan: boolean;
+        endSpan: boolean;
+    }): T;
+    startEventMetrics(a: Record<string, string | number | boolean | undefined>, route?: string): void;
+    endEventMetrics(a: Record<string, string | number | boolean | undefined>, error?: Error): void;
+    getRequest(): IncomingMessage | undefined;
+    getResponse(): (ServerResponse<IncomingMessage> & {
+        _statusCode?: number | undefined;
+        _contentLength?: number | undefined;
+    }) | undefined;
+}
+
+export { MoostBatchSpanProcessor, MoostSimpleSpanProcessor, OtelIgnoreMeter, OtelIgnoreSpan, SpanInjector, type TOtelContext, type TOtelMate, enableOtelForMoost, getOtelMate, shouldSpanBeIgnored, useOtelContext, useOtelPropagation, useSpan, useTrace };