@aws-amplify/core 4.4.1 → 4.4.2-api-logging.5

package/src/Providers/APIProvider/APILoggingProvider.ts

@@ -0,0 +1,286 @@
+import { ConsoleLogger as Logger, LOG_LEVELS, LOG_TYPE } from '../../Logger';
+import LoggerConnectivity from './loggerConnectivity';
+import {
+	LoggingProvider,
+	GenericLogEvent,
+	APILoggingProviderOptions,
+	isLoggerEvent,
+} from '../../types/types';
+import { jitteredExponentialRetry, NonRetryableError } from '../../../';
+import { postOptions } from './Fetch';
+import {
+	API_LOGGING_PROVIDER_NAME,
+	API_LOGGING_PROVIDER_CATEGORY,
+} from '../../Util/Constants';
+import { getStringByteSize } from '../../Util/StringUtils';
+import { InputLogEvent } from '@aws-sdk/client-cloudwatch-logs';
+
+const logger = new Logger('APILoggingProvider');
+const HTTPS = 'https';
+const LOCALHOST = 'http://localhost';
+const DEFAULT_INTERVAL = 3000;
+
+// Exclude these to avoid infinite loop
+const DEFAULT_CLASS_EXCLUDE_LIST = [
+	'APILoggingProvider',
+	'AWSCloudWatch',
+	'Retry', // causes a loop because we're using jitteredExponentialRetry below
+];
+const LAMBDA_PAYLOAD_LIMIT = 6 * 1024 * 1024; // 6MB
+
+/* 
+	Todo:
+	* Refactor this into a FSM - managing state will become complex when remote config functionality gets added in P1
+*/
+class APILoggingProvider implements LoggingProvider {
+	static readonly PROVIDER_NAME = API_LOGGING_PROVIDER_NAME;
+	static readonly CATEGORY = API_LOGGING_PROVIDER_CATEGORY;
+
+	private config: APILoggingProviderOptions;
+	private connectivity: LoggerConnectivity;
+	private online: boolean = false;
+	private bufferInterval: ReturnType<typeof setInterval>;
+	private eventBuffer: GenericLogEvent[] = [];
+
+	constructor(config?: APILoggingProviderOptions) {
+		this.configure(config);
+	}
+
+	public getProviderName(): string {
+		return APILoggingProvider.PROVIDER_NAME;
+	}
+
+	public getCategoryName(): string {
+		return APILoggingProvider.CATEGORY;
+	}
+
+	public configure(
+		config: APILoggingProviderOptions
+	): object | APILoggingProviderOptions {
+		try {
+			this.validateConfig(config);
+			this.config = this.normalizeConfig(config);
+
+			if (this.config.enabled === true) {
+				this.initialize();
+			} else {
+				this.disable();
+			}
+
+			return this.config;
+		} catch (error) {
+			logger.error('Unable to start: ', error);
+		}
+	}
+
+	public pushLogs(events: InputLogEvent[]): void {
+		if (this.config?.enabled === false) {
+			return;
+		}
+
+		events.forEach(event => {
+			if (!isLoggerEvent(event)) {
+				return;
+			}
+
+			const {
+				message,
+				timestamp,
+				loggerInfo: {
+					level,
+					data,
+					name,
+					error: { message: errorMessage, name: errorName } = {},
+				},
+			} = event;
+
+			const error = errorName &&
+				errorMessage && {
+					errorMessage,
+					errorName,
+				};
+
+			const combinedEvent: GenericLogEvent = {
+				level,
+				error,
+				message,
+				context: {
+					category: name,
+					data: { ...data, ...this.config.metadata },
+					logTime: timestamp,
+				},
+			};
+
+			if (this.verifyEvent(combinedEvent)) {
+				this.eventBuffer.push(combinedEvent);
+			}
+		});
+	}
+
+	private validateConfig(config: APILoggingProviderOptions): void {
+		if (typeof config?.endpoint !== 'string') {
+			throw new Error(
+				`Invalid configuration. \`config.endpoint\` must be a string. Received: ${typeof config?.endpoint}`
+			);
+		}
+
+		const protocolStr = config.endpoint.substring(0, 5).toLowerCase();
+		const isUsingLocalhost =
+			config.endpoint.substring(0, LOCALHOST.length).toLowerCase() ===
+			LOCALHOST;
+
+		if (protocolStr !== HTTPS && !isUsingLocalhost) {
+			throw new Error(
+				`Invalid configuration. Only HTTPS endpoints are supported. Received: ${protocolStr}`
+			);
+		}
+	}
+
+	private normalizeConfig(
+		config: APILoggingProviderOptions
+	): APILoggingProviderOptions {
+		const normalizedConfig = {
+			endpoint: config.endpoint,
+			apiKey: config.apiKey,
+			metadata: config.metadata,
+			enabled: config.enabled ?? true,
+			level: config.level ?? LOG_TYPE.WARN,
+			bufferInterval: config.bufferInterval ?? DEFAULT_INTERVAL,
+			excludeClassList:
+				config.excludeClassList instanceof Array
+					? [...DEFAULT_CLASS_EXCLUDE_LIST, ...config.excludeClassList]
+					: DEFAULT_CLASS_EXCLUDE_LIST,
+		};
+
+		return normalizedConfig;
+	}
+
+	private initialize() {
+		this.subscribeConnectivity();
+	}
+
+	private disable() {
+		this.clearInterval();
+		this.unsubscribeConnectivity();
+		this.eventBuffer = [];
+	}
+
+	private subscribeConnectivity() {
+		if (this.connectivity) {
+			return;
+		}
+
+		this.connectivity = new LoggerConnectivity();
+		this.connectivity.status().subscribe(({ online }) => {
+			if (online && !this.online) {
+				this.startInterval();
+			} else {
+				this.clearInterval();
+			}
+
+			this.online = online;
+			logger.debug('Connectivity status: ', online);
+		});
+	}
+
+	private unsubscribeConnectivity() {
+		if (this.connectivity) {
+			this.connectivity.unsubscribe();
+			this.connectivity = undefined;
+		}
+	}
+
+	private startInterval() {
+		if (this.bufferInterval) {
+			this.clearInterval();
+		}
+
+		this.bufferInterval = setInterval(async () => {
+			try {
+				await this.uploadEvents();
+			} catch (error) {
+				logger.error(`Could not upload log events`, error);
+			}
+		}, this.config.bufferInterval);
+	}
+
+	private clearInterval() {
+		clearInterval(this.bufferInterval);
+		this.bufferInterval = undefined;
+	}
+
+	/* 
+		Filter out events that don't adhere to config settings
+	*/
+	private verifyEvent(event: GenericLogEvent): boolean {
+		const { level, context } = event;
+
+		const configLevelValue = LOG_LEVELS[this.config.level];
+		const eventLevelValue = LOG_LEVELS[level];
+
+		if (eventLevelValue < configLevelValue) {
+			return false;
+		}
+
+		if (this.config.excludeClassList.includes(context.category)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private async uploadEvents(): Promise<void> {
+		const eventBatch = this.genericLogEventBatch(this.eventBuffer);
+
+		if (eventBatch.length < 1) {
+			return;
+		}
+
+		const body = {
+			logs: eventBatch,
+		};
+
+		const options = postOptions(body);
+
+		await jitteredExponentialRetry(
+			async (endpoint, options) => {
+				try {
+					await fetch(endpoint, options); // fetch doesnt return info for no-cors request
+				} catch (error) {
+					// fetch will only fail in the event of a network error. Don't retry
+					if (error.message === 'Failed to fetch') {
+						throw new NonRetryableError(error.message);
+					}
+					// all other errors are logged and retried
+					logger.warn(error);
+					throw error;
+				}
+			},
+			[this.config.endpoint, options]
+		);
+
+		// remove events from buffer after the request succeeds
+		this.eventBuffer.splice(0, eventBatch.length);
+	}
+
+	private genericLogEventBatch(buffer: GenericLogEvent[]): GenericLogEvent[] {
+		let totalByteSize = 0;
+		let currentEventIdx = 0;
+
+		while (currentEventIdx < buffer.length) {
+			const currentEvent = buffer[currentEventIdx];
+			const eventSize = getStringByteSize(JSON.stringify(currentEvent));
+
+			if (totalByteSize + eventSize > LAMBDA_PAYLOAD_LIMIT) {
+				break;
+			}
+
+			totalByteSize += eventSize;
+			currentEventIdx += 1;
+		}
+
+		return buffer.slice(0, currentEventIdx);
+	}
+}
+
+export { APILoggingProvider };

package/src/Providers/APIProvider/CloudWatchEventFormatter.ts

@@ -0,0 +1,100 @@
+import { InputLogEvent } from '@aws-sdk/client-cloudwatch-logs';
+import {
+	AWS_CLOUDWATCH_BASE_BUFFER_SIZE,
+	AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE,
+	AWS_CLOUDWATCH_MAX_EVENT_SIZE,
+} from '../../Util/Constants';
+import { GenericLogEvent } from '../../types/types';
+import { ConsoleLogger as Logger, getStringByteSize } from '../../';
+
+const logger = new Logger('APILoggingProvider');
+const TRUNCATE_MAX_LENGTH = 5000;
+
+export const cloudWatchEventFromGeneric = (
+	event: GenericLogEvent
+): InputLogEvent => {
+	const {
+		context: { logTime: timestamp },
+		...message
+	} = event;
+
+	return {
+		timestamp,
+		message: JSON.stringify(event),
+	};
+};
+
+export const truncateOversizedEvent = (event: InputLogEvent): InputLogEvent => {
+	const { timestamp, message } = event;
+
+	try {
+		const messageJson = JSON.parse(message);
+
+		const truncatedObj = {
+			level: messageJson.level,
+			class: messageJson.class,
+			message: messageJson.message.substring(0, TRUNCATE_MAX_LENGTH),
+		};
+
+		if (messageJson.data != null) {
+			truncatedObj[
+				'data'
+			] = `OBJECT SIZE EXCEEDS CLOUDWATCH EVENT LIMIT. Truncated: ${JSON.stringify(
+				messageJson.data
+			).substring(0, TRUNCATE_MAX_LENGTH)}`;
+		}
+
+		return {
+			timestamp,
+			message: JSON.stringify(truncatedObj),
+		};
+	} catch (error) {
+		logger.warn('Could not truncate 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,
+		};
+	}
+};
+
+export const cloudWatchLogEventBatch = (
+	buffer: InputLogEvent[]
+): InputLogEvent[] => {
+	let totalByteSize = 0;
+	let currentEventIdx = 0;
+
+	while (currentEventIdx < buffer.length) {
+		let currentEvent = buffer[currentEventIdx];
+		let eventSize =
+			getStringByteSize(currentEvent.message) + AWS_CLOUDWATCH_BASE_BUFFER_SIZE;
+
+		if (eventSize > AWS_CLOUDWATCH_MAX_EVENT_SIZE) {
+			const errString = `Log event exceeds maximum size for CloudWatch logs. Log size: ${eventSize}. Truncating log message.`;
+			logger.debug(errString);
+
+			currentEvent = truncateOversizedEvent(currentEvent);
+			buffer[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 += 1;
+	}
+
+	return buffer.slice(0, currentEventIdx);
+};

package/src/Providers/APIProvider/Fetch.ts

@@ -0,0 +1,10 @@
+export const postOptions = (body: object) => ({
+	method: 'POST',
+	mode: 'no-cors',
+	cache: 'no-cache',
+	credentials: 'same-origin',
+	headers: {
+		'Content-Type': 'application/json',
+	},
+	body: JSON.stringify(body),
+});

package/src/Providers/APIProvider/LoggerReachability/index.native.ts

@@ -0,0 +1,4 @@
+import { Reachability } from '../../..';
+import { default as NetInfo } from '@react-native-community/netinfo';
+
+export const ReachabilityMonitor = new Reachability().networkMonitor(NetInfo);

package/src/Providers/APIProvider/LoggerReachability/index.ts

@@ -0,0 +1,2 @@
+import { Reachability } from '../../../Util';
+export const ReachabilityMonitor = new Reachability().networkMonitor();

package/src/Providers/APIProvider/index.ts

@@ -0,0 +1 @@
+export { APILoggingProvider } from './APILoggingProvider';

package/src/Providers/APIProvider/loggerConnectivity.ts

@@ -0,0 +1,49 @@
+import Observable, { ZenObservable } from 'zen-observable-ts';
+import { ReachabilityMonitor } from './LoggerReachability';
+
+type ConnectionStatus = {
+	online: boolean;
+};
+
+// TODO: refactor this to a singleton that supports numerous observers
+export default class LoggerConnectivity {
+	private connectionStatus: ConnectionStatus;
+	private observer: ZenObservable.SubscriptionObserver<ConnectionStatus>;
+	private subscription: ZenObservable.Subscription;
+	private timeout: ReturnType<typeof setTimeout>;
+	constructor() {
+		this.connectionStatus = {
+			online: false,
+		};
+	}
+
+	status(): Observable<ConnectionStatus> {
+		if (this.observer) {
+			throw new Error('Subscriber already exists');
+		}
+		return new Observable(observer => {
+			this.observer = observer;
+
+			this.subscription = ReachabilityMonitor.subscribe(({ online }) => {
+				this.connectionStatus.online = online;
+
+				const observerResult = { ...this.connectionStatus };
+
+				observer.next(observerResult);
+			});
+
+			return () => {
+				clearTimeout(this.timeout);
+				this.unsubscribe();
+			};
+		});
+	}
+
+	unsubscribe() {
+		if (this.subscription) {
+			clearTimeout(this.timeout);
+			this.subscription.unsubscribe();
+			this.observer = undefined;
+		}
+	}
+}

package/src/Providers/AWSCloudWatchProvider.ts

@@ -218,7 +218,15 @@ class AWSCloudWatchProvider implements LoggingProvider {
 
 	public pushLogs(logs: InputLogEvent[]): void {
 		logger.debug('pushing log events to Cloudwatch...');
-		this._dataTracker.logEvents = [...this._dataTracker.logEvents, ...logs];
+		const formattedLogs = logs.map(({ message, timestamp }) => ({
+			message,
+			timestamp,
+		}));
+
+		this._dataTracker.logEvents = [
+			...this._dataTracker.logEvents,
+			...formattedLogs,
+		];
 	}
 
 	private async _validateLogGroupExistsAndCreate(

package/src/Providers/index.ts

@@ -1 +1,2 @@
 export * from './AWSCloudWatchProvider';
+export { APILoggingProvider } from './APIProvider';

package/src/Util/Constants.ts

@@ -22,6 +22,8 @@ const RETRY_ERROR_CODES = [
 	'ResourceNotFoundException',
 	'InvalidSequenceTokenException',
 ];
+const API_LOGGING_PROVIDER_NAME = 'API';
+const API_LOGGING_PROVIDER_CATEGORY = 'Logging';
 
 export {
 	AWS_CLOUDWATCH_BASE_BUFFER_SIZE,
@@ -31,4 +33,6 @@ export {
 	AWS_CLOUDWATCH_PROVIDER_NAME,
 	NO_CREDS_ERROR_STRING,
 	RETRY_ERROR_CODES,
+	API_LOGGING_PROVIDER_NAME,
+	API_LOGGING_PROVIDER_CATEGORY,
 };

package/src/Util/Reachability.ts

@@ -1,4 +1,4 @@
-import { browserOrNode, isWebWorker } from '@aws-amplify/core';
+import { browserOrNode, isWebWorker } from '../JS';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 
 type NetworkStatus = {
@@ -32,9 +32,10 @@ export default class ReachabilityNavigator implements Reachability {
 				globalObj.removeEventListener('online', notifyOnline);
 				globalObj.removeEventListener('offline', notifyOffline);
 
-				ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(
-					_observer => _observer !== observer
-				);
+				ReachabilityNavigator._observers =
+					ReachabilityNavigator._observers.filter(
+						_observer => _observer !== observer
+					);
 			};
 		});
 	}
@@ -43,9 +44,10 @@ export default class ReachabilityNavigator implements Reachability {
 	private static _observerOverride(status: NetworkStatus): void {
 		for (const observer of ReachabilityNavigator._observers) {
 			if (observer.closed) {
-				ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(
-					_observer => _observer !== observer
-				);
+				ReachabilityNavigator._observers =
+					ReachabilityNavigator._observers.filter(
+						_observer => _observer !== observer
+					);
 				continue;
 			}
 			observer.next(status);

package/src/Util/Retry.ts

@@ -1,6 +1,6 @@
 import { DelayFunction } from '../types';
 import { ConsoleLogger as Logger } from '../Logger/ConsoleLogger';
-const logger = new Logger('Util');
+const logger = new Logger('Retry');
 
 export class NonRetryableError extends Error {
 	public readonly nonRetryable = true;
@@ -30,7 +30,7 @@ export async function retry(
 	logger.debug(
 		`${
 			functionToRetry.name
-		} attempt #${attempt} with this vars: ${JSON.stringify(args)}`
+		} attempt #${attempt} with these vars: ${JSON.stringify(args)}`
 	);
 
 	try {

package/src/Util/StringUtils.ts

@@ -1,12 +1,8 @@
+import { browserOrNode } from '../../';
 export function urlSafeEncode(str: string) {
 	return str
 		.split('')
-		.map(char =>
-			char
-				.charCodeAt(0)
-				.toString(16)
-				.padStart(2, '0')
-		)
+		.map(char => char.charCodeAt(0).toString(16).padStart(2, '0'))
 		.join('');
 }
 
@@ -16,3 +12,16 @@ export function urlSafeDecode(hex: string) {
 		.map(char => String.fromCharCode(parseInt(char, 16)))
 		.join('');
 }
+export const getStringByteSize = (str: string): number => {
+	if (browserOrNode().isBrowser || Blob !== undefined) {
+		return new Blob([str]).size;
+	}
+
+	if (Buffer !== undefined) {
+		return Buffer.byteLength(str, 'utf8');
+	}
+
+	throw new Error(
+		'Cannot compute string length. Blob and Buffer are undefined'
+	);
+};