@sentry/browser 10.24.0 → 10.26.0

package/build/npm/cjs/prod/integrations/browserapierrors.js

@@ -0,0 +1,259 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const helpers = require('../helpers.js');
+
+const DEFAULT_EVENT_TARGET = [
+  'EventTarget',
+  'Window',
+  'Node',
+  'ApplicationCache',
+  'AudioTrackList',
+  'BroadcastChannel',
+  'ChannelMergerNode',
+  'CryptoOperation',
+  'EventSource',
+  'FileReader',
+  'HTMLUnknownElement',
+  'IDBDatabase',
+  'IDBRequest',
+  'IDBTransaction',
+  'KeyOperation',
+  'MediaController',
+  'MessagePort',
+  'ModalWindow',
+  'Notification',
+  'SVGElementInstance',
+  'Screen',
+  'SharedWorker',
+  'TextTrack',
+  'TextTrackCue',
+  'TextTrackList',
+  'WebSocket',
+  'WebSocketWorker',
+  'Worker',
+  'XMLHttpRequest',
+  'XMLHttpRequestEventTarget',
+  'XMLHttpRequestUpload',
+];
+
+const INTEGRATION_NAME = 'BrowserApiErrors';
+
+const _browserApiErrorsIntegration = ((options = {}) => {
+  const _options = {
+    XMLHttpRequest: true,
+    eventTarget: true,
+    requestAnimationFrame: true,
+    setInterval: true,
+    setTimeout: true,
+    unregisterOriginalCallbacks: false,
+    ...options,
+  };
+
+  return {
+    name: INTEGRATION_NAME,
+    // TODO: This currently only works for the first client this is setup
+    // We may want to adjust this to check for client etc.
+    setupOnce() {
+      if (_options.setTimeout) {
+        core.fill(helpers.WINDOW, 'setTimeout', _wrapTimeFunction);
+      }
+
+      if (_options.setInterval) {
+        core.fill(helpers.WINDOW, 'setInterval', _wrapTimeFunction);
+      }
+
+      if (_options.requestAnimationFrame) {
+        core.fill(helpers.WINDOW, 'requestAnimationFrame', _wrapRAF);
+      }
+
+      if (_options.XMLHttpRequest && 'XMLHttpRequest' in helpers.WINDOW) {
+        core.fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
+      }
+
+      const eventTargetOption = _options.eventTarget;
+      if (eventTargetOption) {
+        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
+        eventTarget.forEach(target => _wrapEventTarget(target, _options));
+      }
+    },
+  };
+}) ;
+
+/**
+ * Wrap timer functions and event targets to catch errors and provide better meta data.
+ */
+const browserApiErrorsIntegration = core.defineIntegration(_browserApiErrorsIntegration);
+
+function _wrapTimeFunction(original) {
+  return function ( ...args) {
+    const originalCallback = args[0];
+    args[0] = helpers.wrap(originalCallback, {
+      mechanism: {
+        handled: false,
+        type: `auto.browser.browserapierrors.${core.getFunctionName(original)}`,
+      },
+    });
+    return original.apply(this, args);
+  };
+}
+
+function _wrapRAF(original) {
+  return function ( callback) {
+    return original.apply(this, [
+      helpers.wrap(callback, {
+        mechanism: {
+          data: {
+            handler: core.getFunctionName(original),
+          },
+          handled: false,
+          type: 'auto.browser.browserapierrors.requestAnimationFrame',
+        },
+      }),
+    ]);
+  };
+}
+
+function _wrapXHR(originalSend) {
+  return function ( ...args) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const xhr = this;
+    const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
+
+    xmlHttpRequestProps.forEach(prop => {
+      if (prop in xhr && typeof xhr[prop] === 'function') {
+        core.fill(xhr, prop, function (original) {
+          const wrapOptions = {
+            mechanism: {
+              data: {
+                handler: core.getFunctionName(original),
+              },
+              handled: false,
+              type: `auto.browser.browserapierrors.xhr.${prop}`,
+            },
+          };
+
+          // If Instrument integration has been called before BrowserApiErrors, get the name of original function
+          const originalFunction = core.getOriginalFunction(original);
+          if (originalFunction) {
+            wrapOptions.mechanism.data.handler = core.getFunctionName(originalFunction);
+          }
+
+          // Otherwise wrap directly
+          return helpers.wrap(original, wrapOptions);
+        });
+      }
+    });
+
+    return originalSend.apply(this, args);
+  };
+}
+
+function _wrapEventTarget(target, integrationOptions) {
+  const globalObject = helpers.WINDOW ;
+  const proto = globalObject[target]?.prototype;
+
+  // eslint-disable-next-line no-prototype-builtins
+  if (!proto?.hasOwnProperty?.('addEventListener')) {
+    return;
+  }
+
+  core.fill(proto, 'addEventListener', function (original)
+
+ {
+    return function ( eventName, fn, options) {
+      try {
+        if (isEventListenerObject(fn)) {
+          // ESlint disable explanation:
+          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would
+          //  introduce a bug here, because bind returns a new function that doesn't have our
+          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.
+          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          fn.handleEvent = helpers.wrap(fn.handleEvent, {
+            mechanism: {
+              data: {
+                handler: core.getFunctionName(fn),
+                target,
+              },
+              handled: false,
+              type: 'auto.browser.browserapierrors.handleEvent',
+            },
+          });
+        }
+      } catch {
+        // can sometimes get 'Permission denied to access property "handle Event'
+      }
+
+      if (integrationOptions.unregisterOriginalCallbacks) {
+        unregisterOriginalCallback(this, eventName, fn);
+      }
+
+      return original.apply(this, [
+        eventName,
+        helpers.wrap(fn, {
+          mechanism: {
+            data: {
+              handler: core.getFunctionName(fn),
+              target,
+            },
+            handled: false,
+            type: 'auto.browser.browserapierrors.addEventListener',
+          },
+        }),
+        options,
+      ]);
+    };
+  });
+
+  core.fill(proto, 'removeEventListener', function (originalRemoveEventListener)
+
+ {
+    return function ( eventName, fn, options) {
+      /**
+       * There are 2 possible scenarios here:
+       *
+       * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
+       * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
+       * as a pass-through, and call original `removeEventListener` with it.
+       *
+       * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
+       * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
+       * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
+       * in order for us to make a distinction between wrapped/non-wrapped functions possible.
+       * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
+       *
+       * When someone adds a handler prior to initialization, and then do it again, but after,
+       * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
+       * to get rid of the initial handler and it'd stick there forever.
+       */
+      try {
+        const originalEventHandler = (fn ).__sentry_wrapped__;
+        if (originalEventHandler) {
+          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
+        }
+      } catch {
+        // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
+      }
+      return originalRemoveEventListener.call(this, eventName, fn, options);
+    };
+  });
+}
+
+function isEventListenerObject(obj) {
+  return typeof (obj ).handleEvent === 'function';
+}
+
+function unregisterOriginalCallback(target, eventName, fn) {
+  if (
+    target &&
+    typeof target === 'object' &&
+    'removeEventListener' in target &&
+    typeof target.removeEventListener === 'function'
+  ) {
+    target.removeEventListener(eventName, fn);
+  }
+}
+
+exports.browserApiErrorsIntegration = browserApiErrorsIntegration;
+//# sourceMappingURL=browserapierrors.js.map

package/build/npm/cjs/prod/integrations/browserapierrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserapierrors.js","sources":["../../../../../src/integrations/browserapierrors.ts"],"sourcesContent":["import type { IntegrationFn, WrappedFunction } from '@sentry/core';\nimport { defineIntegration, fill, getFunctionName, getOriginalFunction } from '@sentry/core';\nimport { WINDOW, wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'BrowserApiErrors';\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\ninterface BrowserApiErrorsOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n\n  /**\n   * If you experience issues with this integration causing double-invocations of event listeners,\n   * try setting this option to `true`. It will unregister the original callbacks from the event targets\n   * before adding the instrumented callback.\n   *\n   * @default false\n   */\n  unregisterOriginalCallbacks: boolean;\n}\n\nconst _browserApiErrorsIntegration = ((options: Partial<BrowserApiErrorsOptions> = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    unregisterOriginalCallbacks: false,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(target => _wrapEventTarget(target, _options));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n */\nexport const browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\nfunction _wrapTimeFunction(original: () => void): () => number {\n  return function (this: unknown, ...args: unknown[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        handled: false,\n        type: `auto.browser.browserapierrors.${getFunctionName(original)}`,\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\nfunction _wrapRAF(original: () => void): (callback: () => void) => unknown {\n  return function (this: unknown, callback: () => void): () => void {\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'auto.browser.browserapierrors.requestAnimationFrame',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend: () => void): () => void {\n  return function (this: XMLHttpRequest, ...args: unknown[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: `auto.browser.browserapierrors.xhr.${prop}`,\n            },\n          };\n\n          // If Instrument integration has been called before BrowserApiErrors, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\nfunction _wrapEventTarget(target: string, integrationOptions: BrowserApiErrorsOptions): void {\n  const globalObject = WINDOW as unknown as Record<string, { prototype?: object }>;\n  const proto = globalObject[target]?.prototype;\n\n  // eslint-disable-next-line no-prototype-builtins\n  if (!proto?.hasOwnProperty?.('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: VoidFunction): (\n    ...args: Parameters<typeof WINDOW.addEventListener>\n  ) => ReturnType<typeof WINDOW.addEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\n      try {\n        if (isEventListenerObject(fn)) {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'auto.browser.browserapierrors.handleEvent',\n            },\n          });\n        }\n      } catch {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      if (integrationOptions.unregisterOriginalCallbacks) {\n        unregisterOriginalCallback(this, eventName, fn);\n      }\n\n      return original.apply(this, [\n        eventName,\n        wrap(fn, {\n          mechanism: {\n            data: {\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'auto.browser.browserapierrors.addEventListener',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener: VoidFunction): (\n    this: unknown,\n    ...args: Parameters<typeof WINDOW.removeEventListener>\n  ) => ReturnType<typeof WINDOW.removeEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\n      /**\n       * There are 2 possible scenarios here:\n       *\n       * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n       * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n       * as a pass-through, and call original `removeEventListener` with it.\n       *\n       * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n       * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n       * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n       * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n       * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n       *\n       * When someone adds a handler prior to initialization, and then do it again, but after,\n       * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n       * to get rid of the initial handler and it'd stick there forever.\n       */\n      try {\n        const originalEventHandler = (fn as WrappedFunction).__sentry_wrapped__;\n        if (originalEventHandler) {\n          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n        }\n      } catch {\n        // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n      }\n      return originalRemoveEventListener.call(this, eventName, fn, options);\n    };\n  });\n}\n\nfunction isEventListenerObject(obj: unknown): obj is EventListenerObject {\n  return typeof (obj as EventListenerObject).handleEvent === 'function';\n}\n\nfunction unregisterOriginalCallback(target: unknown, eventName: string, fn: EventListenerOrEventListenerObject): void {\n  if (\n    target &&\n    typeof target === 'object' &&\n    'removeEventListener' in target &&\n    typeof target.removeEventListener === 'function'\n  ) {\n    target.removeEventListener(eventName, fn);\n  }\n}\n"],"names":["fill","WINDOW","defineIntegration","wrap","getFunctionName","getOriginalFunction"],"mappings":";;;;;AAIA,MAAM,uBAAuB;AAC7B,EAAE,aAAa;AACf,EAAE,QAAQ;AACV,EAAE,MAAM;AACR,EAAE,kBAAkB;AACpB,EAAE,gBAAgB;AAClB,EAAE,kBAAkB;AACpB,EAAE,mBAAmB;AACrB,EAAE,iBAAiB;AACnB,EAAE,aAAa;AACf,EAAE,YAAY;AACd,EAAE,oBAAoB;AACtB,EAAE,aAAa;AACf,EAAE,YAAY;AACd,EAAE,gBAAgB;AAClB,EAAE,cAAc;AAChB,EAAE,iBAAiB;AACnB,EAAE,aAAa;AACf,EAAE,aAAa;AACf,EAAE,cAAc;AAChB,EAAE,oBAAoB;AACtB,EAAE,QAAQ;AACV,EAAE,cAAc;AAChB,EAAE,WAAW;AACb,EAAE,cAAc;AAChB,EAAE,eAAe;AACjB,EAAE,WAAW;AACb,EAAE,iBAAiB;AACnB,EAAE,QAAQ;AACV,EAAE,gBAAgB;AAClB,EAAE,2BAA2B;AAC7B,EAAE,sBAAsB;AACxB,CAAC;;AAED,MAAM,gBAAA,GAAmB,kBAAkB;;AAqB3C,MAAM,4BAAA,IAAgC,CAAC,OAAO,GAAqC,EAAE,KAAK;AAC1F,EAAE,MAAM,WAAW;AACnB,IAAI,cAAc,EAAE,IAAI;AACxB,IAAI,WAAW,EAAE,IAAI;AACrB,IAAI,qBAAqB,EAAE,IAAI;AAC/B,IAAI,WAAW,EAAE,IAAI;AACrB,IAAI,UAAU,EAAE,IAAI;AACpB,IAAI,2BAA2B,EAAE,KAAK;AACtC,IAAI,GAAG,OAAO;AACd,GAAG;;AAEH,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B;AACA;AACA,IAAI,SAAS,GAAG;AAChB,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE;AAC/B,QAAQA,SAAI,CAACC,cAAM,EAAE,YAAY,EAAE,iBAAiB,CAAC;AACrD,MAAM;;AAEN,MAAM,IAAI,QAAQ,CAAC,WAAW,EAAE;AAChC,QAAQD,SAAI,CAACC,cAAM,EAAE,aAAa,EAAE,iBAAiB,CAAC;AACtD,MAAM;;AAEN,MAAM,IAAI,QAAQ,CAAC,qBAAqB,EAAE;AAC1C,QAAQD,SAAI,CAACC,cAAM,EAAE,uBAAuB,EAAE,QAAQ,CAAC;AACvD,MAAM;;AAEN,MAAM,IAAI,QAAQ,CAAC,kBAAkB,gBAAA,IAAoBA,cAAM,EAAE;AACjE,QAAQD,SAAI,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC;AACxD,MAAM;;AAEN,MAAM,MAAM,iBAAA,GAAoB,QAAQ,CAAC,WAAW;AACpD,MAAM,IAAI,iBAAiB,EAAE;AAC7B,QAAQ,MAAM,WAAA,GAAc,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAA,GAAI,iBAAA,GAAoB,oBAAoB;AACvG,QAAQ,WAAW,CAAC,OAAO,CAAC,MAAA,IAAU,gBAAgB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AACzE,MAAM;AACN,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;MACa,2BAAA,GAA8BE,sBAAiB,CAAC,4BAA4B;;AAEzF,SAAS,iBAAiB,CAAC,QAAQ,EAA4B;AAC/D,EAAE,OAAO,WAAyB,GAAG,IAAI,EAAqB;AAC9D,IAAI,MAAM,gBAAA,GAAmB,IAAI,CAAC,CAAC,CAAC;AACpC,IAAI,IAAI,CAAC,CAAC,CAAA,GAAIC,YAAI,CAAC,gBAAgB,EAAE;AACrC,MAAM,SAAS,EAAE;AACjB,QAAQ,OAAO,EAAE,KAAK;AACtB,QAAQ,IAAI,EAAE,CAAC,8BAA8B,EAAEC,oBAAe,CAAC,QAAQ,CAAC,CAAC,CAAA;AACA,OAAA;AACA,KAAA,CAAA;AACA,IAAA,OAAA,QAAA,CAAA,KAAA,CAAA,IAAA,EAAA,IAAA,CAAA;AACA,EAAA,CAAA;AACA;;AAEA,SAAA,QAAA,CAAA,QAAA,EAAA;AACA,EAAA,OAAA,WAAA,QAAA,EAAA;AACA,IAAA,OAAA,QAAA,CAAA,KAAA,CAAA,IAAA,EAAA;AACA,MAAAD,YAAA,CAAA,QAAA,EAAA;AACA,QAAA,SAAA,EAAA;AACA,UAAA,IAAA,EAAA;AACA,YAAA,OAAA,EAAAC,oBAAA,CAAA,QAAA,CAAA;AACA,WAAA;AACA,UAAA,OAAA,EAAA,KAAA;AACA,UAAA,IAAA,EAAA,qDAAA;AACA,SAAA;AACA,OAAA,CAAA;AACA,KAAA,CAAA;AACA,EAAA,CAAA;AACA;;AAEA,SAAA,QAAA,CAAA,YAAA,EAAA;AACA,EAAA,OAAA,WAAA,GAAA,IAAA,EAAA;AACA;AACA,IAAA,MAAA,GAAA,GAAA,IAAA;AACA,IAAA,MAAA,mBAAA,GAAA,CAAA,QAAA,EAAA,SAAA,EAAA,YAAA,EAAA,oBAAA,CAAA;;AAEA,IAAA,mBAAA,CAAA,OAAA,CAAA,IAAA,IAAA;AACA,MAAA,IAAA,IAAA,IAAA,GAAA,IAAA,OAAA,GAAA,CAAA,IAAA,CAAA,KAAA,UAAA,EAAA;AACA,QAAAJ,SAAA,CAAA,GAAA,EAAA,IAAA,EAAA,UAAA,QAAA,EAAA;AACA,UAAA,MAAA,WAAA,GAAA;AACA,YAAA,SAAA,EAAA;AACA,cAAA,IAAA,EAAA;AACA,gBAAA,OAAA,EAAAI,oBAAA,CAAA,QAAA,CAAA;AACA,eAAA;AACA,cAAA,OAAA,EAAA,KAAA;AACA,cAAA,IAAA,EAAA,CAAA,kCAAA,EAAA,IAAA,CAAA,CAAA;AACA,aAAA;AACA,WAAA;;AAEA;AACA,UAAA,MAAA,gBAAA,GAAAC,wBAAA,CAAA,QAAA,CAAA;AACA,UAAA,IAAA,gBAAA,EAAA;AACA,YAAA,WAAA,CAAA,SAAA,CAAA,IAAA,CAAA,OAAA,GAAAD,oBAAA,CAAA,gBAAA,CAAA;AACA,UAAA;;AAEA;AACA,UAAA,OAAAD,YAAA,CAAA,QAAA,EAAA,WAAA,CAAA;AACA,QAAA,CAAA,CAAA;AACA,MAAA;AACA,IAAA,CAAA,CAAA;;AAEA,IAAA,OAAA,YAAA,CAAA,KAAA,CAAA,IAAA,EAAA,IAAA,CAAA;AACA,EAAA,CAAA;AACA;;AAEA,SAAA,gBAAA,CAAA,MAAA,EAAA,kBAAA,EAAA;AACA,EAAA,MAAA,YAAA,GAAAF,cAAA;AACA,EAAA,MAAA,KAAA,GAAA,YAAA,CAAA,MAAA,CAAA,EAAA,SAAA;;AAEA;AACA,EAAA,IAAA,CAAA,KAAA,EAAA,cAAA,GAAA,kBAAA,CAAA,EAAA;AACA,IAAA;AACA,EAAA;;AAEA,EAAAD,SAAA,CAAA,KAAA,EAAA,kBAAA,EAAA,UAAA,QAAA;;AAEA,CAAA;AACA,IAAA,OAAA,WAAA,SAAA,EAAA,EAAA,EAAA,OAAA,EAAA;AACA,MAAA,IAAA;AACA,QAAA,IAAA,qBAAA,CAAA,EAAA,CAAA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAA,EAAA,CAAA,WAAA,GAAAG,YAAA,CAAA,EAAA,CAAA,WAAA,EAAA;AACA,YAAA,SAAA,EAAA;AACA,cAAA,IAAA,EAAA;AACA,gBAAA,OAAA,EAAAC,oBAAA,CAAA,EAAA,CAAA;AACA,gBAAA,MAAA;AACA,eAAA;AACA,cAAA,OAAA,EAAA,KAAA;AACA,cAAA,IAAA,EAAA,2CAAA;AACA,aAAA;AACA,WAAA,CAAA;AACA,QAAA;AACA,MAAA,CAAA,CAAA,MAAA;AACA;AACA,MAAA;;AAEA,MAAA,IAAA,kBAAA,CAAA,2BAAA,EAAA;AACA,QAAA,0BAAA,CAAA,IAAA,EAAA,SAAA,EAAA,EAAA,CAAA;AACA,MAAA;;AAEA,MAAA,OAAA,QAAA,CAAA,KAAA,CAAA,IAAA,EAAA;AACA,QAAA,SAAA;AACA,QAAAD,YAAA,CAAA,EAAA,EAAA;AACA,UAAA,SAAA,EAAA;AACA,YAAA,IAAA,EAAA;AACA,cAAA,OAAA,EAAAC,oBAAA,CAAA,EAAA,CAAA;AACA,cAAA,MAAA;AACA,aAAA;AACA,YAAA,OAAA,EAAA,KAAA;AACA,YAAA,IAAA,EAAA,gDAAA;AACA,WAAA;AACA,SAAA,CAAA;AACA,QAAA,OAAA;AACA,OAAA,CAAA;AACA,IAAA,CAAA;AACA,EAAA,CAAA,CAAA;;AAEA,EAAAJ,SAAA,CAAA,KAAA,EAAA,qBAAA,EAAA,UAAA,2BAAA;;AAGA,CAAA;AACA,IAAA,OAAA,WAAA,SAAA,EAAA,EAAA,EAAA,OAAA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,IAAA;AACA,QAAA,MAAA,oBAAA,GAAA,CAAA,EAAA,GAAA,kBAAA;AACA,QAAA,IAAA,oBAAA,EAAA;AACA,UAAA,2BAAA,CAAA,IAAA,CAAA,IAAA,EAAA,SAAA,EAAA,oBAAA,EAAA,OAAA,CAAA;AACA,QAAA;AACA,MAAA,CAAA,CAAA,MAAA;AACA;AACA,MAAA;AACA,MAAA,OAAA,2BAAA,CAAA,IAAA,CAAA,IAAA,EAAA,SAAA,EAAA,EAAA,EAAA,OAAA,CAAA;AACA,IAAA,CAAA;AACA,EAAA,CAAA,CAAA;AACA;;AAEA,SAAA,qBAAA,CAAA,GAAA,EAAA;AACA,EAAA,OAAA,OAAA,CAAA,GAAA,GAAA,WAAA,KAAA,UAAA;AACA;;AAEA,SAAA,0BAAA,CAAA,MAAA,EAAA,SAAA,EAAA,EAAA,EAAA;AACA,EAAA;AACA,IAAA,MAAA;AACA,IAAA,OAAA,MAAA,KAAA,QAAA;AACA,IAAA,qBAAA,IAAA,MAAA;AACA,IAAA,OAAA,MAAA,CAAA,mBAAA,KAAA;AACA,IAAA;AACA,IAAA,MAAA,CAAA,mBAAA,CAAA,SAAA,EAAA,EAAA,CAAA;AACA,EAAA;AACA;;;;"}

package/build/npm/cjs/prod/integrations/browsersession.js

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const browserUtils = require('@sentry-internal/browser-utils');
+const debugBuild = require('../debug-build.js');
+const helpers = require('../helpers.js');
+
+/**
+ * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.
+ * More information: https://docs.sentry.io/product/releases/health/
+ *
+ * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/
+ */
+const browserSessionIntegration = core.defineIntegration(() => {
+  return {
+    name: 'BrowserSession',
+    setupOnce() {
+      if (typeof helpers.WINDOW.document === 'undefined') {
+        debugBuild.DEBUG_BUILD &&
+          core.debug.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');
+        return;
+      }
+
+      // The session duration for browser sessions does not track a meaningful
+      // concept that can be used as a metric.
+      // Automatically captured sessions are akin to page views, and thus we
+      // discard their duration.
+      core.startSession({ ignoreDuration: true });
+      core.captureSession();
+
+      // We want to create a session for every navigation as well
+      browserUtils.addHistoryInstrumentationHandler(({ from, to }) => {
+        // Don't create an additional session for the initial route or if the location did not change
+        if (from !== undefined && from !== to) {
+          core.startSession({ ignoreDuration: true });
+          core.captureSession();
+        }
+      });
+    },
+  };
+});
+
+exports.browserSessionIntegration = browserSessionIntegration;
+//# sourceMappingURL=browsersession.js.map

package/build/npm/cjs/prod/integrations/browsersession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browsersession.js","sources":["../../../../../src/integrations/browsersession.ts"],"sourcesContent":["import { captureSession, debug, defineIntegration, startSession } from '@sentry/core';\nimport { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\n/**\n * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.\n * More information: https://docs.sentry.io/product/releases/health/\n *\n * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/\n */\nexport const browserSessionIntegration = defineIntegration(() => {\n  return {\n    name: 'BrowserSession',\n    setupOnce() {\n      if (typeof WINDOW.document === 'undefined') {\n        DEBUG_BUILD &&\n          debug.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');\n        return;\n      }\n\n      // The session duration for browser sessions does not track a meaningful\n      // concept that can be used as a metric.\n      // Automatically captured sessions are akin to page views, and thus we\n      // discard their duration.\n      startSession({ ignoreDuration: true });\n      captureSession();\n\n      // We want to create a session for every navigation as well\n      addHistoryInstrumentationHandler(({ from, to }) => {\n        // Don't create an additional session for the initial route or if the location did not change\n        if (from !== undefined && from !== to) {\n          startSession({ ignoreDuration: true });\n          captureSession();\n        }\n      });\n    },\n  };\n});\n"],"names":["defineIntegration","WINDOW","DEBUG_BUILD","debug","startSession","captureSession","addHistoryInstrumentationHandler"],"mappings":";;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;MACa,yBAAA,GAA4BA,sBAAiB,CAAC,MAAM;AACjE,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,IAAI,OAAOC,cAAM,CAAC,QAAA,KAAa,WAAW,EAAE;AAClD,QAAQC,sBAAA;AACR,UAAUC,UAAK,CAAC,IAAI,CAAC,qFAAqF,CAAC;AAC3G,QAAQ;AACR,MAAM;;AAEN;AACA;AACA;AACA;AACA,MAAMC,iBAAY,CAAC,EAAE,cAAc,EAAE,IAAA,EAAM,CAAC;AAC5C,MAAMC,mBAAc,EAAE;;AAEtB;AACA,MAAMC,6CAAgC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAA,EAAI,KAAK;AACzD;AACA,QAAQ,IAAI,IAAA,KAAS,aAAa,IAAA,KAAS,EAAE,EAAE;AAC/C,UAAUF,iBAAY,CAAC,EAAE,cAAc,EAAE,IAAA,EAAM,CAAC;AAChD,UAAUC,mBAAc,EAAE;AAC1B,QAAQ;AACR,MAAM,CAAC,CAAC;AACR,IAAI,CAAC;AACL,GAAG;AACH,CAAC;;;;"}

package/build/npm/cjs/prod/integrations/contextlines.js

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const WINDOW = core.GLOBAL_OBJ ;
+
+const DEFAULT_LINES_OF_CONTEXT = 7;
+
+const INTEGRATION_NAME = 'ContextLines';
+
+const _contextLinesIntegration = ((options = {}) => {
+  const contextLines = options.frameContextLines != null ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
+
+  return {
+    name: INTEGRATION_NAME,
+    processEvent(event) {
+      return addSourceContext(event, contextLines);
+    },
+  };
+}) ;
+
+/**
+ * Collects source context lines around the lines of stackframes pointing to JS embedded in
+ * the current page's HTML.
+ *
+ * This integration DOES NOT work for stack frames pointing to JS files that are loaded by the browser.
+ * For frames pointing to files, context lines are added during ingestion and symbolication
+ * by attempting to download the JS files to the Sentry backend.
+ *
+ * Use this integration if you have inline JS code in HTML pages that can't be accessed
+ * by our backend (e.g. due to a login-protected page).
+ */
+const contextLinesIntegration = core.defineIntegration(_contextLinesIntegration);
+
+/**
+ * Processes an event and adds context lines.
+ */
+function addSourceContext(event, contextLines) {
+  const doc = WINDOW.document;
+  const htmlFilename = WINDOW.location && core.stripUrlQueryAndFragment(WINDOW.location.href);
+  if (!doc || !htmlFilename) {
+    return event;
+  }
+
+  const exceptions = event.exception?.values;
+  if (!exceptions?.length) {
+    return event;
+  }
+
+  const html = doc.documentElement.innerHTML;
+  if (!html) {
+    return event;
+  }
+
+  const htmlLines = ['<!DOCTYPE html>', '<html>', ...html.split('\n'), '</html>'];
+
+  exceptions.forEach(exception => {
+    const stacktrace = exception.stacktrace;
+    if (stacktrace?.frames) {
+      stacktrace.frames = stacktrace.frames.map(frame =>
+        applySourceContextToFrame(frame, htmlLines, htmlFilename, contextLines),
+      );
+    }
+  });
+
+  return event;
+}
+
+/**
+ * Only exported for testing
+ */
+function applySourceContextToFrame(
+  frame,
+  htmlLines,
+  htmlFilename,
+  linesOfContext,
+) {
+  if (frame.filename !== htmlFilename || !frame.lineno || !htmlLines.length) {
+    return frame;
+  }
+
+  core.addContextToFrame(htmlLines, frame, linesOfContext);
+
+  return frame;
+}
+
+exports.applySourceContextToFrame = applySourceContextToFrame;
+exports.contextLinesIntegration = contextLinesIntegration;
+//# sourceMappingURL=contextlines.js.map

package/build/npm/cjs/prod/integrations/contextlines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextlines.js","sources":["../../../../../src/integrations/contextlines.ts"],"sourcesContent":["import type { Event, IntegrationFn, StackFrame } from '@sentry/core';\nimport { addContextToFrame, defineIntegration, GLOBAL_OBJ, stripUrlQueryAndFragment } from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nconst DEFAULT_LINES_OF_CONTEXT = 7;\n\nconst INTEGRATION_NAME = 'ContextLines';\n\ninterface ContextLinesOptions {\n  /**\n   * Sets the number of context lines for each frame when loading a file.\n   * Defaults to 7.\n   *\n   * Set to 0 to disable loading and inclusion of source files.\n   **/\n  frameContextLines?: number;\n}\n\nconst _contextLinesIntegration = ((options: ContextLinesOptions = {}) => {\n  const contextLines = options.frameContextLines != null ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;\n\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(event) {\n      return addSourceContext(event, contextLines);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Collects source context lines around the lines of stackframes pointing to JS embedded in\n * the current page's HTML.\n *\n * This integration DOES NOT work for stack frames pointing to JS files that are loaded by the browser.\n * For frames pointing to files, context lines are added during ingestion and symbolication\n * by attempting to download the JS files to the Sentry backend.\n *\n * Use this integration if you have inline JS code in HTML pages that can't be accessed\n * by our backend (e.g. due to a login-protected page).\n */\nexport const contextLinesIntegration = defineIntegration(_contextLinesIntegration);\n\n/**\n * Processes an event and adds context lines.\n */\nfunction addSourceContext(event: Event, contextLines: number): Event {\n  const doc = WINDOW.document;\n  const htmlFilename = WINDOW.location && stripUrlQueryAndFragment(WINDOW.location.href);\n  if (!doc || !htmlFilename) {\n    return event;\n  }\n\n  const exceptions = event.exception?.values;\n  if (!exceptions?.length) {\n    return event;\n  }\n\n  const html = doc.documentElement.innerHTML;\n  if (!html) {\n    return event;\n  }\n\n  const htmlLines = ['<!DOCTYPE html>', '<html>', ...html.split('\\n'), '</html>'];\n\n  exceptions.forEach(exception => {\n    const stacktrace = exception.stacktrace;\n    if (stacktrace?.frames) {\n      stacktrace.frames = stacktrace.frames.map(frame =>\n        applySourceContextToFrame(frame, htmlLines, htmlFilename, contextLines),\n      );\n    }\n  });\n\n  return event;\n}\n\n/**\n * Only exported for testing\n */\nexport function applySourceContextToFrame(\n  frame: StackFrame,\n  htmlLines: string[],\n  htmlFilename: string,\n  linesOfContext: number,\n): StackFrame {\n  if (frame.filename !== htmlFilename || !frame.lineno || !htmlLines.length) {\n    return frame;\n  }\n\n  addContextToFrame(htmlLines, frame, linesOfContext);\n\n  return frame;\n}\n"],"names":["GLOBAL_OBJ","defineIntegration","stripUrlQueryAndFragment","addContextToFrame"],"mappings":";;;;AAGA,MAAM,MAAA,GAASA,eAAA;;AAEf,MAAM,wBAAA,GAA2B,CAAC;;AAElC,MAAM,gBAAA,GAAmB,cAAc;;AAYvC,MAAM,wBAAA,IAA4B,CAAC,OAAO,GAAwB,EAAE,KAAK;AACzE,EAAE,MAAM,YAAA,GAAe,OAAO,CAAC,iBAAA,IAAqB,IAAA,GAAO,OAAO,CAAC,iBAAA,GAAoB,wBAAwB;;AAE/G,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,YAAY,CAAC,KAAK,EAAE;AACxB,MAAM,OAAO,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC;AAClD,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,uBAAA,GAA0BC,sBAAiB,CAAC,wBAAwB;;AAEjF;AACA;AACA;AACA,SAAS,gBAAgB,CAAC,KAAK,EAAS,YAAY,EAAiB;AACrE,EAAE,MAAM,GAAA,GAAM,MAAM,CAAC,QAAQ;AAC7B,EAAE,MAAM,YAAA,GAAe,MAAM,CAAC,QAAA,IAAYC,6BAAwB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;AACxF,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;AAC7B,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF,EAAE,MAAM,UAAA,GAAa,KAAK,CAAC,SAAS,EAAE,MAAM;AAC5C,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE;AAC3B,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF,EAAE,MAAM,IAAA,GAAO,GAAG,CAAC,eAAe,CAAC,SAAS;AAC5C,EAAE,IAAI,CAAC,IAAI,EAAE;AACb,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF,EAAE,MAAM,SAAA,GAAY,CAAC,iBAAiB,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;;AAEjF,EAAE,UAAU,CAAC,OAAO,CAAC,aAAa;AAClC,IAAI,MAAM,UAAA,GAAa,SAAS,CAAC,UAAU;AAC3C,IAAI,IAAI,UAAU,EAAE,MAAM,EAAE;AAC5B,MAAM,UAAU,CAAC,MAAA,GAAS,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,KAAA;AAChD,QAAQ,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC;AAC/E,OAAO;AACP,IAAI;AACJ,EAAE,CAAC,CAAC;;AAEJ,EAAE,OAAO,KAAK;AACd;;AAEA;AACA;AACA;AACO,SAAS,yBAAyB;AACzC,EAAE,KAAK;AACP,EAAE,SAAS;AACX,EAAE,YAAY;AACd,EAAE,cAAc;AAChB,EAAc;AACd,EAAE,IAAI,KAAK,CAAC,QAAA,KAAa,YAAA,IAAgB,CAAC,KAAK,CAAC,MAAA,IAAU,CAAC,SAAS,CAAC,MAAM,EAAE;AAC7E,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF,EAAEC,sBAAiB,CAAC,SAAS,EAAE,KAAK,EAAE,cAAc,CAAC;;AAErD,EAAE,OAAO,KAAK;AACd;;;;;"}

package/build/npm/cjs/prod/integrations/featureFlags/growthbook/integration.js

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+/**
+ * Sentry integration for capturing feature flag evaluations from GrowthBook.
+ *
+ * See the feature flag documentation: https://develop.sentry.dev/sdk/expected-features/#feature-flags
+ *
+ * @example
+ * ```
+ * import { GrowthBook } from '@growthbook/growthbook';
+ * import * as Sentry from '@sentry/browser';
+ *
+ * Sentry.init({
+ *   dsn: '___PUBLIC_DSN___',
+ *   integrations: [Sentry.growthbookIntegration({ growthbookClass: GrowthBook })],
+ * });
+ *
+ * const gb = new GrowthBook();
+ * gb.isOn('my-feature');
+ * Sentry.captureException(new Error('something went wrong'));
+ * ```
+ */
+const growthbookIntegration = (({ growthbookClass }) =>
+  core.growthbookIntegration({ growthbookClass })) ;
+
+exports.growthbookIntegration = growthbookIntegration;
+//# sourceMappingURL=integration.js.map

package/build/npm/cjs/prod/integrations/featureFlags/growthbook/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sources":["../../../../../../../src/integrations/featureFlags/growthbook/integration.ts"],"sourcesContent":["import type { IntegrationFn } from '@sentry/core';\nimport { growthbookIntegration as coreGrowthbookIntegration } from '@sentry/core';\nimport type { GrowthBookClass } from './types';\n\n/**\n * Sentry integration for capturing feature flag evaluations from GrowthBook.\n *\n * See the feature flag documentation: https://develop.sentry.dev/sdk/expected-features/#feature-flags\n *\n * @example\n * ```\n * import { GrowthBook } from '@growthbook/growthbook';\n * import * as Sentry from '@sentry/browser';\n *\n * Sentry.init({\n *   dsn: '___PUBLIC_DSN___',\n *   integrations: [Sentry.growthbookIntegration({ growthbookClass: GrowthBook })],\n * });\n *\n * const gb = new GrowthBook();\n * gb.isOn('my-feature');\n * Sentry.captureException(new Error('something went wrong'));\n * ```\n */\nexport const growthbookIntegration = (({ growthbookClass }: { growthbookClass: GrowthBookClass }) =>\n  coreGrowthbookIntegration({ growthbookClass })) satisfies IntegrationFn;\n"],"names":["coreGrowthbookIntegration"],"mappings":";;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,yBAAyB,CAAC,EAAE,eAAA,EAAiB;AAC1D,EAAEA,0BAAyB,CAAC,EAAE,eAAA,EAAiB,CAAC,CAAA;;;;"}

package/build/npm/cjs/prod/integrations/featureFlags/launchdarkly/integration.js

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+/**
+ * Sentry integration for capturing feature flag evaluations from LaunchDarkly.
+ *
+ * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.
+ *
+ * @example
+ * ```
+ * import * as Sentry from '@sentry/browser';
+ * import {launchDarklyIntegration, buildLaunchDarklyFlagUsedInspector} from '@sentry/browser';
+ * import * as LaunchDarkly from 'launchdarkly-js-client-sdk';
+ *
+ * Sentry.init(..., integrations: [launchDarklyIntegration()])
+ * const ldClient = LaunchDarkly.initialize(..., {inspectors: [buildLaunchDarklyFlagUsedHandler()]});
+ * ```
+ */
+const launchDarklyIntegration = core.defineIntegration(() => {
+  return {
+    name: 'LaunchDarkly',
+
+    processEvent(event, _hint, _client) {
+      return core._INTERNAL_copyFlagsFromScopeToEvent(event);
+    },
+  };
+}) ;
+
+/**
+ * LaunchDarkly hook to listen for and buffer flag evaluations. This needs to
+ * be registered as an 'inspector' in LaunchDarkly initialize() options,
+ * separately from `launchDarklyIntegration`. Both the hook and the integration
+ * are needed to capture LaunchDarkly flags.
+ */
+function buildLaunchDarklyFlagUsedHandler() {
+  return {
+    name: 'sentry-flag-auditor',
+    type: 'flag-used',
+
+    synchronous: true,
+
+    /**
+     * Handle a flag evaluation by storing its name and value on the current scope.
+     */
+    method: (flagKey, flagDetail, _context) => {
+      core._INTERNAL_insertFlagToScope(flagKey, flagDetail.value);
+      core._INTERNAL_addFeatureFlagToActiveSpan(flagKey, flagDetail.value);
+    },
+  };
+}
+
+exports.buildLaunchDarklyFlagUsedHandler = buildLaunchDarklyFlagUsedHandler;
+exports.launchDarklyIntegration = launchDarklyIntegration;
+//# sourceMappingURL=integration.js.map

package/build/npm/cjs/prod/integrations/featureFlags/launchdarkly/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sources":["../../../../../../../src/integrations/featureFlags/launchdarkly/integration.ts"],"sourcesContent":["import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\nimport {\n  _INTERNAL_addFeatureFlagToActiveSpan,\n  _INTERNAL_copyFlagsFromScopeToEvent,\n  _INTERNAL_insertFlagToScope,\n  defineIntegration,\n} from '@sentry/core';\nimport type { LDContext, LDEvaluationDetail, LDInspectionFlagUsedHandler } from './types';\n\n/**\n * Sentry integration for capturing feature flag evaluations from LaunchDarkly.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import * as Sentry from '@sentry/browser';\n * import {launchDarklyIntegration, buildLaunchDarklyFlagUsedInspector} from '@sentry/browser';\n * import * as LaunchDarkly from 'launchdarkly-js-client-sdk';\n *\n * Sentry.init(..., integrations: [launchDarklyIntegration()])\n * const ldClient = LaunchDarkly.initialize(..., {inspectors: [buildLaunchDarklyFlagUsedHandler()]});\n * ```\n */\nexport const launchDarklyIntegration = defineIntegration(() => {\n  return {\n    name: 'LaunchDarkly',\n\n    processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n      return _INTERNAL_copyFlagsFromScopeToEvent(event);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * LaunchDarkly hook to listen for and buffer flag evaluations. This needs to\n * be registered as an 'inspector' in LaunchDarkly initialize() options,\n * separately from `launchDarklyIntegration`. Both the hook and the integration\n * are needed to capture LaunchDarkly flags.\n */\nexport function buildLaunchDarklyFlagUsedHandler(): LDInspectionFlagUsedHandler {\n  return {\n    name: 'sentry-flag-auditor',\n    type: 'flag-used',\n\n    synchronous: true,\n\n    /**\n     * Handle a flag evaluation by storing its name and value on the current scope.\n     */\n    method: (flagKey: string, flagDetail: LDEvaluationDetail, _context: LDContext) => {\n      _INTERNAL_insertFlagToScope(flagKey, flagDetail.value);\n      _INTERNAL_addFeatureFlagToActiveSpan(flagKey, flagDetail.value);\n    },\n  };\n}\n"],"names":["defineIntegration","_INTERNAL_copyFlagsFromScopeToEvent","_INTERNAL_insertFlagToScope","_INTERNAL_addFeatureFlagToActiveSpan"],"mappings":";;;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,uBAAA,GAA0BA,sBAAiB,CAAC,MAAM;AAC/D,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,cAAc;;AAExB,IAAI,YAAY,CAAC,KAAK,EAAS,KAAK,EAAa,OAAO,EAAiB;AACzE,MAAM,OAAOC,wCAAmC,CAAC,KAAK,CAAC;AACvD,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gCAAgC,GAAgC;AAChF,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,qBAAqB;AAC/B,IAAI,IAAI,EAAE,WAAW;;AAErB,IAAI,WAAW,EAAE,IAAI;;AAErB;AACA;AACA;AACA,IAAI,MAAM,EAAE,CAAC,OAAO,EAAU,UAAU,EAAsB,QAAQ,KAAgB;AACtF,MAAMC,gCAA2B,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC;AAC5D,MAAMC,yCAAoC,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC;AACrE,IAAI,CAAC;AACL,GAAG;AACH;;;;;"}

package/build/npm/cjs/prod/integrations/featureFlags/openfeature/integration.js

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const openFeatureIntegration = core.defineIntegration(() => {
+  return {
+    name: 'OpenFeature',
+
+    processEvent(event, _hint, _client) {
+      return core._INTERNAL_copyFlagsFromScopeToEvent(event);
+    },
+  };
+}) ;
+
+/**
+ * OpenFeature Hook class implementation.
+ */
+class OpenFeatureIntegrationHook  {
+  /**
+   * Successful evaluation result.
+   */
+   after(_hookContext, evaluationDetails) {
+    core._INTERNAL_insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);
+    core._INTERNAL_addFeatureFlagToActiveSpan(evaluationDetails.flagKey, evaluationDetails.value);
+  }
+
+  /**
+   * On error evaluation result.
+   */
+   error(hookContext, _error, _hookHints) {
+    core._INTERNAL_insertFlagToScope(hookContext.flagKey, hookContext.defaultValue);
+    core._INTERNAL_addFeatureFlagToActiveSpan(hookContext.flagKey, hookContext.defaultValue);
+  }
+}
+
+exports.OpenFeatureIntegrationHook = OpenFeatureIntegrationHook;
+exports.openFeatureIntegration = openFeatureIntegration;
+//# sourceMappingURL=integration.js.map

package/build/npm/cjs/prod/integrations/featureFlags/openfeature/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sources":["../../../../../../../src/integrations/featureFlags/openfeature/integration.ts"],"sourcesContent":["/**\n * Sentry integration for capturing OpenFeature feature flag evaluations.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import * as Sentry from \"@sentry/browser\";\n * import { OpenFeature } from \"@openfeature/web-sdk\";\n *\n * Sentry.init(..., integrations: [Sentry.openFeatureIntegration()]);\n * OpenFeature.setProvider(new MyProviderOfChoice());\n * OpenFeature.addHooks(new Sentry.OpenFeatureIntegrationHook());\n * ```\n */\nimport type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\nimport {\n  _INTERNAL_addFeatureFlagToActiveSpan,\n  _INTERNAL_copyFlagsFromScopeToEvent,\n  _INTERNAL_insertFlagToScope,\n  defineIntegration,\n} from '@sentry/core';\nimport type { EvaluationDetails, HookContext, HookHints, JsonValue, OpenFeatureHook } from './types';\n\nexport const openFeatureIntegration = defineIntegration(() => {\n  return {\n    name: 'OpenFeature',\n\n    processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n      return _INTERNAL_copyFlagsFromScopeToEvent(event);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * OpenFeature Hook class implementation.\n */\nexport class OpenFeatureIntegrationHook implements OpenFeatureHook {\n  /**\n   * Successful evaluation result.\n   */\n  public after(_hookContext: Readonly<HookContext<JsonValue>>, evaluationDetails: EvaluationDetails<JsonValue>): void {\n    _INTERNAL_insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);\n    _INTERNAL_addFeatureFlagToActiveSpan(evaluationDetails.flagKey, evaluationDetails.value);\n  }\n\n  /**\n   * On error evaluation result.\n   */\n  public error(hookContext: Readonly<HookContext<JsonValue>>, _error: unknown, _hookHints?: HookHints): void {\n    _INTERNAL_insertFlagToScope(hookContext.flagKey, hookContext.defaultValue);\n    _INTERNAL_addFeatureFlagToActiveSpan(hookContext.flagKey, hookContext.defaultValue);\n  }\n}\n"],"names":["defineIntegration","_INTERNAL_copyFlagsFromScopeToEvent","_INTERNAL_insertFlagToScope","_INTERNAL_addFeatureFlagToActiveSpan"],"mappings":";;;;MAwBa,sBAAA,GAAyBA,sBAAiB,CAAC,MAAM;AAC9D,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,aAAa;;AAEvB,IAAI,YAAY,CAAC,KAAK,EAAS,KAAK,EAAa,OAAO,EAAiB;AACzE,MAAM,OAAOC,wCAAmC,CAAC,KAAK,CAAC;AACvD,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACO,MAAM,4BAAsD;AACnE;AACA;AACA;AACA,GAAS,KAAK,CAAC,YAAY,EAAoC,iBAAiB,EAAsC;AACtH,IAAIC,gCAA2B,CAAC,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC;AACnF,IAAIC,yCAAoC,CAAC,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC;AAC5F,EAAE;;AAEF;AACA;AACA;AACA,GAAS,KAAK,CAAC,WAAW,EAAoC,MAAM,EAAW,UAAU,EAAoB;AAC7G,IAAID,gCAA2B,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,CAAC;AAC9E,IAAIC,yCAAoC,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,CAAC;AACvF,EAAE;AACF;;;;;"}

package/build/npm/cjs/prod/integrations/featureFlags/statsig/integration.js

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+/**
+ * Sentry integration for capturing feature flag evaluations from the Statsig js-client SDK.
+ *
+ * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.
+ *
+ * @example
+ * ```
+ * import { StatsigClient } from '@statsig/js-client';
+ * import * as Sentry from '@sentry/browser';
+ *
+ * const statsigClient = new StatsigClient();
+ *
+ * Sentry.init({
+ *   dsn: '___PUBLIC_DSN___',
+ *   integrations: [Sentry.statsigIntegration({featureFlagClient: statsigClient})],
+ * });
+ *
+ * await statsigClient.initializeAsync();  // or statsigClient.initializeSync();
+ *
+ * const result = statsigClient.checkGate('my-feature-gate');
+ * Sentry.captureException(new Error('something went wrong'));
+ * ```
+ */
+const statsigIntegration = core.defineIntegration(
+  ({ featureFlagClient: statsigClient }) => {
+    return {
+      name: 'Statsig',
+
+      setup(_client) {
+        statsigClient.on('gate_evaluation', (event) => {
+          core._INTERNAL_insertFlagToScope(event.gate.name, event.gate.value);
+          core._INTERNAL_addFeatureFlagToActiveSpan(event.gate.name, event.gate.value);
+        });
+      },
+
+      processEvent(event, _hint, _client) {
+        return core._INTERNAL_copyFlagsFromScopeToEvent(event);
+      },
+    };
+  },
+) ;
+
+exports.statsigIntegration = statsigIntegration;
+//# sourceMappingURL=integration.js.map

package/build/npm/cjs/prod/integrations/featureFlags/statsig/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sources":["../../../../../../../src/integrations/featureFlags/statsig/integration.ts"],"sourcesContent":["import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\nimport {\n  _INTERNAL_addFeatureFlagToActiveSpan,\n  _INTERNAL_copyFlagsFromScopeToEvent,\n  _INTERNAL_insertFlagToScope,\n  defineIntegration,\n} from '@sentry/core';\nimport type { FeatureGate, StatsigClient } from './types';\n\n/**\n * Sentry integration for capturing feature flag evaluations from the Statsig js-client SDK.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import { StatsigClient } from '@statsig/js-client';\n * import * as Sentry from '@sentry/browser';\n *\n * const statsigClient = new StatsigClient();\n *\n * Sentry.init({\n *   dsn: '___PUBLIC_DSN___',\n *   integrations: [Sentry.statsigIntegration({featureFlagClient: statsigClient})],\n * });\n *\n * await statsigClient.initializeAsync();  // or statsigClient.initializeSync();\n *\n * const result = statsigClient.checkGate('my-feature-gate');\n * Sentry.captureException(new Error('something went wrong'));\n * ```\n */\nexport const statsigIntegration = defineIntegration(\n  ({ featureFlagClient: statsigClient }: { featureFlagClient: StatsigClient }) => {\n    return {\n      name: 'Statsig',\n\n      setup(_client: Client) {\n        statsigClient.on('gate_evaluation', (event: { gate: FeatureGate }) => {\n          _INTERNAL_insertFlagToScope(event.gate.name, event.gate.value);\n          _INTERNAL_addFeatureFlagToActiveSpan(event.gate.name, event.gate.value);\n        });\n      },\n\n      processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n        return _INTERNAL_copyFlagsFromScopeToEvent(event);\n      },\n    };\n  },\n) satisfies IntegrationFn;\n"],"names":["defineIntegration","_INTERNAL_insertFlagToScope","_INTERNAL_addFeatureFlagToActiveSpan","_INTERNAL_copyFlagsFromScopeToEvent"],"mappings":";;;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,kBAAA,GAAqBA,sBAAiB;AACnD,EAAE,CAAC,EAAE,iBAAiB,EAAE,aAAA,EAAe,KAA2C;AAClF,IAAI,OAAO;AACX,MAAM,IAAI,EAAE,SAAS;;AAErB,MAAM,KAAK,CAAC,OAAO,EAAU;AAC7B,QAAQ,aAAa,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,KAAK,KAA4B;AAC9E,UAAUC,gCAA2B,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AACxE,UAAUC,yCAAoC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AACjF,QAAQ,CAAC,CAAC;AACV,MAAM,CAAC;;AAEP,MAAM,YAAY,CAAC,KAAK,EAAS,KAAK,EAAa,OAAO,EAAiB;AAC3E,QAAQ,OAAOC,wCAAmC,CAAC,KAAK,CAAC;AACzD,MAAM,CAAC;AACP,KAAK;AACL,EAAE,CAAC;AACH,CAAA;;;;"}