@aws-amplify/analytics 6.5.6-api-v6-models.b3abc9b.0 → 7.0.0

package/src/Providers/AmazonPersonalizeProvider.ts

@@ -1,398 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-import {
-	ConsoleLogger as Logger,
-	Credentials,
-	browserOrNode,
-	AnalyticsAction,
-} from '@aws-amplify/core';
-import {
-	PersonalizeEventsClient,
-	PutEventsCommand,
-	PutEventsCommandInput,
-} from '@aws-sdk/client-personalize-events';
-import {
-	SessionInfo,
-	RequestParams,
-	RecordEventPayload,
-	SessionInfoManager,
-	MediaAutoTrack,
-} from './AmazonPersonalizeHelper';
-import get from 'lodash/get';
-import isEmpty from 'lodash/isEmpty';
-import isEqual from 'lodash/isEqual';
-import { AnalyticsProvider } from '../types';
-import { getAnalyticsUserAgent } from '../utils/UserAgent';
-
-const logger = new Logger('AmazonPersonalizeProvider');
-
-// events buffer
-const FLUSH_SIZE = 5;
-const FLUSH_SIZE_THRESHHOLD = 10;
-const FLUSH_INTERVAL = 5 * 1000; // 5s
-
-const IDENTIFY_EVENT = 'Identify';
-
-export class AmazonPersonalizeProvider implements AnalyticsProvider {
-	private _config;
-	private _personalize;
-	private _buffer;
-	private _timer;
-	private _sessionInfo: SessionInfo;
-	private _sessionManager;
-	private _isBrowser;
-
-	constructor(config?) {
-		this._buffer = [];
-		this._config = config ? config : {};
-		this._config.flushSize =
-			this._config.flushSize > 0 &&
-			this._config.flushSize <= FLUSH_SIZE_THRESHHOLD
-				? this._config.flushSize
-				: FLUSH_SIZE;
-		this._config.flushInterval = this._config.flushInterval || FLUSH_INTERVAL;
-		this._sessionManager = new SessionInfoManager();
-		if (!isEmpty(this._config.trackingId)) {
-			this._sessionInfo = this._sessionManager.retrieveSessionInfo(
-				this._config.trackingId
-			);
-		}
-		this._isBrowser = browserOrNode().isBrowser;
-
-		// flush event buffer
-		this._setupTimer();
-	}
-
-	private _setupTimer() {
-		if (this._timer) {
-			clearInterval(this._timer);
-		}
-		const { flushInterval } = this._config;
-		const that = this;
-		this._timer = setInterval(() => {
-			that._sendFromBuffer();
-		}, flushInterval);
-	}
-
-	/**
-	 * Record event
-	 * @param eventType      - type of the event action. e.g. "Click"
-	 * @param properties     - properties of the event
-	 * @return Promise
-	 */
-	public async record(params): Promise<boolean> {
-		const credentials = await this._getCredentials();
-		if (!credentials) return Promise.resolve(false);
-
-		Object.assign(params, {
-			config: this._config,
-			credentials,
-			sentAt: new Date(),
-		});
-		const { eventType, properties } = params.event;
-
-		if (eventType === IDENTIFY_EVENT) {
-			this._sessionManager.updateSessionInfo(
-				properties && properties.userId ? properties.userId : '',
-				this._sessionInfo
-			);
-			return;
-		} else if (!isEmpty(params.event.userId)) {
-			this._sessionManager.updateSessionInfo(
-				params.event.userId,
-				this._sessionInfo
-			);
-		}
-		const requestParams: RequestParams = this.generateRequestParams(
-			params,
-			this._sessionInfo
-		);
-		if (eventType === 'MediaAutoTrack') {
-			if (this._isBrowser) {
-				if (
-					!isEmpty(
-						get(requestParams, 'eventData.properties.domElementId', null)
-					)
-				) {
-					const isLoaded = await this.isElementFullyLoaded(
-						this.loadElement,
-						requestParams.eventData.properties['domElementId'],
-						500,
-						5
-					);
-					if (isLoaded) {
-						new MediaAutoTrack(requestParams, this);
-					} else {
-						logger.debug('Cannot find the media element.');
-					}
-				} else {
-					logger.debug(
-						"Missing domElementId field in 'properties' for MediaAutoTrack event type."
-					);
-				}
-			} else {
-				logger.debug('MediaAutoTrack only for browser');
-			}
-			return;
-		}
-
-		return this.putToBuffer(requestParams);
-	}
-
-	private loadElement(domId): Promise<boolean> {
-		return new Promise((resolve, reject) => {
-			if (
-				document.getElementById(domId) &&
-				document.getElementById(domId).clientHeight
-			) {
-				return resolve(true);
-			} else {
-				return reject(true);
-			}
-		});
-	}
-
-	private isElementFullyLoaded(
-		operation,
-		params,
-		delay,
-		times
-	): Promise<boolean> {
-		const wait = ms => new Promise(r => setTimeout(r, ms));
-		return new Promise((resolve, reject) => {
-			return operation(params)
-				.then(resolve)
-				.catch(reason => {
-					if (times - 1 > 0) {
-						return wait(delay)
-							.then(
-								this.isElementFullyLoaded.bind(
-									null,
-									operation,
-									params,
-									delay,
-									times - 1
-								)
-							)
-							.then(resolve)
-							.catch(reject);
-					}
-					return reject(reason);
-				});
-		});
-	}
-
-	/**
-	 * get the category of the plugin
-	 */
-	public getCategory(): string {
-		return 'Analytics';
-	}
-
-	/**
-	 * get provider name of the plugin
-	 */
-	public getProviderName(): string {
-		return 'AmazonPersonalize';
-	}
-
-	/**
-	 * configure the plugin
-	 * @param {Object} config - configuration
-	 */
-	public configure(config): object {
-		logger.debug('configure Analytics', config);
-		const conf = config ? config : {};
-		this._config = Object.assign({}, this._config, conf);
-		if (!isEmpty(this._config.trackingId)) {
-			this._sessionInfo = this._sessionManager.retrieveSessionInfo(
-				this._config.trackingId
-			);
-		}
-		this._setupTimer();
-		return this._config;
-	}
-
-	/**
-	 * Generate the requestParams from customer input params and sessionInfo
-	 * @private
-	 * @param eventData      - customer input for event data
-	 * @param api            - api name
-	 * @return RequestParams - wrapper object with all information required for make request
-	 */
-	private generateRequestParams(params, sessionInfo): RequestParams {
-		const requestParams = <RequestParams>{};
-		const { eventType, properties } = params.event;
-		requestParams.eventData = { eventType, properties };
-		requestParams.sessionInfo = sessionInfo;
-		requestParams.sentAt = params.sentAt;
-		requestParams.credentials = params.credentials;
-		requestParams.config = params.config;
-		return requestParams;
-	}
-
-	/**
-	 * record an event
-	 * @param {Object} params - the params of an event
-	 */
-	private _sendEvents(group) {
-		const groupLen = group.length;
-		if (groupLen === 0) {
-			logger.debug('events array is empty, directly return');
-			return;
-		}
-
-		const { config, credentials, sessionInfo } = group[0];
-
-		const initClients = this._init(config, credentials);
-		if (!initClients) return false;
-		if (groupLen > 0) {
-			const events: RecordEventPayload[] = [];
-			for (let i = 0; i < groupLen; i += 1) {
-				const params: RequestParams = group.shift();
-				const eventPayload: RecordEventPayload =
-					this._generateSingleRecordPayload(params, sessionInfo);
-				events.push(eventPayload);
-			}
-			const payload = <PutEventsCommandInput>{};
-			payload.trackingId = sessionInfo.trackingId;
-			payload.sessionId = sessionInfo.sessionId;
-			payload.userId = sessionInfo.userId;
-			payload.eventList = [];
-			events.forEach(event => {
-				// @ts-ignore
-				payload.eventList.push(event);
-			});
-			const command: PutEventsCommand = new PutEventsCommand(payload);
-			this._personalize.send(command, err => {
-				if (err) logger.debug('Failed to call putEvents in Personalize', err);
-				else logger.debug('Put events');
-			});
-		}
-	}
-
-	/**
-	 * Put event into buffer
-	 * @private
-	 * @param params - params for the event recording
-	 */
-	private putToBuffer(params: RequestParams) {
-		if (this._buffer.length < this._config.flushSize) {
-			this._buffer.push(params);
-		} else {
-			this._buffer.push(params);
-			this._sendFromBuffer();
-		}
-		return Promise.resolve(true);
-	}
-
-	/**
-	 * flush the buffer and batch sending the request
-	 * @private
-	 * @param eventsParams - the buffer for cache the payload
-	 */
-	private _sendFromBuffer() {
-		const size = this._buffer.length;
-		if (size <= 0) return;
-		const eventsGroups = [];
-		let preCred = null;
-		let group = [];
-		for (let i = 0; i < size; i += 1) {
-			const currRequestParams: RequestParams = this._buffer.shift();
-			const cred = currRequestParams.credentials;
-			const sessionInfo = currRequestParams.sessionInfo;
-			if (i === 0) {
-				group.push(currRequestParams);
-				preCred = cred;
-			} else {
-				if (
-					isEqual(sessionInfo, this._sessionInfo) &&
-					cred.sessionToken === preCred.sessionToken &&
-					cred.identityId === preCred.identityId
-				) {
-					logger.debug('no change for cred, put event in the same group');
-					group.push(currRequestParams);
-				} else {
-					eventsGroups.push(group);
-					group = [];
-					group.push(currRequestParams);
-					preCred = cred;
-					this._sessionInfo = sessionInfo;
-				}
-			}
-		}
-		eventsGroups.push(group);
-
-		eventsGroups.map(group => {
-			this._sendEvents(group);
-		});
-	}
-
-	/**
-	 * Generate the record payload for single event
-	 * @private
-	 * @param params - RequestParams
-	 */
-	private _generateSingleRecordPayload(
-		params: RequestParams,
-		sessionInfo
-	): RecordEventPayload {
-		const { eventData, sentAt } = params;
-		const trackPayload = <RecordEventPayload>{};
-		trackPayload.sentAt = sentAt;
-		trackPayload.properties =
-			eventData.properties && JSON.stringify(eventData.properties);
-		trackPayload.eventId =
-			this._sessionManager.getTimerKey() + sessionInfo.sessionId;
-		trackPayload.eventType = eventData.eventType;
-		return trackPayload;
-	}
-
-	/**
-	 * Initialize the personalize client
-	 * @private
-	 * @param params - RequestParams
-	 */
-	private _init(config, credentials) {
-		logger.debug('init clients');
-
-		if (
-			this._personalize &&
-			this._config.credentials &&
-			this._config.credentials.sessionToken === credentials.sessionToken &&
-			this._config.credentials.identityId === credentials.identityId
-		) {
-			logger.debug('no change for analytics config, directly return from init');
-			return true;
-		}
-
-		this._config.credentials = credentials;
-		const { region } = config;
-		logger.debug('initialize personalize with credentials', credentials);
-		this._personalize = new PersonalizeEventsClient({
-			region,
-			credentials,
-			customUserAgent: getAnalyticsUserAgent(AnalyticsAction.Record),
-		});
-		return true;
-	}
-
-	/**
-	 * check if current credentials exists
-	 * @private
-	 */
-	private _getCredentials() {
-		const that = this;
-		return Credentials.get()
-			.then(credentials => {
-				if (!credentials) return null;
-				logger.debug('set credentials for analytics', that._config.credentials);
-				return Credentials.shear(credentials);
-			})
-			.catch(err => {
-				logger.debug('ensure credentials error', err);
-				return null;
-			});
-	}
-}

package/src/Providers/EventBuffer.ts

@@ -1,257 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { AnalyticsAction, ConsoleLogger as Logger } from '@aws-amplify/core';
-import {
-	putEvents,
-	PutEventsInput,
-	PutEventsOutput,
-} from '@aws-amplify/core/internals/aws-clients/pinpoint';
-import { EventBuffer, EventObject, EventMap } from '../types';
-import { isAppInForeground } from '../utils/AppUtils';
-import { getAnalyticsUserAgentString } from '../utils/UserAgent';
-
-const logger = new Logger('EventsBuffer');
-const RETRYABLE_CODES = [429, 500];
-const ACCEPTED_CODES = [202];
-
-type EventsBufferConfig = {
-	bufferSize: number;
-	flushSize: number;
-	flushInterval: number;
-	resendLimit: number;
-};
-
-export default class EventsBuffer {
-	private _config;
-	private _interval;
-	private _buffer: EventBuffer;
-	private _pause = false;
-	private _flush = false;
-
-	constructor(config: EventsBufferConfig) {
-		logger.debug('Instantiating buffer with config:', config);
-		this._buffer = [];
-		this._config = config;
-
-		this._sendBatch = this._sendBatch.bind(this);
-
-		this._startLoop();
-	}
-
-	public push(event: EventObject) {
-		// if the buffer is currently at the configured limit, pushing would exceed it
-		if (this._buffer.length >= this._config.bufferSize) {
-			logger.debug('Exceeded analytics events buffer size');
-			return event.handlers.reject(
-				new Error('Exceeded the size of analytics events buffer')
-			);
-		}
-
-		const { eventId } = event.params.event;
-		const bufferElement = { [eventId]: event };
-		this._buffer.push(bufferElement);
-	}
-
-	public pause() {
-		this._pause = true;
-	}
-
-	public resume() {
-		this._pause = false;
-	}
-
-	public flush() {
-		this._flush = true;
-	}
-
-	private _startLoop() {
-		if (this._interval) {
-			clearInterval(this._interval);
-		}
-
-		const { flushInterval } = this._config;
-
-		this._interval = setInterval(this._sendBatch, flushInterval);
-	}
-
-	private _sendBatch() {
-		const bufferLength = this._buffer.length;
-
-		if (this._flush && !bufferLength) {
-			clearInterval(this._interval);
-		}
-
-		// Do not send the batch of events if
-		// the Buffer is paused or is empty or the App is not in the foreground
-		// Apps should be in the foreground since
-		// the OS may restrict access to the network in the background
-		if (this._pause || !bufferLength || !isAppInForeground()) {
-			return;
-		}
-
-		const { flushSize } = this._config;
-
-		const batchSize = Math.min(flushSize, bufferLength);
-		const bufferSubset = this._buffer.splice(0, batchSize);
-
-		this._putEvents(bufferSubset);
-	}
-
-	private async _putEvents(buffer: EventBuffer) {
-		const eventMap: EventMap = this._bufferToMap(buffer);
-		const batchEventParams = this._generateBatchEventParams(eventMap);
-
-		try {
-			const { credentials, region } = this._config;
-			const data: PutEventsOutput = await putEvents(
-				{
-					credentials,
-					region,
-					userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
-				},
-				batchEventParams
-			);
-			this._processPutEventsSuccessResponse(data, eventMap);
-		} catch (err) {
-			return this._handlePutEventsFailure(err, eventMap);
-		}
-	}
-
-	private _generateBatchEventParams(eventMap: EventMap): PutEventsInput {
-		const batchEventParams = {
-			ApplicationId: '',
-			EventsRequest: {
-				BatchItem: {},
-			},
-		};
-
-		Object.values(eventMap).forEach(item => {
-			const { params } = item;
-			const { event, timestamp, config } = params;
-			const { name, attributes, metrics, eventId, session } = event;
-			const { appId, endpointId } = config;
-
-			const batchItem = batchEventParams.EventsRequest.BatchItem;
-
-			batchEventParams.ApplicationId = batchEventParams.ApplicationId || appId;
-
-			if (!batchItem[endpointId]) {
-				batchItem[endpointId] = {
-					Endpoint: {},
-					Events: {},
-				};
-			}
-
-			batchItem[endpointId].Events[eventId] = {
-				EventType: name,
-				Timestamp: new Date(timestamp).toISOString(),
-				Attributes: attributes,
-				Metrics: metrics,
-				Session: session,
-			};
-		});
-
-		return batchEventParams;
-	}
-
-	private _handlePutEventsFailure(err, eventMap: EventMap) {
-		logger.debug('_putEvents Failed: ', err);
-		const statusCode = err.$metadata && err.$metadata.httpStatusCode;
-
-		if (RETRYABLE_CODES.includes(statusCode)) {
-			const retryableEvents = Object.values(eventMap);
-			this._retry(retryableEvents);
-			return;
-		}
-	}
-
-	private _processPutEventsSuccessResponse(
-		data: PutEventsOutput,
-		eventMap: EventMap
-	) {
-		const { Results = {} } = data.EventsResponse ?? {};
-		const retryableEvents: EventObject[] = [];
-
-		Object.entries(Results).forEach(([endpointId, endpointValues]) => {
-			const responses = endpointValues.EventsItemResponse ?? {};
-
-			Object.entries(responses).forEach(([eventId, eventValues]) => {
-				const eventObject = eventMap[eventId];
-				if (!eventObject) {
-					return;
-				}
-
-				const { StatusCode, Message } = eventValues ?? {};
-
-				// manually crafting handlers response to keep API consistant
-				const response = {
-					EventsResponse: {
-						Results: {
-							[endpointId]: {
-								EventsItemResponse: {
-									[eventId]: { StatusCode, Message },
-								},
-							},
-						},
-					},
-				};
-
-				if (StatusCode && ACCEPTED_CODES.includes(StatusCode)) {
-					eventObject.handlers.resolve(response);
-					return;
-				}
-
-				if (StatusCode && RETRYABLE_CODES.includes(StatusCode)) {
-					retryableEvents.push(eventObject);
-					return;
-				}
-
-				const { name } = eventObject.params.event;
-
-				logger.error(
-					`event ${eventId} : ${name} failed with error: ${Message}`
-				);
-				return eventObject.handlers.reject(response);
-			});
-		});
-
-		if (retryableEvents.length) {
-			this._retry(retryableEvents);
-		}
-	}
-
-	private _retry(retryableEvents: EventObject[]) {
-		// retryable events that haven't reached the resendLimit
-		const eligibleEvents: EventBuffer = [];
-
-		retryableEvents.forEach((event: EventObject) => {
-			const { params } = event;
-			const { eventId, name } = params.event;
-
-			if (params.resendLimit-- > 0) {
-				logger.debug(
-					`resending event ${eventId} : ${name} with ${params.resendLimit} retry attempts remaining`
-				);
-				eligibleEvents.push({ [eventId]: event });
-				return;
-			}
-
-			logger.debug(
-				`no retry attempts remaining for event ${eventId} : ${name}`
-			);
-		});
-
-		// add the events to the front of the buffer
-		this._buffer.unshift(...eligibleEvents);
-	}
-
-	// convert buffer to map, i.e. { eventId1: { params, handler }, eventId2: { params, handlers } }
-	// this allows us to easily access the handlers after receiving a batch response
-	private _bufferToMap(buffer: EventBuffer) {
-		return buffer.reduce((acc, curVal) => {
-			const [[key, value]] = Object.entries(curVal);
-			acc[key] = value;
-			return acc;
-		}, {});
-	}
-}

package/src/Providers/index.ts

@@ -1,6 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-export { AWSPinpointProvider } from './AWSPinpointProvider';
-export { AWSKinesisProvider } from './AWSKinesisProvider';
-export { AWSKinesisFirehoseProvider } from './AWSKinesisFirehoseProvider';
-export { AmazonPersonalizeProvider } from './AmazonPersonalizeProvider';