@aws-amplify/auth 5.6.1 → 5.6.2-unstable.bee9c8e.0

package/src/internals/InternalAuth.ts

@@ -25,9 +25,11 @@ import {
 
 import {
 	Amplify,
+	AuthAction,
 	ConsoleLogger as Logger,
 	Credentials,
 	CustomUserAgentDetails,
+	getAmplifyUserAgent,
 	Hub,
 	StorageHelper,
 	ICredentials,
@@ -40,7 +42,6 @@ import {
 } from '@aws-amplify/core';
 import {
 	CookieStorage,
-	CognitoUserPool,
 	AuthenticationDetails,
 	ICognitoUserPoolData,
 	ICognitoUserData,
@@ -60,6 +61,8 @@ import {
 import {
 	addAuthCategoryToCognitoUserAgent,
 	addFrameworkToCognitoUserAgent,
+	InternalCognitoUser,
+	InternalCognitoUserPool,
 } from 'amazon-cognito-identity-js/internals';
 
 import { parse } from 'url';
@@ -72,6 +75,7 @@ import {
 	CognitoHostedUIIdentityProvider,
 	IAuthDevice,
 } from '../types/Auth';
+import { getAuthUserAgentDetails, getAuthUserAgentValue } from '../utils';
 
 const logger = new Logger('AuthClass');
 const USER_ADMIN_SCOPE = 'aws.cognito.signin.user.admin';
@@ -101,7 +105,7 @@ const MAX_AUTOSIGNIN_POLLING_MS = 3 * 60 * 1000;
  */
 export class InternalAuthClass {
 	private _config: AuthOptions;
-	private userPool: CognitoUserPool = null;
+	private userPool: InternalCognitoUserPool = null;
 	private user: any = null;
 	private _oAuthHandler: OAuth;
 	private _storage;
@@ -205,7 +209,7 @@ export class InternalAuthClass {
 			};
 			userPoolData.Storage = this._storage;
 
-			this.userPool = new CognitoUserPool(
+			this.userPool = new InternalCognitoUserPool(
 				userPoolData,
 				this.wrapRefreshSessionCallback
 			);
@@ -256,14 +260,17 @@ export class InternalAuthClass {
 			// Prevents _handleAuthResponse from being called multiple times in Expo
 			// See https://github.com/aws-amplify/amplify-js/issues/4388
 			const usedResponseUrls = {};
-			urlListener(({ url }) => {
-				if (usedResponseUrls[url]) {
-					return;
-				}
+			// Only register urlListener once
+			if (this.getModuleName() === 'InternalAuth') {
+				urlListener(({ url }) => {
+					if (usedResponseUrls[url]) {
+						return;
+					}
 
-				usedResponseUrls[url] = true;
-				this._handleAuthResponse(url);
-			});
+					usedResponseUrls[url] = true;
+					this._handleAuthResponse(url);
+				});
+			}
 		}
 
 		dispatchAuthEvent(
@@ -408,6 +415,10 @@ export class InternalAuthClass {
 		logger.debug('signUp validation data:', validationData);
 
 		return new Promise((resolve, reject) => {
+			const userAgentDetails = getAuthUserAgentDetails(
+				AuthAction.SignUp,
+				customUserAgentDetails
+			);
 			this.userPool.signUp(
 				username,
 				password,
@@ -433,13 +444,15 @@ export class InternalAuthClass {
 								password,
 								autoSignInValidationData,
 								autoSignInClientMetaData,
-								data
+								data,
+								userAgentDetails
 							);
 						}
 						resolve(data);
 					}
 				},
-				clientMetadata
+				clientMetadata,
+				getAmplifyUserAgent(userAgentDetails)
 			);
 		});
 	}
@@ -449,7 +462,8 @@ export class InternalAuthClass {
 		password: string,
 		validationData: {},
 		clientMetadata: any,
-		data: any
+		data: any,
+		customUserAgentDetails: CustomUserAgentDetails
 	) {
 		this.autoSignInInitiated = true;
 		const authDetails = new AuthenticationDetails({
@@ -459,24 +473,34 @@ export class InternalAuthClass {
 			ClientMetadata: clientMetadata,
 		});
 		if (data.userConfirmed) {
-			this.signInAfterUserConfirmed(authDetails);
+			this.signInAfterUserConfirmed(authDetails, customUserAgentDetails);
 		} else if (this._config.signUpVerificationMethod === 'link') {
-			this.handleLinkAutoSignIn(authDetails);
+			this.handleLinkAutoSignIn(authDetails, customUserAgentDetails);
 		} else {
-			this.handleCodeAutoSignIn(authDetails);
+			this.handleCodeAutoSignIn(authDetails, customUserAgentDetails);
 		}
 	}
 
-	private handleCodeAutoSignIn(authDetails: AuthenticationDetails) {
+	private handleCodeAutoSignIn(
+		authDetails: AuthenticationDetails,
+		customUserAgentDetails: CustomUserAgentDetails
+	) {
 		const listenEvent = ({ payload }) => {
 			if (payload.event === 'confirmSignUp') {
-				this.signInAfterUserConfirmed(authDetails, listenEvent);
+				this.signInAfterUserConfirmed(
+					authDetails,
+					customUserAgentDetails,
+					listenEvent
+				);
 			}
 		};
 		Hub.listen('auth', listenEvent);
 	}
 
-	private handleLinkAutoSignIn(authDetails: AuthenticationDetails) {
+	private handleLinkAutoSignIn(
+		authDetails: AuthenticationDetails,
+		customUserAgentDetails: CustomUserAgentDetails
+	) {
 		this._storage.setItem('amplify-polling-started', 'true');
 		const start = Date.now();
 		const autoSignInPollingIntervalId = setInterval(() => {
@@ -491,7 +515,8 @@ export class InternalAuthClass {
 			} else {
 				this.signInAfterUserConfirmed(
 					authDetails,
-					null,
+					customUserAgentDetails,
+					undefined,
 					autoSignInPollingIntervalId
 				);
 			}
@@ -500,6 +525,7 @@ export class InternalAuthClass {
 
 	private async signInAfterUserConfirmed(
 		authDetails: AuthenticationDetails,
+		customUserAgentDetails: CustomUserAgentDetails,
 		listenEvent?: HubCallback,
 		autoSignInPollingIntervalId?: ReturnType<typeof setInterval>
 	) {
@@ -527,8 +553,10 @@ export class InternalAuthClass {
 					error => {
 						logger.error(error);
 						this._storage.removeItem('amplify-auto-sign-in');
-					}
-				)
+					},
+					customUserAgentDetails
+				),
+				getAmplifyUserAgent(customUserAgentDetails)
 			);
 		} catch (error) {
 			logger.error(error);
@@ -596,7 +624,8 @@ export class InternalAuthClass {
 						resolve(data);
 					}
 				},
-				clientMetadata
+				clientMetadata,
+				getAuthUserAgentValue(AuthAction.ConfirmSignUp, customUserAgentDetails)
 			);
 		});
 	}
@@ -627,13 +656,17 @@ export class InternalAuthClass {
 
 		const user = this.createCognitoUser(username);
 		return new Promise((resolve, reject) => {
-			user.resendConfirmationCode((err, data) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(data);
-				}
-			}, clientMetadata);
+			user.resendConfirmationCode(
+				(err, data) => {
+					if (err) {
+						reject(err);
+					} else {
+						resolve(data);
+					}
+				},
+				clientMetadata,
+				getAuthUserAgentValue(AuthAction.ResendSignUp, customUserAgentDetails)
+			);
 		});
 	}
 
@@ -683,24 +716,29 @@ export class InternalAuthClass {
 			ValidationData: validationData,
 			ClientMetadata: clientMetadata,
 		});
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.SignIn,
+			customUserAgentDetails
+		);
 		if (password) {
-			return this.signInWithPassword(authDetails);
+			return this.signInWithPassword(authDetails, userAgentDetails);
 		} else {
-			return this.signInWithoutPassword(authDetails);
+			return this.signInWithoutPassword(authDetails, userAgentDetails);
 		}
 	}
 
 	/**
 	 * Return an object with the authentication callbacks
-	 * @param {CognitoUser} user - the cognito user object
+	 * @param {InternalCognitoUser} user - the cognito user object
 	 * @param {} resolve - function called when resolving the current step
 	 * @param {} reject - function called when rejecting the current step
 	 * @return - an object with the callback methods for user authentication
 	 */
 	private authCallbacks(
-		user: CognitoUser,
-		resolve: (value?: CognitoUser | any) => void,
-		reject: (value?: any) => void
+		user: InternalCognitoUser,
+		resolve: (value?: InternalCognitoUser | any) => void,
+		reject: (value?: any) => void,
+		customUserAgentDetails: CustomUserAgentDetails
 	): IAuthenticationCallback {
 		const that = this;
 		return {
@@ -718,7 +756,10 @@ export class InternalAuthClass {
 					try {
 						// In order to get user attributes and MFA methods
 						// We need to trigger currentUserPoolUser again
-						const currentUser = await this.currentUserPoolUser();
+						const currentUser = await this._currentUserPoolUser(
+							undefined,
+							customUserAgentDetails
+						);
 						that.user = currentUser;
 						dispatchAuthEvent(
 							'signIn',
@@ -787,11 +828,13 @@ export class InternalAuthClass {
 	 * Sign in with a password
 	 * @private
 	 * @param {AuthenticationDetails} authDetails - the user sign in data
+	 * @param {CustomUserAgentDetails} customUserAgentDetails - Optional parameter to send user agent details
 	 * @return - A promise resolves the CognitoUser object if success or mfa required
 	 */
 	private signInWithPassword(
-		authDetails: AuthenticationDetails
-	): Promise<CognitoUser | any> {
+		authDetails: AuthenticationDetails,
+		customUserAgentDetails: CustomUserAgentDetails
+	): Promise<InternalCognitoUser | any> {
 		if (this.pendingSignIn) {
 			throw new Error('Pending sign-in attempt already in progress');
 		}
@@ -810,8 +853,10 @@ export class InternalAuthClass {
 					error => {
 						this.pendingSignIn = null;
 						reject(error);
-					}
-				)
+					},
+					customUserAgentDetails
+				),
+				getAmplifyUserAgent(customUserAgentDetails)
 			);
 		});
 
@@ -822,16 +867,22 @@ export class InternalAuthClass {
 	 * Sign in without a password
 	 * @private
 	 * @param {AuthenticationDetails} authDetails - the user sign in data
-	 * @return - A promise resolves the CognitoUser object if success or mfa required
+	 * @param {CustomUserAgentDetails} customUserAgentDetails - Optional parameter to send user agent details
+	 * @return - A promise resolves the InternalCognitoUser object if success or mfa required
 	 */
 	private signInWithoutPassword(
-		authDetails: AuthenticationDetails
-	): Promise<CognitoUser | any> {
+		authDetails: AuthenticationDetails,
+		customUserAgentDetails: CustomUserAgentDetails
+	): Promise<InternalCognitoUser | any> {
 		const user = this.createCognitoUser(authDetails.getUsername());
 		user.setAuthenticationFlowType('CUSTOM_AUTH');
 
 		return new Promise((resolve, reject) => {
-			user.initiateAuth(authDetails, this.authCallbacks(user, resolve, reject));
+			user.initiateAuth(
+				authDetails,
+				this.authCallbacks(user, resolve, reject, customUserAgentDetails),
+				getAmplifyUserAgent(customUserAgentDetails)
+			);
 		});
 	}
 
@@ -848,8 +899,10 @@ export class InternalAuthClass {
 		user: CognitoUser | any,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<MFAOption[]> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		return new Promise((res, rej) => {
-			user.getMFAOptions((err, mfaOptions) => {
+			internalUser.getMFAOptions((err, mfaOptions) => {
 				if (err) {
 					logger.debug('get MFA Options failed', err);
 					rej(err);
@@ -858,7 +911,7 @@ export class InternalAuthClass {
 				logger.debug('get MFA options success', mfaOptions);
 				res(mfaOptions);
 				return;
-			});
+			}, getAuthUserAgentValue(AuthAction.GetMFAOptions, customUserAgentDetails));
 		});
 	}
 
@@ -873,18 +926,23 @@ export class InternalAuthClass {
 		params?: GetPreferredMFAOpts,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser: InternalCognitoUser | any = user;
 		const that = this;
 		return new Promise((res, rej) => {
 			const clientMetadata = this._config.clientMetadata; // TODO: verify behavior if this is override during signIn
 
 			const bypassCache = params ? params.bypassCache : false;
-			user.getUserData(
+			const userAgentValue = getAuthUserAgentValue(
+				AuthAction.GetPreferredMFA,
+				customUserAgentDetails
+			);
+			internalUser.getUserData(
 				async (err, data) => {
 					if (err) {
 						logger.debug('getting preferred mfa failed', err);
 						if (this.isSessionInvalid(err)) {
 							try {
-								await this.cleanUpInvalidSession(user);
+								await this.cleanUpInvalidSession(user, userAgentValue);
 							} catch (cleanUpError) {
 								rej(
 									new Error(
@@ -907,7 +965,8 @@ export class InternalAuthClass {
 						return;
 					}
 				},
-				{ bypassCache, clientMetadata }
+				{ bypassCache, clientMetadata },
+				userAgentValue
 			);
 		});
 	}
@@ -942,29 +1001,37 @@ export class InternalAuthClass {
 		return ret;
 	}
 
-	private _getUserData(user, params) {
+	private _getUserData(
+		user: InternalCognitoUser,
+		params,
+		userAgentValue: string
+	) {
 		return new Promise((res, rej) => {
-			user.getUserData(async (err, data) => {
-				if (err) {
-					logger.debug('getting user data failed', err);
-					if (this.isSessionInvalid(err)) {
-						try {
-							await this.cleanUpInvalidSession(user);
-						} catch (cleanUpError) {
-							rej(
-								new Error(
-									`Session is invalid due to: ${err.message} and failed to clean up invalid session: ${cleanUpError.message}`
-								)
-							);
-							return;
+			user.getUserData(
+				async (err, data) => {
+					if (err) {
+						logger.debug('getting user data failed', err);
+						if (this.isSessionInvalid(err)) {
+							try {
+								await this.cleanUpInvalidSession(user, userAgentValue);
+							} catch (cleanUpError) {
+								rej(
+									new Error(
+										`Session is invalid due to: ${err.message} and failed to clean up invalid session: ${cleanUpError.message}`
+									)
+								);
+								return;
+							}
 						}
+						rej(err);
+						return;
+					} else {
+						res(data);
 					}
-					rej(err);
-					return;
-				} else {
-					res(data);
-				}
-			}, params);
+				},
+				params,
+				userAgentValue
+			);
 		});
 	}
 
@@ -980,12 +1047,21 @@ export class InternalAuthClass {
 		mfaMethod: 'TOTP' | 'SMS' | 'NOMFA' | 'SMS_MFA' | 'SOFTWARE_TOKEN_MFA',
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser: InternalCognitoUser | any = user;
+		const userAgentValue = getAuthUserAgentValue(
+			AuthAction.SetPreferredMFA,
+			customUserAgentDetails
+		);
 		const clientMetadata = this._config.clientMetadata; // TODO: verify behavior if this is override during signIn
 
-		const userData = await this._getUserData(user, {
-			bypassCache: true,
-			clientMetadata,
-		});
+		const userData = await this._getUserData(
+			user,
+			{
+				bypassCache: true,
+				clientMetadata,
+			},
+			userAgentValue
+		);
 		let smsMfaSettings = null;
 		let totpMfaSettings = null;
 
@@ -1048,7 +1124,7 @@ export class InternalAuthClass {
 
 		const that = this;
 		return new Promise<string>((res, rej) => {
-			user.setUserMfaPreference(
+			internalUser.setUserMfaPreference(
 				smsMfaSettings,
 				totpMfaSettings,
 				(err, result) => {
@@ -1059,13 +1135,13 @@ export class InternalAuthClass {
 					logger.debug('Set user mfa success', result);
 					logger.debug('Caching the latest user data into local');
 					// cache the latest result into user data
-					user.getUserData(
+					internalUser.getUserData(
 						async (err, data) => {
 							if (err) {
 								logger.debug('getting user data failed', err);
 								if (this.isSessionInvalid(err)) {
 									try {
-										await this.cleanUpInvalidSession(user);
+										await this.cleanUpInvalidSession(user, userAgentValue);
 									} catch (cleanUpError) {
 										rej(
 											new Error(
@@ -1083,9 +1159,11 @@ export class InternalAuthClass {
 						{
 							bypassCache: true,
 							clientMetadata,
-						}
+						},
+						userAgentValue
 					);
-				}
+				},
+				userAgentValue
 			);
 		});
 	}
@@ -1101,8 +1179,10 @@ export class InternalAuthClass {
 		user: CognitoUser,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser = user as InternalCognitoUser;
+
 		return new Promise((res, rej) => {
-			user.disableMFA((err, data) => {
+			internalUser.disableMFA((err, data) => {
 				if (err) {
 					logger.debug('disable mfa failed', err);
 					rej(err);
@@ -1111,7 +1191,7 @@ export class InternalAuthClass {
 				logger.debug('disable mfa succeed', data);
 				res(data);
 				return;
-			});
+			}, getAuthUserAgentValue(AuthAction.DisableSMS, customUserAgentDetails));
 		});
 	}
 
@@ -1126,8 +1206,10 @@ export class InternalAuthClass {
 		user: CognitoUser,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser = user as InternalCognitoUser;
+
 		return new Promise((res, rej) => {
-			user.enableMFA((err, data) => {
+			internalUser.enableMFA((err, data) => {
 				if (err) {
 					logger.debug('enable mfa failed', err);
 					rej(err);
@@ -1136,7 +1218,7 @@ export class InternalAuthClass {
 				logger.debug('enable mfa succeed', data);
 				res(data);
 				return;
-			});
+			}, getAuthUserAgentValue(AuthAction.EnableSMS, customUserAgentDetails));
 		});
 	}
 
@@ -1150,19 +1232,24 @@ export class InternalAuthClass {
 		user: CognitoUser | any,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		return new Promise((res, rej) => {
-			user.associateSoftwareToken({
-				onFailure: err => {
-					logger.debug('associateSoftwareToken failed', err);
-					rej(err);
-					return;
-				},
-				associateSecretCode: secretCode => {
-					logger.debug('associateSoftwareToken success', secretCode);
-					res(secretCode);
-					return;
+			internalUser.associateSoftwareToken(
+				{
+					onFailure: err => {
+						logger.debug('associateSoftwareToken failed', err);
+						rej(err);
+						return;
+					},
+					associateSecretCode: secretCode => {
+						logger.debug('associateSoftwareToken success', secretCode);
+						res(secretCode);
+						return;
+					},
 				},
-			});
+				getAuthUserAgentValue(AuthAction.SetupTOTP, customUserAgentDetails)
+			);
 		});
 	}
 
@@ -1179,38 +1266,50 @@ export class InternalAuthClass {
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUserSession> {
 		logger.debug('verification totp token', user, challengeAnswer);
+		const internalUser: InternalCognitoUser | any = user;
 
 		let signInUserSession;
-		if (user && typeof user.getSignInUserSession === 'function') {
-			signInUserSession = (user as CognitoUser).getSignInUserSession();
+		if (
+			internalUser &&
+			typeof internalUser.getSignInUserSession === 'function'
+		) {
+			signInUserSession = (user as InternalCognitoUser).getSignInUserSession();
 		}
 		const isLoggedIn = signInUserSession?.isValid();
 
 		return new Promise((res, rej) => {
-			user.verifySoftwareToken(challengeAnswer, 'My TOTP device', {
-				onFailure: err => {
-					logger.debug('verifyTotpToken failed', err);
-					rej(err);
-					return;
-				},
-				onSuccess: data => {
-					if (!isLoggedIn) {
+			internalUser.verifySoftwareToken(
+				challengeAnswer,
+				'My TOTP device',
+				{
+					onFailure: err => {
+						logger.debug('verifyTotpToken failed', err);
+						rej(err);
+						return;
+					},
+					onSuccess: data => {
+						if (!isLoggedIn) {
+							dispatchAuthEvent(
+								'signIn',
+								internalUser,
+								`A user ${internalUser.getUsername()} has been signed in`
+							);
+						}
 						dispatchAuthEvent(
-							'signIn',
-							user,
-							`A user ${user.getUsername()} has been signed in`
+							'verify',
+							internalUser,
+							`A user ${internalUser.getUsername()} has been verified`
 						);
-					}
-					dispatchAuthEvent(
-						'verify',
-						user,
-						`A user ${user.getUsername()} has been verified`
-					);
-					logger.debug('verifyTotpToken success', data);
-					res(data);
-					return;
+						logger.debug('verifyTotpToken success', data);
+						res(data);
+						return;
+					},
 				},
-			});
+				getAuthUserAgentValue(
+					AuthAction.VerifyTotpToken,
+					customUserAgentDetails
+				)
+			);
 		});
 	}
 
@@ -1229,13 +1328,19 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUser | any> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		if (!code) {
 			return this.rejectAuthError(AuthErrorTypes.EmptyCode);
 		}
 
 		const that = this;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.ConfirmSignIn,
+			customUserAgentDetails
+		);
 		return new Promise((resolve, reject) => {
-			user.sendMFACode(
+			internalUser.sendMFACode(
 				code,
 				{
 					onSuccess: async session => {
@@ -1247,19 +1352,24 @@ export class InternalAuthClass {
 						} catch (e) {
 							logger.debug('cannot get cognito credentials', e);
 						} finally {
-							that.user = user;
+							that.user = internalUser;
 							try {
-								const currentUser = await this.currentUserPoolUser();
-								user.attributes = currentUser.attributes;
+								const currentUser = await this._currentUserPoolUser(
+									undefined,
+									userAgentDetails
+								);
+								Object.assign(internalUser, {
+									attributes: currentUser.attributes,
+								});
 							} catch (e) {
 								logger.debug('cannot get updated Cognito User', e);
 							}
 							dispatchAuthEvent(
 								'signIn',
-								user,
-								`A user ${user.getUsername()} has been signed in`
+								internalUser,
+								`A user ${internalUser.getUsername()} has been signed in`
 							);
-							resolve(user);
+							resolve(internalUser);
 						}
 					},
 					onFailure: err => {
@@ -1268,7 +1378,8 @@ export class InternalAuthClass {
 					},
 				},
 				mfaType,
-				clientMetadata
+				clientMetadata,
+				getAmplifyUserAgent(userAgentDetails)
 			);
 		});
 	}
@@ -1280,13 +1391,15 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUser | any> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		if (!password) {
 			return this.rejectAuthError(AuthErrorTypes.EmptyPassword);
 		}
 
 		const that = this;
 		return new Promise((resolve, reject) => {
-			user.completeNewPasswordChallenge(
+			internalUser.completeNewPasswordChallenge(
 				password,
 				requiredAttributes,
 				{
@@ -1299,13 +1412,13 @@ export class InternalAuthClass {
 						} catch (e) {
 							logger.debug('cannot get cognito credentials', e);
 						} finally {
-							that.user = user;
+							that.user = internalUser;
 							dispatchAuthEvent(
 								'signIn',
-								user,
-								`A user ${user.getUsername()} has been signed in`
+								internalUser,
+								`A user ${internalUser.getUsername()} has been signed in`
 							);
-							resolve(user);
+							resolve(internalUser);
 						}
 					},
 					onFailure: err => {
@@ -1319,24 +1432,28 @@ export class InternalAuthClass {
 					},
 					mfaRequired: (challengeName, challengeParam) => {
 						logger.debug('signIn MFA required');
-						user['challengeName'] = challengeName;
-						user['challengeParam'] = challengeParam;
-						resolve(user);
+						internalUser['challengeName'] = challengeName;
+						internalUser['challengeParam'] = challengeParam;
+						resolve(internalUser);
 					},
 					mfaSetup: (challengeName, challengeParam) => {
 						logger.debug('signIn mfa setup', challengeName);
-						user['challengeName'] = challengeName;
-						user['challengeParam'] = challengeParam;
-						resolve(user);
+						internalUser['challengeName'] = challengeName;
+						internalUser['challengeParam'] = challengeParam;
+						resolve(internalUser);
 					},
 					totpRequired: (challengeName, challengeParam) => {
 						logger.debug('signIn mfa setup', challengeName);
-						user['challengeName'] = challengeName;
-						user['challengeParam'] = challengeParam;
-						resolve(user);
+						internalUser['challengeName'] = challengeName;
+						internalUser['challengeParam'] = challengeParam;
+						resolve(internalUser);
 					},
 				},
-				clientMetadata
+				clientMetadata,
+				getAuthUserAgentValue(
+					AuthAction.CompleteNewPassword,
+					customUserAgentDetails
+				)
 			);
 		});
 	}
@@ -1347,6 +1464,7 @@ export class InternalAuthClass {
 	 * @param {String} challengeResponses - The confirmation code
 	 * @param {ClientMetaData} clientMetadata - optional client metadata defaults to config
 	 * @param {CustomUserAgentDetails} customUserAgentDetails - Optional parameter to send user agent details
+	 *
 	 */
 	public sendCustomChallengeAnswer(
 		user: CognitoUser | any,
@@ -1354,6 +1472,8 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUser | any> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		if (!this.userPool) {
 			return this.rejectNoUserPool();
 		}
@@ -1362,11 +1482,16 @@ export class InternalAuthClass {
 		}
 
 		const that = this;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.SendCustomChallengeAnswer,
+			customUserAgentDetails
+		);
 		return new Promise((resolve, reject) => {
-			user.sendCustomChallengeAnswer(
+			internalUser.sendCustomChallengeAnswer(
 				challengeResponses,
-				this.authCallbacks(user, resolve, reject),
-				clientMetadata
+				this.authCallbacks(internalUser, resolve, reject, userAgentDetails),
+				clientMetadata,
+				getAmplifyUserAgent(userAgentDetails)
 			);
 		});
 	}
@@ -1383,16 +1508,25 @@ export class InternalAuthClass {
 		attributeNames: string[],
 		customUserAgentDetails?: CustomUserAgentDetails
 	) {
+		const internalUser: InternalCognitoUser | any = user;
 		const that = this;
+		const userAgentValue = getAuthUserAgentValue(
+			AuthAction.DeleteUserAttributes,
+			customUserAgentDetails
+		);
 		return new Promise((resolve, reject) => {
-			that.userSession(user).then(session => {
-				user.deleteAttributes(attributeNames, (err, result) => {
-					if (err) {
-						return reject(err);
-					} else {
-						return resolve(result);
-					}
-				});
+			that._userSession(userAgentValue, internalUser).then(session => {
+				internalUser.deleteAttributes(
+					attributeNames,
+					(err, result) => {
+						if (err) {
+							return reject(err);
+						} else {
+							return resolve(result);
+						}
+					},
+					userAgentValue
+				);
 			});
 		});
 	}
@@ -1419,18 +1553,26 @@ export class InternalAuthClass {
 
 		return new Promise(async (res, rej) => {
 			if (this.userPool) {
-				const user = this.userPool.getCurrentUser();
+				const internalUser =
+					this.userPool.getCurrentUser() as InternalCognitoUser;
 
-				if (!user) {
+				if (!internalUser) {
 					logger.debug('Failed to get user from user pool');
 					return rej(new Error('No current user.'));
 				} else {
-					user.getSession(async (err, session) => {
+					const userAgentValue = getAuthUserAgentValue(
+						AuthAction.DeleteUser,
+						customUserAgentDetails
+					);
+					internalUser.getSession(async (err, session) => {
 						if (err) {
 							logger.debug('Failed to get the user session', err);
 							if (this.isSessionInvalid(err)) {
 								try {
-									await this.cleanUpInvalidSession(user);
+									await this.cleanUpInvalidSession(
+										internalUser,
+										userAgentValue
+									);
 								} catch (cleanUpError) {
 									rej(
 										new Error(
@@ -1442,36 +1584,40 @@ export class InternalAuthClass {
 							}
 							return rej(err);
 						} else {
-							user.deleteUser((err, result: string) => {
-								if (err) {
-									rej(err);
-								} else {
-									dispatchAuthEvent(
-										'userDeleted',
-										result,
-										'The authenticated user has been deleted.'
-									);
-									user.signOut();
-									this.user = null;
-									try {
-										this.cleanCachedItems(); // clean aws credentials
-									} catch (e) {
-										// TODO: change to rejects in refactor
-										logger.debug('failed to clear cached items');
-									}
-
-									if (isSignedInHostedUI) {
-										this.oAuthSignOutRedirect(res, rej);
+							internalUser.deleteUser(
+								(err, result: string) => {
+									if (err) {
+										rej(err);
 									} else {
 										dispatchAuthEvent(
-											'signOut',
-											this.user,
-											`A user has been signed out`
+											'userDeleted',
+											result,
+											'The authenticated user has been deleted.'
 										);
-										res(result);
+										internalUser.signOut(undefined, userAgentValue);
+										this.user = null;
+										try {
+											this.cleanCachedItems(); // clean aws credentials
+										} catch (e) {
+											// TODO: change to rejects in refactor
+											logger.debug('failed to clear cached items');
+										}
+
+										if (isSignedInHostedUI) {
+											this.oAuthSignOutRedirect(res, rej);
+										} else {
+											dispatchAuthEvent(
+												'signOut',
+												this.user,
+												`A user has been signed out`
+											);
+											res(result);
+										}
 									}
-								}
-							});
+								},
+								undefined,
+								userAgentValue
+							);
 						}
 					});
 				}
@@ -1496,10 +1642,15 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const internalUser: InternalCognitoUser | any = user;
 		const attributeList: ICognitoUserAttributeData[] = [];
 		const that = this;
+		const userAgentValue = getAuthUserAgentValue(
+			AuthAction.UpdateUserAttributes,
+			customUserAgentDetails
+		);
 		return new Promise((resolve, reject) => {
-			that.userSession(user).then(session => {
+			that._userSession(userAgentValue, internalUser).then(session => {
 				for (const key in attributes) {
 					if (key !== 'sub' && key.indexOf('_verified') < 0) {
 						const attr: ICognitoUserAttributeData = {
@@ -1509,7 +1660,7 @@ export class InternalAuthClass {
 						attributeList.push(attr);
 					}
 				}
-				user.updateAttributes(
+				internalUser.updateAttributes(
 					attributeList,
 					(err, result, details) => {
 						if (err) {
@@ -1532,7 +1683,8 @@ export class InternalAuthClass {
 							return resolve(result);
 						}
 					},
-					clientMetadata
+					clientMetadata,
+					userAgentValue
 				);
 			});
 		});
@@ -1568,15 +1720,27 @@ export class InternalAuthClass {
 		user: CognitoUser | any,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUserAttribute[]> {
+		return this._userAttributes(user, customUserAgentDetails);
+	}
+
+	private _userAttributes(
+		user: CognitoUser | any,
+		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<CognitoUserAttribute[]> {
+		const internalUser: InternalCognitoUser | any = user;
+		const userAgentValue = getAuthUserAgentValue(
+			AuthAction.UserAttributes,
+			customUserAgentDetails
+		);
 		return new Promise((resolve, reject) => {
-			this.userSession(user).then(session => {
-				user.getUserAttributes((err, attributes) => {
+			this._userSession(userAgentValue, internalUser).then(session => {
+				internalUser.getUserAttributes((err, attributes) => {
 					if (err) {
 						reject(err);
 					} else {
 						resolve(attributes);
 					}
-				});
+				}, userAgentValue);
 			});
 		});
 	}
@@ -1586,7 +1750,13 @@ export class InternalAuthClass {
 		customUserAgentDetails?: CustomUserAgentDetails
 	) {
 		const that = this;
-		return this.userAttributes(user).then(attributes => {
+		return this._userAttributes(
+			user,
+			getAuthUserAgentDetails(
+				AuthAction.VerifiedContact,
+				customUserAgentDetails
+			)
+		).then(attributes => {
 			const attrs = that.attributesToObject(attributes);
 			const unverified = {};
 			const verified = {};
@@ -1687,8 +1857,11 @@ export class InternalAuthClass {
 		);
 	}
 
-	private async cleanUpInvalidSession(user: CognitoUser) {
-		user.signOut();
+	private async cleanUpInvalidSession(
+		internalUser: InternalCognitoUser,
+		userAgentValue: string
+	) {
+		internalUser.signOut(undefined, userAgentValue);
 		this.user = null;
 		try {
 			await this.cleanCachedItems(); // clean aws credentials
@@ -1713,6 +1886,13 @@ export class InternalAuthClass {
 	public currentUserPoolUser(
 		params?: CurrentUserOpts,
 		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<CognitoUser | any> {
+		return this._currentUserPoolUser(params, customUserAgentDetails);
+	}
+
+	private _currentUserPoolUser(
+		params?: CurrentUserOpts,
+		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUser | any> {
 		if (!this.userPool) {
 			return this.rejectNoUserPool();
@@ -1753,9 +1933,10 @@ export class InternalAuthClass {
 						});
 					}
 
-					const user = this.userPool.getCurrentUser();
+					const internalUser =
+						this.userPool.getCurrentUser() as InternalCognitoUser;
 
-					if (!user) {
+					if (!internalUser) {
 						logger.debug('Failed to get user from user pool');
 						rej('No current user');
 						return;
@@ -1763,7 +1944,14 @@ export class InternalAuthClass {
 
 					// refresh the session if the session expired.
 					try {
-						const session = await this._userSession(user);
+						const userAgentValue = getAuthUserAgentValue(
+							AuthAction.CurrentUserPoolUser,
+							customUserAgentDetails
+						);
+						const session = await this._userSession(
+							userAgentValue,
+							internalUser
+						);
 
 						// get user data from Cognito
 						const bypassCache = params ? params.bypassCache : false;
@@ -1777,13 +1965,16 @@ export class InternalAuthClass {
 						// validate the token's scope first before calling this function
 						const { scope = '' } = session.getAccessToken().decodePayload();
 						if (scope.split(' ').includes(USER_ADMIN_SCOPE)) {
-							user.getUserData(
+							internalUser.getUserData(
 								async (err, data) => {
 									if (err) {
 										logger.debug('getting user data failed', err);
 										if (this.isSessionInvalid(err)) {
 											try {
-												await this.cleanUpInvalidSession(user);
+												await this.cleanUpInvalidSession(
+													internalUser,
+													userAgentValue
+												);
 											} catch (cleanUpError) {
 												rej(
 													new Error(
@@ -1794,12 +1985,12 @@ export class InternalAuthClass {
 											}
 											rej(err);
 										} else {
-											res(user);
+											res(internalUser);
 										}
 										return;
 									}
 									const preferredMFA = data.PreferredMfaSetting || 'NOMFA';
-									const attributeList = [];
+									const attributeList: CognitoUserAttribute[] = [];
 
 									for (let i = 0; i < data.UserAttributes.length; i++) {
 										const attribute = {
@@ -1811,17 +2002,18 @@ export class InternalAuthClass {
 									}
 
 									const attributes = this.attributesToObject(attributeList);
-									Object.assign(user, { attributes, preferredMFA });
-									return res(user);
+									Object.assign(internalUser, { attributes, preferredMFA });
+									return res(internalUser);
 								},
-								{ bypassCache, clientMetadata }
+								{ bypassCache, clientMetadata },
+								userAgentValue
 							);
 						} else {
 							logger.debug(
 								`Unable to get the user data because the ${USER_ADMIN_SCOPE} ` +
 									`is not in the scopes of the access token`
 							);
-							return res(user);
+							return res(internalUser);
 						}
 					} catch (err) {
 						rej(err);
@@ -1844,7 +2036,14 @@ export class InternalAuthClass {
 	 * @param {CustomUserAgentDetails} customUserAgentDetails - Optional parameter to send user agent details
 	 * @return - A promise resolves to current authenticated CognitoUser if success
 	 */
-	public async currentAuthenticatedUser(
+	public currentAuthenticatedUser(
+		params?: CurrentUserOpts,
+		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<CognitoUser | any> {
+		return this._currentAuthenticatedUser(params, customUserAgentDetails);
+	}
+
+	private async _currentAuthenticatedUser(
 		params?: CurrentUserOpts,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUser | any> {
@@ -1879,7 +2078,13 @@ export class InternalAuthClass {
 			logger.debug('get current authenticated userpool user');
 			let user = null;
 			try {
-				user = await this.currentUserPoolUser(params);
+				user = await this._currentUserPoolUser(
+					params,
+					getAuthUserAgentDetails(
+						AuthAction.CurrentAuthenticatedUser,
+						customUserAgentDetails
+					)
+				);
 			} catch (e) {
 				if (e === 'No userPool') {
 					logger.error(
@@ -1902,8 +2107,18 @@ export class InternalAuthClass {
 	 */
 	public currentSession(
 		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<CognitoUserSession> {
+		return this._currentSession(customUserAgentDetails);
+	}
+
+	private _currentSession(
+		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUserSession> {
 		const that = this;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.CurrentSession,
+			customUserAgentDetails
+		);
 		logger.debug('Getting current session');
 		// Purposely not calling the reject method here because we don't need a console error
 		if (!this.userPool) {
@@ -1912,10 +2127,10 @@ export class InternalAuthClass {
 
 		return new Promise((res, rej) => {
 			that
-				.currentUserPoolUser()
+				._currentUserPoolUser(undefined, userAgentDetails)
 				.then(user => {
 					that
-						.userSession(user)
+						._userSession(getAmplifyUserAgent(userAgentDetails), user)
 						.then(session => {
 							res(session);
 							return;
@@ -1934,8 +2149,11 @@ export class InternalAuthClass {
 		});
 	}
 
-	private async _userSession(user?: CognitoUser): Promise<CognitoUserSession> {
-		if (!user) {
+	private async _userSession(
+		userAgentValue: string,
+		internalUser?: InternalCognitoUser
+	): Promise<CognitoUserSession> {
+		if (!internalUser) {
 			logger.debug('the user is null');
 			return this.rejectAuthError(AuthErrorTypes.NoUserSession);
 		}
@@ -1945,13 +2163,19 @@ export class InternalAuthClass {
 		if (this.inflightSessionPromiseCounter === 0) {
 			this.inflightSessionPromise = new Promise<CognitoUserSession>(
 				(res, rej) => {
-					user.getSession(
+					internalUser.getSession(
 						async (err, session) => {
 							if (err) {
-								logger.debug('Failed to get the session from user', user);
+								logger.debug(
+									'Failed to get the session from user',
+									internalUser
+								);
 								if (this.isSessionInvalid(err)) {
 									try {
-										await this.cleanUpInvalidSession(user);
+										await this.cleanUpInvalidSession(
+											internalUser,
+											userAgentValue
+										);
 									} catch (cleanUpError) {
 										rej(
 											new Error(
@@ -1969,7 +2193,8 @@ export class InternalAuthClass {
 								return;
 							}
 						},
-						{ clientMetadata }
+						{ clientMetadata },
+						userAgentValue
 					);
 				}
 			);
@@ -1980,7 +2205,7 @@ export class InternalAuthClass {
 			const userSession = await this.inflightSessionPromise;
 			// Set private member. Avoid user.setSignInUserSession() to prevent excessive localstorage refresh.
 			// @ts-ignore
-			user.signInUserSession = userSession;
+			internalUser.signInUserSession = userSession;
 			return userSession!;
 		} finally {
 			this.inflightSessionPromiseCounter--;
@@ -1997,7 +2222,10 @@ export class InternalAuthClass {
 		user,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<CognitoUserSession> {
-		return this._userSession(user);
+		return this._userSession(
+			getAuthUserAgentValue(AuthAction.UserSession, customUserAgentDetails),
+			user
+		);
 	}
 
 	/**
@@ -2031,7 +2259,12 @@ export class InternalAuthClass {
 			// refresh the jwt token here if necessary
 			return this.Credentials.refreshFederatedToken(federatedInfo);
 		} else {
-			return this.currentSession()
+			return this._currentSession(
+				getAuthUserAgentDetails(
+					AuthAction.CurrentUserCredentials,
+					customUserAgentDetails
+				)
+			)
 				.then(session => {
 					logger.debug('getting session success', session);
 					return this.Credentials.set(session, 'session');
@@ -2054,6 +2287,8 @@ export class InternalAuthClass {
 	 * Initiate an attribute confirmation request
 	 * @param {Object} user - The CognitoUser
 	 * @param {Object} attr - The attributes to be verified
+	 * @param {ClientMetaData} clientMetadata - optional client metadata, defaults to config
+	 * @param {CustomUserAgentDetails} customUserAgentDetails - Optional parameter to send user agent details
 	 * @return - A promise resolves to callback data if success
 	 */
 	public verifyUserAttribute(
@@ -2062,8 +2297,24 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<void> {
+		return this._verifyUserAttribute(
+			user,
+			attr,
+			clientMetadata,
+			customUserAgentDetails
+		);
+	}
+
+	private _verifyUserAttribute(
+		user: CognitoUser | any,
+		attr: string,
+		clientMetadata: ClientMetaData = this._config.clientMetadata,
+		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<void> {
+		const internalUser: InternalCognitoUser | any = user;
+
 		return new Promise((resolve, reject) => {
-			user.getAttributeVerificationCode(
+			internalUser.getAttributeVerificationCode(
 				attr,
 				{
 					onSuccess(success) {
@@ -2073,7 +2324,11 @@ export class InternalAuthClass {
 						return reject(err);
 					},
 				},
-				clientMetadata
+				clientMetadata,
+				getAuthUserAgentValue(
+					AuthAction.VerifyUserAttribute,
+					customUserAgentDetails
+				)
 			);
 		});
 	}
@@ -2091,22 +2346,45 @@ export class InternalAuthClass {
 		attr: string,
 		code: string,
 		customUserAgentDetails?: CustomUserAgentDetails
+	): Promise<string> {
+		return this._verifyUserAttributeSubmit(
+			user,
+			attr,
+			code,
+			customUserAgentDetails
+		);
+	}
+
+	private _verifyUserAttributeSubmit(
+		user: CognitoUser | any,
+		attr: string,
+		code: string,
+		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
 		if (!code) {
 			return this.rejectAuthError(AuthErrorTypes.EmptyCode);
 		}
+		const internalUser: InternalCognitoUser | any = user;
 
 		return new Promise((resolve, reject) => {
-			user.verifyAttribute(attr, code, {
-				onSuccess(data) {
-					resolve(data);
-					return;
-				},
-				onFailure(err) {
-					reject(err);
-					return;
+			internalUser.verifyAttribute(
+				attr,
+				code,
+				{
+					onSuccess(data) {
+						resolve(data);
+						return;
+					},
+					onFailure(err) {
+						reject(err);
+						return;
+					},
 				},
-			});
+				getAuthUserAgentValue(
+					AuthAction.VerifyUserAttributeSubmit,
+					customUserAgentDetails
+				)
+			);
 		});
 	}
 
@@ -2114,10 +2392,16 @@ export class InternalAuthClass {
 		attr: string,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<void> {
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.VerifyCurrentUserAttribute,
+			customUserAgentDetails
+		);
 		const that = this;
 		return that
-			.currentUserPoolUser()
-			.then(user => that.verifyUserAttribute(user, attr));
+			._currentUserPoolUser(undefined, userAgentDetails)
+			.then(user =>
+				that._verifyUserAttribute(user, attr, undefined, userAgentDetails)
+			);
 	}
 
 	/**
@@ -2132,15 +2416,22 @@ export class InternalAuthClass {
 		code: string,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string> {
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.VerifyCurrentUserAttributeSubmit,
+			customUserAgentDetails
+		);
 		const that = this;
 		return that
-			.currentUserPoolUser()
-			.then(user => that.verifyUserAttributeSubmit(user, attr, code));
+			._currentUserPoolUser(undefined, userAgentDetails)
+			.then(user =>
+				that._verifyUserAttributeSubmit(user, attr, code, userAgentDetails)
+			);
 	}
 
 	private async cognitoIdentitySignOut(
 		opts: SignOutOpts,
-		user: CognitoUser | any
+		internalUser: InternalCognitoUser | any,
+		userAgentValue: string
 	) {
 		try {
 			await this._storageSync;
@@ -2155,18 +2446,21 @@ export class InternalAuthClass {
 
 		return new Promise((res, rej) => {
 			if (opts && opts.global) {
-				logger.debug('user global sign out', user);
+				logger.debug('user global sign out', internalUser);
 				// in order to use global signout
 				// we must validate the user as an authenticated user by using getSession
 				const clientMetadata = this._config.clientMetadata; // TODO: verify behavior if this is override during signIn
 
-				user.getSession(
+				internalUser.getSession(
 					async (err, result) => {
 						if (err) {
 							logger.debug('failed to get the user session', err);
 							if (this.isSessionInvalid(err)) {
 								try {
-									await this.cleanUpInvalidSession(user);
+									await this.cleanUpInvalidSession(
+										internalUser,
+										userAgentValue
+									);
 								} catch (cleanUpError) {
 									rej(
 										new Error(
@@ -2178,32 +2472,36 @@ export class InternalAuthClass {
 							}
 							return rej(err);
 						}
-						user.globalSignOut({
-							onSuccess: data => {
-								logger.debug('global sign out success');
-								if (isSignedInHostedUI) {
-									this.oAuthSignOutRedirect(res, rej);
-								} else {
-									return res();
-								}
-							},
-							onFailure: err => {
-								logger.debug('global sign out failed', err);
-								return rej(err);
+						internalUser.globalSignOut(
+							{
+								onSuccess: data => {
+									logger.debug('global sign out success');
+									if (isSignedInHostedUI) {
+										this.oAuthSignOutRedirect(res, rej);
+									} else {
+										return res();
+									}
+								},
+								onFailure: err => {
+									logger.debug('global sign out failed', err);
+									return rej(err);
+								},
 							},
-						});
+							userAgentValue
+						);
 					},
-					{ clientMetadata }
+					{ clientMetadata },
+					userAgentValue
 				);
 			} else {
-				logger.debug('user sign out', user);
-				user.signOut(() => {
+				logger.debug('user sign out', internalUser);
+				internalUser.signOut(() => {
 					if (isSignedInHostedUI) {
 						this.oAuthSignOutRedirect(res, rej);
 					} else {
 						return res();
 					}
-				});
+				}, userAgentValue);
 			}
 		});
 	}
@@ -2250,9 +2548,14 @@ export class InternalAuthClass {
 		}
 
 		if (this.userPool) {
-			const user = this.userPool.getCurrentUser();
-			if (user) {
-				await this.cognitoIdentitySignOut(opts, user);
+			const internalUser =
+				this.userPool.getCurrentUser() as InternalCognitoUser;
+			if (internalUser) {
+				await this.cognitoIdentitySignOut(
+					opts,
+					internalUser,
+					getAuthUserAgentValue(AuthAction.SignOut, customUserAgentDetails)
+				);
 			} else {
 				logger.debug('no current Cognito user');
 			}
@@ -2291,9 +2594,15 @@ export class InternalAuthClass {
 		clientMetadata: ClientMetaData = this._config.clientMetadata,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<'SUCCESS'> {
+		const internalUser: InternalCognitoUser | any = user;
+		const userAgentValue = getAuthUserAgentValue(
+			AuthAction.ChangePassword,
+			customUserAgentDetails
+		);
+
 		return new Promise((resolve, reject) => {
-			this.userSession(user).then(session => {
-				user.changePassword(
+			this._userSession(userAgentValue, internalUser).then(session => {
+				internalUser.changePassword(
 					oldPassword,
 					newPassword,
 					(err, data) => {
@@ -2304,7 +2613,8 @@ export class InternalAuthClass {
 							return resolve(data);
 						}
 					},
-					clientMetadata
+					clientMetadata,
+					userAgentValue
 				);
 			});
 		});
@@ -2329,9 +2639,9 @@ export class InternalAuthClass {
 			return this.rejectAuthError(AuthErrorTypes.EmptyUsername);
 		}
 
-		const user = this.createCognitoUser(username);
+		const internalUser = this.createCognitoUser(username);
 		return new Promise((resolve, reject) => {
-			user.forgotPassword(
+			internalUser.forgotPassword(
 				{
 					onSuccess: () => {
 						resolve();
@@ -2350,14 +2660,15 @@ export class InternalAuthClass {
 					inputVerificationCode: data => {
 						dispatchAuthEvent(
 							'forgotPassword',
-							user,
+							internalUser,
 							`${username} has initiated forgot password flow`
 						);
 						resolve(data);
 						return;
 					},
 				},
-				clientMetadata
+				clientMetadata,
+				getAuthUserAgentValue(AuthAction.ForgotPassword, customUserAgentDetails)
 			);
 		});
 	}
@@ -2391,16 +2702,16 @@ export class InternalAuthClass {
 			return this.rejectAuthError(AuthErrorTypes.EmptyPassword);
 		}
 
-		const user = this.createCognitoUser(username);
+		const internalUser = this.createCognitoUser(username);
 		return new Promise((resolve, reject) => {
-			user.confirmPassword(
+			internalUser.confirmPassword(
 				code,
 				password,
 				{
 					onSuccess: success => {
 						dispatchAuthEvent(
 							'forgotPasswordSubmit',
-							user,
+							internalUser,
 							`${username} forgotPasswordSubmit successful`
 						);
 						resolve(success);
@@ -2416,7 +2727,11 @@ export class InternalAuthClass {
 						return;
 					},
 				},
-				clientMetadata
+				clientMetadata,
+				getAuthUserAgentValue(
+					AuthAction.ForgotPasswordSubmit,
+					customUserAgentDetails
+				)
 			);
 		});
 	}
@@ -2431,17 +2746,25 @@ export class InternalAuthClass {
 		customUserAgentDetails?: CustomUserAgentDetails
 	) {
 		const source = this.Credentials.getCredSource();
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.CurrentUserInfo,
+			customUserAgentDetails
+		);
 
 		if (!source || source === 'aws' || source === 'userPool') {
-			const user = await this.currentUserPoolUser().catch(err =>
-				logger.error(err)
-			);
-			if (!user) {
+			const internalUser: InternalCognitoUser = await this._currentUserPoolUser(
+				undefined,
+				userAgentDetails
+			).catch(err => logger.error(err));
+			if (!internalUser) {
 				return null;
 			}
 
 			try {
-				const attributes = await this.userAttributes(user);
+				const attributes = await this._userAttributes(
+					internalUser,
+					userAgentDetails
+				);
 				const userAttrs: object = this.attributesToObject(attributes);
 				let credentials = null;
 				try {
@@ -2455,7 +2778,7 @@ export class InternalAuthClass {
 
 				const info = {
 					id: credentials ? credentials.identityId : undefined,
-					username: user.getUsername(),
+					username: internalUser.getUsername(),
 					attributes: userAttrs,
 				};
 				return info;
@@ -2521,6 +2844,14 @@ export class InternalAuthClass {
 					? this._config.oauth.redirectSignIn
 					: this._config.oauth.redirectUri;
 
+				this._storage.setItem(
+					'aws-amplify-federatedUserAgent',
+					getAuthUserAgentValue(
+						AuthAction.FederatedSignIn,
+						customUserAgentDetails
+					)
+				);
+
 				this._oAuthHandler.oauthSignIn(
 					this._config.oauth.responseType,
 					this._config.oauth.domain,
@@ -2550,7 +2881,7 @@ export class InternalAuthClass {
 				{ provider, token, identity_id, user, expires_at },
 				'federation'
 			);
-			const currentUser = await this.currentAuthenticatedUser();
+			const currentUser = await this._currentAuthenticatedUser();
 			dispatchAuthEvent(
 				'signIn',
 				currentUser,
@@ -2601,9 +2932,15 @@ export class InternalAuthClass {
 
 			if (hasCodeOrError || hasTokenOrError) {
 				this._storage.setItem('amplify-redirected-from-hosted-ui', 'true');
+				const userAgentValue =
+					this._storage.getItem('aws-amplify-federatedUserAgent') || undefined;
+				this._storage.removeItem('aws-amplify-federatedUserAgent');
 				try {
 					const { accessToken, idToken, refreshToken, state } =
-						await this._oAuthHandler.handleAuthResponse(currentUrl);
+						await this._oAuthHandler.handleAuthResponse(
+							currentUrl,
+							userAgentValue
+						);
 					const session = new CognitoUserSession({
 						IdToken: new CognitoIdToken({ IdToken: idToken }),
 						RefreshToken: new CognitoRefreshToken({
@@ -2745,7 +3082,7 @@ export class InternalAuthClass {
 		);
 	}
 
-	private createCognitoUser(username: string): CognitoUser {
+	private createCognitoUser(username: string): InternalCognitoUser {
 		const userData: ICognitoUserData = {
 			Username: username,
 			Pool: this.userPool,
@@ -2754,11 +3091,11 @@ export class InternalAuthClass {
 
 		const { authenticationFlowType } = this._config;
 
-		const user = new CognitoUser(userData);
+		const internalUser = new InternalCognitoUser(userData);
 		if (authenticationFlowType) {
-			user.setAuthenticationFlowType(authenticationFlowType);
+			internalUser.setAuthenticationFlowType(authenticationFlowType);
 		}
-		return user;
+		return internalUser;
 	}
 
 	private _isValidAuthStorage(obj) {
@@ -2793,78 +3130,105 @@ export class InternalAuthClass {
 	public async rememberDevice(
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<string | AuthError> {
-		let currUser;
+		let internalUser: InternalCognitoUser | any;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.RememberDevice,
+			customUserAgentDetails
+		);
 
 		try {
-			currUser = await this.currentUserPoolUser();
+			internalUser = await this._currentUserPoolUser(
+				undefined,
+				userAgentDetails
+			);
 		} catch (error) {
 			logger.debug('The user is not authenticated by the error', error);
 			return Promise.reject('The user is not authenticated');
 		}
 
-		currUser.getCachedDeviceKeyAndPassword();
+		internalUser.getCachedDeviceKeyAndPassword();
 		return new Promise((res, rej) => {
-			currUser.setDeviceStatusRemembered({
-				onSuccess: data => {
-					res(data);
-				},
-				onFailure: err => {
-					if (err.code === 'InvalidParameterException') {
-						rej(new AuthError(AuthErrorTypes.DeviceConfig));
-					} else if (err.code === 'NetworkError') {
-						rej(new AuthError(AuthErrorTypes.NetworkError));
-					} else {
-						rej(err);
-					}
+			internalUser.setDeviceStatusRemembered(
+				{
+					onSuccess: data => {
+						res(data);
+					},
+					onFailure: err => {
+						if (err.code === 'InvalidParameterException') {
+							rej(new AuthError(AuthErrorTypes.DeviceConfig));
+						} else if (err.code === 'NetworkError') {
+							rej(new AuthError(AuthErrorTypes.NetworkError));
+						} else {
+							rej(err);
+						}
+					},
 				},
-			});
+				getAmplifyUserAgent(userAgentDetails)
+			);
 		});
 	}
 
 	public async forgetDevice(
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<void> {
-		let currUser;
+		let internalUser: InternalCognitoUser | any;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.ForgetDevice,
+			customUserAgentDetails
+		);
 
 		try {
-			currUser = await this.currentUserPoolUser();
+			internalUser = await this._currentUserPoolUser(
+				undefined,
+				userAgentDetails
+			);
 		} catch (error) {
 			logger.debug('The user is not authenticated by the error', error);
 			return Promise.reject('The user is not authenticated');
 		}
 
-		currUser.getCachedDeviceKeyAndPassword();
+		internalUser.getCachedDeviceKeyAndPassword();
 		return new Promise((res, rej) => {
-			currUser.forgetDevice({
-				onSuccess: data => {
-					res(data);
-				},
-				onFailure: err => {
-					if (err.code === 'InvalidParameterException') {
-						rej(new AuthError(AuthErrorTypes.DeviceConfig));
-					} else if (err.code === 'NetworkError') {
-						rej(new AuthError(AuthErrorTypes.NetworkError));
-					} else {
-						rej(err);
-					}
+			internalUser.forgetDevice(
+				{
+					onSuccess: data => {
+						res(data);
+					},
+					onFailure: err => {
+						if (err.code === 'InvalidParameterException') {
+							rej(new AuthError(AuthErrorTypes.DeviceConfig));
+						} else if (err.code === 'NetworkError') {
+							rej(new AuthError(AuthErrorTypes.NetworkError));
+						} else {
+							rej(err);
+						}
+					},
 				},
-			});
+				getAmplifyUserAgent(userAgentDetails)
+			);
 		});
 	}
 
 	public async fetchDevices(
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<IAuthDevice[]> {
-		let currUser;
+		let internalUser: InternalCognitoUser | any;
+		const userAgentDetails = getAuthUserAgentDetails(
+			AuthAction.FetchDevices,
+			customUserAgentDetails
+		);
 
 		try {
-			currUser = await this.currentUserPoolUser();
+			internalUser = await this._currentUserPoolUser(
+				undefined,
+				userAgentDetails
+			);
 		} catch (error) {
 			logger.debug('The user is not authenticated by the error', error);
 			throw new Error('The user is not authenticated');
 		}
 
-		currUser.getCachedDeviceKeyAndPassword();
+		internalUser.getCachedDeviceKeyAndPassword();
 		return new Promise((res, rej) => {
 			const cb = {
 				onSuccess(data) {
@@ -2892,7 +3256,12 @@ export class InternalAuthClass {
 					}
 				},
 			};
-			currUser.listDevices(MAX_DEVICES, null, cb);
+			internalUser.listDevices(
+				MAX_DEVICES,
+				null,
+				cb,
+				getAmplifyUserAgent(userAgentDetails)
+			);
 		});
 	}
 }