@midwayjs/core 4.0.0-beta.11 → 4.0.0-beta.13

package/dist/service/traceService.js

@@ -0,0 +1,306 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayTraceService = void 0;
+const api_1 = require("@opentelemetry/api");
+const decorator_1 = require("../decorator");
+const interface_1 = require("../interface");
+const tracer_1 = require("../decorator/common/tracer");
+const decoratorService_1 = require("./decoratorService");
+let MidwayTraceService = class MidwayTraceService {
+    currentTracerName = 'midway';
+    tracingConfig;
+    app;
+    decoratorService;
+    tracingOptions;
+    logger;
+    init() {
+        this.currentTracerName = this.app?.getProjectName?.() ?? 'unknown_project';
+        this.tracingConfig = {
+            enable: true,
+            onError: 'ignore',
+            logOnError: false,
+            ...(this.tracingOptions ?? {}),
+        };
+        this.decoratorService.registerMethodHandler(tracer_1.TRACE_KEY, options => {
+            return {
+                around: async (joinPoint) => {
+                    return this.createSpan(options.metadata['spanName'], async (span) => {
+                        try {
+                            const result = await joinPoint.proceed(...joinPoint.args);
+                            span.setStatus({
+                                code: api_1.SpanStatusCode.OK,
+                            });
+                            span.end();
+                            return result;
+                        }
+                        catch (err) {
+                            span.setStatus({
+                                code: api_1.SpanStatusCode.ERROR,
+                            });
+                            span.recordException(err);
+                            span.end();
+                            throw err;
+                        }
+                    });
+                },
+            };
+        });
+    }
+    getCurrentSpan() {
+        return api_1.trace.getSpan(api_1.context.active());
+    }
+    getTraceId() {
+        return this.getCurrentSpan()?.spanContext().traceId;
+    }
+    createSpan(name, callback) {
+        return api_1.trace.getTracer(this.currentTracerName).startActiveSpan(name, {
+            kind: api_1.SpanKind.CLIENT,
+        }, callback);
+    }
+    defaultGetter = {
+        get(carrier, key) {
+            if (!carrier || !key) {
+                return undefined;
+            }
+            if (typeof carrier.get === 'function') {
+                return carrier.get(key);
+            }
+            const lowerKey = key.toLowerCase();
+            const realKey = Object.keys(carrier).find(item => item.toLowerCase() === lowerKey);
+            return realKey ? carrier[realKey] : undefined;
+        },
+        keys(carrier) {
+            if (!carrier) {
+                return [];
+            }
+            return Object.keys(carrier);
+        },
+    };
+    defaultSetter = {
+        set(carrier, key, value) {
+            if (!carrier || !key) {
+                return;
+            }
+            if (typeof carrier.setHeader === 'function') {
+                carrier.setHeader(key, value);
+                return;
+            }
+            if (typeof carrier.set === 'function') {
+                carrier.set(key, value);
+                return;
+            }
+            carrier[key] = value;
+        },
+    };
+    getProtocolFromAttributes(attributes) {
+        const protocol = attributes?.['midway.protocol'];
+        if (!protocol || typeof protocol !== 'string') {
+            return 'default';
+        }
+        return protocol;
+    }
+    isProtocolEnabled() {
+        return this.tracingConfig?.enable !== false;
+    }
+    handleTraceError(err, phase) {
+        if (this.tracingConfig?.logOnError) {
+            this.logger?.warn?.(`[midway:trace] ${phase} failed: ${err?.message || err}`);
+        }
+        if (this.tracingConfig?.onError === 'throw') {
+            throw err;
+        }
+    }
+    pickTraceMetaValue(meta) {
+        if (!meta || typeof meta !== 'object') {
+            return {};
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(meta)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean') {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    resolveTraceMeta(resolver, args) {
+        if (!resolver) {
+            return {};
+        }
+        const mergeMeta = (target, source) => {
+            if (!source) {
+                return;
+            }
+            const resolved = typeof source === 'function'
+                ? source(args)
+                : source;
+            Object.assign(target, this.pickTraceMetaValue(resolved));
+        };
+        if (typeof resolver === 'function') {
+            return this.pickTraceMetaValue(resolver(args));
+        }
+        const resolverWithDirection = resolver;
+        if (resolverWithDirection.common !== undefined ||
+            resolverWithDirection.entry !== undefined ||
+            resolverWithDirection.exit !== undefined) {
+            const result = {};
+            mergeMeta(result, resolverWithDirection.common);
+            mergeMeta(result, resolverWithDirection[args.direction]);
+            return result;
+        }
+        return this.pickTraceMetaValue(resolver);
+    }
+    runWithEntrySpan(name, options, callback) {
+        const protocol = this.getProtocolFromAttributes(options.attributes);
+        const traceMeta = this.resolveTraceMeta(options.meta, {
+            direction: 'entry',
+            protocol,
+            spanName: name,
+            ...(options.metaArgs ?? {}),
+        });
+        const spanAttributes = {
+            ...(options.attributes ?? {}),
+            ...traceMeta,
+        };
+        if (!this.isProtocolEnabled() || options.enable === false) {
+            return Promise.resolve(callback(undefined));
+        }
+        const getter = options.getter ?? this.defaultGetter;
+        const setter = options.setter ?? this.defaultSetter;
+        let parentContext = api_1.context.active();
+        if (options.carrier) {
+            try {
+                parentContext = api_1.propagation.extract(api_1.context.active(), options.carrier, getter);
+            }
+            catch (err) {
+                this.handleTraceError(err, 'extract entry context');
+            }
+        }
+        return api_1.trace.getTracer(this.currentTracerName).startActiveSpan(name, {
+            kind: options.kind ?? api_1.SpanKind.SERVER,
+            attributes: spanAttributes,
+        }, parentContext, async (span) => {
+            try {
+                const result = await callback(span);
+                span.setStatus({
+                    code: api_1.SpanStatusCode.OK,
+                });
+                if (options.responseCarrier) {
+                    try {
+                        api_1.propagation.inject(api_1.context.active(), options.responseCarrier, setter);
+                    }
+                    catch (err) {
+                        this.handleTraceError(err, 'inject entry response context');
+                    }
+                }
+                return result;
+            }
+            catch (err) {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                });
+                span.recordException(err);
+                throw err;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    runWithExitSpan(name, options, callback) {
+        const protocol = this.getProtocolFromAttributes(options.attributes);
+        const traceMeta = this.resolveTraceMeta(options.meta, {
+            direction: 'exit',
+            protocol,
+            spanName: name,
+            ...(options.metaArgs ?? {}),
+        });
+        const spanAttributes = {
+            ...(options.attributes ?? {}),
+            ...traceMeta,
+        };
+        if (!this.isProtocolEnabled() || options.enable === false) {
+            return Promise.resolve(callback(undefined));
+        }
+        const setter = options.setter ?? this.defaultSetter;
+        const carrier = options.carrier ?? {};
+        return api_1.trace.getTracer(this.currentTracerName).startActiveSpan(name, {
+            kind: options.kind ?? api_1.SpanKind.CLIENT,
+            attributes: spanAttributes,
+        }, async (span) => {
+            try {
+                try {
+                    api_1.propagation.inject(api_1.context.active(), carrier, setter);
+                }
+                catch (err) {
+                    this.handleTraceError(err, 'inject exit context');
+                }
+                const result = await callback(span);
+                span.setStatus({
+                    code: api_1.SpanStatusCode.OK,
+                });
+                return result;
+            }
+            catch (err) {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                });
+                span.recordException(err);
+                throw err;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    injectContext(carrier, setter) {
+        try {
+            api_1.propagation.inject(api_1.context.active(), carrier, setter ?? this.defaultSetter);
+        }
+        catch (err) {
+            this.handleTraceError(err, 'inject context');
+        }
+        return carrier;
+    }
+};
+exports.MidwayTraceService = MidwayTraceService;
+__decorate([
+    (0, decorator_1.MainApp)(),
+    __metadata("design:type", Object)
+], MidwayTraceService.prototype, "app", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", decoratorService_1.MidwayDecoratorService)
+], MidwayTraceService.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Config)('tracing'),
+    __metadata("design:type", Object)
+], MidwayTraceService.prototype, "tracingOptions", void 0);
+__decorate([
+    (0, decorator_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], MidwayTraceService.prototype, "logger", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], MidwayTraceService.prototype, "init", null);
+exports.MidwayTraceService = MidwayTraceService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
+], MidwayTraceService);
+//# sourceMappingURL=traceService.js.map

package/dist/service/webRouterService.d.ts

@@ -1,4 +1,5 @@
 import { ControllerOption } from '../decorator';
+import { MidwayLoggerService } from './loggerService';
 export interface RouterInfo {
     /**
      * uuid
@@ -104,6 +105,31 @@ export interface RouterInfo {
      * version prefix for URI versioning
      */
     versionPrefix?: string;
+    /**
+     * route definition source
+     */
+    source?: 'functional' | 'decorator';
+    /**
+     * route-level ignore global prefix
+     */
+    ignoreGlobalPrefix?: boolean;
+}
+export interface RouteManifestItem {
+    source: 'functional' | 'decorator';
+    operationId: string;
+    controllerId?: string;
+    controllerPrefix: string;
+    method: string;
+    path: string;
+    fullPath: string;
+    routerName?: string;
+    middlewareCount: number;
+    ignoreGlobalPrefix: boolean;
+    version?: string | string[];
+    versionType?: 'URI' | 'HEADER' | 'MEDIA_TYPE' | 'CUSTOM';
+    versionPrefix?: string;
+    summary?: string;
+    description?: string;
 }
 export type DynamicRouterInfo = Omit<RouterInfo, 'id' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
 export interface RouterPriority {
@@ -126,6 +152,7 @@ export declare class MidwayWebRouterService {
     private isReady;
     protected routes: Map<string, RouterInfo[]>;
     protected routesPriority: RouterPriority[];
+    loggerService: MidwayLoggerService;
     constructor(options?: RouterCollectorOptions);
     protected analyze(): Promise<void>;
     protected analyzeController(): void;
@@ -256,6 +283,14 @@ export declare class MidwayWebRouterService {
          * version prefix for URI versioning
          */
         versionPrefix?: string;
+        /**
+         * route definition source
+         */
+        source?: "functional" | "decorator";
+        /**
+         * route-level ignore global prefix
+         */
+        ignoreGlobalPrefix?: boolean;
     }[];
     getRoutePriorityList(): Promise<RouterPriority[]>;
     getRouterTable(): Promise<Map<string, RouterInfo[]>>;
@@ -263,6 +298,11 @@ export declare class MidwayWebRouterService {
         compileUrlPattern?: boolean;
     }): Promise<RouterInfo[]>;
     getMatchedRouterInfo(routerUrl: string, method: string): Promise<RouterInfo | undefined>;
+    getRouteManifest(): Promise<RouteManifestItem[]>;
     protected checkDuplicateAndPush(prefix: any, routerInfo: RouterInfo): void;
+    protected logRouteLoaded(routerInfo: RouterInfo): void;
+    protected getRouterHandlerIdentity(routerInfo: RouterInfo): string;
+    protected getOperationId(routeInfo: RouterInfo): string;
+    protected checkDuplicateOperationId(manifest: RouteManifestItem[]): void;
 }
 //# sourceMappingURL=webRouterService.d.ts.map