@aws-amplify/core 4.3.14 → 4.3.15-cloud-logging.10

package/src/Providers/AWSCloudWatchProvider.ts

@@ -39,6 +39,7 @@ import {
 	AWSCloudWatchProviderOptions,
 	CloudWatchDataTracker,
 	LoggingProvider,
+	AmplifyConfigure,
 } from '../types/types';
 import { Credentials } from '../..';
 import { ConsoleLogger as Logger } from '../Logger';
@@ -54,8 +55,15 @@ import {
 	RETRY_ERROR_CODES,
 } from '../Util/Constants';
 
-const logger = new Logger('AWSCloudWatch');
+if (
+	typeof window === 'undefined' ||
+	(typeof window === 'object' && !window.TextEncoder)
+) {
+	require('fast-text-encoding');
+}
 
+const logger = new Logger('AWSCloudWatch');
+const INTERVAL = 10000;
 class AWSCloudWatchProvider implements LoggingProvider {
 	static readonly PROVIDER_NAME = AWS_CLOUDWATCH_PROVIDER_NAME;
 	static readonly CATEGORY = AWS_CLOUDWATCH_CATEGORY;
@@ -65,15 +73,25 @@ class AWSCloudWatchProvider implements LoggingProvider {
 	private _currentLogBatch: InputLogEvent[];
 	private _timer;
 	private _nextSequenceToken: string | undefined;
+	private _processing: boolean;
+	private _initialized = false;
+	private _preFlightCheck: () => Promise<boolean>;
+
+	constructor(config?: AmplifyConfigure) {
+		console.log('cstr', config);
+		if (!this._initialized) {
+			this.configure(config);
+
+			this._dataTracker = {
+				eventUploadInProgress: false,
+				logEvents: [],
+				verifiedLogGroup: { logGroupName: this._config.logGroupName },
+			};
 
-	constructor(config?: AWSCloudWatchProviderOptions) {
-		this.configure(config);
-		this._dataTracker = {
-			eventUploadInProgress: false,
-			logEvents: [],
-		};
-		this._currentLogBatch = [];
-		this._initiateLogPushInterval();
+			this._currentLogBatch = [];
+			this._initiateLogPushInterval();
+			this._initialized = true;
+		}
 	}
 
 	public getProviderName(): string {
@@ -88,9 +106,13 @@ class AWSCloudWatchProvider implements LoggingProvider {
 		return this._dataTracker.logEvents;
 	}
 
-	public configure(
-		config?: AWSCloudWatchProviderOptions
-	): AWSCloudWatchProviderOptions {
+	public setPreFlightCheck(cb): void {
+		if (typeof cb === 'function') {
+			this._preFlightCheck = cb;
+		}
+	}
+
+	public configure(config?: AmplifyConfigure): AWSCloudWatchProviderOptions {
 		if (!config) return this._config || {};
 
 		const conf = Object.assign(
@@ -217,8 +239,25 @@ class AWSCloudWatchProvider implements LoggingProvider {
 	}
 
 	public pushLogs(logs: InputLogEvent[]): void {
-		logger.debug('pushing log events to Cloudwatch...');
-		this._dataTracker.logEvents = [...this._dataTracker.logEvents, ...logs];
+		logger.debug('pushing log events to buffer');
+		this._dataTracker.logEvents = this._dataTracker.logEvents.concat(logs);
+	}
+
+	public pause() {
+		this._processing = false;
+		if (this._timer) {
+			clearInterval(this._timer);
+		}
+	}
+
+	public resume() {
+		this._processing = true;
+		this._initiateLogPushInterval();
+	}
+
+	public clear() {
+		this._dataTracker.logEvents = [];
+		this._currentLogBatch = [];
 	}
 
 	private async _validateLogGroupExistsAndCreate(
@@ -394,6 +433,11 @@ class AWSCloudWatchProvider implements LoggingProvider {
 			 * We also need to ensure that the logs in the batch are sorted in chronological order.
 			 * https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html
 			 */
+			if (!(await this._preFlightCheck())) {
+				this.clear();
+				return;
+			}
+
 			const seqToken = await this._getNextSequenceToken();
 			const logBatch =
 				this._currentLogBatch.length === 0
@@ -431,6 +475,47 @@ class AWSCloudWatchProvider implements LoggingProvider {
 		}
 	}
 
+	private truncateOversizedEvent(event) {
+		const { timestamp, message } = event;
+		let messageJson;
+		try {
+			messageJson = JSON.parse(message);
+
+			const truncated = JSON.stringify({
+				level: messageJson.level,
+				class: messageJson.class,
+				message: messageJson.message.substring(0, 500),
+			});
+
+			if (messageJson.data != null) {
+				truncated[
+					'data'
+				] = `OBJECT SIZE EXCEEDS CLOUDWATCH EVENT LIMIT. Truncated: ${JSON.stringify(
+					messageJson.data
+				).substring(0, 500)}`;
+			}
+
+			return {
+				timestamp,
+				message: truncated,
+			};
+		} catch (error) {
+			logger.warn('Could not minify oversized event', error);
+
+			const truncated = JSON.stringify({
+				level: 'UNKNOWN',
+				class: 'Unknown',
+				message:
+					'OBJECT SIZE EXCEEDS CLOUDWATCH EVENT LIMIT. Could not parse event to truncate',
+			});
+
+			return {
+				timestamp,
+				message: truncated,
+			};
+		}
+	}
+
 	private _getBufferedBatchOfLogs(): InputLogEvent[] {
 		/**
 		 * CloudWatch has restrictions on the size of the log events that get sent up.
@@ -444,20 +529,28 @@ class AWSCloudWatchProvider implements LoggingProvider {
 		let totalByteSize = 0;
 
 		while (currentEventIdx < this._dataTracker.logEvents.length) {
-			const currentEvent = this._dataTracker.logEvents[currentEventIdx];
-			const eventSize = currentEvent
+			let currentEvent = this._dataTracker.logEvents[currentEventIdx];
+
+			let eventSize = currentEvent
 				? new TextEncoder().encode(currentEvent.message).length +
 				  AWS_CLOUDWATCH_BASE_BUFFER_SIZE
 				: 0;
+
 			if (eventSize > AWS_CLOUDWATCH_MAX_EVENT_SIZE) {
 				const errString = `Log entry exceeds maximum size for CloudWatch logs. Log size: ${eventSize}. Truncating log message.`;
 				logger.warn(errString);
 
-				currentEvent.message = currentEvent.message.substring(0, eventSize);
+				currentEvent = this.truncateOversizedEvent(currentEvent);
+				this._dataTracker.logEvents[currentEventIdx] = currentEvent;
+
+				eventSize =
+					new TextEncoder().encode(currentEvent.message).length +
+					AWS_CLOUDWATCH_BASE_BUFFER_SIZE;
 			}
 
 			if (totalByteSize + eventSize > AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE)
 				break;
+
 			totalByteSize += eventSize;
 			currentEventIdx++;
 		}
@@ -509,8 +602,9 @@ class AWSCloudWatchProvider implements LoggingProvider {
 				logger.error(
 					`error when calling _safeUploadLogEvents in the timer interval - ${err}`
 				);
+				this.pause();
 			}
-		}, 2000);
+		}, INTERVAL);
 	}
 
 	private _getDocUploadPermissibility(): boolean {

package/src/Providers/AmazonKinesisLoggingProvider.ts

@@ -0,0 +1,43 @@
+import { AmazonKinesisLoggerOptions, LoggingProvider } from '../types/types';
+import { ConsoleLogger as Logger } from '../Logger';
+import {
+	AMAZON_KINESIS_LOGGING_PROVIDER_NAME,
+	AMAZON_KINESIS_LOGGING_CATEGORY,
+	NO_CREDS_ERROR_STRING,
+	RETRY_ERROR_CODES,
+} from '../Util/Constants';
+
+const logger = new Logger('AmazonKinesisLoggingProvider');
+
+export class AmazonKinesisLoggingProvider implements LoggingProvider {
+	static readonly PROVIDER_NAME = AMAZON_KINESIS_LOGGING_PROVIDER_NAME;
+	static readonly CATEGORY = AMAZON_KINESIS_LOGGING_CATEGORY;
+
+	private _config: AmazonKinesisLoggerOptions;
+
+	constructor(config?: AmazonKinesisLoggerOptions) {}
+
+	public getProviderName(): string {
+		return AmazonKinesisLoggingProvider.PROVIDER_NAME;
+	}
+
+	public getCategoryName(): string {
+		return AmazonKinesisLoggingProvider.CATEGORY;
+	}
+
+	public configure(
+		config?: AmazonKinesisLoggerOptions
+	): AmazonKinesisLoggerOptions {
+		if (!config) return this._config || {};
+
+		return this._config;
+	}
+
+	public pushLogs(logs: any[]): void {
+		logger.debug('pushing log events to Kinesis...');
+	}
+
+	public pause() {}
+
+	public resume() {}
+}

package/src/Util/Constants.ts

@@ -12,11 +12,16 @@
  */
 
 // Logging constants
+// Cloudwatch
 const AWS_CLOUDWATCH_BASE_BUFFER_SIZE = 26;
 const AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE = 1048576;
 const AWS_CLOUDWATCH_MAX_EVENT_SIZE = 256000;
 const AWS_CLOUDWATCH_CATEGORY = 'Logging';
 const AWS_CLOUDWATCH_PROVIDER_NAME = 'AWSCloudWatch';
+
+const AMAZON_KINESIS_LOGGING_CATEGORY = 'KinesisLogging';
+const AMAZON_KINESIS_LOGGING_PROVIDER_NAME = 'AmazonKinesisLogging';
+
 const NO_CREDS_ERROR_STRING = 'No credentials';
 const RETRY_ERROR_CODES = [
 	'ResourceNotFoundException',
@@ -31,4 +36,6 @@ export {
 	AWS_CLOUDWATCH_PROVIDER_NAME,
 	NO_CREDS_ERROR_STRING,
 	RETRY_ERROR_CODES,
+	AMAZON_KINESIS_LOGGING_PROVIDER_NAME,
+	AMAZON_KINESIS_LOGGING_CATEGORY,
 };

package/src/types/types.ts

@@ -1,62 +1,79 @@
-import { InputLogEvent, LogGroup } from '@aws-sdk/client-cloudwatch-logs';
-import { Credentials } from '@aws-sdk/types';
-
-export interface AmplifyConfig {
-	Analytics?: object;
-	Auth?: object;
-	API?: object;
-	Logging?: object;
-	Storage?: object;
-	Cache?: object;
-	Geo?: object;
-	ssr?: boolean;
-}
-
-export interface ICredentials {
-	accessKeyId: string;
-	sessionToken: string;
-	secretAccessKey: string;
-	identityId: string;
-	authenticated: boolean;
-	// Long term creds do not provide an expiration date
-	expiration?: Date;
-}
-
-/**
- * @private
- * Internal use of Amplify only
- */
-
-export type DelayFunction = (
-	attempt: number,
-	args?: any[],
-	error?: Error
-) => number | false;
-
-export interface LoggingProvider {
-	// return the name of you provider
-	getProviderName(): string;
-
-	// return the name of you category
-	getCategoryName(): string;
-
-	// configure the plugin
-	configure(config?: object): object;
-
-	// take logs and push to provider
-	pushLogs(logs: InputLogEvent[]): void;
-}
-
-export interface AWSCloudWatchProviderOptions {
-	logGroupName?: string;
-	logStreamName?: string;
-	region?: string;
-	credentials?: Credentials;
-	endpoint?: string;
-}
-
-export interface CloudWatchDataTracker {
-	eventUploadInProgress: boolean;
-	logEvents: InputLogEvent[];
-	verifiedLogGroup?: LogGroup;
-}
+import { InputLogEvent, LogGroup } from '@aws-sdk/client-cloudwatch-logs';
+import { Credentials } from '@aws-sdk/types';
+
+export interface AmplifyConfig {
+	Analytics?: object;
+	Auth?: object;
+	API?: object;
+	Logging?: object;
+	Storage?: object;
+	Cache?: object;
+	Geo?: object;
+	ssr?: boolean;
+}
+
+export interface ICredentials {
+	accessKeyId: string;
+	sessionToken: string;
+	secretAccessKey: string;
+	identityId: string;
+	authenticated: boolean;
+	// Long term creds do not provide an expiration date
+	expiration?: Date;
+}
+
+/**
+ * @private
+ * Internal use of Amplify only
+ */
+
+export type DelayFunction = (
+	attempt: number,
+	args?: any[],
+	error?: Error
+) => number | false;
+
+export interface LoggingProvider {
+	// return the name of you provider
+	getProviderName(): string;
+
+	// return the name of you category
+	getCategoryName(): string;
+
+	// configure the plugin
+	configure(config?: object): object;
+
+	// take logs and push to provider
+	pushLogs(logs: InputLogEvent[]): void;
+
+	// pause sending logs
+	pause(): void;
+	resume(): void;
+}
+
+export interface AWSCloudWatchProviderOptions {
+	logGroupName?: string;
+	logStreamName?: string;
+	region?: string;
+	credentials?: Credentials;
+	endpoint?: string;
+}
+
+export interface AmplifyConfigure {
+	Logging: {
+		logGroupName: string;
+		logStreamName: string;
+	};
+}
+
+export interface CloudWatchDataTracker {
+	eventUploadInProgress: boolean;
+	logEvents: InputLogEvent[];
+	verifiedLogGroup?: LogGroup;
+}
+
+export interface AmazonKinesisLoggerOptions {
+	region?: string;
+	credentials?: Credentials;
+	endpoint?: string;
+}