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

package/lib-esm/types/index.d.ts

@@ -1,3 +1,4 @@
 export { AutoTrackAttributes, AutoTrackEventOpts, AutoTrackPageViewOpts, AutoTrackSessionOpts, EventAttributes, EventMetrics, EventTrackOpts, PageViewTrackOpts, SessionTrackOpts, } from './analytics';
 export { AnalyticsServiceOptions } from './options';
 export { AnalyticsIdentifyUserInput } from './inputs';
+export { KinesisStream, KinesisShard, KinesisEventData } from './kinesis';

package/lib-esm/types/kinesis.d.ts

@@ -0,0 +1,8 @@
+export type KinesisStream = {
+    region: string;
+    streamName: string;
+};
+export type KinesisShard = KinesisStream & {
+    partitionKey: string;
+};
+export type KinesisEventData = Record<string, unknown> | Uint8Array;

package/lib-esm/types/kinesis.js

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

package/lib-esm/utils/eventBuffer/EventBuffer.d.ts

@@ -0,0 +1,16 @@
+import { EventBufferConfig, IAnalyticsClient } from './';
+export declare class EventBuffer<T> {
+    private list;
+    private readonly config;
+    private getAnalyticsClient;
+    private timer?;
+    constructor(config: EventBufferConfig, getAnalyticsClient: () => IAnalyticsClient<T>);
+    append(...events: T[]): void;
+    flushAll(): Promise<void>;
+    release(): void;
+    get length(): number;
+    private head;
+    private insertAtBeginning;
+    private startEventLoop;
+    private submitEvents;
+}

package/lib-esm/utils/eventBuffer/EventBuffer.js

@@ -0,0 +1,88 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __read, __spreadArray, __values } from "tslib";
+import { ConsoleLogger } from '@aws-amplify/core/internals/utils';
+var logger = new ConsoleLogger('EventBuffer');
+var EventBuffer = /** @class */ (function () {
+    function EventBuffer(config, getAnalyticsClient) {
+        this.list = [];
+        this.config = config;
+        this.getAnalyticsClient = getAnalyticsClient;
+        this.startEventLoop();
+    }
+    EventBuffer.prototype.append = function () {
+        var e_1, _a;
+        var events = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            events[_i] = arguments[_i];
+        }
+        try {
+            for (var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
+                var event_1 = events_1_1.value;
+                if (this.list.length + 1 > this.config.bufferSize) {
+                    logger.debug("Exceed ".concat(typeof event_1, " event buffer limits, event dropped"));
+                    continue;
+                }
+                this.list.push(event_1);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    EventBuffer.prototype.flushAll = function () {
+        return this.submitEvents(this.list.length);
+    };
+    EventBuffer.prototype.release = function () {
+        this.list = [];
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+    };
+    Object.defineProperty(EventBuffer.prototype, "length", {
+        get: function () {
+            return this.list.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EventBuffer.prototype.head = function (count) {
+        return this.list.splice(0, count);
+    };
+    EventBuffer.prototype.insertAtBeginning = function () {
+        var _a;
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        (_a = this.list).unshift.apply(_a, __spreadArray([], __read(data), false));
+    };
+    EventBuffer.prototype.startEventLoop = function () {
+        var _this = this;
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        var _a = this.config, flushSize = _a.flushSize, flushInterval = _a.flushInterval;
+        setInterval(function () {
+            _this.submitEvents(flushSize);
+        }, flushInterval);
+    };
+    EventBuffer.prototype.submitEvents = function (count) {
+        var _this = this;
+        var events = this.head(count);
+        if (events.length === 0) {
+            return Promise.resolve();
+        }
+        return this.getAnalyticsClient()(events).then(function (result) {
+            if (result.length > 0) {
+                _this.insertAtBeginning.apply(_this, __spreadArray([], __read(result), false));
+            }
+        });
+    };
+    return EventBuffer;
+}());
+export { EventBuffer };

package/lib-esm/utils/eventBuffer/index.d.ts

@@ -0,0 +1,2 @@
+export { EventBuffer } from './EventBuffer';
+export { EventBufferConfig, IAnalyticsClient } from './types';

package/lib-esm/utils/eventBuffer/index.js

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

package/lib-esm/utils/eventBuffer/types.d.ts

@@ -0,0 +1,8 @@
+export interface IAnalyticsClient<T> {
+    (events: T[]): Promise<T[]>;
+}
+export type EventBufferConfig = {
+    flushSize: number;
+    flushInterval: number;
+    bufferSize: number;
+};

package/lib-esm/utils/eventBuffer/types.js

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

package/lib-esm/utils/groupBy.d.ts

@@ -0,0 +1 @@
+export declare const groupBy: <T>(getGroupId: (x: T) => string, list: T[]) => Record<string, T[]>;

package/lib-esm/utils/groupBy.js

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __assign, __read, __spreadArray } from "tslib";
+export var groupBy = function (getGroupId, list) {
+    return list.reduce(function (result, current) {
+        var _a;
+        var _b;
+        var groupId = getGroupId(current);
+        return __assign(__assign({}, result), (_a = {}, _a[groupId] = __spreadArray(__spreadArray([], __read(((_b = result[groupId]) !== null && _b !== void 0 ? _b : [])), false), [current], false), _a));
+    }, {});
+};

package/lib-esm/utils/index.d.ts

@@ -1,2 +1,5 @@
+export { resolveCredentials } from './resolveCredentials';
+export { groupBy } from './groupBy';
+export { EventBuffer, IAnalyticsClient, EventBufferConfig, } from './eventBuffer';
 export { enableAnalytics, disableAnalytics, isAnalyticsEnabled, } from './statusHelpers';
 export { getAnalyticsUserAgent, getAnalyticsUserAgentString, } from './userAgent';

package/lib-esm/utils/index.js

@@ -1,4 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+export { resolveCredentials } from './resolveCredentials';
+export { groupBy } from './groupBy';
+export { EventBuffer, } from './eventBuffer';
 export { enableAnalytics, disableAnalytics, isAnalyticsEnabled, } from './statusHelpers';
 export { getAnalyticsUserAgent, getAnalyticsUserAgentString, } from './userAgent';

package/lib-esm/utils/resolveCredentials.d.ts

@@ -0,0 +1,9 @@
+export declare const resolveCredentials: () => Promise<{
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string | undefined;
+        expiration?: Date | undefined;
+    };
+    identityId: string | undefined;
+}>;

package/lib-esm/utils/resolveCredentials.js

@@ -0,0 +1,17 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+import { AnalyticsValidationErrorCode, assertValidationError } from '../errors';
+import { fetchAuthSession } from '@aws-amplify/core';
+export var resolveCredentials = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, credentials, identityId;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, fetchAuthSession()];
+            case 1:
+                _a = _b.sent(), credentials = _a.credentials, identityId = _a.identityId;
+                assertValidationError(!!credentials, AnalyticsValidationErrorCode.NoCredentials);
+                return [2 /*return*/, { credentials: credentials, identityId: identityId }];
+        }
+    });
+}); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/analytics",
-  "version": "7.0.1-console-preview.11cf989.0+11cf989",
+  "version": "7.0.1-console-preview.4ae78ed.0+4ae78ed",
   "description": "Analytics category of aws-amplify",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -96,14 +96,15 @@
     "uuid": "^9.0.0"
   },
   "peerDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.11cf989.0+11cf989"
+    "@aws-amplify/core": "6.0.1-console-preview.4ae78ed.0+4ae78ed"
   },
   "devDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.11cf989.0+11cf989",
+    "@aws-amplify/core": "6.0.1-console-preview.4ae78ed.0+4ae78ed",
     "@aws-sdk/client-firehose": "3.398.0",
     "@aws-sdk/client-kinesis": "3.398.0",
     "@aws-sdk/client-personalize-events": "3.398.0",
     "@aws-sdk/types": "3.398.0",
+    "@smithy/util-utf8": "2.0.0",
     "@types/uuid": "^9.0.0",
     "typescript": "5.0.2"
   },
@@ -151,5 +152,5 @@
       "<rootDir>/src/setupTests.ts"
     ]
   },
-  "gitHead": "11cf9890e0229d7f36a7b2375e57bc0decf9935a"
+  "gitHead": "4ae78ed23fc03ae718488c98fc48782d2bd6f5f3"
 }

package/src/errors/assertValidationError.ts

@@ -9,11 +9,17 @@ import { AnalyticsValidationErrorCode, validationErrorMap } from './validation';
  */
 export function assertValidationError(
 	assertion: boolean,
-	name: AnalyticsValidationErrorCode
+	name: AnalyticsValidationErrorCode,
+	message?: string
 ): asserts assertion {
-	const { message, recoverySuggestion } = validationErrorMap[name];
+	const { message: defaultMessage, recoverySuggestion } =
+		validationErrorMap[name];
 
 	if (!assertion) {
-		throw new AnalyticsError({ name, message, recoverySuggestion });
+		throw new AnalyticsError({
+			name,
+			message: message ?? defaultMessage,
+			recoverySuggestion,
+		});
 	}
 }

package/src/errors/validation.ts

@@ -8,6 +8,8 @@ export enum AnalyticsValidationErrorCode {
 	NoCredentials = 'NoCredentials',
 	NoEventName = 'NoEventName',
 	NoRegion = 'NoRegion',
+	NoTrackingId = 'NoTrackingId',
+	InvalidFlushSize = 'InvalidFlushSize',
 }
 
 export const validationErrorMap: AmplifyErrorMap<AnalyticsValidationErrorCode> =
@@ -24,4 +26,10 @@ export const validationErrorMap: AmplifyErrorMap<AnalyticsValidationErrorCode> =
 		[AnalyticsValidationErrorCode.NoRegion]: {
 			message: 'Missing region.',
 		},
+		[AnalyticsValidationErrorCode.InvalidFlushSize]: {
+			message: 'Invalid FlushSize, it should be smaller than BufferSize',
+		},
+		[AnalyticsValidationErrorCode.NoTrackingId]: {
+			message: 'A trackingId is required to use Amazon Personalize',
+		},
 	};

package/src/index.ts

@@ -6,6 +6,7 @@ export {
 	identifyUser,
 	RecordInput,
 	IdentifyUserInput,
+	flushEvents,
 } from './providers/pinpoint';
 export { enable, disable } from './apis';
 export { AnalyticsError } from './errors';

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

@@ -0,0 +1,42 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { resolveConfig } from '../utils/resolveConfig';
+import {
+	getAnalyticsUserAgentString,
+	resolveCredentials,
+} from '../../../utils';
+import { getEventBuffer } from '../utils/getEventBuffer';
+import {
+	AnalyticsAction,
+	ConsoleLogger,
+} from '@aws-amplify/core/internals/utils';
+
+const logger = new ConsoleLogger('Kinesis');
+
+/**
+ * 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/apis/index.ts

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

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

@@ -2,7 +2,59 @@
 // 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,
+	ConsoleLogger,
+} from '@aws-amplify/core/internals/utils';
 
-export const record = (input: RecordInput): void => {
-	throw new Error('Not Yet Implemented!');
+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

@@ -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/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 { Credentials } from '@aws-sdk/types';
+import { KinesisShard } from '../../../types';
+
+export type KinesisBufferEvent = KinesisShard & {
+	event: Uint8Array;
+	timestamp: number;
+	retryCount: number;
+};
+
+export type KinesisEventBufferConfig = EventBufferConfig & {
+	region: string;
+	credentials: Credentials;
+	identityId?: string;
+	resendLimit?: number;
+	userAgentValue?: string;
+};

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

@@ -2,3 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { RecordInput } from './inputs';
+export { KinesisBufferEvent, KinesisEventBufferConfig } from './buffer';

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

@@ -1,4 +1,10 @@
 // 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;
+	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,41 @@
+// 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('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

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