Function onThrow

packages/trigger-sdk/src/v3/retry.ts:31–110

(
  fn: (options: { attempt: number; maxAttempts: number }) => Promise<T>,
  options: RetryOptions
)

export type { RetryOptions };

function onThrow<T>(
  fn: (options: { attempt: number; maxAttempts: number }) => Promise<T>,
  options: RetryOptions
): Promise<T> {
  const opts = {
    ...defaultRetryOptions,
    ...options,
  };

  return tracer.startActiveSpan(
    `retry.onThrow()`,
    async (span) => {
      let attempt = 1;

      while (attempt <= opts.maxAttempts) {
        const innerSpan = tracer.startSpan("retry.fn()", {
          attributes: {
            [SemanticInternalAttributes.STYLE_ICON]: "function",
            ...accessoryAttributes({
              items: [
                {
                  text: `${attempt}/${opts.maxAttempts}`,
                  variant: "normal",
                },
              ],
              style: "codepath",
            }),
          },
        });

        const contextWithSpanSet = trace.setSpan(context.active(), innerSpan);

        try {
          const result = await context.with(contextWithSpanSet, async () => {
            return fn({ attempt, maxAttempts: opts.maxAttempts });
          });

          innerSpan.end();

          return result;
        } catch (e) {
          if (e instanceof Error || typeof e === "string") {
            innerSpan.recordException(e);
          } else {
            innerSpan.recordException(String(e));
          }

          innerSpan.setStatus({ code: SpanStatusCode.ERROR });

          const nextRetryDelay = calculateNextRetryDelay(opts, attempt);

          if (!nextRetryDelay) {
            innerSpan.end();

            throw e;
          }

          innerSpan.setAttribute(