iureiure 1.0.0

package/packages/analytics-js-plugins/rollup.config.mjs

@@ -0,0 +1,245 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import path from 'path';
+import babel from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+import resolve from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import terser from '@rollup/plugin-terser';
+import json from '@rollup/plugin-json';
+import { visualizer } from 'rollup-plugin-visualizer';
+import filesize from 'rollup-plugin-filesize';
+import livereload from 'rollup-plugin-livereload';
+import serve from 'rollup-plugin-serve';
+import typescript from 'rollup-plugin-typescript2';
+import nodePolyfills from 'rollup-plugin-polyfill-node';
+import { DEFAULT_EXTENSIONS } from '@babel/core';
+import del from 'rollup-plugin-delete';
+import dts from 'rollup-plugin-dts';
+import alias from '@rollup/plugin-alias';
+import federation from '@originjs/vite-plugin-federation';
+import * as dotenv from 'dotenv';
+import pkg from './package.json' assert { type: 'json' };
+
+dotenv.config();
+const isLegacyBuild = process.env.BROWSERSLIST_ENV !== 'modern';
+const variantSubfolder = isLegacyBuild ? '/legacy' : '/modern';
+const sourceMapType =
+  process.env.PROD_DEBUG === 'inline' ? 'inline' : process.env.PROD_DEBUG === 'true';
+const outDirNpmRoot = `dist/npm`;
+const outDirCDNRoot = `dist/cdn`;
+const outDirNpm = `${outDirNpmRoot}${variantSubfolder}`;
+const outDirCDN = `${outDirCDNRoot}${variantSubfolder}/plugins`;
+const distName = 'rsa-plugins';
+const modName = 'rudderAnalyticsRemotePlugins';
+const remotePluginsExportsFilename = `${distName}.js`;
+const moduleType = process.env.MODULE_TYPE || 'cdn';
+const isNpmPackageBuild = moduleType === 'npm';
+const isCDNPackageBuild = moduleType === 'cdn';
+const pluginsMap = {
+  './BeaconQueue': './src/beaconQueue/index.ts',
+  './Bugsnag': './src/bugsnag/index.ts',
+  './CustomConsentManager': './src/customConsentManager/index.ts',
+  './DeviceModeDestinations': './src/deviceModeDestinations/index.ts',
+  './DeviceModeTransformation': './src/deviceModeTransformation/index.ts',
+  './ErrorReporting': './src/errorReporting/index.ts',
+  './ExternalAnonymousId': './src/externalAnonymousId/index.ts',
+  './GoogleLinker': './src/googleLinker/index.ts',
+  './KetchConsentManager': './src/ketchConsentManager/index.ts',
+  './NativeDestinationQueue': './src/nativeDestinationQueue/index.ts',
+  './OneTrustConsentManager': './src/oneTrustConsentManager/index.ts',
+  './StorageEncryption': './src/storageEncryption/index.ts',
+  './StorageEncryptionLegacy': './src/storageEncryptionLegacy/index.ts',
+  './StorageMigrator': './src/storageMigrator/index.ts',
+  './XhrQueue': './src/xhrQueue/index.ts',
+};
+
+const bugsnagSDKUrl = 'https://d2wy8f7a9ursnm.cloudfront.net/v6/bugsnag.min.js';
+
+export function getDefaultConfig(distName) {
+  const version = process.env.VERSION || 'dev-snapshot';
+  const isLocalServerEnabled = isCDNPackageBuild && process.env.DEV_SERVER;
+
+  return {
+    watch: {
+      include: ['src/**'],
+    },
+    external: [...Object.keys(pkg.peerDependencies || {})],
+    onwarn(warning, warn) {
+      // Silence 'this' has been rewritten to 'undefined' warning
+      // https://rollupjs.org/guide/en/#error-this-is-undefined
+      if (warning.code === 'THIS_IS_UNDEFINED') {
+        return;
+      }
+
+      warn(warning);
+    },
+    plugins: [
+      replace({
+        preventAssignment: true,
+        __PACKAGE_VERSION__: version,
+        __MODULE_TYPE__: moduleType,
+        __BUNDLE_ALL_PLUGINS__: isLegacyBuild,
+        __RS_BUGSNAG_API_KEY__: process.env.BUGSNAG_API_KEY || '{{__RS_BUGSNAG_API_KEY__}}',
+        __RS_BUGSNAG_RELEASE_STAGE__: process.env.BUGSNAG_RELEASE_STAGE || 'production',
+        __RS_BUGSNAG_SDK_URL__: bugsnagSDKUrl,
+      }),
+      resolve({
+        jsnext: true,
+        browser: true,
+        preferBuiltins: false,
+        extensions: ['.js', '.ts', '.mjs'],
+      }),
+      nodePolyfills({
+        include: ['crypto'],
+      }),
+      commonjs({
+        include: /node_modules/,
+        requireReturnsDefault: 'auto',
+      }),
+      json(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        useTsconfigDeclarationDir: true,
+      }),
+      babel({
+        compact: true,
+        babelHelpers: 'bundled',
+        exclude: ['node_modules/@babel/**', 'node_modules/core-js/**'],
+        extensions: [...DEFAULT_EXTENSIONS, '.ts'],
+        sourcemap: sourceMapType,
+      }),
+      !isLegacyBuild && isCDNPackageBuild &&
+      federation({
+        name: modName,
+        filename: remotePluginsExportsFilename,
+        exposes: pluginsMap,
+        remoteType: 'promise',
+      }),
+      process.env.UGLIFY === 'true' &&
+      terser({
+        safari10: isLegacyBuild,
+        ecma: isLegacyBuild ? 2015 : 2017,
+        format: {
+          comments: false,
+        },
+      }),
+      filesize({
+        showBeforeSizes: 'build',
+        showBrotliSize: true,
+      }),
+      process.env.VISUALIZER === 'true' &&
+      visualizer({
+        filename: `./stats/${distName}.html`,
+        title: `Rollup Visualizer - ${distName}`,
+        sourcemap: true,
+        open: true,
+        gzipSize: true,
+        brotliSize: true,
+      }),
+      isLocalServerEnabled &&
+      serve({
+        contentBase: ['dist'],
+        host: 'localhost',
+        port: 3002,
+        headers: {
+          'Access-Control-Allow-Origin': '*',
+        },
+      }),
+      isLocalServerEnabled && livereload(),
+    ],
+  };
+}
+
+const outputFilesNpm = [
+  {
+    entryFileNames: `index.js`,
+    dir: outDirNpm + '/esm/',
+    format: 'esm',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+  {
+    entryFileNames: `index.js`,
+    dir: outDirNpm + '/cjs',
+    format: 'cjs',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+];
+
+const outputFilesCdn = [
+  {
+    chunkFileNames: `${distName}-[name]${process.env.UGLIFY === 'true' ? '.min' : ''}.js`,
+    dir: outDirCDN,
+    format: 'esm',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+    // This will merge generated code chunks for common code based on provided logic
+    manualChunks: function (id) {
+      if (id.includes('shared-chunks')) {
+        // file name without extension
+        return path.basename(id).split('.')[0];
+      }
+    }
+  },
+];
+
+const buildConfig = () => {
+  return {
+    ...getDefaultConfig(distName),
+  };
+};
+
+const buildEntries = () => {
+  const outputFiles = isCDNPackageBuild ? outputFilesCdn : outputFilesNpm;
+
+  if(isCDNPackageBuild) {
+    return[{
+      ...buildConfig(),
+      input: 'src/index.ts',
+      output: outputFiles,
+    }];
+  }
+
+  return [
+    {
+      ...buildConfig(),
+      input: 'src/index.ts',
+      output: outputFiles,
+    },
+    {
+      input: `dist/dts/packages/analytics-js-plugins/src/index.d.ts`,
+      plugins: [
+        alias({
+          entries: [
+            {
+              find: '@rudderstack/analytics-js-plugins',
+              replacement: path.resolve('./dist/dts/packages/analytics-js-plugins/src'),
+            },
+            {
+              find: '@rudderstack/analytics-js-common',
+              replacement: path.resolve('./dist/dts/packages/analytics-js-common/src'),
+            }
+          ]
+        }),
+        dts(),
+        del({ hook: "buildEnd", targets: "./dist/dts" }),
+      ],
+      output: {
+        file: `${outDirNpmRoot}/index.d.ts`,
+        format: 'es',
+      },
+    }
+  ];
+}
+
+export default buildEntries();

package/packages/analytics-js-plugins/src/beaconQueue/constants.ts

@@ -0,0 +1,27 @@
+const DEFAULT_BEACON_QUEUE_MAX_SIZE = 10;
+const DEFAULT_BEACON_QUEUE_FLUSH_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+
+// Limit of the Beacon transfer mechanism on the browsers
+const MAX_BATCH_PAYLOAD_SIZE_BYTES = 64 * 1024; // 64 KB
+
+const DEFAULT_BEACON_QUEUE_OPTIONS = {
+  maxItems: DEFAULT_BEACON_QUEUE_MAX_SIZE,
+  flushQueueInterval: DEFAULT_BEACON_QUEUE_FLUSH_INTERVAL_MS,
+};
+
+const REQUEST_TIMEOUT_MS = 10 * 1000; // 10 seconds
+
+const DATA_PLANE_API_VERSION = 'v1';
+
+const QUEUE_NAME = 'rudder_beacon';
+
+const BEACON_QUEUE_PLUGIN = 'BeaconQueuePlugin';
+
+export {
+  MAX_BATCH_PAYLOAD_SIZE_BYTES,
+  DEFAULT_BEACON_QUEUE_OPTIONS,
+  REQUEST_TIMEOUT_MS,
+  DATA_PLANE_API_VERSION,
+  QUEUE_NAME,
+  BEACON_QUEUE_PLUGIN,
+};

package/packages/analytics-js-plugins/src/beaconQueue/index.ts

@@ -0,0 +1,146 @@
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { IHttpClient } from '@rudderstack/analytics-js-common/types/HttpClient';
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type {
+  BeaconQueueOpts,
+  QueueOpts,
+} from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { getCurrentTimeFormatted } from '@rudderstack/analytics-js-common/utilities/timestamp';
+import type { DoneCallback, IQueue } from '../types/plugins';
+import {
+  getNormalizedBeaconQueueOptions,
+  getDeliveryUrl,
+  getBatchDeliveryPayload,
+} from './utilities';
+import { eventsDelivery, timestamp, storages } from '../shared-chunks/common';
+import { BEACON_QUEUE_PLUGIN, MAX_BATCH_PAYLOAD_SIZE_BYTES, QUEUE_NAME } from './constants';
+import type { BeaconQueueBatchItemData, BeaconQueueItemData } from './types';
+import {
+  BEACON_PLUGIN_EVENTS_QUEUE_DEBUG,
+  BEACON_QUEUE_SEND_ERROR,
+  BEACON_QUEUE_DELIVERY_ERROR,
+} from './logMessages';
+import { RetryQueue } from '../utilities/retryQueue/RetryQueue';
+
+const pluginName: PluginName = 'BeaconQueue';
+
+const BeaconQueue = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  dataplaneEventsQueue: {
+    /**
+     * Initialize the queue for delivery
+     * @param state Application state
+     * @param httpClient http client instance
+     * @param storeManager Store Manager instance
+     * @param errorHandler Error handler instance
+     * @param logger Logger instance
+     * @returns BeaconItemsQueue instance
+     */
+    init(
+      state: ApplicationState,
+      httpClient: IHttpClient,
+      storeManager: IStoreManager,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): IQueue {
+      const writeKey = state.lifecycle.writeKey.value as string;
+      const dataplaneUrl = state.lifecycle.activeDataplaneUrl.value as string;
+      const url = getDeliveryUrl(dataplaneUrl, writeKey);
+
+      const finalQOpts: BeaconQueueOpts = getNormalizedBeaconQueueOptions(
+        state.loadOptions.value.beaconQueueOptions ?? {},
+      );
+
+      const queueProcessCallback = (itemData: BeaconQueueBatchItemData, done: DoneCallback) => {
+        logger?.debug(BEACON_PLUGIN_EVENTS_QUEUE_DEBUG(BEACON_QUEUE_PLUGIN));
+        const currentTime = getCurrentTimeFormatted();
+        const finalEvents = itemData.map((queueItemData: BeaconQueueItemData) =>
+          eventsDelivery.getFinalEventForDeliveryMutator(queueItemData.event, currentTime),
+        );
+        const data = getBatchDeliveryPayload(finalEvents, currentTime, logger);
+
+        if (data) {
+          try {
+            const isEnqueuedInBeacon = navigator.sendBeacon(url, data);
+            if (!isEnqueuedInBeacon) {
+              logger?.error(BEACON_QUEUE_SEND_ERROR(BEACON_QUEUE_PLUGIN));
+            }
+
+            done(null, isEnqueuedInBeacon);
+          } catch (err) {
+            errorHandler?.onError(err, BEACON_QUEUE_PLUGIN, BEACON_QUEUE_DELIVERY_ERROR(url));
+            // Remove the item from queue
+            done(null);
+          }
+        } else {
+          // Mark the item as done so that it can be removed from the queue
+          done(null);
+        }
+      };
+
+      const eventsQueue = new RetryQueue(
+        `${QUEUE_NAME}_${writeKey}`,
+        {
+          batch: {
+            enabled: true,
+            flushInterval: finalQOpts.flushQueueInterval,
+            maxSize: MAX_BATCH_PAYLOAD_SIZE_BYTES, // set the hard limit
+            maxItems: finalQOpts.maxItems,
+          },
+        } as QueueOpts,
+        queueProcessCallback,
+        storeManager,
+        storages.LOCAL_STORAGE,
+        logger,
+        (itemData: BeaconQueueItemData[]): number => {
+          const currentTime = getCurrentTimeFormatted();
+          const events = itemData.map((queueItemData: BeaconQueueItemData) => queueItemData.event);
+          // type casting to Blob as we know that the event has already been validated prior to enqueue
+          return (getBatchDeliveryPayload(events, currentTime, logger) as Blob).size;
+        },
+      );
+
+      return eventsQueue;
+    },
+
+    /**
+     * Add event to the queue for delivery
+     * @param state Application state
+     * @param eventsQueue IQueue instance
+     * @param event RudderEvent object
+     * @param errorHandler Error handler instance
+     * @param logger Logger instance
+     * @returns none
+     */
+    enqueue(
+      state: ApplicationState,
+      eventsQueue: IQueue,
+      event: RudderEvent,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): void {
+      // sentAt is only added here for the validation step
+      // It'll be updated to the latest timestamp during actual delivery
+      event.sentAt = timestamp.getCurrentTimeFormatted();
+      eventsDelivery.validateEventPayloadSize(event, logger);
+
+      eventsQueue.addItem({
+        event,
+      } as BeaconQueueItemData);
+    },
+  },
+});
+
+export { BeaconQueue };
+
+export default BeaconQueue;

package/packages/analytics-js-plugins/src/beaconQueue/logMessages.ts

@@ -0,0 +1,24 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+
+const BEACON_PLUGIN_EVENTS_QUEUE_DEBUG = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Sending events to data plane.`;
+
+const BEACON_QUEUE_STRING_CONVERSION_FAILURE_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to convert events batch object to string.`;
+
+const BEACON_QUEUE_BLOB_CONVERSION_FAILURE_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to convert events batch object to Blob.`;
+
+const BEACON_QUEUE_SEND_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to send events batch data to the browser's beacon queue. The events will be dropped.`;
+
+const BEACON_QUEUE_DELIVERY_ERROR = (url: string): string =>
+  `Failed to send events batch data to the browser's beacon queue for URL ${url}.`;
+
+export {
+  BEACON_PLUGIN_EVENTS_QUEUE_DEBUG,
+  BEACON_QUEUE_STRING_CONVERSION_FAILURE_ERROR,
+  BEACON_QUEUE_BLOB_CONVERSION_FAILURE_ERROR,
+  BEACON_QUEUE_SEND_ERROR,
+  BEACON_QUEUE_DELIVERY_ERROR,
+};

package/packages/analytics-js-plugins/src/beaconQueue/types.ts

@@ -0,0 +1,12 @@
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+
+export type BeaconQueueItemData = {
+  event: RudderEvent;
+};
+
+export type BeaconQueueBatchItemData = BeaconQueueItemData[];
+
+export type BeaconBatchData = {
+  batch: RudderEvent[];
+  sentAt: string;
+};

package/packages/analytics-js-plugins/src/beaconQueue/utilities.ts

@@ -0,0 +1,68 @@
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { BeaconQueueOpts } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import { json, url } from '../shared-chunks/common';
+import {
+  BEACON_QUEUE_STRING_CONVERSION_FAILURE_ERROR,
+  BEACON_QUEUE_BLOB_CONVERSION_FAILURE_ERROR,
+} from './logMessages';
+import {
+  BEACON_QUEUE_PLUGIN,
+  DATA_PLANE_API_VERSION,
+  DEFAULT_BEACON_QUEUE_OPTIONS,
+} from './constants';
+import type { BeaconBatchData } from './types';
+
+/**
+ * Utility to get the stringified event payload as Blob
+ * @param events RudderEvent object array
+ * @param logger Logger instance
+ * @returns stringified events payload as Blob, undefined if error occurs.
+ */
+const getBatchDeliveryPayload = (
+  events: RudderEvent[],
+  currentTime: string,
+  logger?: ILogger,
+): Blob | undefined => {
+  const data: BeaconBatchData = {
+    batch: events,
+    sentAt: currentTime,
+  };
+
+  try {
+    const blobPayload = json.stringifyWithoutCircular(data, true);
+    const blobOptions: BlobPropertyBag = { type: 'text/plain' };
+
+    if (blobPayload) {
+      return new Blob([blobPayload], blobOptions);
+    }
+    logger?.error(BEACON_QUEUE_STRING_CONVERSION_FAILURE_ERROR(BEACON_QUEUE_PLUGIN));
+  } catch (err) {
+    logger?.error(BEACON_QUEUE_BLOB_CONVERSION_FAILURE_ERROR(BEACON_QUEUE_PLUGIN), err);
+  }
+  return undefined;
+};
+
+const getNormalizedBeaconQueueOptions = (queueOpts: BeaconQueueOpts): BeaconQueueOpts =>
+  mergeDeepRight(DEFAULT_BEACON_QUEUE_OPTIONS, queueOpts);
+
+const getDeliveryUrl = (dataplaneUrl: string, writeKey: string): string => {
+  const dpUrl = new URL(dataplaneUrl);
+  return new URL(
+    url.removeDuplicateSlashes(
+      [
+        dpUrl.pathname,
+        '/',
+        'beacon',
+        '/',
+        DATA_PLANE_API_VERSION,
+        '/',
+        `batch?writeKey=${writeKey}`,
+      ].join(''),
+    ),
+    dpUrl,
+  ).href;
+};
+
+export { getBatchDeliveryPayload, getDeliveryUrl, getNormalizedBeaconQueueOptions };

package/packages/analytics-js-plugins/src/bugsnag/constants.ts

@@ -0,0 +1,52 @@
+const BUGSNAG_LIB_INSTANCE_GLOBAL_KEY_NAME = 'bugsnag'; // For version 6 and below
+const BUGSNAG_LIB_V7_INSTANCE_GLOBAL_KEY_NAME = 'Bugsnag';
+const GLOBAL_LIBRARY_OBJECT_NAMES = [
+  BUGSNAG_LIB_V7_INSTANCE_GLOBAL_KEY_NAME,
+  BUGSNAG_LIB_INSTANCE_GLOBAL_KEY_NAME,
+];
+const BUGSNAG_CDN_URL = '__RS_BUGSNAG_SDK_URL__';
+const ERROR_REPORT_PROVIDER_NAME_BUGSNAG = 'rs-bugsnag';
+// This API key token is parsed in the CI pipeline
+const API_KEY = '__RS_BUGSNAG_API_KEY__';
+const BUGSNAG_VALID_MAJOR_VERSION = '6';
+const SDK_LOAD_POLL_INTERVAL_MS = 100; // ms
+const MAX_WAIT_FOR_SDK_LOAD_MS = 100 * SDK_LOAD_POLL_INTERVAL_MS; // ms
+
+// Errors from the below scripts are NOT allowed to reach Bugsnag
+const SDK_FILE_NAME_PREFIXES = (): string[] => [
+  'rsa', // Prefix for all the SDK scripts including plugins and module federated chunks
+];
+
+const DEV_HOSTS = ['www.test-host.com', 'localhost', '127.0.0.1', '[::1]'];
+
+// List of keys to exclude from the metadata
+// Potential PII or sensitive data
+const APP_STATE_EXCLUDE_KEYS = [
+  'userId',
+  'userTraits',
+  'groupId',
+  'groupTraits',
+  'anonymousId',
+  'config',
+  'instance', // destination instance objects
+  'eventBuffer', // pre-load event buffer (may contain PII)
+  'traits',
+];
+
+const BUGSNAG_PLUGIN = 'BugsnagPlugin';
+
+export {
+  BUGSNAG_LIB_INSTANCE_GLOBAL_KEY_NAME,
+  BUGSNAG_LIB_V7_INSTANCE_GLOBAL_KEY_NAME,
+  GLOBAL_LIBRARY_OBJECT_NAMES,
+  BUGSNAG_CDN_URL,
+  ERROR_REPORT_PROVIDER_NAME_BUGSNAG,
+  API_KEY,
+  BUGSNAG_VALID_MAJOR_VERSION,
+  MAX_WAIT_FOR_SDK_LOAD_MS,
+  SDK_FILE_NAME_PREFIXES,
+  SDK_LOAD_POLL_INTERVAL_MS,
+  DEV_HOSTS,
+  APP_STATE_EXCLUDE_KEYS,
+  BUGSNAG_PLUGIN,
+};

package/packages/analytics-js-plugins/src/bugsnag/index.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { IExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader/types';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { BugsnagLib } from '../types/plugins';
+import { BUGSNAG_API_KEY_VALIDATION_ERROR, BUGSNAG_SDK_URL_ERROR } from './logMessages';
+import { API_KEY } from './constants';
+import { initBugsnagClient, loadBugsnagSDK, isApiKeyValid, getAppStateForMetadata } from './utils';
+
+const pluginName: PluginName = 'Bugsnag';
+
+const Bugsnag = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  errorReportingProvider: {
+    init: (
+      state: ApplicationState,
+      externalSrcLoader: IExternalSrcLoader,
+      logger?: ILogger,
+    ): Promise<BugsnagLib.Client> =>
+      new Promise((resolve, reject) => {
+        // If API key token is not parsed or invalid, don't proceed to initialize the client
+        if (!isApiKeyValid(API_KEY)) {
+          reject(new Error(BUGSNAG_API_KEY_VALIDATION_ERROR(API_KEY)));
+          return;
+        }
+
+        // If SDK URL is empty, don't proceed to initialize the client
+        // eslint-disable-next-line no-constant-condition
+        if (!'__RS_BUGSNAG_SDK_URL__') {
+          reject(new Error(BUGSNAG_SDK_URL_ERROR));
+          return;
+        }
+
+        loadBugsnagSDK(externalSrcLoader, logger);
+
+        initBugsnagClient(state, resolve, reject, logger);
+      }),
+    notify: (
+      client: BugsnagLib.Client,
+      error: Error,
+      state: ApplicationState,
+      logger?: ILogger,
+    ): void => {
+      client?.notify(error, {
+        metaData: {
+          state: getAppStateForMetadata(state),
+        },
+      });
+    },
+    breadcrumb: (client: BugsnagLib.Client, message: string, logger?: ILogger): void => {
+      client?.leaveBreadcrumb(message);
+    },
+  },
+});
+
+export { Bugsnag };
+
+export default Bugsnag;

package/packages/analytics-js-plugins/src/bugsnag/logMessages.ts

@@ -0,0 +1,19 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+
+const BUGSNAG_API_KEY_VALIDATION_ERROR = (apiKey: string): string =>
+  `The Bugsnag API key (${apiKey}) is invalid or not provided.`;
+
+const BUGSNAG_SDK_LOAD_TIMEOUT_ERROR = (timeout: number): string =>
+  `A timeout ${timeout} ms occurred while trying to load the Bugsnag SDK.`;
+
+const BUGSNAG_SDK_LOAD_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to load the Bugsnag SDK.`;
+
+const BUGSNAG_SDK_URL_ERROR = 'The Bugsnag SDK URL is invalid. Failed to load the Bugsnag SDK.';
+
+export {
+  BUGSNAG_API_KEY_VALIDATION_ERROR,
+  BUGSNAG_SDK_LOAD_TIMEOUT_ERROR,
+  BUGSNAG_SDK_LOAD_ERROR,
+  BUGSNAG_SDK_URL_ERROR,
+};