Function wrappedHandle

packages/core/src/integrations/postgresjs.ts:220–311

(this: { executed?: boolean }, ...args: unknown[])

  // IMPORTANT: We must replace the handle function directly, not use a Proxy,
  // because Query.then() internally calls this.handle(), which would bypass a Proxy wrapper.
  const wrappedHandle = async function (this: { executed?: boolean }, ...args: unknown[]): Promise<unknown> {
    // postgres.js calls handle() from then/catch/finally — only the first call executes SQL,
    // subsequent calls are no-ops (guarded by this.executed). Skip span creation for no-ops.
    if (this.executed || !_shouldCreateSpans(options)) {
      return originalHandle.apply(this, args);
    }

    const fullQuery = _reconstructQuery(query.strings);
    const sanitizedSqlQuery = _sanitizeSqlQuery(fullQuery);

    return startSpanManual(
      {
        name: sanitizedSqlQuery || 'postgresjs.query',
        op: 'db',
      },
      (span: Span) => {
        span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.postgresjs');

        span.setAttributes({
          'db.system.name': 'postgres',
          'db.query.text': sanitizedSqlQuery,
        });

        const connectionContext = sqlInstance
          ? ((sqlInstance as Record<symbol, unknown>)[CONNECTION_CONTEXT_SYMBOL] as
              | PostgresConnectionContext
              | undefined)
          : undefined;

        _setConnectionAttributes(span, connectionContext);

        if (options.requestHook) {
          try {
            options.requestHook(span, sanitizedSqlQuery, connectionContext);
          } catch (e) {
            span.setAttribute('sentry.hook.error', 'requestHook failed');
            DEBUG_BUILD && debug.error('Error in requestHook for PostgresJs instrumentation:', e);
          }
        }

        const queryWithCallbacks = this as {
          resolve: unknown;
          reject: unknown;
        };

        queryWithCallbacks.resolve = new Proxy(queryWithCallbacks.resolve as (...args: unknown[]) => unknown, {
          apply: (resolveTarget, resolveThisArg, resolveArgs: [{ command?: string }]) => {
            try {
              _setOperationName(span, sanitizedSqlQuery, resolveArgs?.[0]?.command);
              span.end();
            } catch (e) {
              DEBUG_BUILD && debug.error('Error ending span in resolve callback:', e);
            }

            return Reflect.apply(resolveTarget, resolveThisArg, resolveArgs);
          },
        });