@sentry/node/esm/handlers.js

import { startTransaction, getCurrentHub, withScope, captureException } from '@sentry/core';
import { isString, extractTraceparentData, parseBaggageSetMutability, extractPathForTransaction, addRequestDataToTransaction, logger } from '@sentry/utils';
import * as domain from 'domain';
import { parseRequest } from './requestDataDeprecated.js';
export { extractRequestData, parseRequest } from './requestDataDeprecated.js';
import { extractRequestData, isAutoSessionTrackingEnabled, addRequestDataToEvent, flush } from './sdk.js';

/**
 * Express-compatible tracing handler.
 * @see Exposed as `Handlers.tracingHandler`
 */
function tracingHandler()

 {
  return function sentryTracingMiddleware(
    req,
    res,
    next,
  ) {
    // If there is a trace header set, we extract the data from it (parentSpanId, traceId, and sampling decision)
    var traceparentData =
      req.headers && isString(req.headers['sentry-trace']) && extractTraceparentData(req.headers['sentry-trace']);
    var rawBaggageString = req.headers && isString(req.headers.baggage) && req.headers.baggage;

    var baggage = parseBaggageSetMutability(rawBaggageString, traceparentData);

    var transaction = startTransaction(
      {
        name: extractPathForTransaction(req, { path: true, method: true }),
        op: 'http.server',
        ...traceparentData,
        metadata: { baggage },
      },
      // extra context passed to the tracesSampler
      { request: extractRequestData(req) },
    );

    // We put the transaction on the scope so users can attach children to it
    getCurrentHub().configureScope(scope => {
      scope.setSpan(transaction);
    });

    // We also set __sentry_transaction on the response so people can grab the transaction there to add
    // spans to it later.
        (res ).__sentry_transaction = transaction;

    res.once('finish', () => {
      // Push `transaction.finish` to the next event loop so open spans have a chance to finish before the transaction
      // closes
      setImmediate(() => {
        addRequestDataToTransaction(transaction, req);
        transaction.setHttpStatus(res.statusCode);
        transaction.finish();
      });
    });

    next();
  };
}

/**
 * Express compatible request handler.
 * @see Exposed as `Handlers.requestHandler`
 */
function requestHandler(
  options,
) {
  var currentHub = getCurrentHub();
  var client = currentHub.getClient();
  // Initialise an instance of SessionFlusher on the client when `autoSessionTracking` is enabled and the
  // `requestHandler` middleware is used indicating that we are running in SessionAggregates mode
  if (client && isAutoSessionTrackingEnabled(client)) {
    client.initSessionFlusher();

    // If Scope contains a Single mode Session, it is removed in favor of using Session Aggregates mode
    var scope = currentHub.getScope();
    if (scope && scope.getSession()) {
      scope.setSession();
    }
  }

  return function sentryRequestMiddleware(
    req,
    res,
    next,
  ) {
    // TODO (v8 / XXX) Remove this shim and just use `addRequestDataToEvent`
    let backwardsCompatibleEventProcessor;
    if (options && 'include' in options) {
      backwardsCompatibleEventProcessor = (event) => addRequestDataToEvent(event, req, options);
    } else {
            backwardsCompatibleEventProcessor = (event) => parseRequest(event, req, options );
    }

    if (options && options.flushTimeout && options.flushTimeout > 0) {
            var _end = res.end;
      res.end = function (chunk, encoding, cb) {
        void flush(options.flushTimeout)
          .then(() => {
            _end.call(this, chunk, encoding, cb);
          })
          .then(null, e => {
            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);
            _end.call(this, chunk, encoding, cb);
          });
      };
    }
    var local = domain.create();
    local.add(req);
    local.add(res);
    local.on('error', next);

    local.run(() => {
      var currentHub = getCurrentHub();

      currentHub.configureScope(scope => {
        scope.addEventProcessor(backwardsCompatibleEventProcessor);
        var client = currentHub.getClient();
        if (isAutoSessionTrackingEnabled(client)) {
          var scope = currentHub.getScope();
          if (scope) {
            // Set `status` of `RequestSession` to Ok, at the beginning of the request
            scope.setRequestSession({ status: 'ok' });
          }
        }
      });

      res.once('finish', () => {
        var client = currentHub.getClient();
        if (isAutoSessionTrackingEnabled(client)) {
          setImmediate(() => {
                        if (client && (client )._captureRequestSession) {
              // Calling _captureRequestSession to capture request session at the end of the request by incrementing
              // the correct SessionAggregates bucket i.e. crashed, errored or exited
                            (client )._captureRequestSession();
            }
          });
        }
      });
      next();
    });
  };
}

/** JSDoc */

/** JSDoc */
function getStatusCodeFromResponse(error) {
  var statusCode = error.status || error.statusCode || error.status_code || (error.output && error.output.statusCode);
  return statusCode ? parseInt(statusCode , 10) : 500;
}

/** Returns true if response code is internal server error */
function defaultShouldHandleError(error) {
  var status = getStatusCodeFromResponse(error);
  return status >= 500;
}

/**
 * Express compatible error handler.
 * @see Exposed as `Handlers.errorHandler`
 */
function errorHandler(options

)

 {
  return function sentryErrorMiddleware(
    error,
    _req,
    res,
    next,
  ) {
        var shouldHandleError = (options && options.shouldHandleError) || defaultShouldHandleError;

    if (shouldHandleError(error)) {
      withScope(_scope => {
        // For some reason we need to set the transaction on the scope again
                var transaction = (res ).__sentry_transaction ;
        if (transaction && _scope.getSpan() === undefined) {
          _scope.setSpan(transaction);
        }

        var client = getCurrentHub().getClient();
        if (client && isAutoSessionTrackingEnabled(client)) {
          // Check if the `SessionFlusher` is instantiated on the client to go into this branch that marks the
          // `requestSession.status` as `Crashed`, and this check is necessary because the `SessionFlusher` is only
          // instantiated when the the`requestHandler` middleware is initialised, which indicates that we should be
          // running in SessionAggregates mode
                    var isSessionAggregatesMode = (client )._sessionFlusher !== undefined;
          if (isSessionAggregatesMode) {
            var requestSession = _scope.getRequestSession();
            // If an error bubbles to the `errorHandler`, then this is an unhandled error, and should be reported as a
            // Crashed session. The `_requestSession.status` is checked to ensure that this error is happening within
            // the bounds of a request, and if so the status is updated
            if (requestSession && requestSession.status !== undefined) {
              requestSession.status = 'crashed';
            }
          }
        }

        var eventId = captureException(error);
                (res ).sentry = eventId;
        next(error);
      });

      return;
    }

    next(error);
  };
}

// TODO (v8 / #5257): Remove this
;

export { errorHandler, requestHandler, tracingHandler };
//# sourceMappingURL=handlers.js.map