refactor(otel): remove TraceDecoratorOptions['scope'] for @trace param scope and more

- TraceDecoratorOptions['scope']
- genTraceScopeFrom()
- getScopeStringCache()
- genTraceScope()
- updateTraceScopeProperty()
- getTraceScopeParamFromArgs()

Author: waitingsong

packages/otel/src/lib/decorator.helper.base.ts

@@ -1,17 +1,10 @@
-import assert from 'node:assert'
-
 import type { Span } from '@opentelemetry/api'
-import { isArrowFunction } from '@waiting/shared-core'
 
 import type {
-  DecoratorContextBase,
-  DecoratorExecutorParam,
   DecoratorTraceDataResp,
-  ScopeGenerator,
-  TraceDecoratorOptions,
   TraceService,
 } from './trace.service/index.trace.service.js'
-import type { Attributes, TraceContext, TraceScopeParamType, TraceScopeType } from './types.js'
+import type { Attributes, TraceContext, TraceScopeParamType } from './types.js'
 import { getSpan } from './util.js'
 
 
@@ -55,143 +48,6 @@ function processEvents(
   traceService.addEvent(span, events)
 }
 
-/**
- * @deprecated
- * @note
- * - input options.traceScope will be updated by generated traceScope
- * - the first object arg of methodArgs will be appended key `traceScope` and set value
- */
-export function genTraceScopeFrom(options: DecoratorExecutorParam): TraceScopeType | undefined {
-  if (options.traceScope && isTraceScopeParamType(options.traceScope)) {
-    return options.traceScope
-  }
-
-  const decoratorContextBase: DecoratorContextBase = {
-    webApp: options.webApp,
-    webContext: options.webContext,
-    traceService: options.traceService,
-    traceScope: options.traceScope,
-    /** Caller Class name */
-    instanceName: options.instanceName,
-    /** Caller method name */
-    methodName: options.methodName,
-    // instance: options.instance,
-  }
-
-  const scopeFromArg = getTraceScopeParamFromArgs(options.methodArgs as GetTraceScopeFromArgsOptions[])
-  let ret = genTraceScope({
-    scope: scopeFromArg,
-    methodArgs: options.methodArgs,
-    decoratorContext: decoratorContextBase,
-    instance: options.instance,
-  })
-  if (! ret) {
-    const scope: TraceScopeParamType | undefined = options.mergedDecoratorParam?.scope
-    ret = genTraceScope({
-      scope,
-      methodArgs: options.methodArgs,
-      decoratorContext: decoratorContextBase,
-      instance: options.instance,
-    })
-  }
-  return ret
-}
-
-const traceScopeStringCache = new Map<string, symbol>()
-/**
- * @deprecated
- */
-export function getScopeStringCache(key: string): symbol {
-  let sym = traceScopeStringCache.get(key)
-  if (! sym) {
-    sym = Symbol(key)
-    setScopeStringCache(key, sym)
-  }
-  return sym
-}
-function setScopeStringCache(key: string, sym: symbol): void {
-  /* c8 ignore next 3 */
-  if (traceScopeStringCache.size > 10000) {
-    console.warn('traceScopeStringCache.size > 10000, should clear it')
-  }
-  traceScopeStringCache.set(key, sym)
-}
-
-export interface GenTraceScopeOptions {
-  scope: TraceDecoratorOptions['scope']
-  methodArgs: unknown[]
-  decoratorContext: DecoratorContextBase
-  instance: DecoratorExecutorParam['instance']
-}
-export function genTraceScope(options: GenTraceScopeOptions): TraceScopeType | undefined {
-  const { scope } = options
-
-  let ret: TraceScopeType | undefined
-  switch (typeof scope) {
-    case 'string': {
-      // Symbol.for() invalid as key of WeakMap
-      ret = getScopeStringCache(scope)
-      break
-    }
-
-    case 'object': {
-      ret = scope
-      break
-    }
-
-    case 'undefined':
-      return
-
-    case 'function': {
-      assert(options.instance, 'instance is required')
-      const funcBind = (isArrowFunction(scope as ScopeGenerator) ? scope : scope.bind(options.instance)) as ScopeGenerator
-      ret = funcBind(options.methodArgs, options.decoratorContext)
-      assert(typeof ret === 'object' || typeof ret === 'symbol', 'scope function must return an object or a symbol')
-      break
-    }
-
-    case 'symbol': {
-      ret = scope
-      break
-    }
-
-    /* c8 ignore next 2 */
-    default:
-      throw new Error('scope must be a string, an object, a symbol, or a function')
-  }
-
-  return ret
-}
-
-// function updateTraceScopeProperty(input: TraceScopeType): void {
-//   assert(typeof input === 'object', 'input must be an object')
-//   if (input.isTraceScope) { return }
-//   Object.defineProperty(input, 'isTraceScope', { value: true })
-// }
-
-type GetTraceScopeFromArgsOptions = TraceScopeParamType | { traceScope?: TraceScopeParamType, [key: string]: unknown }
-
-export function getTraceScopeParamFromArgs(
-  args: GetTraceScopeFromArgsOptions[] | undefined,
-): TraceScopeParamType | undefined {
-
-  const key = 'traceScope'
-
-  if (! args || ! Array.isArray(args)) { return }
-  for (const arg of args) {
-
-    if (! arg || typeof arg !== 'object') { continue }
-
-    // @ts-ignore
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const val = arg[key]
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    if (val && isTraceScopeParamType(val)) {
-      return val
-    }
-  }
-}
-
 export function isTraceScopeParamType(input: TraceScopeParamType | undefined): input is TraceScopeParamType {
   if (! input) {
     return false

packages/otel/src/lib/index.ts

@@ -55,9 +55,5 @@ export {
 
 
 export { genDecoratorExecutorOptions } from './trace.helper.js'
-export {
-  genTraceScope, getScopeStringCache,
-} from './decorator.helper.base.js'
-
 export { AttrNames } from './attrnames.types.js'
 

packages/otel/src/lib/trace.service/trace.service.ts

@@ -40,7 +40,6 @@ import {
   type SpanStatusOptions,
   AttrNames,
   ConfigKey,
-  TraceScopeParamType,
   TraceScopeType,
   middlewareEnableCacheKey,
 } from '../types.js'
@@ -268,21 +267,6 @@ export interface TraceDecoratorOptions<
    */
   spanNameDelimiter: string | undefined
 
-  /**
-   * 生成唯一标识符，用于确定同一方法的跨度, 避免异步方法并发调用时调用链关系混乱
-   * Generate the unique key for spans determination of the same method,
-   * avoid the confusion of call chain relationship when async methods are called concurrently
-   * @default undefined, runtime value rule (priority from high to low):
-   * - passed value in options.traceScope
-   * - generated automatically retrieved from object arg of the method args, that containing key `traceScope`,
-   * - webContext (traceService.ctx)
-   * - run before the `before()` method
-   * @caution symbol must be non-registered symbols, it means Symbol(string) is valid, and Symbol.for(string) is invalid
-   * @note `TraceInit()` not supported
-   * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
-   */
-  scope: ScopeGenerator<MThis, MParamType> | TraceScopeParamType | undefined
-
   before: MethodTypeUnknown<
     [MParamType, DecoratorContext<MThis>], // input args
     DecoratorTraceDataResp | DecoratorTraceDataRespAsync, // output data

packages/otel/test/api-test.ts

@@ -44,7 +44,6 @@ export const apiMethod = {
   scope: 'scope',
   simple_scope: 'simple_scope',
   trace_auto_scope: 'trace_auto_scope',
-  scope_priority: 'scope_priority',
 
   after_throw: 'after_throw',
 }

packages/otel/test/decorator/114.docorator-scope-priority.test.ts

@@ -4,15 +4,12 @@ import {
   Inject,
 } from '@midwayjs/core'
 import { MConfig } from '@mwcp/share'
-import { sleep } from '@waiting/shared-core'
 
 import { apiBase, apiMethod } from '../types/api-test.js'
 import { Trace, TraceService } from '../types/index.js'
 import { Config, ConfigKey } from '../types/lib-types.js'
 
 
-const scope1 = Symbol('scope1')
-
 @Controller(apiBase.decorator_data)
 export class DecoratorScopeComponentController {
 
@@ -30,19 +27,15 @@ export class DecoratorScopeComponentController {
 
   // #region private methods
 
-  @Trace<DecoratorScopeComponentController['_simple1']>({
-    scope: scope1,
-  })
+  @Trace<DecoratorScopeComponentController['_simple1']>()
   private async _simple1(): Promise<string> {
     await this._simple1a()
     return 'ok'
   }
 
   // #region private methods sub
 
-  @Trace<DecoratorScopeComponentController['_simple1a']>({
-    scope: () => scope1,
-  })
+  @Trace<DecoratorScopeComponentController['_simple1a']>()
   private async _simple1a(): Promise<string> {
     return 'ok'
   }