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

package/dist/functional/api.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineApi = defineApi;
+const decorator_1 = require("../decorator");
+const error_1 = require("../error");
+const metadataManager_1 = require("../decorator/metadataManager");
+const util_1 = require("util");
+const crypto_1 = require("crypto");
+const constants_1 = require("./constants");
+const debug = (0, util_1.debuglog)('midway:debug');
+function normalizeClassNameSegment(input, fallback = 'root') {
+    const normalized = (input || '')
+        .replace(/[^a-zA-Z0-9_$]+/g, '_')
+        .replace(/^(\d)/, '_$1')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 40);
+    return normalized || fallback;
+}
+function createNamedFunctionalController(prefix, routeNames) {
+    const prefixPart = normalizeClassNameSegment(prefix);
+    const hash = (0, crypto_1.createHash)('sha1')
+        .update(`${prefix}|${routeNames.join('|')}`)
+        .digest('hex')
+        .slice(0, 8);
+    const className = `FunctionalApi_${prefixPart}_${hash}`;
+    return {
+        [className]: class {
+        },
+    }[className];
+}
+const HTTP_METHODS = [
+    decorator_1.RequestMethod.GET,
+    decorator_1.RequestMethod.POST,
+    decorator_1.RequestMethod.PUT,
+    decorator_1.RequestMethod.DELETE,
+    decorator_1.RequestMethod.PATCH,
+    decorator_1.RequestMethod.OPTIONS,
+    decorator_1.RequestMethod.HEAD,
+    decorator_1.RequestMethod.ALL,
+];
+function createRouteBuilder(method, path = '/') {
+    const route = {
+        method,
+        path,
+        options: {
+            middleware: [],
+        },
+    };
+    const builder = {
+        __isRouteBuilder: true,
+        input(schema) {
+            route.options.input = schema;
+            return builder;
+        },
+        output(schema) {
+            route.options.output = schema;
+            return builder;
+        },
+        middleware(mw) {
+            route.options.middleware = mw || [];
+            return builder;
+        },
+        meta(options) {
+            route.options = {
+                ...route.options,
+                ...(options || {}),
+            };
+            return builder;
+        },
+        handle(fn) {
+            route.handle = fn;
+            return builder.__build();
+        },
+        __build() {
+            if (!route.handle) {
+                throw new Error('Functional route is missing handler, call .handle(fn) to finish route definition');
+            }
+            return route;
+        },
+    };
+    return builder;
+}
+function getInputFromContext(ctx) {
+    return {
+        params: ctx?.params,
+        query: ctx?.query,
+        body: ctx?.request?.body,
+        headers: ctx?.headers ?? ctx?.request?.headers,
+    };
+}
+async function runSchemaValidation(schema, value, label) {
+    if (!schema) {
+        return value;
+    }
+    try {
+        if (typeof schema.safeParseAsync === 'function') {
+            const result = await schema.safeParseAsync(value);
+            if (!result.success) {
+                throw result.error;
+            }
+            return result.data;
+        }
+        if (typeof schema.safeParse === 'function') {
+            const result = schema.safeParse(value);
+            if (!result.success) {
+                throw result.error;
+            }
+            return result.data;
+        }
+        if (typeof schema.parseAsync === 'function') {
+            return await schema.parseAsync(value);
+        }
+        if (typeof schema.parse === 'function') {
+            return schema.parse(value);
+        }
+    }
+    catch (err) {
+        throw new error_1.MidwayCommonError(`Functional API ${label} validation failed: ${err?.message || err}`);
+    }
+    return value;
+}
+async function validateInput(schema, input) {
+    if (!schema) {
+        return input;
+    }
+    return {
+        params: await runSchemaValidation(schema.params, input.params, 'input.params'),
+        query: await runSchemaValidation(schema.query, input.query, 'input.query'),
+        body: await runSchemaValidation(schema.body, input.body, 'input.body'),
+        headers: await runSchemaValidation(schema.headers, input.headers, 'input.headers'),
+    };
+}
+function normalizeRouteDefinition(routeName, routeValue) {
+    const route = routeValue?.__isRouteBuilder
+        ? routeValue.__build()
+        : routeValue;
+    if (!route || typeof route !== 'object') {
+        throw new Error(`Functional route "${routeName}" must be a route definition`);
+    }
+    if (typeof route.handle !== 'function') {
+        throw new Error(`Functional route "${routeName}" is missing handler, call .handle(fn)`);
+    }
+    return {
+        ...route,
+        path: route.path || '/',
+        options: {
+            middleware: [],
+            ...route.options,
+        },
+    };
+}
+function defineApi(prefix, factory, controllerOptions = {
+    middleware: [],
+    sensitive: true,
+}) {
+    const routeFactory = {
+        get(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.GET, path);
+        },
+        post(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.POST, path);
+        },
+        put(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.PUT, path);
+        },
+        delete(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.DELETE, path);
+        },
+        patch(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.PATCH, path);
+        },
+        options(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.OPTIONS, path);
+        },
+        head(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.HEAD, path);
+        },
+        all(path = '/') {
+            return createRouteBuilder(decorator_1.RequestMethod.ALL, path);
+        },
+    };
+    const definedRoutes = factory(routeFactory);
+    const normalizedRoutes = {};
+    const routeNames = Object.keys(definedRoutes || {});
+    const FunctionalApiController = createNamedFunctionalController(prefix, routeNames);
+    const controllerClassName = FunctionalApiController.name;
+    debug(`[functional-api] begin register routes, controller="${controllerClassName}", prefix="${prefix}", count=${routeNames.length}`);
+    for (const routeName of routeNames) {
+        const route = normalizeRouteDefinition(routeName, definedRoutes[routeName]);
+        normalizedRoutes[routeName] = route;
+        if (!HTTP_METHODS.includes(route.method)) {
+            throw new Error(`Functional route "${routeName}" has unsupported http method "${route.method}"`);
+        }
+        Object.defineProperty(FunctionalApiController.prototype, routeName, {
+            value: async function (ctx, next) {
+                const rawInput = getInputFromContext(ctx);
+                const validatedInput = await validateInput(route.options.input, rawInput);
+                const result = await route.handle({
+                    input: validatedInput,
+                    ctx,
+                    next,
+                });
+                return runSchemaValidation(route.options.output, result, 'output');
+            },
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+        const descriptor = Object.getOwnPropertyDescriptor(FunctionalApiController.prototype, routeName);
+        (0, decorator_1.RequestMapping)({
+            path: route.path,
+            requestMethod: route.method,
+            routerName: route.options.routerName,
+            middleware: route.options.middleware || [],
+            summary: route.options.summary,
+            description: route.options.description,
+            ignoreGlobalPrefix: route.options.ignoreGlobalPrefix,
+        })(FunctionalApiController.prototype, routeName, descriptor);
+        debug(`[functional-api] register route, controller="${controllerClassName}", prefix="${prefix}", method=${String(route.method).toUpperCase()}, path="${String(route.path)}", routeName="${routeName}", routerName="${route.options.routerName || routeName}"`);
+    }
+    (0, decorator_1.Controller)(prefix, controllerOptions)(FunctionalApiController);
+    // Keep compatibility with mock container module filtering:
+    // class-based controllers are marked via container.bindClass(onBeforeBind),
+    // while defineApi creates an internal class that may not be bound directly.
+    // If mock bind map exists, mark this generated controller as bound.
+    const bindModuleMap = decorator_1.DecoratorManager?._bindModuleMap;
+    if (bindModuleMap && typeof bindModuleMap.set === 'function') {
+        bindModuleMap.set(FunctionalApiController, true);
+    }
+    // In some integration paths (e.g. mixed runtime loaders), make sure
+    // functional controllers are visible to the active/global decorator manager.
+    decorator_1.DecoratorManager.saveModule(decorator_1.CONTROLLER_KEY, FunctionalApiController);
+    const globalDecoratorManager = globalThis['MIDWAY_GLOBAL_DECORATOR_MANAGER'];
+    if (globalDecoratorManager &&
+        globalDecoratorManager !== decorator_1.DecoratorManager &&
+        typeof globalDecoratorManager.saveModule === 'function') {
+        globalDecoratorManager.saveModule(decorator_1.CONTROLLER_KEY, FunctionalApiController);
+    }
+    metadataManager_1.MetadataManager.defineMetadata(decorator_1.FUNCTIONAL_API_CONTROLLER_KEY, true, FunctionalApiController);
+    Object.defineProperty(normalizedRoutes, constants_1.FUNCTIONAL_API_MODULE_META_KEY, {
+        value: {
+            prefix,
+            ignoreGlobalPrefix: controllerOptions?.ignoreGlobalPrefix,
+            version: controllerOptions?.version,
+            versionType: controllerOptions?.versionType,
+            versionPrefix: controllerOptions?.versionPrefix,
+        },
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    metadataManager_1.MetadataManager.defineMetadata(constants_1.FUNCTIONAL_API_CONTROLLER_CLASS_KEY, FunctionalApiController, normalizedRoutes);
+    // Keep hidden property for compatibility with existing ecosystem reads.
+    Object.defineProperty(normalizedRoutes, constants_1.FUNCTIONAL_API_CONTROLLER_CLASS_KEY, {
+        value: FunctionalApiController,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return normalizedRoutes;
+}
+//# sourceMappingURL=api.js.map

package/dist/functional/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FUNCTIONAL_API_MODULE_META_KEY = "__midwayApiMeta";
+export declare const FUNCTIONAL_API_CONTROLLER_CLASS_KEY = "__midwayApiControllerClass";
+//# sourceMappingURL=constants.d.ts.map

package/dist/functional/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FUNCTIONAL_API_CONTROLLER_CLASS_KEY = exports.FUNCTIONAL_API_MODULE_META_KEY = void 0;
+exports.FUNCTIONAL_API_MODULE_META_KEY = '__midwayApiMeta';
+exports.FUNCTIONAL_API_CONTROLLER_CLASS_KEY = '__midwayApiControllerClass';
+//# sourceMappingURL=constants.js.map

package/dist/functional/hooks.js

@@ -44,7 +44,6 @@ async function useInject(identifier, args) {
     return requestContext.getAsync(identifier, args);
 }
 function useInjectSync(identifier, args) {
-    ``;
     const ctx = useContext();
     const requestContext = ctx
         ? ctx['requestContext']

package/dist/functional/index.d.ts

@@ -1,3 +1,6 @@
 export { defineConfiguration, FunctionalConfiguration } from './configuration';
+export { defineApi, FunctionalControllerOptions, FunctionalRouteDefinition, FunctionalRouteInput, FunctionalRouteOptions, RouteBuilder, } from './api';
+export { FUNCTIONAL_API_CONTROLLER_CLASS_KEY, FUNCTIONAL_API_MODULE_META_KEY, } from './constants';
 export * from './hooks';
+export * from './adapter';
 //# sourceMappingURL=index.d.ts.map

package/dist/functional/index.js

@@ -14,9 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionalConfiguration = exports.defineConfiguration = void 0;
+exports.FUNCTIONAL_API_MODULE_META_KEY = exports.FUNCTIONAL_API_CONTROLLER_CLASS_KEY = exports.defineApi = exports.FunctionalConfiguration = exports.defineConfiguration = void 0;
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "defineConfiguration", { enumerable: true, get: function () { return configuration_1.defineConfiguration; } });
 Object.defineProperty(exports, "FunctionalConfiguration", { enumerable: true, get: function () { return configuration_1.FunctionalConfiguration; } });
+var api_1 = require("./api");
+Object.defineProperty(exports, "defineApi", { enumerable: true, get: function () { return api_1.defineApi; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "FUNCTIONAL_API_CONTROLLER_CLASS_KEY", { enumerable: true, get: function () { return constants_1.FUNCTIONAL_API_CONTROLLER_CLASS_KEY; } });
+Object.defineProperty(exports, "FUNCTIONAL_API_MODULE_META_KEY", { enumerable: true, get: function () { return constants_1.FUNCTIONAL_API_MODULE_META_KEY; } });
 __exportStar(require("./hooks"), exports);
+__exportStar(require("./adapter"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export { MidwayMockService } from './service/mockService';
 export { MidwayHealthService } from './service/healthService';
 export { RouterInfo, DynamicRouterInfo, RouterPriority, RouterCollectorOptions, MidwayWebRouterService, } from './service/webRouterService';
 export { MidwayServerlessFunctionService } from './service/slsFunctionService';
+export { MidwayTraceService } from './service/traceService';
 export { DataSourceManager } from './common/dataSourceManager';
 export { DEFAULT_PRIORITY, MidwayPriorityManager, } from './common/priorityManager';
 export * from './common/loggerFactory';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicMidwayContainer = exports.MidwayPerformanceManager = exports.TypedResourceManager = exports.HttpServerResponse = exports.ServerResponse = exports.NetworkUtils = exports.FORMAT = exports.FileUtils = exports.PathFileUtils = exports.Types = exports.retryWith = exports.retryWithAsync = exports.extend = exports.Utils = exports.sleep = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = exports.ASYNC_ROOT_CONTEXT = exports.MidwayPriorityManager = exports.DEFAULT_PRIORITY = exports.DataSourceManager = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayHealthService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.DynamicMidwayContainer = exports.MidwayPerformanceManager = exports.TypedResourceManager = exports.HttpServerResponse = exports.ServerResponse = exports.NetworkUtils = exports.FORMAT = exports.FileUtils = exports.PathFileUtils = exports.Types = exports.retryWith = exports.retryWithAsync = exports.extend = exports.Utils = exports.sleep = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = exports.ASYNC_ROOT_CONTEXT = exports.MidwayPriorityManager = exports.DEFAULT_PRIORITY = exports.DataSourceManager = exports.MidwayTraceService = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayHealthService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -49,6 +49,8 @@ var webRouterService_1 = require("./service/webRouterService");
 Object.defineProperty(exports, "MidwayWebRouterService", { enumerable: true, get: function () { return webRouterService_1.MidwayWebRouterService; } });
 var slsFunctionService_1 = require("./service/slsFunctionService");
 Object.defineProperty(exports, "MidwayServerlessFunctionService", { enumerable: true, get: function () { return slsFunctionService_1.MidwayServerlessFunctionService; } });
+var traceService_1 = require("./service/traceService");
+Object.defineProperty(exports, "MidwayTraceService", { enumerable: true, get: function () { return traceService_1.MidwayTraceService; } });
 var dataSourceManager_1 = require("./common/dataSourceManager");
 Object.defineProperty(exports, "DataSourceManager", { enumerable: true, get: function () { return dataSourceManager_1.DataSourceManager; } });
 var priorityManager_1 = require("./common/priorityManager");

package/dist/interface.d.ts

@@ -386,7 +386,32 @@ export interface MidwayCoreDefaultConfig {
         serverReadyTimeout?: number;
         stopTimeout?: number;
     };
+    tracing?: {
+        enable?: boolean;
+        onError?: 'throw' | 'ignore';
+        logOnError?: boolean;
+    };
 }
+export type TraceMetaDirection = 'entry' | 'exit';
+export type TraceMetaValue = string | number | boolean | undefined | null;
+export type TraceMetaRecord = Record<string, TraceMetaValue>;
+export interface TraceMetaResolverArgs {
+    direction: TraceMetaDirection;
+    protocol: string;
+    spanName: string;
+    span?: unknown;
+    ctx?: unknown;
+    carrier?: unknown;
+    request?: unknown;
+    response?: unknown;
+    error?: Error;
+    custom?: Record<string, unknown>;
+}
+export type TraceMetaResolver = TraceMetaRecord | ((args: TraceMetaResolverArgs) => TraceMetaRecord) | {
+    common?: TraceMetaRecord | ((args: TraceMetaResolverArgs) => TraceMetaRecord);
+    entry?: TraceMetaRecord | ((args: TraceMetaResolverArgs) => TraceMetaRecord);
+    exit?: TraceMetaRecord | ((args: TraceMetaResolverArgs) => TraceMetaRecord);
+};
 export type ServiceFactoryConfigOption<OPTIONS> = {
     default?: PowerPartial<OPTIONS>;
     client?: PowerPartial<OPTIONS>;
@@ -622,7 +647,7 @@ export interface IMidwayContainer extends IObjectFactory {
     /**
      * Get IoC identifier
      */
-    getIdentifier(identifier: (ClassType | string)): string;
+    getIdentifier(identifier: ClassType | string): string;
     /**
      * Get instance IoC container scope
      * @param instance
@@ -663,6 +688,7 @@ export interface Context {
      * Custom properties.
      */
     requestContext: IMidwayContainer;
+    traceId?: string;
     logger: ILogger;
     getLogger(name?: string): ILogger;
     startTime: number;
@@ -1010,7 +1036,7 @@ export declare const LoadBalancerType: {
     readonly RANDOM: "random";
     readonly ROUND_ROBIN: "roundRobin";
 };
-export type LoadBalancerType = typeof LoadBalancerType[keyof typeof LoadBalancerType];
+export type LoadBalancerType = (typeof LoadBalancerType)[keyof typeof LoadBalancerType];
 export declare const ServiceDiscoveryHealthCheckType: {
     readonly SELF: "self";
     readonly TTL: "ttl";
@@ -1018,7 +1044,7 @@ export declare const ServiceDiscoveryHealthCheckType: {
     readonly TCP: "tcp";
     readonly CUSTOM: "custom";
 };
-export type ServiceDiscoveryHealthCheckType = typeof ServiceDiscoveryHealthCheckType[keyof typeof ServiceDiscoveryHealthCheckType];
+export type ServiceDiscoveryHealthCheckType = (typeof ServiceDiscoveryHealthCheckType)[keyof typeof ServiceDiscoveryHealthCheckType];
 /**
  * 基础健康检查配置
  */

package/dist/interface.js

@@ -65,6 +65,6 @@ exports.ServiceDiscoveryHealthCheckType = {
     TTL: 'ttl',
     HTTP: 'http',
     TCP: 'tcp',
-    CUSTOM: 'custom'
+    CUSTOM: 'custom',
 };
 //# sourceMappingURL=interface.js.map

package/dist/service/configService.js

@@ -133,7 +133,6 @@ let MidwayConfigService = class MidwayConfigService {
         for (const [idx, filename] of [...defaultSet, ...currentEnvSet].entries()) {
             let config = this.loadConfig(filename);
             if (types_1.Types.isFunction(config)) {
-                // eslint-disable-next-line prefer-spread
                 config = config.apply(null, [this.appInfo, target]);
             }
             if (!config) {

package/dist/service/lifeCycleService.js

@@ -47,7 +47,9 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
                 debug(`[core]: Lifecycle run ${cycle.namespace} init`);
                 cycle.instance = await this.applicationContext.getAsync(cycle.target);
             }
-            cycle.instance && this.lifecycleInstanceList.push(cycle);
+            if (cycle.instance) {
+                this.lifecycleInstanceList.push(cycle);
+            }
         }
         // init health check service
         await this.healthService.init(this.lifecycleInstanceList);

package/dist/service/traceService.d.ts

@@ -0,0 +1,49 @@
+import { Span, SpanKind, TextMapGetter, TextMapSetter } from '@opentelemetry/api';
+import { ILogger, IMidwayApplication, TraceMetaRecord, TraceMetaResolver, TraceMetaResolverArgs } from '../interface';
+import { MidwayDecoratorService } from './decoratorService';
+export declare class MidwayTraceService {
+    private currentTracerName;
+    private tracingConfig;
+    protected app: IMidwayApplication;
+    protected decoratorService: MidwayDecoratorService;
+    protected tracingOptions: {
+        enable?: boolean;
+        onError?: 'throw' | 'ignore';
+        logOnError?: boolean;
+    };
+    protected logger: ILogger;
+    protected init(): void;
+    private getCurrentSpan;
+    getTraceId(): string;
+    createSpan(name: string, callback: (span: Span) => unknown): unknown;
+    private readonly defaultGetter;
+    private readonly defaultSetter;
+    private getProtocolFromAttributes;
+    private isProtocolEnabled;
+    private handleTraceError;
+    private pickTraceMetaValue;
+    resolveTraceMeta(resolver: TraceMetaResolver | undefined, args: TraceMetaResolverArgs): TraceMetaRecord;
+    runWithEntrySpan<T = unknown>(name: string, options: {
+        enable?: boolean;
+        carrier?: any;
+        responseCarrier?: any;
+        getter?: TextMapGetter<any>;
+        setter?: TextMapSetter<any>;
+        kind?: SpanKind;
+        attributes?: Record<string, any>;
+        meta?: TraceMetaResolver;
+        metaArgs?: Omit<TraceMetaResolverArgs, 'direction' | 'protocol' | 'spanName'>;
+    }, callback: (span: Span) => Promise<T> | T): Promise<T>;
+    runWithExitSpan<T = unknown>(name: string, options: {
+        enable?: boolean;
+        carrier?: any;
+        getter?: TextMapGetter<any>;
+        setter?: TextMapSetter<any>;
+        kind?: SpanKind;
+        attributes?: Record<string, any>;
+        meta?: TraceMetaResolver;
+        metaArgs?: Omit<TraceMetaResolverArgs, 'direction' | 'protocol' | 'spanName'>;
+    }, callback: (span: Span) => Promise<T> | T): Promise<T>;
+    injectContext(carrier: any, setter?: TextMapSetter<any>): any;
+}
+//# sourceMappingURL=traceService.d.ts.map