@opentelemetry/api/dist/experimental/trace/SugaredTracer.mjs.map

Public API for OpenTelemetry

{"version":3,"file":"SugaredTracer.mjs","names":["contextApi"],"sources":["../../../src/experimental/trace/SugaredTracer.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { SugaredSpanOptions } from './SugaredOptions';\nimport type { Context, Span, Tracer } from '../../';\nimport { context as contextApi, SpanStatusCode } from '../../';\n\nconst defaultOnException = (e: Error, span: Span) => {\n  span.recordException(e);\n  span.setStatus({\n    code: SpanStatusCode.ERROR,\n  });\n};\n\n/**\n * return a new SugaredTracer created from the supplied one\n * @param tracer\n */\nexport function wrapTracer(tracer: Tracer): SugaredTracer {\n  return new SugaredTracer(tracer);\n}\n\nexport class SugaredTracer implements Tracer {\n  private readonly _tracer: Tracer;\n\n  constructor(tracer: Tracer) {\n    this._tracer = tracer;\n    this.startSpan = tracer.startSpan.bind(this._tracer);\n    this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);\n  }\n\n  startActiveSpan: Tracer['startActiveSpan'];\n  startSpan: Tracer['startSpan'];\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally, the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *     const something = tracer.withActiveSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withActiveSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: F | SugaredSpanOptions,\n    arg3?: F | Context,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    return this._tracer.startActiveSpan(name, opts, ctx, (span: Span) =>\n      handleFn(span, opts, fn)\n    ) as ReturnType<F>;\n  }\n\n  /**\n   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.\n   *\n   * This method does NOT modify the current Context.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns Span The newly created span\n   * @example\n   *     const something = tracer.withSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: SugaredSpanOptions | F,\n    arg3?: Context | F,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    const span = this._tracer.startSpan(name, opts, ctx);\n    return handleFn(span, opts, fn) as ReturnType<F>;\n  }\n}\n\n/**\n * Massages parameters of withSpan and withActiveSpan to allow signature overwrites\n * @param arg\n * @param arg2\n * @param arg3\n */\nfunction massageParams<F extends (span: Span) => ReturnType<F>>(\n  arg: F | SugaredSpanOptions,\n  arg2?: F | Context,\n  arg3?: F\n) {\n  let opts: SugaredSpanOptions | undefined;\n  let ctx: Context | undefined;\n  let fn: F;\n\n  if (!arg2 && !arg3) {\n    fn = arg as F;\n  } else if (!arg3) {\n    opts = arg as SugaredSpanOptions;\n    fn = arg2 as F;\n  } else {\n    opts = arg as SugaredSpanOptions;\n    ctx = arg2 as Context;\n    fn = arg3 as F;\n  }\n  opts = opts ?? {};\n  ctx = ctx ?? contextApi.active();\n\n  return { opts, ctx, fn };\n}\n\n/**\n * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling\n * @param span\n * @param opts\n * @param fn\n */\nfunction handleFn<F extends (span: Span) => ReturnType<F>>(\n  span: Span,\n  opts: SugaredSpanOptions,\n  fn: F\n): ReturnType<F> {\n  const onException = opts.onException ?? defaultOnException;\n  const errorHandler = (e: Error) => {\n    onException(e, span);\n    span.end();\n    throw e;\n  };\n\n  try {\n    const ret = fn(span) as Promise<ReturnType<F>>;\n    // if fn is an async function, attach a recordException and spanEnd callback to the promise\n    if (typeof ret?.then === 'function') {\n      return ret.then(val => {\n        span.end();\n        return val;\n      }, errorHandler) as ReturnType<F>;\n    }\n    span.end();\n    return ret as ReturnType<F>;\n  } catch (e) {\n    // add throw to signal the compiler that this will throw in the inner scope\n    throw errorHandler(e);\n  }\n}\n"],"mappings":";;;AAQA,MAAM,sBAAsB,GAAU,SAAe;CACnD,KAAK,gBAAgB,CAAC;CACtB,KAAK,UAAU,EACb,MAAA,EACF,CAAC;AACH;;;;;AAMA,SAAgB,WAAW,QAA+B;CACxD,OAAO,IAAI,cAAc,MAAM;AACjC;AAEA,IAAa,gBAAb,MAA6C;CAG3C,YAAY,QAAgB;EAC1B,KAAK,UAAU;EACf,KAAK,YAAY,OAAO,UAAU,KAAK,KAAK,OAAO;EACnD,KAAK,kBAAkB,OAAO,gBAAgB,KAAK,KAAK,OAAO;CACjE;CA0CA,eACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAExD,OAAO,KAAK,QAAQ,gBAAgB,MAAM,MAAM,MAAM,SACpD,SAAS,MAAM,MAAM,EAAE,CACzB;CACF;CA4CA,SACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAGxD,OAAO,SADM,KAAK,QAAQ,UAAU,MAAM,MAAM,GAC7B,GAAG,MAAM,EAAE;CAChC;AACF;;;;;;;AAQA,SAAS,cACP,KACA,MACA,MACA;;CACA,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,IAAI,CAAC,QAAQ,CAAC,MACZ,KAAK;MACA,IAAI,CAAC,MAAM;EAChB,OAAO;EACP,KAAK;CACP,OAAO;EACL,OAAO;EACP,MAAM;EACN,KAAK;CACP;CACA,QAAA,QAAO,UAAA,QAAA,UAAA,KAAA,IAAA,QAAQ,CAAC;CAChB,OAAA,OAAM,SAAA,QAAA,SAAA,KAAA,IAAA,OAAOA,QAAW,OAAO;CAE/B,OAAO;EAAE;EAAM;EAAK;CAAG;AACzB;;;;;;;AAQA,SAAS,SACP,MACA,MACA,IACe;;CACf,MAAM,eAAA,oBAAc,KAAK,iBAAA,QAAA,sBAAA,KAAA,IAAA,oBAAe;CACxC,MAAM,gBAAgB,MAAa;EACjC,YAAY,GAAG,IAAI;EACnB,KAAK,IAAI;EACT,MAAM;CACR;CAEA,IAAI;EACF,MAAM,MAAM,GAAG,IAAI;EAEnB,IAAI,QAAA,QAAA,QAAA,QAAA,KAAA,IAAA,KAAA,IAAO,IAAK,UAAS,YACvB,OAAO,IAAI,MAAK,QAAO;GACrB,KAAK,IAAI;GACT,OAAO;EACT,GAAG,YAAY;EAEjB,KAAK,IAAI;EACT,OAAO;CACT,SAAS,GAAG;EAEV,MAAM,aAAa,CAAC;CACtB;AACF"}