iureiure 1.0.0

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

@@ -0,0 +1,47 @@
+/* eslint-disable no-param-reassign */
+import type { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import type { StorageType } from '@rudderstack/analytics-js-common/types/Storage';
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { AnonymousIdOptions } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { getSegmentAnonymousId } from './util';
+import { externallyLoadedSessionStorageKeys } from './constants';
+
+const pluginName: PluginName = 'ExternalAnonymousId';
+
+const ExternalAnonymousId = (): ExtensionPlugin => ({
+  name: pluginName,
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  storage: {
+    getAnonymousId(
+      getStorageEngine: (type?: StorageType) => IStorage,
+      options?: AnonymousIdOptions,
+    ) {
+      let anonymousId;
+      if (options?.autoCapture?.enabled && options.autoCapture.source) {
+        const source = options.autoCapture.source.toLowerCase();
+        if (!Object.keys(externallyLoadedSessionStorageKeys).includes(source)) {
+          return anonymousId;
+        }
+
+        // eslint-disable-next-line sonarjs/no-small-switch
+        switch (source) {
+          case 'segment':
+            anonymousId = getSegmentAnonymousId(getStorageEngine);
+            break;
+
+          default:
+            break;
+        }
+      }
+      return anonymousId;
+    },
+  },
+});
+
+export { ExternalAnonymousId };
+
+export default ExternalAnonymousId;

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

@@ -0,0 +1,25 @@
+import type { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import type { StorageType } from '@rudderstack/analytics-js-common/types/Storage';
+import { storages } from '../shared-chunks/common';
+import { externallyLoadedSessionStorageKeys } from './constants';
+
+const getSegmentAnonymousId = (getStorageEngine: (type?: StorageType) => IStorage) => {
+  let anonymousId;
+  /**
+   * First check the local storage for anonymousId
+   * Ref: https://segment.com/docs/connections/sources/catalog/libraries/website/javascript/#identify
+   */
+  const lsEngine = getStorageEngine(storages.LOCAL_STORAGE);
+  if (lsEngine?.isEnabled) {
+    anonymousId = lsEngine.getItem(externallyLoadedSessionStorageKeys.segment);
+  }
+
+  // If anonymousId is not present in local storage and find it in cookies
+  const csEngine = getStorageEngine(storages.COOKIE_STORAGE);
+  if (!anonymousId && csEngine?.isEnabled) {
+    anonymousId = csEngine.getItem(externallyLoadedSessionStorageKeys.segment);
+  }
+  return anonymousId;
+};
+
+export { getSegmentAnonymousId };

package/packages/analytics-js-plugins/src/googleLinker/base64Decoder.ts

@@ -0,0 +1,33 @@
+/**
+ * This is utility function for decoding from base 64 to utf8
+ *
+ * @param {string} str base64
+ *
+ * @returns {string} utf8
+ */
+const b64DecodeUnicode = (str: string): string =>
+  // Going backwards: from bytestream, to percent-encoding, to original string.
+  decodeURIComponent(
+    globalThis
+      .atob(str)
+      .split('')
+      .map(c => {
+        const percentEncodingChar = `00${c.charCodeAt(0).toString(16)}`;
+        return `%${percentEncodingChar.slice(-2)}`;
+      })
+      .join(''),
+  );
+
+/**
+ * This is utility function for decoding from base 64 to utf8
+ *
+ * @param {string} data
+ *
+ * @return {string}
+ */
+const decode = (data = ''): string => {
+  const decodedData = data.endsWith('..') ? data.substring(0, data.length - 2) : data;
+  return b64DecodeUnicode(decodedData);
+};
+
+export { decode };

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

@@ -0,0 +1 @@
+export const AMP_LINKER_ANONYMOUS_ID_KEY = 'rs_amp_id';

package/packages/analytics-js-plugins/src/googleLinker/crc32.ts

@@ -0,0 +1,44 @@
+/* eslint-disable no-bitwise */
+
+/**
+ * generate crc table
+ *
+ * @params none
+ * @returns array of CRC table
+ */
+
+const makeCRCTable = (): number[] => {
+  const crcTable = [];
+  let c;
+
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[n] = c;
+  }
+
+  return crcTable;
+};
+
+/**
+ * This is utility function for crc32 algorithm
+ *
+ * @param {string} str
+ * @returns {number} crc32
+ */
+const crc32 = (str: string): number => {
+  const crcTable = makeCRCTable();
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < str.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+};
+
+export { crc32 };

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

@@ -0,0 +1,30 @@
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { AMP_LINKER_ANONYMOUS_ID_KEY } from './constants';
+import { parseLinker } from './utils';
+
+const pluginName: PluginName = 'GoogleLinker';
+
+const GoogleLinker = (): ExtensionPlugin => ({
+  name: pluginName,
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  userSession: {
+    anonymousIdGoogleLinker(rudderAmpLinkerParam?: Nullable<string>): Nullable<string | undefined> {
+      if (!rudderAmpLinkerParam) {
+        return null;
+      }
+
+      const parsedAnonymousIdObj = rudderAmpLinkerParam ? parseLinker(rudderAmpLinkerParam) : null;
+      return parsedAnonymousIdObj ? parsedAnonymousIdObj[AMP_LINKER_ANONYMOUS_ID_KEY] : null;
+    },
+  },
+});
+
+export { GoogleLinker };
+
+export default GoogleLinker;

package/packages/analytics-js-plugins/src/googleLinker/userLib.ts

@@ -0,0 +1,16 @@
+/**
+ * An interface to fetch user device details.
+ */
+const USER_INTERFACE = {
+  /**
+   * @returns {string} user language
+   */
+  getUserLanguage: (): string => navigator?.language,
+
+  /**
+   * @returns {string} userAgent
+   */
+  getUserAgent: (): string => navigator?.userAgent,
+};
+
+export { USER_INTERFACE };

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

@@ -0,0 +1,156 @@
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { crc32 } from './crc32';
+import { USER_INTERFACE } from './userLib';
+import { decode } from './base64Decoder';
+
+const KEY_VALIDATOR = /^[\w.-]+$/;
+const CHECKSUM_OFFSET_MAX_MIN = 1;
+const VALID_VERSION = 1;
+const DELIMITER = '*';
+
+/**
+ * Parse the linker param value to version checksum and serializedParams
+ *
+ * @param {string} value
+ *
+ * @return {?Object}
+ */
+const parseLinkerParamValue = (value: string): Nullable<Record<string, string>> => {
+  const parts = value.split(DELIMITER);
+  const isEven = parts.length % 2 === 0;
+
+  if (parts.length < 4 || !isEven) {
+    // Format <version>*<checksum>*<key1>*<value1>
+    // Note: linker makes sure there's at least one pair of non empty key value
+    // Make sure there is at least three delimiters.
+    return null;
+  }
+
+  const version = Number(parts.shift());
+  if (version !== VALID_VERSION) {
+    return null;
+  }
+
+  const checksum = parts.shift();
+  const serializedIds = parts.join(DELIMITER);
+
+  return {
+    checksum: checksum ?? '',
+    serializedIds,
+  };
+};
+
+/**
+ * Deserialize the serializedIds and return keyValue pairs.
+ *
+ * @param {string} serializedIds
+ *
+ * @return {!Object<string, string>}
+ */
+const deserialize = (serializedIds?: string): Record<string, string> => {
+  if (!serializedIds) {
+    return {};
+  }
+
+  const keyValuePairs: Record<string, string> = {};
+  const params = serializedIds.split(DELIMITER);
+  for (let i = 0; i < params.length; i += 2) {
+    const key = params[i] as string;
+    const valid = KEY_VALIDATOR.test(key);
+    if (valid) {
+      keyValuePairs[key] = decode(params[i + 1]);
+    }
+  }
+  return keyValuePairs;
+};
+
+/**
+ * Generates a semi-unique value for page visitor.
+ *
+ * @return {string}
+ */
+const getFingerprint = (userAgent: string, language: string): string => {
+  const date = new Date();
+  const timezone = date.getTimezoneOffset();
+  return [userAgent, timezone, language].join(DELIMITER);
+};
+
+/**
+ * Rounded time used to check if t2 - t1 is within our time tolerance.
+ * Timestamp in minutes, floored.
+ *
+ * @return {number}
+ */
+const getMinSinceEpoch = (): number => Math.floor(Date.now() / 60000);
+
+/**
+ * Create a unique checksum hashing the fingerprint and a few other values.
+ *
+ * @param {string} serializedIds
+ * @param {number=} optOffsetMin
+ * @param {string} userAgent
+ * @param {string} language
+ *
+ * @return {string}
+ */
+const getCheckSum = (
+  serializedIds: string,
+  optOffsetMin: number,
+  userAgent: string,
+  language: string,
+): string => {
+  const fingerprint = getFingerprint(userAgent, language);
+  const offset = optOffsetMin || 0;
+  const timestamp = getMinSinceEpoch() - offset;
+  const crc = crc32([fingerprint, timestamp, serializedIds].join(DELIMITER));
+
+  // Encoded to base36 for fewer bytes.
+  return crc.toString(36);
+};
+
+/**
+ * Check if the checksum is valid with time offset tolerance.
+ *
+ * @param {string} serializedIds
+ * @param {string} checksum
+ *
+ * @return {boolean}
+ */
+const isCheckSumValid = (serializedIds: string, checksum: string): boolean => {
+  const userAgent = USER_INTERFACE.getUserAgent();
+  const language = USER_INTERFACE.getUserLanguage();
+
+  for (let i = 0; i <= CHECKSUM_OFFSET_MAX_MIN; i += 1) {
+    const calculateCheckSum = getCheckSum(serializedIds, i, userAgent, language);
+    if (calculateCheckSum === checksum) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * AMP Linker Parser (works for Rudder, GA or any other linker created by following Google's linker standard.)
+ *
+ * @param {string} value
+ *
+ * @return {?Object<string, string>}
+ */
+const parseLinker = (value: string): Nullable<Record<string, string>> => {
+  const linkerObj = parseLinkerParamValue(value);
+
+  if (!linkerObj) {
+    return null;
+  }
+
+  const { checksum, serializedIds } = linkerObj;
+
+  if (!serializedIds || !checksum || !isCheckSumValid(serializedIds, checksum)) {
+    return null;
+  }
+
+  return deserialize(serializedIds);
+};
+
+export { parseLinker };

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

@@ -0,0 +1,15 @@
+export { default as BeaconQueue } from './beaconQueue';
+export { default as Bugsnag } from './bugsnag';
+export { default as CustomConsentManager } from './customConsentManager';
+export { default as DeviceModeDestinations } from './deviceModeDestinations';
+export { default as DeviceModeTransformation } from './deviceModeTransformation';
+export { default as ErrorReporting } from './errorReporting';
+export { default as ExternalAnonymousId } from './externalAnonymousId';
+export { default as GoogleLinker } from './googleLinker';
+export { default as NativeDestinationQueue } from './nativeDestinationQueue';
+export { default as OneTrustConsentManager } from './oneTrustConsentManager';
+export { default as KetchConsentManager } from './ketchConsentManager';
+export { default as StorageEncryption } from './storageEncryption';
+export { default as StorageEncryptionLegacy } from './storageEncryptionLegacy';
+export { default as StorageMigrator } from './storageMigrator';
+export { default as XhrQueue } from './xhrQueue';

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

@@ -0,0 +1,4 @@
+const KETCH_CONSENT_MANAGER_PLUGIN = 'KetchConsentManagerPlugin';
+const KETCH_CONSENT_COOKIE_NAME_V1 = '_ketch_consent_v1_';
+
+export { KETCH_CONSENT_MANAGER_PLUGIN, KETCH_CONSENT_COOKIE_NAME_V1 };

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

@@ -0,0 +1,120 @@
+/* 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 } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { DestinationConfig } from '@rudderstack/analytics-js-common/types/Destination';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { checks } from '../shared-chunks/common';
+import { DESTINATION_CONSENT_STATUS_ERROR } from './logMessages';
+import { KETCH_CONSENT_MANAGER_PLUGIN } from './constants';
+import type { KetchConsentData } from './types';
+import { getKetchConsentData, updateConsentStateFromData } from './utils';
+
+const pluginName: PluginName = 'KetchConsentManager';
+
+const KetchConsentManager = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  consentManager: {
+    init(state: ApplicationState, logger?: ILogger): void {
+      // getKetchUserConsentedPurposes returns current ketch opted-in purposes
+      // This will be helpful for debugging
+      (globalThis as any).getKetchUserConsentedPurposes = () =>
+        (state.consents.data.value.allowedConsentIds as string[])?.slice();
+
+      // getKetchUserDeniedPurposes returns current ketch opted-out purposes
+      // This will be helpful for debugging
+      (globalThis as any).getKetchUserDeniedPurposes = () =>
+        (state.consents.data.value.deniedConsentIds as string[])?.slice();
+
+      // updateKetchConsent callback function to update current consent purpose state
+      // this will be called from ketch rudderstack plugin
+      (globalThis as any).updateKetchConsent = (ketchConsentData: KetchConsentData) => {
+        updateConsentStateFromData(state, ketchConsentData);
+      };
+    },
+
+    updateConsentsInfo(
+      state: ApplicationState,
+      storeManager?: IStoreManager,
+      logger?: ILogger,
+    ): void {
+      // retrieve consent data and update the state
+      let ketchConsentData;
+      if (!checks.isUndefined((globalThis as any).ketchConsent)) {
+        ketchConsentData = (globalThis as any).ketchConsent;
+      } else {
+        ketchConsentData = getKetchConsentData(storeManager, logger);
+      }
+
+      updateConsentStateFromData(state, ketchConsentData);
+    },
+
+    isDestinationConsented(
+      state: ApplicationState,
+      destConfig: DestinationConfig,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): boolean {
+      if (!state.consents.initialized.value) {
+        return true;
+      }
+
+      const allowedConsentIds = state.consents.data.value.allowedConsentIds as string[];
+
+      try {
+        const { ketchConsentPurposes, consentManagement } = destConfig;
+        const matchPredicate = (consent: string) => allowedConsentIds.includes(consent);
+
+        // Generic consent management
+        if (consentManagement) {
+          // Get the corresponding consents for the destination
+          const cmpConsents = consentManagement.find(
+            c => c.provider === state.consents.provider.value,
+          )?.consents;
+
+          // If there are no consents configured for the destination for the current provider, events should be sent.
+          if (!cmpConsents) {
+            return true;
+          }
+
+          const configuredConsents = cmpConsents.map(c => c.consent.trim()).filter(n => n);
+
+          // match the configured consents with user provided consents as per
+          // the configured resolution strategy
+          switch (state.consents.resolutionStrategy.value) {
+            case 'or':
+              return configuredConsents.some(matchPredicate) || configuredConsents.length === 0;
+            case 'and':
+            default:
+              return configuredConsents.every(matchPredicate);
+          }
+
+          // Legacy cookie consent management
+          // TODO: To be removed once the source config API is updated to support generic consent management
+        } else if (ketchConsentPurposes) {
+          const configuredConsents = ketchConsentPurposes.map(p => p.purpose.trim()).filter(n => n);
+
+          // Check if any of the destination's mapped ketch purposes are consented by the user in the browser.
+          return configuredConsents.some(matchPredicate) || configuredConsents.length === 0;
+        }
+
+        // If there are no consents configured for the destination for the current provider, events should be sent.
+        return true;
+      } catch (err) {
+        errorHandler?.onError(err, KETCH_CONSENT_MANAGER_PLUGIN, DESTINATION_CONSENT_STATUS_ERROR);
+        return true;
+      }
+    },
+  },
+});
+
+export { KetchConsentManager };
+
+export default KetchConsentManager;

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

@@ -0,0 +1,15 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+
+const KETCH_CONSENT_COOKIE_READ_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to read the consent cookie.`;
+
+const KETCH_CONSENT_COOKIE_PARSE_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to parse the consent cookie.`;
+
+const DESTINATION_CONSENT_STATUS_ERROR = `Failed to determine the consent status for the destination. Please check the destination configuration and try again.`;
+
+export {
+  KETCH_CONSENT_COOKIE_READ_ERROR,
+  KETCH_CONSENT_COOKIE_PARSE_ERROR,
+  DESTINATION_CONSENT_STATUS_ERROR,
+};

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

@@ -0,0 +1,11 @@
+export type KetchPurpose = {
+  status: string;
+};
+
+export type KetchConsentCookieData = {
+  [purposeCode: string]: KetchPurpose | undefined;
+};
+
+export type KetchConsentData = {
+  [purposeCode: string]: boolean;
+};

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

@@ -0,0 +1,95 @@
+/* eslint-disable no-param-reassign */
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ConsentsInfo } from '@rudderstack/analytics-js-common/types/Consent';
+import { isDefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import { checks, storages, string } from '../shared-chunks/common';
+import { KETCH_CONSENT_COOKIE_PARSE_ERROR, KETCH_CONSENT_COOKIE_READ_ERROR } from './logMessages';
+import { KETCH_CONSENT_COOKIE_NAME_V1, KETCH_CONSENT_MANAGER_PLUGIN } from './constants';
+import type { KetchConsentCookieData, KetchConsentData } from './types';
+
+/**
+ * Gets the consent data from the Ketch's consent cookie
+ * @param storeManager Store manager instance
+ * @param logger Logger instance
+ * @returns Consent data from the consent cookie
+ */
+const getKetchConsentData = (
+  storeManager?: IStoreManager,
+  logger?: ILogger,
+): KetchConsentData | undefined => {
+  let rawConsentCookieData = null;
+  try {
+    // Create a data store instance to read the consent cookie
+    const dataStore = storeManager?.setStore({
+      id: KETCH_CONSENT_MANAGER_PLUGIN,
+      name: KETCH_CONSENT_MANAGER_PLUGIN,
+      type: storages.COOKIE_STORAGE,
+    });
+    rawConsentCookieData = dataStore?.engine.getItem(KETCH_CONSENT_COOKIE_NAME_V1);
+  } catch (err) {
+    logger?.error(KETCH_CONSENT_COOKIE_READ_ERROR(KETCH_CONSENT_MANAGER_PLUGIN), err);
+    return undefined;
+  }
+
+  if (checks.isNullOrUndefined(rawConsentCookieData)) {
+    return undefined;
+  }
+
+  // Decode and parse the cookie data to JSON
+  let consentCookieData: KetchConsentCookieData;
+  try {
+    consentCookieData = JSON.parse(string.fromBase64(rawConsentCookieData as string));
+  } catch (err) {
+    logger?.error(KETCH_CONSENT_COOKIE_PARSE_ERROR(KETCH_CONSENT_MANAGER_PLUGIN), err);
+    return undefined;
+  }
+
+  if (!consentCookieData) {
+    return undefined;
+  }
+
+  // Convert the cookie data to consent data
+  const consentPurposes: KetchConsentData = {};
+  Object.entries(consentCookieData).forEach(pEntry => {
+    const purposeCode = pEntry[0];
+    const purposeValue = pEntry[1];
+    consentPurposes[purposeCode] = purposeValue?.status === 'granted';
+  });
+  return consentPurposes;
+};
+
+/**
+ * Gets the consent data in the format expected by the application state
+ * @param ketchConsentData Consent data derived from the consent cookie
+ * @returns Consent data
+ */
+const getConsentData = (ketchConsentData?: KetchConsentData): ConsentsInfo => {
+  const allowedConsentIds: string[] = [];
+  const deniedConsentIds: string[] = [];
+  if (ketchConsentData) {
+    Object.entries(ketchConsentData).forEach(e => {
+      const purposeCode = e[0];
+      const isConsented = e[1];
+      if (isConsented) {
+        allowedConsentIds.push(purposeCode);
+      } else {
+        deniedConsentIds.push(purposeCode);
+      }
+    });
+  }
+
+  return { allowedConsentIds, deniedConsentIds };
+};
+
+const updateConsentStateFromData = (
+  state: ApplicationState,
+  ketchConsentData: KetchConsentData,
+) => {
+  const consentData = getConsentData(ketchConsentData);
+  state.consents.initialized.value = isDefined(ketchConsentData);
+  state.consents.data.value = consentData;
+};
+
+export { getKetchConsentData, getConsentData, updateConsentStateFromData };

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

@@ -0,0 +1,9 @@
+const DEFAULT_QUEUE_OPTIONS = {
+  maxItems: 100,
+};
+
+const QUEUE_NAME = 'rudder_destinations_events';
+
+const NATIVE_DESTINATION_QUEUE_PLUGIN = 'NativeDestinationQueuePlugin';
+
+export { DEFAULT_QUEUE_OPTIONS, QUEUE_NAME, NATIVE_DESTINATION_QUEUE_PLUGIN };