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

package/lib-esm/Providers/AmazonKinesisLoggingProvider.js

@@ -0,0 +1,28 @@
+import { ConsoleLogger as Logger } from '../Logger';
+import { AMAZON_KINESIS_LOGGING_PROVIDER_NAME, AMAZON_KINESIS_LOGGING_CATEGORY, } from '../Util/Constants';
+var logger = new Logger('AmazonKinesisLoggingProvider');
+var AmazonKinesisLoggingProvider = /** @class */ (function () {
+    function AmazonKinesisLoggingProvider(config) {
+    }
+    AmazonKinesisLoggingProvider.prototype.getProviderName = function () {
+        return AmazonKinesisLoggingProvider.PROVIDER_NAME;
+    };
+    AmazonKinesisLoggingProvider.prototype.getCategoryName = function () {
+        return AmazonKinesisLoggingProvider.CATEGORY;
+    };
+    AmazonKinesisLoggingProvider.prototype.configure = function (config) {
+        if (!config)
+            return this._config || {};
+        return this._config;
+    };
+    AmazonKinesisLoggingProvider.prototype.pushLogs = function (logs) {
+        logger.debug('pushing log events to Kinesis...');
+    };
+    AmazonKinesisLoggingProvider.prototype.pause = function () { };
+    AmazonKinesisLoggingProvider.prototype.resume = function () { };
+    AmazonKinesisLoggingProvider.PROVIDER_NAME = AMAZON_KINESIS_LOGGING_PROVIDER_NAME;
+    AmazonKinesisLoggingProvider.CATEGORY = AMAZON_KINESIS_LOGGING_CATEGORY;
+    return AmazonKinesisLoggingProvider;
+}());
+export { AmazonKinesisLoggingProvider };
+//# sourceMappingURL=AmazonKinesisLoggingProvider.js.map

package/lib-esm/Providers/AmazonKinesisLoggingProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmazonKinesisLoggingProvider.js","sourceRoot":"","sources":["../../src/Providers/AmazonKinesisLoggingProvider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EACN,oCAAoC,EACpC,+BAA+B,GAG/B,MAAM,mBAAmB,CAAC;AAE3B,IAAM,MAAM,GAAG,IAAI,MAAM,CAAC,8BAA8B,CAAC,CAAC;AAE1D;IAMC,sCAAY,MAAmC;IAAG,CAAC;IAE5C,sDAAe,GAAtB;QACC,OAAO,4BAA4B,CAAC,aAAa,CAAC;IACnD,CAAC;IAEM,sDAAe,GAAtB;QACC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;IAC9C,CAAC;IAEM,gDAAS,GAAhB,UACC,MAAmC;QAEnC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC;QAEvC,OAAO,IAAI,CAAC,OAAO,CAAC;IACrB,CAAC;IAEM,+CAAQ,GAAf,UAAgB,IAAW;QAC1B,MAAM,CAAC,KAAK,CAAC,kCAAkC,CAAC,CAAC;IAClD,CAAC;IAEM,4CAAK,GAAZ,cAAgB,CAAC;IAEV,6CAAM,GAAb,cAAiB,CAAC;IA7BF,0CAAa,GAAG,oCAAoC,CAAC;IACrD,qCAAQ,GAAG,+BAA+B,CAAC;IA6B5D,mCAAC;CAAA,AA/BD,IA+BC;SA/BY,4BAA4B"}

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

@@ -3,6 +3,8 @@ declare const AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE = 1048576;
 declare const AWS_CLOUDWATCH_MAX_EVENT_SIZE = 256000;
 declare const AWS_CLOUDWATCH_CATEGORY = "Logging";
 declare const AWS_CLOUDWATCH_PROVIDER_NAME = "AWSCloudWatch";
+declare const AMAZON_KINESIS_LOGGING_CATEGORY = "KinesisLogging";
+declare const AMAZON_KINESIS_LOGGING_PROVIDER_NAME = "AmazonKinesisLogging";
 declare const NO_CREDS_ERROR_STRING = "No credentials";
 declare const RETRY_ERROR_CODES: string[];
-export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, };
+export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, AMAZON_KINESIS_LOGGING_PROVIDER_NAME, AMAZON_KINESIS_LOGGING_CATEGORY, };

package/lib-esm/Util/Constants.js

@@ -11,15 +11,18 @@
  * and limitations under the License.
  */
 // Logging constants
+// Cloudwatch
 var AWS_CLOUDWATCH_BASE_BUFFER_SIZE = 26;
 var AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE = 1048576;
 var AWS_CLOUDWATCH_MAX_EVENT_SIZE = 256000;
 var AWS_CLOUDWATCH_CATEGORY = 'Logging';
 var AWS_CLOUDWATCH_PROVIDER_NAME = 'AWSCloudWatch';
+var AMAZON_KINESIS_LOGGING_CATEGORY = 'KinesisLogging';
+var AMAZON_KINESIS_LOGGING_PROVIDER_NAME = 'AmazonKinesisLogging';
 var NO_CREDS_ERROR_STRING = 'No credentials';
 var RETRY_ERROR_CODES = [
     'ResourceNotFoundException',
     'InvalidSequenceTokenException',
 ];
-export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, };
+export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, AMAZON_KINESIS_LOGGING_PROVIDER_NAME, AMAZON_KINESIS_LOGGING_CATEGORY, };
 //# sourceMappingURL=Constants.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"Constants.js","sourceRoot":"","sources":["../../src/Util/Constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,oBAAoB;AACpB,IAAM,+BAA+B,GAAG,EAAE,CAAC;AAC3C,IAAM,mCAAmC,GAAG,OAAO,CAAC;AACpD,IAAM,6BAA6B,GAAG,MAAM,CAAC;AAC7C,IAAM,uBAAuB,GAAG,SAAS,CAAC;AAC1C,IAAM,4BAA4B,GAAG,eAAe,CAAC;AACrD,IAAM,qBAAqB,GAAG,gBAAgB,CAAC;AAC/C,IAAM,iBAAiB,GAAG;IACzB,2BAA2B;IAC3B,+BAA+B;CAC/B,CAAC;AAEF,OAAO,EACN,+BAA+B,EAC/B,uBAAuB,EACvB,mCAAmC,EACnC,6BAA6B,EAC7B,4BAA4B,EAC5B,qBAAqB,EACrB,iBAAiB,GACjB,CAAC"}
+{"version":3,"file":"Constants.js","sourceRoot":"","sources":["../../src/Util/Constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,oBAAoB;AACpB,aAAa;AACb,IAAM,+BAA+B,GAAG,EAAE,CAAC;AAC3C,IAAM,mCAAmC,GAAG,OAAO,CAAC;AACpD,IAAM,6BAA6B,GAAG,MAAM,CAAC;AAC7C,IAAM,uBAAuB,GAAG,SAAS,CAAC;AAC1C,IAAM,4BAA4B,GAAG,eAAe,CAAC;AAErD,IAAM,+BAA+B,GAAG,gBAAgB,CAAC;AACzD,IAAM,oCAAoC,GAAG,sBAAsB,CAAC;AAEpE,IAAM,qBAAqB,GAAG,gBAAgB,CAAC;AAC/C,IAAM,iBAAiB,GAAG;IACzB,2BAA2B;IAC3B,+BAA+B;CAC/B,CAAC;AAEF,OAAO,EACN,+BAA+B,EAC/B,uBAAuB,EACvB,mCAAmC,EACnC,6BAA6B,EAC7B,4BAA4B,EAC5B,qBAAqB,EACrB,iBAAiB,EACjB,oCAAoC,EACpC,+BAA+B,GAC/B,CAAC"}

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

@@ -28,6 +28,8 @@ export interface LoggingProvider {
     getCategoryName(): string;
     configure(config?: object): object;
     pushLogs(logs: InputLogEvent[]): void;
+    pause(): void;
+    resume(): void;
 }
 export interface AWSCloudWatchProviderOptions {
     logGroupName?: string;
@@ -36,8 +38,19 @@ export interface AWSCloudWatchProviderOptions {
     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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aws-amplify/core",
-	"version": "4.3.14",
+	"version": "4.3.15-cloud-logging.3+819a5a227",
 	"description": "Core category of aws-amplify",
 	"main": "./lib/index.js",
 	"module": "./lib-esm/index.js",
@@ -61,6 +61,7 @@
 		"@aws-sdk/credential-provider-cognito-identity": "3.6.1",
 		"@aws-sdk/types": "3.6.1",
 		"@aws-sdk/util-hex-encoding": "3.6.1",
+		"fast-text-encoding": "1.0.3",
 		"universal-cookie": "^4.0.4",
 		"zen-observable-ts": "0.8.19"
 	},
@@ -108,5 +109,5 @@
 			"lib-esm"
 		]
 	},
-	"gitHead": "bac74b640fbd123cc43e02365af70f1b241978f5"
+	"gitHead": "819a5a2271232a709426c530bdfdc3a72c89addd"
 }

package/src/Hub.ts

@@ -63,6 +63,7 @@ export class HubClass {
 		'interactions',
 		'pubsub',
 		'storage',
+		'ui',
 		'xr',
 	];
 

package/src/Logger/ConsoleLogger.ts

@@ -24,6 +24,8 @@ const LOG_LEVELS = {
 	ERROR: 5,
 };
 
+const COMPATIBLE_PLUGINS = [AWS_CLOUDWATCH_CATEGORY];
+
 export enum LOG_TYPE {
 	DEBUG = 'DEBUG',
 	ERROR = 'ERROR',
@@ -32,6 +34,14 @@ export enum LOG_TYPE {
 	VERBOSE = 'VERBOSE',
 }
 
+const cloudWatchExcludeList = [
+	'AWSCloudWatch',
+	'Amplify',
+	'Credentials',
+	'AuthClass',
+	'CloudLogger',
+];
+
 /**
  * Write logs
  * @class Logger
@@ -41,6 +51,7 @@ export class ConsoleLogger implements Logger {
 	level: LOG_TYPE | string;
 	private _pluggables: LoggingProvider[];
 	private _config: object;
+	private static _globalpluggables: LoggingProvider[] = [];
 
 	/**
 	 * @constructor
@@ -50,9 +61,21 @@ export class ConsoleLogger implements Logger {
 		this.name = name;
 		this.level = level;
 		this._pluggables = [];
+		this.addPluggable = this.addPluggable.bind(this);
 	}
 
 	static LOG_LEVEL = null;
+	static CLOUD_LOG_LEVEL = null;
+	static globalPluggables(pluggable: LoggingProvider) {
+		if (pluggable && COMPATIBLE_PLUGINS.includes(pluggable.getCategoryName())) {
+			ConsoleLogger._globalpluggables.push(pluggable);
+		}
+	}
+
+	static clearGlobalPluggables() {
+		ConsoleLogger._globalpluggables = [];
+	}
+	static connectivity;
 
 	_padding(n) {
 		return n < 10 ? '0' + n : '' + n;
@@ -77,6 +100,19 @@ export class ConsoleLogger implements Logger {
 		return this._config;
 	}
 
+	_checkPluggables() {
+		if (this._pluggables.length !== ConsoleLogger._globalpluggables.length) {
+			if (ConsoleLogger._globalpluggables.length > 0) {
+				ConsoleLogger._globalpluggables.forEach(this.addPluggable);
+				return;
+			}
+
+			if (ConsoleLogger._globalpluggables.length === 0) {
+				this._pluggables = [];
+			}
+		}
+	}
+
 	/**
 	 * Write log
 	 * @method
@@ -85,6 +121,39 @@ export class ConsoleLogger implements Logger {
 	 * @param {string|object} msg - Logging message or object
 	 */
 	_log(type: LOG_TYPE | string, ...msg) {
+		if (!cloudWatchExcludeList.includes(this.name)) {
+			this._checkPluggables();
+		}
+
+		const generateMessage = (msg: any[]): void => {};
+
+		const generateCloudMessage = (msg: any[]) => {
+			let message = '';
+			let data;
+
+			if (msg.length === 1 && typeof msg[0] === 'string') {
+				message = 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];
+				}
+				message = msg[0];
+				data = obj;
+			} else {
+				data = msg;
+			}
+
+			return JSON.stringify({
+				level: type,
+				class: this.name,
+				message,
+				data,
+			});
+		};
+
 		let logger_level_name = this.level;
 		if (ConsoleLogger.LOG_LEVEL) {
 			logger_level_name = ConsoleLogger.LOG_LEVEL;
@@ -94,43 +163,60 @@ export class ConsoleLogger implements Logger {
 		}
 		const logger_level = LOG_LEVELS[logger_level_name];
 		const type_level = LOG_LEVELS[type];
-		if (!(type_level >= logger_level)) {
-			// Do nothing if type is not greater than or equal to logger level (handle undefined)
-			return;
-		}
+		if (type_level >= logger_level) {
+			let log = console.log.bind(console);
 
-		let log = console.log.bind(console);
-		if (type === LOG_TYPE.ERROR && console.error) {
-			log = console.error.bind(console);
-		}
-		if (type === LOG_TYPE.WARN && console.warn) {
-			log = console.warn.bind(console);
-		}
+			if (type === LOG_TYPE.ERROR && console.error) {
+				log = console.error.bind(console);
+			}
+			if (type === LOG_TYPE.WARN && console.warn) {
+				log = console.warn.bind(console);
+			}
+
+			const prefix = `[${type}] ${this._ts()} ${this.name}`;
+			let message = '';
+			let data;
 
-		const prefix = `[${type}] ${this._ts()} ${this.name}`;
-		let message = '';
-
-		if (msg.length === 1 && typeof msg[0] === 'string') {
-			message = `${prefix} - ${msg[0]}`;
-			log(message);
-		} else if (msg.length === 1) {
-			message = `${prefix} ${msg[0]}`;
-			log(prefix, msg[0]);
-		} else if (typeof msg[0] === 'string') {
-			let obj = msg.slice(1);
-			if (obj.length === 1) {
-				obj = obj[0];
+			if (msg.length === 1 && typeof msg[0] === 'string') {
+				message = msg[0];
+				log(`${prefix} - ${message}`);
+			} else if (msg.length === 1) {
+				data = msg[0];
+				log(prefix, data);
+			} else if (typeof msg[0] === 'string') {
+				let obj = msg.slice(1);
+				if (obj.length === 1) {
+					obj = obj[0];
+				}
+				message = msg[0];
+				data = obj;
+				log(`${prefix} - ${message}`, data);
+			} else {
+				data = msg;
+				log(prefix, data);
 			}
-			message = `${prefix} - ${msg[0]} ${obj}`;
-			log(`${prefix} - ${msg[0]}`, obj);
-		} else {
-			message = `${prefix} ${msg}`;
-			log(prefix, msg);
 		}
 
-		for (const plugin of this._pluggables) {
-			const logEvent: InputLogEvent = { message, timestamp: Date.now() };
-			plugin.pushLogs([logEvent]);
+		if (
+			ConsoleLogger.CLOUD_LOG_LEVEL != null &&
+			!cloudWatchExcludeList.includes(this.name)
+		) {
+			const cloudMessage = generateCloudMessage(msg);
+			for (const plugin of this._pluggables) {
+				const logger_level = LOG_LEVELS[ConsoleLogger.CLOUD_LOG_LEVEL];
+				const type_level = LOG_LEVELS[type];
+
+				const logEvent: InputLogEvent = {
+					message: cloudMessage,
+					timestamp: Date.now(),
+				};
+
+				if (type_level >= logger_level) {
+					plugin.pushLogs([logEvent]);
+				} else {
+					plugin.pushLogs([]);
+				}
+			}
 		}
 	}
 
@@ -195,9 +281,8 @@ export class ConsoleLogger implements Logger {
 	}
 
 	addPluggable(pluggable: LoggingProvider) {
-		if (pluggable && pluggable.getCategoryName() === AWS_CLOUDWATCH_CATEGORY) {
+		if (pluggable && COMPATIBLE_PLUGINS.includes(pluggable.getCategoryName())) {
 			this._pluggables.push(pluggable);
-			pluggable.configure(this._config);
 		}
 	}
 

package/src/Platform/version.ts

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

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 = 30000;
 class AWSCloudWatchProvider implements LoggingProvider {
 	static readonly PROVIDER_NAME = AWS_CLOUDWATCH_PROVIDER_NAME;
 	static readonly CATEGORY = AWS_CLOUDWATCH_CATEGORY;
@@ -65,17 +73,29 @@ 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 static instance: AWSCloudWatchProvider;
+
 	public getProviderName(): string {
 		return AWSCloudWatchProvider.PROVIDER_NAME;
 	}
@@ -88,9 +108,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 +241,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 Cloudwatch 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 +435,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
@@ -509,8 +555,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,
 };