iureiure 1.0.0

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

@@ -0,0 +1,40 @@
+import type {
+  DestinationIntgConfig,
+  IntegrationOpts,
+} from '@rudderstack/analytics-js-common/types/Integration';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import { checks } from '../shared-chunks/common';
+
+const isDestIntgConfigTruthy = (destIntgConfig: DestinationIntgConfig): boolean =>
+  !checks.isUndefined(destIntgConfig) && Boolean(destIntgConfig) === true;
+
+const isDestIntgConfigFalsy = (destIntgConfig: DestinationIntgConfig): boolean =>
+  !checks.isUndefined(destIntgConfig) && Boolean(destIntgConfig) === false;
+
+/**
+ * Filters the destinations that should not be loaded or forwarded events to based on the integration options (load or events API)
+ * @param intgOpts Integration options object
+ * @param destinations Destinations array
+ * @returns Destinations array filtered based on the integration options
+ */
+const filterDestinations = (intgOpts: IntegrationOpts, destinations: Destination[]) => {
+  const allOptVal = intgOpts.All ?? true;
+  return destinations.filter(dest => {
+    const destDisplayName = dest.displayName;
+    let isDestEnabled;
+    if (allOptVal) {
+      isDestEnabled = true;
+      if (isDestIntgConfigFalsy(intgOpts[destDisplayName])) {
+        isDestEnabled = false;
+      }
+    } else {
+      isDestEnabled = false;
+      if (isDestIntgConfigTruthy(intgOpts[destDisplayName])) {
+        isDestEnabled = true;
+      }
+    }
+    return isDestEnabled;
+  });
+};
+
+export { isDestIntgConfigTruthy, isDestIntgConfigFalsy, filterDestinations };

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

@@ -0,0 +1,85 @@
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import { clone } from 'ramda';
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { stringifyWithoutCircular } from '@rudderstack/analytics-js-common/utilities/json';
+import { EVENT_PAYLOAD_SIZE_BYTES_LIMIT } from './constants';
+import type { TransformationRequestPayload } from '../deviceModeTransformation/types';
+
+const EVENT_PAYLOAD_SIZE_CHECK_FAIL_WARNING = (
+  context: string,
+  payloadSize: number,
+  sizeLimit: number,
+): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}The size of the event payload (${payloadSize} bytes) exceeds the maximum limit of ${sizeLimit} bytes. Events with large payloads may be dropped in the future. Please review your instrumentation to ensure that event payloads are within the size limit.`;
+
+const EVENT_PAYLOAD_SIZE_VALIDATION_WARNING = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to validate event payload size. Please make sure that the event payload is within the size limit and is a valid JSON object.`;
+
+const QUEUE_UTILITIES = 'QueueUtilities';
+
+/**
+ * Utility to get the stringified event payload
+ * @param event RudderEvent object
+ * @param logger Logger instance
+ * @returns stringified event payload. Empty string if error occurs.
+ */
+const getDeliveryPayload = (event: RudderEvent, logger?: ILogger): Nullable<string> =>
+  stringifyWithoutCircular<RudderEvent>(event, true, undefined, logger);
+
+const getDMTDeliveryPayload = (
+  dmtRequestPayload: TransformationRequestPayload,
+  logger?: ILogger,
+): Nullable<string> =>
+  stringifyWithoutCircular<TransformationRequestPayload>(
+    dmtRequestPayload,
+    true,
+    undefined,
+    logger,
+  );
+
+/**
+ * Utility to validate final payload size before sending to server
+ * @param event RudderEvent object
+ * @param logger Logger instance
+ */
+const validateEventPayloadSize = (event: RudderEvent, logger?: ILogger) => {
+  const payloadStr = getDeliveryPayload(event, logger);
+  if (payloadStr) {
+    const payloadSize = payloadStr.length;
+    if (payloadSize > EVENT_PAYLOAD_SIZE_BYTES_LIMIT) {
+      logger?.warn(
+        EVENT_PAYLOAD_SIZE_CHECK_FAIL_WARNING(
+          QUEUE_UTILITIES,
+          payloadSize,
+          EVENT_PAYLOAD_SIZE_BYTES_LIMIT,
+        ),
+      );
+    }
+  } else {
+    logger?.warn(EVENT_PAYLOAD_SIZE_VALIDATION_WARNING(QUEUE_UTILITIES));
+  }
+};
+
+/**
+ * Mutates the event and return final event for delivery
+ * Updates certain parameters like sentAt timestamp, integrations config etc.
+ * @param event RudderEvent object
+ * @returns Final event ready to be delivered
+ */
+const getFinalEventForDeliveryMutator = (event: RudderEvent, currentTime: string): RudderEvent => {
+  const finalEvent = clone(event);
+
+  // Update sentAt timestamp to the latest timestamp
+  finalEvent.sentAt = currentTime;
+
+  return finalEvent;
+};
+
+export {
+  getDeliveryPayload,
+  validateEventPayloadSize,
+  getFinalEventForDeliveryMutator,
+  getDMTDeliveryPayload,
+};

package/packages/analytics-js-plugins/src/utilities/retryQueue/README.md

@@ -0,0 +1,135 @@
+# RetryQueue
+
+Provides durable retries with a queue held in `localStorage` (with graceful fallbacks to memory when necessary).
+
+## How It Works
+
+Each page maintains its own list of queued and in-progress tasks, while constantly refreshing its ack time. If a queue goes more than 10s without updating its ack, another page will remove it, claim all queued tasks, and retry all in-progress tasks.
+
+## API
+
+### new RetryQueue(name, [opts], processFunc(item, done(err, res)))
+
+You can omit the `opts` argument to initialize the queue with defaults:
+
+```javascript
+var queue = new RetryQueue('my_queue_name', function process(item, done) {
+  sendAsync(item, function (err, res) {
+    if (err) return done(err);
+    done(null, res);
+  });
+});
+
+queue.start();
+```
+
+### Options
+
+The queue can be initialized with the following options (_defaults shown_):
+
+```js
+var options = {
+  minRetryDelay: 1000,   // min retry delay in ms (used in exp. backoff calcs)
+  maxRetryDelay: 30000,  // max retry delay in ms (used in exp. backoff calcs)
+  backoffFactor: 2,      // exponential backoff factor (attempts^n)
+  backoffJitter: 0,      // jitter factor for backoff calcs (0 is usually fine)
+  maxItems: Infinity     // queue high water mark (we suggest 100 as a max)
+  maxAttempts: Infinity  // max retry attempts before discarding
+};
+
+var queue = new RetryQueue('my_queue_name', options, (item, done) => {
+  sendAsync(item, (err, res) => {
+    if (err) return done(err);
+    done(null, res);
+  });
+});
+
+queue.start();
+```
+
+### .addItem(item)
+
+Adds an item to the queue
+
+```javascript
+queue.addItem({ a: 'b' });
+```
+
+### .getDelay `(attemptNumber) -> ms`
+
+Can be overridden to provide a custom retry delay in ms. You'll likely want to use the queue instance's backoff constants here.
+
+```js
+this.backoff = {
+  MIN_RETRY_DELAY: opts.minRetryDelay || 1000,
+  MAX_RETRY_DELAY: opts.maxRetryDelay || 30000,
+  FACTOR: opts.backoffFactor || 2,
+  JITTER: opts.backoffJitter || 0,
+};
+```
+
+Default implementation:
+
+```javascript
+queue.getDelay = function (attemptNumber) {
+  var ms = this.backoff.MIN_RETRY_DELAY * Math.pow(this.backoff.FACTOR, attemptNumber);
+  if (this.backoff.JITTER) {
+    var rand = Math.random();
+    var deviation = Math.floor(rand * this.backoff.JITTER * ms);
+    if (Math.floor(rand * 10) < 5) {
+      ms -= deviation;
+    } else {
+      ms += deviation;
+    }
+  }
+  return Number(Math.min(ms, this.backoff.MAX_RETRY_DELAY).toPrecision(1));
+};
+```
+
+### .shouldRetry `(item, attemptNumber, error) -> boolean`
+
+Can be overridden to provide custom logic for whether to requeue the item. You'll likely want to use the queue instance's `maxAttempts` variable (which is overridable via constructor's `opts` argument).
+
+**Default**:
+
+```js
+queue.shouldRetry = function (item, attemptNumber, error) {
+  if (attemptNumber > this.maxAttempts) return false;
+  return true;
+};
+```
+
+You may also want to selectively retry based on error returned by your process function or something in the item itself.
+
+**Override Example**:
+
+```javascript
+queue.shouldRetry = function (item, attemptNumber, error) {
+  // max attempts
+  if (attemptNumber > this.maxAttempts) return false;
+
+  // based on something in the item itself
+  if (new Date(item.timestamp) - new Date() > 86400000) return false;
+
+  // selective error handling
+  if (error.code === '429') return false;
+
+  return true;
+};
+```
+
+### .start
+
+Starts the queue processing items. Anything added before calling `.start` will be queued until `.start` is called.
+
+```javascript
+queue.start();
+```
+
+### .stop
+
+Stops the queue from processing. Any retries queued may be picked claimed by another queue after a timeout.
+
+```javascript
+queue.stop();
+```