@aws-amplify/analytics 7.0.1-preview-testing.034e780.0 → 7.0.1-server-generate-client.1e317a1.0

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

@@ -0,0 +1,58 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { RecordInput } from '../types';
+import { getEventBuffer } from '../utils/getEventBuffer';
+import { resolveConfig } from '../utils/resolveConfig';
+import {
+	getAnalyticsUserAgentString,
+	isAnalyticsEnabled,
+	resolveCredentials,
+} from '../../../utils';
+import { fromUtf8 } from '@smithy/util-utf8';
+import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+
+const logger = new ConsoleLogger('Kinesis');
+
+export const record = ({
+	streamName,
+	partitionKey,
+	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,
+				bufferSize,
+				flushSize,
+				flushInterval,
+				credentials,
+				identityId,
+				resendLimit,
+				userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+			});
+
+			buffer.append({
+				region,
+				streamName,
+				partitionKey,
+				event: ArrayBuffer.isView(data) ? data : fromUtf8(JSON.stringify(data)),
+				timestamp,
+				retryCount: 0,
+			});
+		})
+		.catch(e => {
+			// An error occured while fetching credentials or persisting the event to the buffer
+			logger.warn('Failed to record event.', e);
+		});
+};

package/src/providers/kinesis/index.ts

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

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

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

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

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

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

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

package/src/providers/kinesis/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_CONFIG = {
+	bufferSize: 1_000,
+	flushSize: 100,
+	flushInterval: 5_000,
+	resendLimit: 5,
+};

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

@@ -0,0 +1,110 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { KinesisBufferEvent, KinesisEventBufferConfig } from '../types';
+import { EventBuffer, groupBy, IAnalyticsClient } from '../../../utils';
+import { KinesisClient, PutRecordsCommand } from '@aws-sdk/client-kinesis';
+
+/**
+ * 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<KinesisBufferEvent>> = {};
+const cachedClients: Record<string, KinesisClient> = {};
+
+const createKinesisPutRecordsCommand = (
+	streamName: string,
+	events: KinesisBufferEvent[]
+): PutRecordsCommand =>
+	new PutRecordsCommand({
+		StreamName: streamName,
+		Records: events.map(event => ({
+			PartitionKey: event.partitionKey,
+			Data: event.event,
+		})),
+	});
+
+const submitEvents = async (
+	events: KinesisBufferEvent[],
+	client: KinesisClient,
+	resendLimit?: number
+): Promise<KinesisBufferEvent[]> => {
+	const groupedByStreamName = Object.entries(
+		groupBy(event => event.streamName, events)
+	);
+	const requests = groupedByStreamName
+		.map(([streamName, events]) =>
+			createKinesisPutRecordsCommand(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,
+	flushInterval,
+	flushSize,
+	bufferSize,
+	credentials,
+	identityId,
+	resendLimit,
+	userAgentValue,
+}: KinesisEventBufferConfig): EventBuffer<KinesisBufferEvent> => {
+	const { sessionToken } = credentials;
+	const sessionIdentityKey = [region, sessionToken, identityId]
+		.filter(x => !!x)
+		.join('-');
+
+	if (!eventBufferMap[sessionIdentityKey]) {
+		const getKinesisClient = (): IAnalyticsClient<KinesisBufferEvent> => {
+			if (!cachedClients[sessionIdentityKey]) {
+				cachedClients[sessionIdentityKey] = new KinesisClient({
+					credentials,
+					region,
+					customUserAgent: userAgentValue,
+				});
+			}
+
+			return events =>
+				submitEvents(events, cachedClients[sessionIdentityKey], resendLimit);
+		};
+
+		// create new session
+		eventBufferMap[sessionIdentityKey] = new EventBuffer<KinesisBufferEvent>(
+			{
+				flushInterval,
+				flushSize,
+				bufferSize,
+			},
+			getKinesisClient
+		);
+
+		// release other sessions
+		const releaseSessionKeys = Object.keys(eventBufferMap).filter(
+			x => x !== sessionIdentityKey
+		);
+		for (const releaseSessionKey of releaseSessionKeys) {
+			eventBufferMap[releaseSessionKey].release();
+			delete eventBufferMap[releaseSessionKey];
+			delete cachedClients[releaseSessionKey];
+		}
+	}
+
+	return eventBufferMap[sessionIdentityKey];
+};

package/src/providers/kinesis/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_CONFIG } from './constants';
+
+export const resolveConfig = () => {
+	const config = Amplify.getConfig().Analytics?.Kinesis;
+	const {
+		region,
+		bufferSize = DEFAULT_KINESIS_CONFIG.bufferSize,
+		flushSize = DEFAULT_KINESIS_CONFIG.flushSize,
+		flushInterval = DEFAULT_KINESIS_CONFIG.flushInterval,
+		resendLimit,
+	} = {
+		...DEFAULT_KINESIS_CONFIG,
+		...config,
+	};
+
+	assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
+	assertValidationError(
+		flushSize < bufferSize,
+		AnalyticsValidationErrorCode.InvalidFlushSize
+	);
+	return {
+		region,
+		bufferSize,
+		flushSize,
+		flushInterval,
+		resendLimit,
+	};
+};

package/src/providers/kinesis-firehose/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 } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+
+const logger = new ConsoleLogger('KinesisFirehose');
+
+/**
+ * Flushes all buffered Kinesis 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, flushInterval, bufferSize, resendLimit } =
+		resolveConfig();
+	resolveCredentials()
+		.then(({ credentials, identityId }) =>
+			getEventBuffer({
+				region,
+				flushSize,
+				flushInterval,
+				bufferSize,
+				credentials,
+				identityId,
+				resendLimit,
+				userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+			})
+		)
+		.then(eventBuffer => eventBuffer.flushAll())
+		.catch(e => logger.warn('Failed to flush events.', e));
+};

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

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

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

@@ -0,0 +1,51 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// 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 } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+
+const logger = new ConsoleLogger('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

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+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 { AWSCredentials } from '@aws-amplify/core/internals/utils';
+
+export type KinesisFirehoseBufferEvent = KinesisStream & {
+	event: Uint8Array;
+	retryCount: number;
+	timestamp: number;
+};
+
+export type KinesisFirehoseEventBufferConfig = EventBufferConfig & {
+	region: string;
+	credentials: AWSCredentials;
+	identityId?: string;
+	resendLimit?: number;
+	userAgentValue?: string;
+};

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

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { RecordInput } from './inputs';
+
+export {
+	KinesisFirehoseBufferEvent,
+	KinesisFirehoseEventBufferConfig,
+} from './buffer';

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

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+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,37 @@
+// 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 } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+
+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

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