{"version":3,"file":"trace.jkLkvwC_.js","sources":["../../../../../../node_modules/@sentry/core/esm/semanticAttributes.js","../../../../../../node_modules/@sentry/core/esm/utils/handleCallbackErrors.js","../../../../../../node_modules/@sentry/core/esm/utils/hasTracingEnabled.js","../../../../../../node_modules/@sentry/core/esm/tracing/trace.js"],"sourcesContent":["/**\n * Use this attribute to represent the source of a span.\n * Should be one of: custom, url, route, view, component, task, unknown\n *\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = 'sentry.source';\n\n/**\n * Use this attribute to represent the sample rate used for a span.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = 'sentry.sample_rate';\n\n/**\n * Use this attribute to represent the operation of a span.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_OP = 'sentry.op';\n\n/**\n * Use this attribute to represent the origin of a span.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = 'sentry.origin';\n\nexport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE };\n//# sourceMappingURL=semanticAttributes.js.map\n","import { isThenable } from '@sentry/utils';\n\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nfunction handleCallbackErrors\n\n(\n  fn,\n  onError,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onFinally = () => {},\n) {\n  let maybePromiseResult;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n * Other than this, it will generally return the given value as-is.\n */\nfunction maybeHandlePromiseRejection(\n  value,\n  onError,\n  onFinally,\n) {\n  if (isThenable(value)) {\n    // @ts-expect-error - the isThenable check returns the \"wrong\" type here\n    return value.then(\n      res => {\n        onFinally();\n        return res;\n      },\n      e => {\n        onError(e);\n        onFinally();\n        throw e;\n      },\n    );\n  }\n\n  onFinally();\n  return value;\n}\n\nexport { handleCallbackErrors };\n//# sourceMappingURL=handleCallbackErrors.js.map\n","import { getClient } from '../exports.js';\n\n// Treeshakable guard to remove all code related to tracing\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nfunction hasTracingEnabled(\n  maybeOptions,\n) {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const client = getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  return !!options && (options.enableTracing || 'tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\nexport { hasTracingEnabled };\n//# sourceMappingURL=hasTracingEnabled.js.map\n","import { tracingContextFromHeaders, logger, dropUndefinedKeys, addNonEnumerableProperty } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { getCurrentScope, withScope } from '../exports.js';\nimport { getCurrentHub, runWithAsyncContext, getIsolationScope } from '../hub.js';\nimport { handleCallbackErrors } from '../utils/handleCallbackErrors.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { spanToJSON, spanTimeInputToSeconds } from '../utils/spanUtils.js';\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n *\n * This function is meant to be used internally and may break at any time. Use at your own risk.\n *\n * @internal\n * @private\n *\n * @deprecated Use `startSpan` instead.\n */\nfunction trace(\n  context,\n  callback,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onError = () => {},\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  afterFinish = () => {},\n) {\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n  const scope = getCurrentScope();\n  // eslint-disable-next-line deprecation/deprecation\n  const parentSpan = scope.getSpan();\n\n  const ctx = normalizeContext(context);\n  const activeSpan = createChildSpanOrTransaction(hub, parentSpan, ctx);\n\n  // eslint-disable-next-line deprecation/deprecation\n  scope.setSpan(activeSpan);\n\n  return handleCallbackErrors(\n    () => callback(activeSpan),\n    error => {\n      activeSpan && activeSpan.setStatus('internal_error');\n      onError(error, activeSpan);\n    },\n    () => {\n      activeSpan && activeSpan.end();\n      // eslint-disable-next-line deprecation/deprecation\n      scope.setSpan(parentSpan);\n      afterFinish();\n    },\n  );\n}\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getSpan()`, as long as the function is executed while the scope is active.\n *\n * If you want to create a span that is not set as active, use {@link startInactiveSpan}.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nfunction startSpan(context, callback) {\n  const ctx = normalizeContext(context);\n\n  return runWithAsyncContext(() => {\n    return withScope(context.scope, scope => {\n      // eslint-disable-next-line deprecation/deprecation\n      const hub = getCurrentHub();\n      // eslint-disable-next-line deprecation/deprecation\n      const parentSpan = scope.getSpan();\n\n      const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan ? undefined : createChildSpanOrTransaction(hub, parentSpan, ctx);\n\n      // eslint-disable-next-line deprecation/deprecation\n      scope.setSpan(activeSpan);\n\n      return handleCallbackErrors(\n        () => callback(activeSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet\n          if (activeSpan) {\n            const { status } = spanToJSON(activeSpan);\n            if (!status || status === 'ok') {\n              activeSpan.setStatus('internal_error');\n            }\n          }\n        },\n        () => activeSpan && activeSpan.end(),\n      );\n    });\n  });\n}\n\n/**\n * @deprecated Use {@link startSpan} instead.\n */\nconst startActiveSpan = startSpan;\n\n/**\n * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span\n * after the function is done automatically. You'll have to call `span.end()` manually.\n *\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nfunction startSpanManual(\n  context,\n  callback,\n) {\n  const ctx = normalizeContext(context);\n\n  return runWithAsyncContext(() => {\n    return withScope(context.scope, scope => {\n      // eslint-disable-next-line deprecation/deprecation\n      const hub = getCurrentHub();\n      // eslint-disable-next-line deprecation/deprecation\n      const parentSpan = scope.getSpan();\n\n      const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan ? undefined : createChildSpanOrTransaction(hub, parentSpan, ctx);\n\n      // eslint-disable-next-line deprecation/deprecation\n      scope.setSpan(activeSpan);\n\n      function finishAndSetSpan() {\n        activeSpan && activeSpan.end();\n      }\n\n      return handleCallbackErrors(\n        () => callback(activeSpan, finishAndSetSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          if (activeSpan && activeSpan.isRecording()) {\n            const { status } = spanToJSON(activeSpan);\n            if (!status || status === 'ok') {\n              activeSpan.setStatus('internal_error');\n            }\n          }\n        },\n      );\n    });\n  });\n}\n\n/**\n * Creates a span. This span is not set as active, so will not get automatic instrumentation spans\n * as children or be able to be accessed via `Sentry.getSpan()`.\n *\n * If you want to create a span that is set as active, use {@link startSpan}.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate` or `tracesSampler`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nfunction startInactiveSpan(context) {\n  if (!hasTracingEnabled()) {\n    return undefined;\n  }\n\n  const ctx = normalizeContext(context);\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n  const parentSpan = context.scope\n    ? // eslint-disable-next-line deprecation/deprecation\n      context.scope.getSpan()\n    : getActiveSpan();\n\n  const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n\n  if (shouldSkipSpan) {\n    return undefined;\n  }\n\n  const isolationScope = getIsolationScope();\n  const scope = getCurrentScope();\n\n  let span;\n\n  if (parentSpan) {\n    // eslint-disable-next-line deprecation/deprecation\n    span = parentSpan.startChild(ctx);\n  } else {\n    const { traceId, dsc, parentSpanId, sampled } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    // eslint-disable-next-line deprecation/deprecation\n    span = hub.startTransaction({\n      traceId,\n      parentSpanId,\n      parentSampled: sampled,\n      ...ctx,\n      metadata: {\n        dynamicSamplingContext: dsc,\n        // eslint-disable-next-line deprecation/deprecation\n        ...ctx.metadata,\n      },\n    });\n  }\n\n  setCapturedScopesOnSpan(span, scope, isolationScope);\n\n  return span;\n}\n\n/**\n * Returns the currently active span.\n */\nfunction getActiveSpan() {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentScope().getSpan();\n}\n\nconst continueTrace = (\n  {\n    sentryTrace,\n    baggage,\n  }\n\n,\n  callback,\n) => {\n  // TODO(v8): Change this function so it doesn't do anything besides setting the propagation context on the current scope:\n  /*\n    return withScope((scope) => {\n      const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n      scope.setPropagationContext(propagationContext);\n      return callback();\n    })\n  */\n\n  const currentScope = getCurrentScope();\n\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceparentData, dynamicSamplingContext, propagationContext } = tracingContextFromHeaders(\n    sentryTrace,\n    baggage,\n  );\n\n  currentScope.setPropagationContext(propagationContext);\n\n  if (DEBUG_BUILD && traceparentData) {\n    logger.log(`[Tracing] Continuing trace ${traceparentData.traceId}.`);\n  }\n\n  const transactionContext = {\n    ...traceparentData,\n    metadata: dropUndefinedKeys({\n      dynamicSamplingContext,\n    }),\n  };\n\n  if (!callback) {\n    return transactionContext;\n  }\n\n  return runWithAsyncContext(() => {\n    return callback(transactionContext);\n  });\n};\n\nfunction createChildSpanOrTransaction(\n  hub,\n  parentSpan,\n  ctx,\n) {\n  if (!hasTracingEnabled()) {\n    return undefined;\n  }\n\n  const isolationScope = getIsolationScope();\n  const scope = getCurrentScope();\n\n  let span;\n  if (parentSpan) {\n    // eslint-disable-next-line deprecation/deprecation\n    span = parentSpan.startChild(ctx);\n  } else {\n    const { traceId, dsc, parentSpanId, sampled } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    // eslint-disable-next-line deprecation/deprecation\n    span = hub.startTransaction({\n      traceId,\n      parentSpanId,\n      parentSampled: sampled,\n      ...ctx,\n      metadata: {\n        dynamicSamplingContext: dsc,\n        // eslint-disable-next-line deprecation/deprecation\n        ...ctx.metadata,\n      },\n    });\n  }\n\n  setCapturedScopesOnSpan(span, scope, isolationScope);\n\n  return span;\n}\n\n/**\n * This converts StartSpanOptions to TransactionContext.\n * For the most part (for now) we accept the same options,\n * but some of them need to be transformed.\n *\n * Eventually the StartSpanOptions will be more aligned with OpenTelemetry.\n */\nfunction normalizeContext(context) {\n  if (context.startTime) {\n    const ctx = { ...context };\n    ctx.startTimestamp = spanTimeInputToSeconds(context.startTime);\n    delete ctx.startTime;\n    return ctx;\n  }\n\n  return context;\n}\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\nfunction setCapturedScopesOnSpan(span, scope, isolationScope) {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nfunction getCapturedScopesOnSpan(span) {\n  return {\n    scope: (span )[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span )[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n\nexport { continueTrace, getActiveSpan, getCapturedScopesOnSpan, startActiveSpan, startInactiveSpan, startSpan, startSpanManual, trace };\n//# sourceMappingURL=trace.js.map\n"],"names":["SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","handleCallbackErrors","fn","onError","onFinally","maybePromiseResult","e","maybeHandlePromiseRejection","value","isThenable","res","hasTracingEnabled","maybeOptions","client","getClient","options","startSpan","context","callback","ctx","normalizeContext","runWithAsyncContext","withScope","scope","hub","getCurrentHub","parentSpan","activeSpan","createChildSpanOrTransaction","status","spanToJSON","startInactiveSpan","getActiveSpan","isolationScope","getIsolationScope","getCurrentScope","span","traceId","dsc","parentSpanId","sampled","setCapturedScopesOnSpan","spanTimeInputToSeconds","SCOPE_ON_START_SPAN_FIELD","ISOLATION_SCOPE_ON_START_SPAN_FIELD","addNonEnumerableProperty","getCapturedScopesOnSpan"],"mappings":"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","x_google_ignoreList":[0,1,2,3]}