MultiTransport with version 7.x

[ZMDominik]

Hello,

I have found this MultiTransport class written in Python that sends all events to two instances of sentry at once. We are currently moving from one instance to another and wanted to run them parallel to each other in case the new sentry has issues.

class MultiTransport(sentry_sdk.transport.Transport): 
    def __init__(self, options=None):                                                   
        self.transports = []                                                      
        options.pop('transport', None)        
        dsn = options.pop('dsn', [])        
        for d in dsn:                
            options['dsn'] = d
            self.transports.append(sentry_sdk.transport.HttpTransport(options))
        super().__init__(options)                                                   
    
    def capture_envelope(self, envelope):        
        for t in self.transports:            
            t.capture_envelope(envelope)    

   def capture_event(self, event):                                                     
        for t in self.transports:                                                    
           t.capture_event(event)                                                  

    def flush(self, timeout, callback=None):                                            
        for t in self.transports:                                                     
            t.flush(timeout, callback)                                              

    def kill(self):                                                                     
        for t in self.transports:                                                     
            t.kill()

I can't seem to convert this into something that works in version 7.x as it's impossible to import BrowserOptions or access the makeRequest function from outside the makeXXXXTransport() functions.

I created this in an attempt to make multi transport work, but it's not even sending errors to one of the dsn

const global = getGlobalObject<Window>();

function makeMultiTransport(options: BaseTransportOptions): Transport {
  function makeRequest(
    request: TransportRequest
  ): PromiseLike<TransportMakeRequestResponse> {
    let resp: PromiseLike<TransportMakeRequestResponse>;

    const dsns: string[] = [
      "DSN1",
      "DSN2",
    ];

    for (const d of dsns) {
      // I got this from fetch.ts 
      resp = global
        .fetch(d, {
          body: request.body,
          method: "POST",
          credentials: "omit",
          keepalive: true,
        })
        .then((response) => ({
          headers: {
            "x-sentry-rate-limits": response.headers.get(
              "X-Sentry-Rate-Limits"
            ),
            "retry-after": response.headers.get("Retry-After"),
          },
        }));
    }
    return resp;
  }
  return createTransport(options, makeRequest);
}

I am aware I could theorhetically make a separate BrowserClient for each dsn and then duplicate every call to Sentry, but that would require me to modify a rather massive amount of files and would leave the possibility for someone to accidentally omit one of the sentry instances when using sentry in the future.

[ZMDominik]

I suppose this is one of those moments when you find a better solution after asking a question:

     const commonOptions = {
       integrations: [
         new Integrations.BrowserTracing({
           routingInstrumentation: Sentry.routingInstrumentation,
         }),
       ],
       environment: environment.type,
       release: env.version,

       // Set tracesSampleRate to 1.0 to capture 100%
       // of transactions for performance monitoring.
       // We recommend adjusting this value in production
       tracesSampleRate: 1.0,

       transport: makeFetchTransport,
       stackParser: defaultStackParser,
     }

     const sentry2 = new Sentry.BrowserClient({
       dsn: DSN2,
       ...commonOptions,
     });

     Sentry.init({
       dsn: DSN1,
       beforeSend(event, hint){
         sentry2.captureException(event, hint);
         return event;
       },
       ...commonOptions,
     });

     throw new Error("TESTING TESTING");

kind of works, the sentry with DSN1 gets "TESTING TESTING" just fine, however,
the sentry with DSN2 only gets a Module.captureException "non-error exception captured with keys: breadcrumbs, contexts, environment", but neither description nor the tags come through

[AbhiPrasad]

If you call sentry2.captureEvent that should work!

[ZMDominik]

interestingly, captureEvent has reduced sentry2 to never receiving. It's possible that captureException never worked and was finding some other error.

[AbhiPrasad]

I created this in an attempt to make multi transport work, but it's not even sending errors to one of the dsn

The issue with the first approach is that you have to convert the DSN to be a URL to send to. You can do this via the makeDsn and getEnvelopeEndpointWithUrlEncodedAuth that is exported from the base packages.

const dsn = makeDsn("STRING DSN HERE");
const url = getEnvelopeEndpointWithUrlEncodedAuth(dsn);

Below is an example that should work - but I haven't tested it. Pay special attention to the fact that it respects rate limits, which is important.

/**
 * Creates a Transport that uses the Fetch API to send events to multiple Sentry DSNs.
 */
export function makeMultiTransport(options: BrowserTransportOptions): Transport {
  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {
    const requestOptions: RequestInit = {
      body: request.body,
      method: 'POST',
      referrerPolicy: 'origin',
      headers: options.headers,
      keepalive: request.body.length <= 65536,
      ...options.fetchOptions,
    };

    try {
      return Promise.all(
        ['FIRST_DSN_HERE', 'SECOND_DSN_HERE'].map(dsnString => {
          const dsn = makeDsn(dsnString);
          const url = getEnvelopeEndpointWithUrlEncodedAuth(dsn);
          return fetch(url, requestOptions).then(response => ({
            statusCode: response.status,
            headers: {
              'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
              'retry-after': response.headers.get('Retry-After'),
            },
          }));
        }),
      ).then((transportResponses: TransportMakeRequestResponse[]) => {
        // Return first response that has rate limits
        for (const response of transportResponses) {
          if (response && response.headers && response.headers['x-sentry-rate-limits']) {
            return response;
          }
        }

        // Otherwise just return first response
        return transportResponses[0];
      });
    } catch (e) {
      return rejectedSyncPromise(e);
    }
  }

  return createTransport(options, makeRequest);
}

[ZMDominik]

would the rate limits be as important with on-premise sentry?

[AbhiPrasad]

Depends on the volume of events being sent and what the amount of resources given to your service - but generally no, so you could ignore them.

They do help alleviate spikes though, which can help reduce the chance of Sentry getting taken down.

[ZMDominik]

another possibly stupid question: is there a way to import BrowserTransportOptions? I tried:
import {BrowserTransportOptions} from "@sentry/browser" and from @sentry/types, but both claim it doesn't exist

[ZMDominik]

should its export have been included here? https://github.com/getsentry/sentry-javascript/blob/develop/packages/browser/src/exports.ts

[AbhiPrasad]

You can use BrowserOptions['transportOptions'], which should be exported!