iureiure 1.0.0

package/packages/analytics-js-plugins/src/deviceModeDestinations/utils.ts

@@ -0,0 +1,249 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { clone } from 'ramda';
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import type {
+  Destination,
+  DeviceModeDestination,
+} from '@rudderstack/analytics-js-common/types/Destination';
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { IRudderAnalytics } from '@rudderstack/analytics-js-common/types/IRudderAnalytics';
+import type { ApiObject } from '@rudderstack/analytics-js-common/types/ApiObject';
+import type { ApiCallback, ApiOptions } from '@rudderstack/analytics-js-common/types/EventApi';
+import type { IntegrationOpts } from '@rudderstack/analytics-js-common/types/Integration';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { IdentifyTraits } from '@rudderstack/analytics-js-common/types/traits';
+import { checks } from '../shared-chunks/common';
+import { eventMethodOverloads, destinations } from '../shared-chunks/deviceModeDestinations';
+import type { DeviceModeDestinationsAnalyticsInstance } from './types';
+import { DEVICE_MODE_DESTINATIONS_PLUGIN, READY_CHECK_TIMEOUT_MS } from './constants';
+import {
+  DESTINATION_INIT_ERROR,
+  DESTINATION_INTEGRATIONS_DATA_ERROR,
+  DESTINATION_READY_TIMEOUT_ERROR,
+} from './logMessages';
+
+/**
+ * Determines if the destination SDK code is evaluated
+ * @param destSDKIdentifier The name of the global globalThis object that contains the destination SDK
+ * @param sdkTypeName The name of the destination SDK type
+ * @param logger Logger instance
+ * @returns true if the destination SDK code is evaluated, false otherwise
+ */
+const isDestinationSDKMounted = (
+  destSDKIdentifier: string,
+  sdkTypeName: string,
+  logger?: ILogger,
+): boolean =>
+  Boolean(
+    (globalThis as any)[destSDKIdentifier] &&
+      (globalThis as any)[destSDKIdentifier][sdkTypeName] &&
+      (globalThis as any)[destSDKIdentifier][sdkTypeName].prototype &&
+      typeof (globalThis as any)[destSDKIdentifier][sdkTypeName].prototype.constructor !==
+        'undefined',
+  );
+
+const wait = (time: number) =>
+  new Promise(resolve => {
+    (globalThis as typeof window).setTimeout(resolve, time);
+  });
+
+const createDestinationInstance = (
+  destSDKIdentifier: string,
+  sdkTypeName: string,
+  dest: Destination,
+  state: ApplicationState,
+) => {
+  const rAnalytics = (globalThis as any).rudderanalytics as IRudderAnalytics;
+  const analytics = rAnalytics.getAnalyticsInstance(state.lifecycle.writeKey.value);
+
+  return new (globalThis as any)[destSDKIdentifier][sdkTypeName](
+    clone(dest.config),
+    {
+      loadIntegration: state.nativeDestinations.loadIntegration.value,
+      logLevel: state.lifecycle.logLevel.value,
+      loadOnlyIntegrations:
+        state.consents.postConsent.value?.integrations ??
+        state.nativeDestinations.loadOnlyIntegrations.value,
+      page: (
+        category?: string | Nullable<ApiObject> | ApiCallback,
+        name?: string | Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+        properties?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+        options?: Nullable<ApiOptions> | ApiCallback,
+        callback?: ApiCallback,
+      ) =>
+        analytics.page(
+          eventMethodOverloads.pageArgumentsToCallOptions(
+            category,
+            name,
+            properties,
+            options,
+            callback,
+          ),
+        ),
+      track: (
+        event: string,
+        properties?: Nullable<ApiObject> | ApiCallback,
+        options?: Nullable<ApiOptions> | ApiCallback,
+        callback?: ApiCallback,
+      ) =>
+        analytics.track(
+          eventMethodOverloads.trackArgumentsToCallOptions(event, properties, options, callback),
+        ),
+      identify: (
+        userId?: string | number | Nullable<IdentifyTraits>,
+        traits?: Nullable<IdentifyTraits> | Nullable<ApiOptions> | ApiCallback,
+        options?: Nullable<ApiOptions> | ApiCallback,
+        callback?: ApiCallback,
+      ) =>
+        analytics.identify(
+          eventMethodOverloads.identifyArgumentsToCallOptions(userId, traits, options, callback),
+        ),
+      alias: (
+        to?: Nullable<string> | ApiCallback,
+        from?: string | Nullable<ApiOptions> | ApiCallback,
+        options?: Nullable<ApiOptions> | ApiCallback,
+        callback?: ApiCallback,
+      ) =>
+        analytics.alias(
+          eventMethodOverloads.aliasArgumentsToCallOptions(to, from, options, callback),
+        ),
+      group: (
+        groupId: string | number | Nullable<ApiObject> | ApiCallback,
+        traits?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+        options?: Nullable<ApiOptions> | ApiCallback,
+        callback?: ApiCallback,
+      ) =>
+        analytics.group(
+          eventMethodOverloads.groupArgumentsToCallOptions(groupId, traits, options, callback),
+        ),
+      getAnonymousId: () => analytics.getAnonymousId(),
+      getUserId: () => analytics.getUserId(),
+      getUserTraits: () => analytics.getUserTraits(),
+      getGroupId: () => analytics.getGroupId(),
+      getGroupTraits: () => analytics.getGroupTraits(),
+      getSessionId: () => analytics.getSessionId(),
+    } as DeviceModeDestinationsAnalyticsInstance,
+    {
+      shouldApplyDeviceModeTransformation: dest.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: dest.propagateEventsUntransformedOnError,
+      destinationId: dest.id,
+    },
+  );
+};
+
+const isDestinationReady = (dest: Destination) =>
+  new Promise((resolve, reject) => {
+    const instance = dest.instance as DeviceModeDestination;
+    let handleNumber: number;
+    const checkReady = () => {
+      if (instance.isLoaded() && (!instance.isReady || instance.isReady())) {
+        resolve(true);
+      } else {
+        handleNumber = globalThis.requestAnimationFrame(checkReady);
+      }
+    };
+    checkReady();
+    setTimeout(() => {
+      globalThis.cancelAnimationFrame(handleNumber);
+      reject(
+        new Error(DESTINATION_READY_TIMEOUT_ERROR(READY_CHECK_TIMEOUT_MS, dest.userFriendlyId)),
+      );
+    }, READY_CHECK_TIMEOUT_MS);
+  });
+
+/**
+ * Extracts the integration config, if any, from the given destination
+ * and merges it with the current integrations config
+ * @param dest Destination object
+ * @param curDestIntgConfig Current destinations integration config
+ * @param logger Logger object
+ * @returns Combined destinations integrations config
+ */
+const getCumulativeIntegrationsConfig = (
+  dest: Destination,
+  curDestIntgConfig: IntegrationOpts,
+  errorHandler?: IErrorHandler,
+): IntegrationOpts => {
+  let integrationsConfig: IntegrationOpts = curDestIntgConfig;
+  if (checks.isFunction(dest.instance?.getDataForIntegrationsObject)) {
+    try {
+      integrationsConfig = mergeDeepRight(
+        curDestIntgConfig,
+        dest.instance?.getDataForIntegrationsObject(),
+      );
+    } catch (err) {
+      errorHandler?.onError(
+        err,
+        DEVICE_MODE_DESTINATIONS_PLUGIN,
+        DESTINATION_INTEGRATIONS_DATA_ERROR(dest.userFriendlyId),
+      );
+    }
+  }
+  return integrationsConfig;
+};
+
+const initializeDestination = (
+  dest: Destination,
+  state: ApplicationState,
+  destSDKIdentifier: string,
+  sdkTypeName: string,
+  errorHandler?: IErrorHandler,
+  logger?: ILogger,
+) => {
+  try {
+    const initializedDestination = clone(dest);
+    const destInstance = createDestinationInstance(destSDKIdentifier, sdkTypeName, dest, state);
+    initializedDestination.instance = destInstance;
+
+    destInstance.init();
+
+    isDestinationReady(initializedDestination)
+      .then(() => {
+        // Collect the integrations data for the hybrid mode destinations
+        if (destinations.isHybridModeDestination(initializedDestination)) {
+          state.nativeDestinations.integrationsConfig.value = getCumulativeIntegrationsConfig(
+            initializedDestination,
+            state.nativeDestinations.integrationsConfig.value,
+            errorHandler,
+          );
+        }
+
+        state.nativeDestinations.initializedDestinations.value = [
+          ...state.nativeDestinations.initializedDestinations.value,
+          initializedDestination,
+        ];
+      })
+      .catch(err => {
+        state.nativeDestinations.failedDestinations.value = [
+          ...state.nativeDestinations.failedDestinations.value,
+          dest,
+        ];
+
+        // The error message is already formatted in the isDestinationReady function
+        logger?.error(err);
+      });
+  } catch (err) {
+    state.nativeDestinations.failedDestinations.value = [
+      ...state.nativeDestinations.failedDestinations.value,
+      dest,
+    ];
+
+    errorHandler?.onError(
+      err,
+      DEVICE_MODE_DESTINATIONS_PLUGIN,
+      DESTINATION_INIT_ERROR(dest.userFriendlyId),
+    );
+  }
+};
+
+export {
+  isDestinationSDKMounted,
+  wait,
+  createDestinationInstance,
+  isDestinationReady,
+  getCumulativeIntegrationsConfig,
+  initializeDestination,
+};

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

@@ -0,0 +1,12 @@
+const DEFAULT_TRANSFORMATION_QUEUE_OPTIONS = {
+  minRetryDelay: 500,
+  backoffFactor: 2,
+  maxAttempts: 3,
+};
+
+const REQUEST_TIMEOUT_MS = 10 * 1000; // 10 seconds
+
+const QUEUE_NAME = 'rudder';
+const DMT_PLUGIN = 'DeviceModeTransformationPlugin';
+
+export { DEFAULT_TRANSFORMATION_QUEUE_OPTIONS, REQUEST_TIMEOUT_MS, QUEUE_NAME, DMT_PLUGIN };

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

@@ -0,0 +1,111 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type {
+  IPluginsManager,
+  PluginName,
+} from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { IHttpClient } from '@rudderstack/analytics-js-common/types/HttpClient';
+import { MEMORY_STORAGE } from '@rudderstack/analytics-js-common/constants/storages';
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import { isErrRetryable } from '@rudderstack/analytics-js-common/utilities/http';
+import { createPayload, sendTransformedEventToDestinations } from './utilities';
+import { getDMTDeliveryPayload } from '../utilities/eventsDelivery';
+import { DEFAULT_TRANSFORMATION_QUEUE_OPTIONS, QUEUE_NAME, REQUEST_TIMEOUT_MS } from './constants';
+import { RetryQueue } from '../utilities/retryQueue/RetryQueue';
+import type { DoneCallback, IQueue } from '../types/plugins';
+import type { TransformationQueueItemData } from './types';
+
+const pluginName: PluginName = 'DeviceModeTransformation';
+
+const DeviceModeTransformation = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  transformEvent: {
+    init(
+      state: ApplicationState,
+      pluginsManager: IPluginsManager,
+      httpClient: IHttpClient,
+      storeManager: IStoreManager,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ) {
+      const writeKey = state.lifecycle.writeKey.value as string;
+      httpClient.setAuthHeader(writeKey);
+
+      const eventsQueue = new RetryQueue(
+        // adding write key to the queue name to avoid conflicts
+        `${QUEUE_NAME}_${writeKey}`,
+        DEFAULT_TRANSFORMATION_QUEUE_OPTIONS,
+        (
+          item: TransformationQueueItemData,
+          done: DoneCallback,
+          attemptNumber?: number,
+          maxRetryAttempts?: number,
+        ) => {
+          const payload = createPayload(item.event, item.destinationIds, item.token);
+
+          httpClient.getAsyncData({
+            url: `${state.lifecycle.dataPlaneUrl.value}/transform`,
+            options: {
+              method: 'POST',
+              data: getDMTDeliveryPayload(payload) as string,
+              sendRawData: true,
+            },
+            isRawResponse: true,
+            timeout: REQUEST_TIMEOUT_MS,
+            callback: (result, details) => {
+              // null means item will not be requeued
+              const queueErrResp = isErrRetryable(details) ? details : null;
+
+              if (!queueErrResp || attemptNumber === maxRetryAttempts) {
+                sendTransformedEventToDestinations(
+                  state,
+                  pluginsManager,
+                  item.destinationIds,
+                  result,
+                  details?.xhr?.status,
+                  item.event,
+                  errorHandler,
+                  logger,
+                );
+              }
+
+              done(queueErrResp, result);
+            },
+          });
+        },
+        storeManager,
+        MEMORY_STORAGE,
+      );
+
+      return eventsQueue;
+    },
+
+    enqueue(
+      state: ApplicationState,
+      eventsQueue: IQueue,
+      event: RudderEvent,
+      destinations: Destination[],
+    ) {
+      const destinationIds = destinations.map(d => d.id);
+      eventsQueue.addItem({
+        event,
+        destinationIds,
+        token: state.session.authToken.value,
+      } as TransformationQueueItemData);
+    },
+  },
+});
+
+export { DeviceModeTransformation };
+
+export default DeviceModeTransformation;

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

@@ -0,0 +1,28 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+
+const DMT_TRANSFORMATION_UNSUCCESSFUL_ERROR = (
+  context: string,
+  displayName: string,
+  reason: string,
+  action: string,
+): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Event transformation unsuccessful for destination "${displayName}". Reason: ${reason}. ${action}.`;
+
+const DMT_REQUEST_FAILED_ERROR = (
+  context: string,
+  displayName: string,
+  status: number | undefined,
+  action: string,
+): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}[Destination: ${displayName}].Transformation request failed with status: ${status}. Retries exhausted. ${action}.`;
+
+const DMT_EXCEPTION = (displayName: string): string => `[Destination:${displayName}].`;
+const DMT_SERVER_ACCESS_DENIED_WARNING = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Transformation server access is denied. The configuration data seems to be out of sync. Sending untransformed event to the destination.`;
+
+export {
+  DMT_TRANSFORMATION_UNSUCCESSFUL_ERROR,
+  DMT_REQUEST_FAILED_ERROR,
+  DMT_EXCEPTION,
+  DMT_SERVER_ACCESS_DENIED_WARNING,
+};

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

@@ -0,0 +1,38 @@
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+
+export type BatchPayloadData = {
+  orderNo: number;
+  destinationIds: string[];
+  event: RudderEvent;
+};
+
+export type TransformationRequestPayload = {
+  metadata: {
+    'Custom-Authorization': Nullable<string>;
+  };
+  batch: BatchPayloadData[];
+};
+
+export type TransformationQueueItemData = {
+  event: RudderEvent;
+  destinationIds: string[];
+  token: Nullable<string>;
+};
+
+export type TransformedEvent = RudderEvent | null | Record<string, never> | unknown;
+
+export type TransformedPayload = {
+  orderNo: number;
+  status: string;
+  event?: TransformedEvent;
+};
+
+export type TransformedBatch = {
+  id: string;
+  payload: TransformedPayload[] | [];
+};
+
+export type TransformationResponsePayload = {
+  transformedBatch: TransformedBatch[];
+};

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

@@ -0,0 +1,155 @@
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { isNonEmptyObject } from '@rudderstack/analytics-js-common/utilities/object';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { IPluginsManager } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type {
+  TransformationRequestPayload,
+  TransformationResponsePayload,
+  TransformedBatch,
+  TransformedEvent,
+  TransformedPayload,
+} from './types';
+import { DMT_PLUGIN } from './constants';
+import {
+  DMT_EXCEPTION,
+  DMT_REQUEST_FAILED_ERROR,
+  DMT_SERVER_ACCESS_DENIED_WARNING,
+  DMT_TRANSFORMATION_UNSUCCESSFUL_ERROR,
+} from './logMessages';
+
+/**
+ * A helper function that will take rudderEvent and generate
+ * a batch payload that will be sent to transformation server
+ *
+ */
+const createPayload = (
+  event: RudderEvent,
+  destinationIds: string[],
+  token: Nullable<string>,
+): TransformationRequestPayload => {
+  const orderNo = Date.now();
+  const payload = {
+    metadata: {
+      'Custom-Authorization': token,
+    },
+    batch: [
+      {
+        orderNo,
+        destinationIds,
+        event,
+      },
+    ],
+  };
+  return payload;
+};
+
+const sendTransformedEventToDestinations = (
+  state: ApplicationState,
+  pluginsManager: IPluginsManager,
+  destinationIds: string[],
+  result: any,
+  status: number | undefined,
+  event: RudderEvent,
+  errorHandler?: IErrorHandler,
+  logger?: ILogger,
+) => {
+  const NATIVE_DEST_EXT_POINT = 'destinationsEventsQueue.enqueueEventToDestination';
+  const ACTION_TO_SEND_UNTRANSFORMED_EVENT = 'Sending untransformed event';
+  const ACTION_TO_DROP_EVENT = 'Dropping the event';
+  const destinations: Destination[] = state.nativeDestinations.initializedDestinations.value.filter(
+    d => d && destinationIds.includes(d.id),
+  );
+
+  destinations.forEach(dest => {
+    try {
+      const eventsToSend: TransformedEvent[] = [];
+      switch (status) {
+        case 200: {
+          const response: TransformationResponsePayload = JSON.parse(result);
+          const destTransformedResult = response.transformedBatch.find(
+            (e: TransformedBatch) => e.id === dest.id,
+          );
+          destTransformedResult?.payload.forEach((tEvent: TransformedPayload) => {
+            if (tEvent.status === '200') {
+              eventsToSend.push(tEvent.event);
+            } else {
+              let reason = 'Unknown';
+              if (tEvent.status === '410') {
+                reason = 'Transformation is not available';
+              }
+
+              let action = ACTION_TO_DROP_EVENT;
+              if (dest.propagateEventsUntransformedOnError === true) {
+                action = ACTION_TO_SEND_UNTRANSFORMED_EVENT;
+                eventsToSend.push(event);
+                logger?.warn(
+                  DMT_TRANSFORMATION_UNSUCCESSFUL_ERROR(
+                    DMT_PLUGIN,
+                    dest.displayName,
+                    reason,
+                    action,
+                  ),
+                );
+              } else {
+                logger?.error(
+                  DMT_TRANSFORMATION_UNSUCCESSFUL_ERROR(
+                    DMT_PLUGIN,
+                    dest.displayName,
+                    reason,
+                    action,
+                  ),
+                );
+              }
+            }
+          });
+
+          break;
+        }
+        // Transformation server access denied
+        case 404: {
+          logger?.warn(DMT_SERVER_ACCESS_DENIED_WARNING(DMT_PLUGIN));
+          eventsToSend.push(event);
+          break;
+        }
+        default: {
+          if (dest.propagateEventsUntransformedOnError === true) {
+            logger?.warn(
+              DMT_REQUEST_FAILED_ERROR(
+                DMT_PLUGIN,
+                dest.displayName,
+                status,
+                ACTION_TO_SEND_UNTRANSFORMED_EVENT,
+              ),
+            );
+            eventsToSend.push(event);
+          } else {
+            logger?.error(
+              DMT_REQUEST_FAILED_ERROR(DMT_PLUGIN, dest.displayName, status, ACTION_TO_DROP_EVENT),
+            );
+          }
+          break;
+        }
+      }
+      eventsToSend?.forEach((tEvent?: TransformedEvent) => {
+        if (isNonEmptyObject(tEvent)) {
+          pluginsManager.invokeSingle(
+            NATIVE_DEST_EXT_POINT,
+            state,
+            tEvent,
+            dest,
+            errorHandler,
+            logger,
+          );
+        }
+      });
+    } catch (e) {
+      errorHandler?.onError(e, DMT_PLUGIN, DMT_EXCEPTION(dest.displayName));
+    }
+  });
+};
+
+export { createPayload, sendTransformedEventToDestinations };

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

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type {
+  ExtensionPlugin,
+  IPluginEngine,
+} from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { IExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader/types';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { INVALID_SOURCE_CONFIG_ERROR } from './logMessages';
+
+const pluginName: PluginName = 'ErrorReporting';
+
+const ErrorReporting = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  errorReporting: {
+    init: (
+      state: ApplicationState,
+      pluginEngine: IPluginEngine,
+      externalSrcLoader: IExternalSrcLoader,
+      logger?: ILogger,
+    ): Nullable<Promise<any>> => {
+      if (!state.source.value?.config || !state.source.value?.id) {
+        return Promise.reject(new Error(INVALID_SOURCE_CONFIG_ERROR));
+      }
+
+      return pluginEngine.invokeSingle(
+        'errorReportingProvider.init',
+        state,
+        externalSrcLoader,
+        logger,
+      );
+    },
+    notify: (
+      pluginEngine: IPluginEngine,
+      client: any,
+      error: Error,
+      state: ApplicationState,
+      logger?: ILogger,
+    ): void => {
+      pluginEngine.invokeSingle('errorReportingProvider.notify', client, error, state, logger);
+    },
+    breadcrumb: (
+      pluginEngine: IPluginEngine,
+      client: any,
+      message: string,
+      logger?: ILogger,
+    ): void => {
+      pluginEngine.invokeSingle('errorReportingProvider.breadcrumb', client, message, logger);
+    },
+  },
+});
+
+export { ErrorReporting };
+
+export default ErrorReporting;

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

@@ -0,0 +1,3 @@
+const INVALID_SOURCE_CONFIG_ERROR = `Invalid source configuration or source id.`;
+
+export { INVALID_SOURCE_CONFIG_ERROR };

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

@@ -0,0 +1,5 @@
+const externallyLoadedSessionStorageKeys = {
+  segment: 'ajs_anonymous_id',
+};
+
+export { externallyLoadedSessionStorageKeys };