@aws-amplify/analytics 7.0.1-console-preview.11cf989.0 → 7.0.1-console-preview.4ae78ed.0

package/src/providers/kinesis-firehose/apis/record.ts

@@ -2,7 +2,52 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { RecordInput } from '../types';
+import { getEventBuffer, resolveConfig } from '../utils';
+import {
+	getAnalyticsUserAgentString,
+	isAnalyticsEnabled,
+	resolveCredentials,
+} from '../../../utils';
+import { fromUtf8 } from '@smithy/util-utf8';
+import {
+	AnalyticsAction,
+	ConsoleLogger as Logger,
+} from '@aws-amplify/core/internals/utils';
 
-export const record = (input: RecordInput): void => {
-	throw new Error('Not Yet Implemented');
+const logger = new Logger('KinesisFirehose');
+
+export const record = ({ streamName, data }: RecordInput): void => {
+	if (!isAnalyticsEnabled()) {
+		logger.debug('Analytics is disabled, event will not be recorded.');
+		return;
+	}
+
+	const timestamp = Date.now();
+	const { region, bufferSize, flushSize, flushInterval, resendLimit } =
+		resolveConfig();
+
+	resolveCredentials()
+		.then(({ credentials, identityId }) => {
+			const buffer = getEventBuffer({
+				region,
+				credentials,
+				identityId,
+				bufferSize,
+				flushSize,
+				flushInterval,
+				resendLimit,
+				userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+			});
+
+			buffer.append({
+				region,
+				streamName,
+				event: ArrayBuffer.isView(data) ? data : fromUtf8(JSON.stringify(data)),
+				timestamp,
+				retryCount: 0,
+			});
+		})
+		.catch(e => {
+			logger.warn('Failed to record event.', e);
+		});
 };

package/src/providers/kinesis-firehose/index.ts

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { record } from './apis';
+export { record, flushEvents } from './apis';

package/src/providers/kinesis-firehose/types/buffer.ts

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EventBufferConfig } from '../../../utils';
+import { KinesisStream } from '../../../types';
+import { Credentials } from '@aws-sdk/types';
+
+export type KinesisFirehoseBufferEvent = KinesisStream & {
+	event: Uint8Array;
+	retryCount: number;
+	timestamp: number;
+};
+
+export type KinesisFirehoseEventBufferConfig = EventBufferConfig & {
+	region: string;
+	credentials: Credentials;
+	identityId?: string;
+	resendLimit?: number;
+	userAgentValue?: string;
+};

package/src/providers/kinesis-firehose/types/index.ts

@@ -2,3 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { RecordInput } from './inputs';
+
+export {
+	KinesisFirehoseBufferEvent,
+	KinesisFirehoseEventBufferConfig,
+} from './buffer';

package/src/providers/kinesis-firehose/types/inputs.ts

@@ -1,4 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export type RecordInput = {};
+import { KinesisEventData } from '../../../types';
+
+export type RecordInput = {
+	streamName: string;
+	data: KinesisEventData;
+};

package/src/providers/kinesis-firehose/utils/constants.ts

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export const DEFAULT_KINESIS_FIREHOSE_CONFIG = {
+	bufferSize: 1_000,
+	flushSize: 100,
+	flushInterval: 5_000,
+	resendLimit: 5,
+};

package/src/providers/kinesis-firehose/utils/getEventBuffer.ts

@@ -0,0 +1,118 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EventBuffer, groupBy, IAnalyticsClient } from '../../../utils';
+import {
+	FirehoseClient,
+	PutRecordBatchCommand,
+} from '@aws-sdk/client-firehose';
+import {
+	KinesisFirehoseBufferEvent,
+	KinesisFirehoseEventBufferConfig,
+} from '../types';
+
+/**
+ * These Records hold cached event buffers and AWS clients.
+ * The hash key is determined by the region and session,
+ * consisting of a combined value comprising [region, sessionToken, identityId].
+ *
+ * Only one active session should exist at any given moment.
+ * When a new session is initiated, the previous ones should be released.
+ * */
+const eventBufferMap: Record<
+	string,
+	EventBuffer<KinesisFirehoseBufferEvent>
+> = {};
+const cachedClients: Record<string, FirehoseClient> = {};
+
+const createPutRecordsBatchCommand = (
+	streamName: string,
+	events: KinesisFirehoseBufferEvent[]
+): PutRecordBatchCommand =>
+	new PutRecordBatchCommand({
+		DeliveryStreamName: streamName,
+		Records: events.map(event => ({
+			Data: event.event,
+		})),
+	});
+
+const submitEvents = async (
+	events: KinesisFirehoseBufferEvent[],
+	client: FirehoseClient,
+	resendLimit?: number
+): Promise<KinesisFirehoseBufferEvent[]> => {
+	const groupedByStreamName = Object.entries(
+		groupBy(event => event.streamName, events)
+	);
+
+	const requests = groupedByStreamName
+		.map(([streamName, events]) =>
+			createPutRecordsBatchCommand(streamName, events)
+		)
+		.map(command => client.send(command));
+
+	const responses = await Promise.allSettled(requests);
+	const failedEvents = responses
+		.map((response, i) =>
+			response.status === 'rejected' ? groupedByStreamName[i][1] : []
+		)
+		.flat();
+	return resendLimit
+		? failedEvents
+				.filter(event => event.retryCount < resendLimit)
+				.map(event => ({ ...event, retryCount: event.retryCount + 1 }))
+				.sort((a, b) => a.timestamp - b.timestamp)
+		: [];
+};
+
+export const getEventBuffer = ({
+	region,
+	credentials,
+	identityId,
+	bufferSize,
+	flushSize,
+	flushInterval,
+	resendLimit,
+	userAgentValue,
+}: KinesisFirehoseEventBufferConfig): EventBuffer<KinesisFirehoseBufferEvent> => {
+	const { sessionToken } = credentials;
+	const sessionIdentityKey = [region, sessionToken, identityId]
+		.filter(id => !!id)
+		.join('-');
+
+	if (!eventBufferMap[sessionIdentityKey]) {
+		const getClient = (): IAnalyticsClient<KinesisFirehoseBufferEvent> => {
+			if (!cachedClients[sessionIdentityKey]) {
+				cachedClients[sessionIdentityKey] = new FirehoseClient({
+					region,
+					credentials,
+					customUserAgent: userAgentValue,
+				});
+			}
+
+			const firehoseClient = cachedClients[sessionIdentityKey];
+			return events => submitEvents(events, firehoseClient, resendLimit);
+		};
+
+		eventBufferMap[sessionIdentityKey] =
+			new EventBuffer<KinesisFirehoseBufferEvent>(
+				{
+					bufferSize,
+					flushSize,
+					flushInterval,
+				},
+				getClient
+			);
+
+		const releaseSessionKeys = Object.keys(eventBufferMap).filter(
+			key => key !== sessionIdentityKey
+		);
+		for (const releaseSessionKey of releaseSessionKeys) {
+			eventBufferMap[releaseSessionKey].release();
+			delete eventBufferMap[releaseSessionKey];
+			delete cachedClients[releaseSessionKey];
+		}
+	}
+
+	return eventBufferMap[sessionIdentityKey];
+};

package/src/providers/kinesis-firehose/utils/index.ts

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { getEventBuffer } from './getEventBuffer';
+export { resolveConfig } from './resolveConfig';

package/src/providers/kinesis-firehose/utils/resolveConfig.ts

@@ -0,0 +1,36 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Amplify } from '@aws-amplify/core';
+import {
+	AnalyticsValidationErrorCode,
+	assertValidationError,
+} from '../../../errors';
+import { DEFAULT_KINESIS_FIREHOSE_CONFIG } from './constants';
+
+export const resolveConfig = () => {
+	const config = Amplify.getConfig().Analytics?.KinesisFirehose;
+	const {
+		region,
+		bufferSize = DEFAULT_KINESIS_FIREHOSE_CONFIG.bufferSize,
+		flushSize = DEFAULT_KINESIS_FIREHOSE_CONFIG.flushSize,
+		flushInterval = DEFAULT_KINESIS_FIREHOSE_CONFIG.flushInterval,
+		resendLimit,
+	} = {
+		...DEFAULT_KINESIS_FIREHOSE_CONFIG,
+		...config,
+	};
+
+	assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
+	assertValidationError(
+		flushSize < bufferSize,
+		AnalyticsValidationErrorCode.InvalidFlushSize
+	);
+	return {
+		region,
+		bufferSize,
+		flushSize,
+		flushInterval,
+		resendLimit,
+	};
+};

package/src/providers/personalize/apis/flushEvents.ts

@@ -0,0 +1,39 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { getEventBuffer, resolveConfig } from '../utils';
+import {
+	getAnalyticsUserAgentString,
+	resolveCredentials,
+} from '../../../utils';
+import {
+	AnalyticsAction,
+	ConsoleLogger,
+} from '@aws-amplify/core/internals/utils';
+
+const logger = new ConsoleLogger('Personalize');
+
+/**
+ * Flushes all buffered Personalize events to the service.
+ *
+ * @note
+ * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
+ * this API may not be included in the flush.
+ */
+export const flushEvents = () => {
+	const { region, flushSize, bufferSize, flushInterval } = resolveConfig();
+	resolveCredentials()
+		.then(({ credentials, identityId }) =>
+			getEventBuffer({
+				region,
+				flushSize,
+				flushInterval,
+				bufferSize,
+				credentials,
+				identityId,
+				userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+			})
+		)
+		.then(eventBuffer => eventBuffer.flushAll())
+		.catch(e => logger.warn('Failed to flush events', e));
+};

package/src/providers/personalize/apis/index.ts

@@ -2,3 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { record } from './record';
+export { flushEvents } from './flushEvents';

package/src/providers/personalize/apis/record.ts

@@ -2,7 +2,103 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { RecordInput } from '../types';
+import {
+	autoTrackMedia,
+	getEventBuffer,
+	resolveCachedSession,
+	resolveConfig,
+	updateCachedSession,
+} from '../utils';
+import {
+	getAnalyticsUserAgentString,
+	isAnalyticsEnabled,
+	resolveCredentials,
+} from '../../../utils';
+import {
+	AnalyticsAction,
+	ConsoleLogger,
+} from '@aws-amplify/core/internals/utils';
+import {
+	IDENTIFY_EVENT_TYPE,
+	MEDIA_AUTO_TRACK_EVENT_TYPE,
+} from '../utils/constants';
 
-export const record = (input: RecordInput): void => {
-	throw new Error('Not Yet Implemented');
+const logger = new ConsoleLogger('Personalize');
+
+export const record = ({
+	userId,
+	eventId,
+	eventType,
+	properties,
+}: RecordInput): void => {
+	if (!isAnalyticsEnabled()) {
+		logger.debug('Analytics is disabled, event will not be recorded.');
+		return;
+	}
+
+	const { region, trackingId, bufferSize, flushSize, flushInterval } =
+		resolveConfig();
+	resolveCredentials()
+		.then(({ credentials, identityId }) => {
+			const timestamp = Date.now();
+			const { sessionId: cachedSessionId, userId: cachedUserId } =
+				resolveCachedSession(trackingId);
+			if (eventType === IDENTIFY_EVENT_TYPE) {
+				updateCachedSession(
+					typeof properties.userId === 'string' ? properties.userId : '',
+					cachedSessionId,
+					cachedUserId
+				);
+			} else if (!!userId) {
+				updateCachedSession(userId, cachedSessionId, cachedUserId);
+			}
+
+			const { sessionId: updatedSessionId, userId: updatedUserId } =
+				resolveCachedSession(trackingId);
+
+			const eventBuffer = getEventBuffer({
+				region,
+				flushSize,
+				flushInterval,
+				bufferSize,
+				credentials,
+				identityId,
+				userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+			});
+
+			if (eventType === MEDIA_AUTO_TRACK_EVENT_TYPE) {
+				autoTrackMedia(
+					{
+						trackingId,
+						sessionId: updatedSessionId,
+						userId: updatedUserId,
+						event: {
+							eventId,
+							eventType,
+							properties,
+						},
+					},
+					eventBuffer
+				);
+			} else {
+				eventBuffer.append({
+					trackingId,
+					sessionId: updatedSessionId,
+					userId: updatedUserId,
+					event: {
+						eventId,
+						eventType,
+						properties,
+					},
+					timestamp,
+				});
+			}
+
+			if (eventBuffer.length >= bufferSize) {
+				eventBuffer.flushAll();
+			}
+		})
+		.catch(e => {
+			logger.warn('Failed to record event.', e);
+		});
 };

package/src/providers/personalize/index.ts

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { record } from './apis';
+export { record, flushEvents } from './apis';

package/src/providers/personalize/types/buffer.ts

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PersonalizeEvent } from './';
+import { EventBufferConfig } from '../../../utils';
+import { Credentials } from '@aws-sdk/types';
+
+export type PersonalizeBufferEvent = {
+	trackingId: string;
+	sessionId?: string;
+	userId?: string;
+	event: PersonalizeEvent;
+	timestamp: number;
+};
+
+export type PersonalizeBufferConfig = EventBufferConfig & {
+	region: string;
+	credentials: Credentials;
+	identityId?: string;
+	userAgentValue?: string;
+};

package/src/providers/personalize/types/index.ts

@@ -1,4 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { RecordInput } from './inputs';
+export { RecordInput, PersonalizeEvent } from './inputs';
+export { PersonalizeBufferEvent, PersonalizeBufferConfig } from './buffer';

package/src/providers/personalize/types/inputs.ts

@@ -1,4 +1,11 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export type RecordInput = {};
+export type PersonalizeEvent = {
+	userId?: string;
+	eventId?: string;
+	eventType: string;
+	properties: Record<string, unknown>;
+};
+
+export type RecordInput = PersonalizeEvent;