jwt expired

  environment: "production",

});

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

function simulateExpressError(scenario, message) {

  const ErrClass = global[scenario.type.split(".")[0]] || Error;

  const err = new ErrClass(message);

  err.name = scenario.type;

  throw err;

}

(async () => {

  let cycleTime = 0;

        scope.addBreadcrumb({

          level: "info",

          category: randomChoice(["http", "auth", "db", "upload", "queue"]),

          message: randomChoice(BREADCRUMBS),

        });

        try {

          simulateExpressError(scenario, message);

        } catch (e) {

          Sentry.captureException(e);

          console.log(`Sent: ${e.name} – ${e.message}`);

        }

      });

      await sleep(Math.random() * 1500 + 500);

    // We depend on the otelContextManager to handle the context/hub

    // We set the `SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY` context value, which is picked up by

    // the OTEL context manager, which uses the presence of this key to determine if it should

    // fork the isolation scope, or not

    // as by default, we don't want to fork this, unless triggered explicitly by `withScope`

    return api.context.with(ctx, () => {

      return callback(getCurrentScope());

    });

  }

  function withSetScope(scope, callback) {

    const ctx = getContextFromScope(scope) || api.context.active();

    // We depend on the otelContextManager to handle the context/hub

        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();

    }

    active() {

        return this._asyncLocalStorage.getStore() ?? api_1.ROOT_CONTEXT;

    }

    with(context, fn, thisArg, ...args) {

        const cb = thisArg == null ? fn : fn.bind(thisArg);

        return this._asyncLocalStorage.run(context, cb, ...args);

    }

    enable() {

        return this;

    }

    disable() {

        this._asyncLocalStorage.disable();

        return this;

      const ctx2 = ctx1

        .deleteValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY)

        .deleteValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY)

        .deleteValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY);

      setContextOnScope(newCurrentScope, ctx2);

      return super.with(ctx2, fn, thisArg, ...args);

    }

  }

  return SentryContextManager ;

}

/**

     *

     * @param context context to be active during function execution

     * @param fn function to execute in a context

     * @param thisArg optional receiver to be used for calling fn

     * @param args optional arguments forwarded to fn

     */

    with(context, fn, thisArg, ...args) {

        return this._getContextManager().with(context, fn, thisArg, ...args);

    }

    /**

     * Bind a context to a target function or event emitter

     *

     * @param context context to bind to the event emitter or function. Defaults to the currently active context

     * @param target function or event emitter to bind

     */

    const ctx = api.context.active();

    // We depend on the otelContextManager to handle the context/hub

    // We set the `SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY` context value, which is picked up by

    // the OTEL context manager, which uses the presence of this key to determine if it should

    // fork the isolation scope, or not

    // as by default, we don't want to fork this, unless triggered explicitly by `withScope`

    return api.context.with(ctx, () => {

      return callback(getCurrentScope());

    });

  }

  function withSetScope(scope, callback) {

    const ctx = getContextFromScope(scope) || api.context.active();

    if (!scope) {

      return acs.withScope(callback);

    }

    return acs.withSetScope(scope, callback);

  }

  return acs.withScope(rest[0]);

}

/**

 * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no

 * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the

 * case, for example, in the browser).

 *

    for (let i = 0; i < burstSize; i++) {

      const scenario = randomChoice(ERROR_SCENARIOS);

      const message = scenario.message.replace(/{}/g, () =>

        randomChoice(REPLACEMENTS)()

      );

      Sentry.withScope((scope) => {

        scope.setUser({

          id: String(Math.floor(Math.random() * 100000 + 1)),

          username: `user_${Math.floor(Math.random() * 10000)}`,

          email: `user${Math.floor(Math.random() * 10000)}@example.com`,

        });

        scope.setTags({