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

package/lib-esm/Util/Retry.js

@@ -68,7 +68,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 import { ConsoleLogger as Logger } from '../Logger/ConsoleLogger';
-var logger = new Logger('Util');
+var logger = new Logger('Retry');
 var NonRetryableError = /** @class */ (function (_super) {
     __extends(NonRetryableError, _super);
     function NonRetryableError(message) {
@@ -97,7 +97,7 @@ export function retry(functionToRetry, args, delayFn, attempt) {
                     if (typeof functionToRetry !== 'function') {
                         throw Error('functionToRetry must be a function');
                     }
-                    logger.debug(functionToRetry.name + " attempt #" + attempt + " with this vars: " + JSON.stringify(args));
+                    logger.debug(functionToRetry.name + " attempt #" + attempt + " with these vars: " + JSON.stringify(args));
                     _a.label = 1;
                 case 1:
                     _a.trys.push([1, 3, , 8]);

package/lib-esm/Util/Retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"Retry.js","sourceRoot":"","sources":["../../src/Util/Retry.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAClE,IAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;AAElC;IAAuC,qCAAK;IAE3C,2BAAY,OAAe;QAA3B,YACC,kBAAM,OAAO,CAAC,SACd;QAHe,kBAAY,GAAG,IAAI,CAAC;;IAGpC,CAAC;IACF,wBAAC;AAAD,CAAC,AALD,CAAuC,KAAK,GAK3C;;AAED,IAAM,mBAAmB,GAAG,UAAC,GAAQ;IACpC,IAAM,GAAG,GAA4B,cAAc,CAAC;IACpD,OAAO,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AACxB,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAgB,KAAK,CAC1B,eAAyB,EACzB,IAAW,EACX,OAAsB,EACtB,OAAmB;IAAnB,wBAAA,EAAA,WAAmB;;;;;;oBAEnB,IAAI,OAAO,eAAe,KAAK,UAAU,EAAE;wBAC1C,MAAM,KAAK,CAAC,oCAAoC,CAAC,CAAC;qBAClD;oBACD,MAAM,CAAC,KAAK,CAEV,eAAe,CAAC,IAAI,kBACR,OAAO,yBAAoB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAG,CAC9D,CAAC;;;;oBAGM,qBAAM,eAAe,wBAAI,IAAI,IAAC;wBAArC,sBAAO,SAA8B,EAAC;;;oBAEtC,MAAM,CAAC,KAAK,CAAC,cAAY,eAAe,CAAC,IAAM,EAAE,KAAG,CAAC,CAAC;oBAEtD,IAAI,mBAAmB,CAAC,KAAG,CAAC,EAAE;wBAC7B,MAAM,CAAC,KAAK,CAAI,eAAe,CAAC,IAAI,yBAAsB,EAAE,KAAG,CAAC,CAAC;wBACjE,MAAM,KAAG,CAAC;qBACV;oBAEK,YAAU,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,KAAG,CAAC,CAAC;oBAC5C,MAAM,CAAC,KAAK,CAAI,eAAe,CAAC,IAAI,qBAAgB,SAAO,QAAK,CAAC,CAAC;yBAE9D,CAAA,SAAO,KAAK,KAAK,CAAA,EAAjB,wBAAiB;oBACpB,qBAAM,IAAI,OAAO,CAAC,UAAA,GAAG,IAAI,OAAA,UAAU,CAAC,GAAG,EAAE,SAAO,CAAC,EAAxB,CAAwB,CAAC,EAAA;;oBAAlD,SAAkD,CAAC;oBAC5C,qBAAM,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC,EAAA;wBAA/D,sBAAO,SAAwD,EAAC;wBAEhE,MAAM,KAAG,CAAC;;;;;;CAGZ;AAED,IAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAEnC,SAAS,eAAe,CAAC,UAAkB;IAC1C,IAAM,YAAY,GAAG,GAAG,CAAC;IACzB,IAAM,aAAa,GAAG,GAAG,CAAC;IAE1B,OAAO,UAAA,OAAO;QACb,IAAM,KAAK,GAAG,SAAA,CAAC,EAAI,OAAO,CAAA,GAAG,YAAY,GAAG,aAAa,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC1E,OAAO,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3C,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,IAAM,wBAAwB,GAAG,UACvC,eAAyB,EACzB,IAAW,EACX,UAAiC;IAAjC,2BAAA,EAAA,yBAAiC;IAC7B,OAAA,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;AAAzD,CAAyD,CAAC"}
+{"version":3,"file":"Retry.js","sourceRoot":"","sources":["../../src/Util/Retry.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAClE,IAAM,MAAM,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnC;IAAuC,qCAAK;IAE3C,2BAAY,OAAe;QAA3B,YACC,kBAAM,OAAO,CAAC,SACd;QAHe,kBAAY,GAAG,IAAI,CAAC;;IAGpC,CAAC;IACF,wBAAC;AAAD,CAAC,AALD,CAAuC,KAAK,GAK3C;;AAED,IAAM,mBAAmB,GAAG,UAAC,GAAQ;IACpC,IAAM,GAAG,GAA4B,cAAc,CAAC;IACpD,OAAO,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AACxB,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAgB,KAAK,CAC1B,eAAyB,EACzB,IAAW,EACX,OAAsB,EACtB,OAAmB;IAAnB,wBAAA,EAAA,WAAmB;;;;;;oBAEnB,IAAI,OAAO,eAAe,KAAK,UAAU,EAAE;wBAC1C,MAAM,KAAK,CAAC,oCAAoC,CAAC,CAAC;qBAClD;oBACD,MAAM,CAAC,KAAK,CAEV,eAAe,CAAC,IAAI,kBACR,OAAO,0BAAqB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAG,CAC/D,CAAC;;;;oBAGM,qBAAM,eAAe,wBAAI,IAAI,IAAC;wBAArC,sBAAO,SAA8B,EAAC;;;oBAEtC,MAAM,CAAC,KAAK,CAAC,cAAY,eAAe,CAAC,IAAM,EAAE,KAAG,CAAC,CAAC;oBAEtD,IAAI,mBAAmB,CAAC,KAAG,CAAC,EAAE;wBAC7B,MAAM,CAAC,KAAK,CAAI,eAAe,CAAC,IAAI,yBAAsB,EAAE,KAAG,CAAC,CAAC;wBACjE,MAAM,KAAG,CAAC;qBACV;oBAEK,YAAU,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,KAAG,CAAC,CAAC;oBAC5C,MAAM,CAAC,KAAK,CAAI,eAAe,CAAC,IAAI,qBAAgB,SAAO,QAAK,CAAC,CAAC;yBAE9D,CAAA,SAAO,KAAK,KAAK,CAAA,EAAjB,wBAAiB;oBACpB,qBAAM,IAAI,OAAO,CAAC,UAAA,GAAG,IAAI,OAAA,UAAU,CAAC,GAAG,EAAE,SAAO,CAAC,EAAxB,CAAwB,CAAC,EAAA;;oBAAlD,SAAkD,CAAC;oBAC5C,qBAAM,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC,EAAA;wBAA/D,sBAAO,SAAwD,EAAC;wBAEhE,MAAM,KAAG,CAAC;;;;;;CAGZ;AAED,IAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAEnC,SAAS,eAAe,CAAC,UAAkB;IAC1C,IAAM,YAAY,GAAG,GAAG,CAAC;IACzB,IAAM,aAAa,GAAG,GAAG,CAAC;IAE1B,OAAO,UAAA,OAAO;QACb,IAAM,KAAK,GAAG,SAAA,CAAC,EAAI,OAAO,CAAA,GAAG,YAAY,GAAG,aAAa,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC1E,OAAO,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3C,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,IAAM,wBAAwB,GAAG,UACvC,eAAyB,EACzB,IAAW,EACX,UAAiC;IAAjC,2BAAA,EAAA,yBAAiC;IAC7B,OAAA,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;AAAzD,CAAyD,CAAC"}

package/lib-esm/Util/StringUtils.d.ts

@@ -1,2 +1,3 @@
 export declare function urlSafeEncode(str: string): string;
 export declare function urlSafeDecode(hex: string): string;
+export declare const getStringByteSize: (str: string) => number;

package/lib-esm/Util/StringUtils.js

@@ -1,12 +1,8 @@
+import { browserOrNode } from '../../';
 export function urlSafeEncode(str) {
     return str
         .split('')
-        .map(function (char) {
-        return char
-            .charCodeAt(0)
-            .toString(16)
-            .padStart(2, '0');
-    })
+        .map(function (char) { return char.charCodeAt(0).toString(16).padStart(2, '0'); })
         .join('');
 }
 export function urlSafeDecode(hex) {
@@ -15,4 +11,13 @@ export function urlSafeDecode(hex) {
         .map(function (char) { return String.fromCharCode(parseInt(char, 16)); })
         .join('');
 }
+export var getStringByteSize = function (str) {
+    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');
+};
 //# sourceMappingURL=StringUtils.js.map

package/lib-esm/Util/StringUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"StringUtils.js","sourceRoot":"","sources":["../../src/Util/StringUtils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa,CAAC,GAAW;IACxC,OAAO,GAAG;SACR,KAAK,CAAC,EAAE,CAAC;SACT,GAAG,CAAC,UAAA,IAAI;QACR,OAAA,IAAI;aACF,UAAU,CAAC,CAAC,CAAC;aACb,QAAQ,CAAC,EAAE,CAAC;aACZ,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;IAHlB,CAGkB,CAClB;SACA,IAAI,CAAC,EAAE,CAAC,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAAW;IACxC,OAAO,GAAG;SACR,KAAK,CAAC,OAAO,CAAC;SACd,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAvC,CAAuC,CAAC;SACpD,IAAI,CAAC,EAAE,CAAC,CAAC;AACZ,CAAC"}
+{"version":3,"file":"StringUtils.js","sourceRoot":"","sources":["../../src/Util/StringUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,MAAM,UAAU,aAAa,CAAC,GAAW;IACxC,OAAO,GAAG;SACR,KAAK,CAAC,EAAE,CAAC;SACT,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAhD,CAAgD,CAAC;SAC7D,IAAI,CAAC,EAAE,CAAC,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAAW;IACxC,OAAO,GAAG;SACR,KAAK,CAAC,OAAO,CAAC;SACd,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAvC,CAAuC,CAAC;SACpD,IAAI,CAAC,EAAE,CAAC,CAAC;AACZ,CAAC;AACD,MAAM,CAAC,IAAM,iBAAiB,GAAG,UAAC,GAAW;IAC5C,IAAI,aAAa,EAAE,CAAC,SAAS,IAAI,IAAI,KAAK,SAAS,EAAE;QACpD,OAAO,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;KAC5B;IAED,IAAI,MAAM,KAAK,SAAS,EAAE;QACzB,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;KACtC;IAED,MAAM,IAAI,KAAK,CACd,6DAA6D,CAC7D,CAAC;AACH,CAAC,CAAC"}

package/lib-esm/types/index.js

@@ -1 +1,2 @@
+export * from './types';
 //# sourceMappingURL=index.js.map

package/lib-esm/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

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

@@ -1,5 +1,6 @@
 import { InputLogEvent, LogGroup } from '@aws-sdk/client-cloudwatch-logs';
 import { Credentials } from '@aws-sdk/types';
+import { LOG_TYPE } from '../Logger/ConsoleLogger';
 export interface AmplifyConfig {
     Analytics?: object;
     Auth?: object;
@@ -27,7 +28,8 @@ export interface LoggingProvider {
     getProviderName(): string;
     getCategoryName(): string;
     configure(config?: object): object;
-    pushLogs(logs: InputLogEvent[]): void;
+    pushLogs?(logs: InputLogEvent[]): void;
+    pushLog?(log: GenericLogEvent): void;
 }
 export interface AWSCloudWatchProviderOptions {
     logGroupName?: string;
@@ -41,3 +43,26 @@ export interface CloudWatchDataTracker {
     logEvents: InputLogEvent[];
     verifiedLogGroup?: LogGroup;
 }
+export interface APILoggingProviderOptions {
+    endpoint: string;
+    apiKey?: string;
+    enabled?: boolean;
+    level?: LOG_TYPE;
+    excludeClassList?: string[];
+    metadata?: {
+        [key: string]: any;
+    };
+    eventFormat?: EVENT_FORMAT;
+    bufferInterval?: number;
+}
+export declare enum EVENT_FORMAT {
+    GENERIC = "GENERIC",
+    CLOUDWATCH = "CLOUDWATCH"
+}
+export interface GenericLogEvent {
+    level: string;
+    source: string;
+    timestamp: number;
+    message?: string;
+    data?: object;
+}

package/lib-esm/types/types.js

@@ -1 +1,6 @@
+export var EVENT_FORMAT;
+(function (EVENT_FORMAT) {
+    EVENT_FORMAT["GENERIC"] = "GENERIC";
+    EVENT_FORMAT["CLOUDWATCH"] = "CLOUDWATCH";
+})(EVENT_FORMAT || (EVENT_FORMAT = {}));
 //# sourceMappingURL=types.js.map

package/lib-esm/types/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AA6EA,MAAM,CAAN,IAAY,YAGX;AAHD,WAAY,YAAY;IACvB,mCAAmB,CAAA;IACnB,yCAAyB,CAAA;AAC1B,CAAC,EAHW,YAAY,KAAZ,YAAY,QAGvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aws-amplify/core",
-	"version": "4.4.1",
+	"version": "4.4.2-api-logging.2+ad8e979fc",
 	"description": "Core category of aws-amplify",
 	"main": "./lib/index.js",
 	"module": "./lib-esm/index.js",
@@ -108,5 +108,5 @@
 			"lib-esm"
 		]
 	},
-	"gitHead": "7a870d60aa6e6dce4fca59b43b6f7bf14379ba54"
+	"gitHead": "ad8e979fc00dfdab256c46f97d9973e8facbcfaa"
 }

package/src/Logger/ConsoleLogger.ts

@@ -12,11 +12,11 @@
  */
 
 import { InputLogEvent } from '@aws-sdk/client-cloudwatch-logs';
-import { LoggingProvider } from '../types';
+import { GenericLogEvent, LoggingProvider } from '../types';
 import { AWS_CLOUDWATCH_CATEGORY } from '../Util/Constants';
 import { Logger } from './logger-interface';
 
-const LOG_LEVELS = {
+export const LOG_LEVELS = {
 	VERBOSE: 1,
 	DEBUG: 2,
 	INFO: 3,
@@ -42,6 +42,11 @@ export class ConsoleLogger implements Logger {
 	private _pluggables: LoggingProvider[];
 	private _config: object;
 
+	private static pluggables: LoggingProvider[] = [];
+	public static addPluggable(pluggable: LoggingProvider) {
+		ConsoleLogger.pluggables.push(pluggable);
+	}
+
 	/**
 	 * @constructor
 	 * @param {string} name - Name of the logger
@@ -77,6 +82,42 @@ export class ConsoleLogger implements Logger {
 		return this._config;
 	}
 
+	_logGlobal(type: LOG_TYPE | string, ...msg) {
+		for (const pluggable of ConsoleLogger.pluggables) {
+			const event = this._generateGenericEvent(type, msg);
+			pluggable.pushLog(event);
+		}
+	}
+
+	_generateGenericEvent(type: LOG_TYPE | string, msg: any[]): GenericLogEvent {
+		let strMessage = '';
+		let data;
+
+		if (msg.length === 1 && typeof msg[0] === 'string') {
+			strMessage = msg[0];
+		} else if (msg.length === 1) {
+			data = msg[0];
+		} else if (typeof msg[0] === 'string') {
+			let obj = msg.slice(1);
+			if (obj.length === 1) {
+				obj = obj[0];
+			}
+			strMessage = msg[0];
+			data = obj;
+		} else {
+			data = msg;
+		}
+
+		const event = {
+			data,
+			level: type,
+			message: strMessage,
+			source: this.name,
+			timestamp: Date.now(),
+		};
+
+		return event;
+	}
 	/**
 	 * Write log
 	 * @method
@@ -85,6 +126,8 @@ export class ConsoleLogger implements Logger {
 	 * @param {string|object} msg - Logging message or object
 	 */
 	_log(type: LOG_TYPE | string, ...msg) {
+		this._logGlobal(type, ...msg);
+
 		let logger_level_name = this.level;
 		if (ConsoleLogger.LOG_LEVEL) {
 			logger_level_name = ConsoleLogger.LOG_LEVEL;

package/src/Platform/version.ts

@@ -1,2 +1,2 @@
 // generated by genversion
-export const version = '4.4.0';
+export const version = '4.4.1';

package/src/Providers/APIProvider/APILoggingProvider.ts

@@ -0,0 +1,286 @@
+import { InputLogEvent } from '@aws-sdk/client-cloudwatch-logs';
+import { ConsoleLogger as Logger, LOG_LEVELS, LOG_TYPE } from '../../Logger';
+import LoggerConnectivity from './loggerConnectivity';
+import {
+	EVENT_FORMAT,
+	LoggingProvider,
+	GenericLogEvent,
+	APILoggingProviderOptions,
+} from '../../types/types';
+import { jitteredExponentialRetry, NonRetryableError } from '../../../';
+import {
+	cloudWatchEventFromGeneric,
+	cloudWatchLogEventBatch,
+} from './CloudWatchEventFormatter';
+import { postOptions } from './Fetch';
+import {
+	API_LOGGING_PROVIDER_NAME,
+	API_LOGGING_PROVIDER_CATEGORY,
+} from '../../Util/Constants';
+import { getStringByteSize } from '../../Util/StringUtils';
+
+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[] | InputLogEvent[] = [];
+
+	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 pushLog(event: GenericLogEvent): void {
+		if (this.config?.enabled === false) {
+			return;
+		}
+
+		if (!this.verifyEvent(event)) {
+			return;
+		}
+
+		switch (this.config.eventFormat) {
+			case EVENT_FORMAT.CLOUDWATCH:
+				const cloudWatchEvent = cloudWatchEventFromGeneric(event);
+				(this.eventBuffer as InputLogEvent[]).push(cloudWatchEvent);
+				break;
+			case EVENT_FORMAT.GENERIC:
+			default:
+				(this.eventBuffer as GenericLogEvent[]).push(event);
+				break;
+		}
+	}
+
+	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,
+			eventFormat: config.eventFormat ?? EVENT_FORMAT.CLOUDWATCH,
+			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, source } = event;
+
+		const configLevelValue = LOG_LEVELS[this.config.level];
+		const eventLevelValue = LOG_LEVELS[level];
+
+		if (eventLevelValue < configLevelValue) {
+			return false;
+		}
+
+		if (this.config.excludeClassList.includes(source)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private async uploadEvents(): Promise<void> {
+		const eventBatch = this.generateEventBatch(this.eventBuffer);
+
+		if (eventBatch.length < 1) {
+			return;
+		}
+
+		const body = {
+			logEvents: eventBatch,
+			metadata: this.config.metadata,
+		};
+
+		const options = postOptions(body);
+
+		await jitteredExponentialRetry(
+			async (endpoint, options) => {
+				try {
+					const res = await fetch(endpoint, options);
+					if (!res.ok)
+						throw new Error(
+							`Request Failed. Status: ${res.status} - ${res.statusText}`
+						);
+				} 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 generateEventBatch(
+		buffer: GenericLogEvent[] | InputLogEvent[]
+	): GenericLogEvent[] | InputLogEvent[] {
+		switch (this.config.eventFormat) {
+			case EVENT_FORMAT.CLOUDWATCH:
+				return cloudWatchLogEventBatch(buffer as InputLogEvent[]);
+
+			case EVENT_FORMAT.GENERIC:
+			default:
+				return this.genericLogEventBatch(buffer as GenericLogEvent[]);
+		}
+	}
+
+	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,97 @@
+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 { timestamp, ...message } = event;
+
+	return {
+		timestamp,
+		message: JSON.stringify(message),
+	};
+};
+
+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: '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';