fable 3.0.115 → 3.0.117

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.115",
+    "version": "3.0.117",
     "description": "Anentity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {

package/source/Fable.js

@@ -72,11 +72,13 @@ class Fable extends libFableServiceBase.CoreServiceProviderBase
 		this.addAndInstantiateServiceType('DataGeneration', require('./services/Fable-Service-DataGeneration.js'));
 		this.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
 		this.addAndInstantiateServiceType('Math', require('./services/Fable-Service-Math.js'));
-		this.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
 		this.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
-		this.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
 		this.addServiceType('Manifest', require('manyfest'));
 		this.addServiceType('ObjectCache', require('cachetrax'));
+		this.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
+		this.addServiceType('ProgressTracker', require('./services/Fable-Service-ProgressTracker.js'));
+		this.addAndInstantiateServiceType('ProgressTime', require('./services/Fable-Service-ProgressTime.js'));
+		this.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
 		this.addServiceType('FilePersistence', require('./services/Fable-Service-FilePersistence.js'));
 	}
 

package/source/services/Fable-Service-DataGeneration.js

@@ -31,7 +31,7 @@ class FableServiceDataGeneration extends libFableServiceBase
 	randomNumericString(pLength, pMaxNumber)
 	{
 		let tmpLength = (typeof(pLength) === 'undefined') ? 10 : pLength;
-		let tmpMaxNumber = (typeof(pMaxNumber) === 'undefined') ? ((10 ** tmpLength) - 1) : pMaxNumber;
+		let tmpMaxNumber = (typeof(pMaxNumber) === 'undefined') ? 9999999999 : pMaxNumber;
 
 		return this.services.DataFormat.stringPadStart(this.randomIntegerUpTo(tmpMaxNumber), pLength, '0');
 	}

package/source/services/Fable-Service-Math.js

@@ -1,11 +1,12 @@
 const libFableServiceBase = require('fable-serviceproviderbase');
 
 /**
-* Arbitrary Precision Math Operations
-* @author      Steven Velozo <steven@velozo.com>
-* @description Simple functions that perform arbitrary precision math operations and return string resultant values.  Wraps big.js
-*/
-
+ * Arbitrary Precision Math Operations
+ * @author      Steven Velozo <steven@velozo.com>
+ * @description Simple functions that perform arbitrary precision math operations and return string resultant values.  Wraps big.js
+ * @class FableServiceMath
+ * @extends libFableServiceBase
+ */
 class FableServiceMath extends libFableServiceBase
 {
 	constructor(pFable, pOptions, pServiceHash)
@@ -15,9 +16,8 @@ class FableServiceMath extends libFableServiceBase
         this.serviceType = 'Math';
 	}
 
-
 /*
-	Rounding Methods:
+	Pass-through Rounding Method Constants
 
 	Property	   Value   BigDecimal Equiv   Description
 	----------     -----   ----------------   -----------

package/source/services/Fable-Service-Operation-DefaultSettings.js

@@ -1,25 +1,20 @@
 module.exports = (
-    {
-        "Metadata": {
-            "UUID": false,
-            "Hash": false,
+	{
+		"Metadata": {
+			"UUID": false,
+			"Hash": false,
 
-            "Name": "",
-            "Summary": "",
+			"Name": "",
+			"Summary": "",
 
-            "Version": 0
-        },
-        "Status": {
-            "Completed": false,
-
-            "CompletionProgress": 0,
-            "CompletionTimeElapsed": 0,
-
-            "TimeStart": 0,
-            "TimeEnd": 0
-        },
-        "Steps": [],
-        "Errors": [],
-        "Log": []
-    }
+			"Version": 0
+		},
+		"Status": {
+			"Completed": false,
+			"StepCount": 0
+		},
+		"Steps": [],
+		"Errors": [],
+		"Log": []
+	}
 );

package/source/services/Fable-Service-Operation.js

@@ -1,3 +1,4 @@
+const { PE } = require('big.js');
 const libFableServiceBase = require('fable-serviceproviderbase');
 
 const _OperationStatePrototypeString = JSON.stringify(require('./Fable-Service-Operation-DefaultSettings.js'));
@@ -12,9 +13,6 @@ class FableOperation extends libFableServiceBase
 		// Timestamps will just be the long ints
 		this.timeStamps = {};
 
-		// ProgressTrackers have an object format of: {Hash:'SomeHash',EndTime:UINT,CurrentTime:UINT,TotalCount:INT,CurrentCount:INT}
-		this.progressTrackers = {};
-
         this.serviceType = 'PhasedOperation';
 
 		this.state = JSON.parse(_OperationStatePrototypeString);
@@ -29,96 +27,134 @@ class FableOperation extends libFableServiceBase
 		this.state.Metadata.Name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
 		this.name = this.state.Metadata.Name;
 
+		this.progressTrackers = this.fable.instantiateServiceProviderWithoutRegistration('ProgressTracker');
+
+		this.state.OverallProgressTracker = this.progressTrackers.createProgressTracker(`Overall-${this.state.Metadata.UUID}`);
+
+		// This is here to use the pass-through logging functions in the operation itself.
 		this.log = this;
 	}
 
 	execute(fExecutionCompleteCallback)
 	{
-		if (this.state.Status.TimeStart)
+		// TODO: Should the same operation be allowed to execute more than one time?
+		if (this.state.OverallProgressTracker.StartTimeStamp > 0)
 		{
 			return fExecutionCompleteCallback(new Error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} has already been executed!`));
 		}
 
-		this.state.Status.TimeStart = +new Date();
-
 		let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
-
-		for (let i = 0; i < this.state.Steps; i++)
-		{
-			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(this));
+		
+		this.progressTrackers.setProgressTrackerTotalOperations(this.state.OverallProgressTracker.Hash, this.state.Status.StepCount);
+		this.progressTrackers.startProgressTracker(this.state.OverallProgressTracker.Hash);
+		this.info(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} starting...`);
+
+		for (let i = 0; i < this.state.Steps.length; i++)
+		{
+			tmpAnticipate.anticipate(
+				function(fNext)
+				{
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} starting...`);
+					this.progressTrackers.startProgressTracker(this.state.Steps[i].ProgressTracker.Hash);
+					return fNext();
+				}.bind(this));
+			// Steps are executed in a custom context with 
+			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(
+				{
+					log:this,
+					fable:this.fable,
+					ProgressTracker:this.progressTrackers.getProgressTracker(this.state.Steps[i].ProgressTracker.Hash),
+					updateProgressTracker: function(pProgressAmount)
+						{
+							return this.progressTrackers.updateProgressTracker(this.state.Steps[i].ProgressTracker.Hash, pProgressAmount);
+						}.bind(this),
+					incrementProgressTracker: function(pProgressIncrementAmount)
+						{
+							return this.progressTrackers.incrementProgressTracker(this.state.Steps[i].ProgressTracker.Hash, pProgressIncrementAmount);
+						}.bind(this),
+					setProgressTrackerTotalOperations: function(pTotalOperationCount)
+						{
+							return this.progressTrackers.setProgressTrackerTotalOperations(this.state.Steps[i].ProgressTracker.Hash, pTotalOperationCount);
+						}.bind(this),
+					getProgressTrackerStatusString: function() 
+						{
+							return this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash);
+						}.bind(this),
+					logProgressTrackerStatus: function() 
+						{
+							return this.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}]: ${this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash)}`);
+						}.bind(this),
+					OperationState:this.state,
+					StepState:this.state.Steps[i]
+				}));
+			tmpAnticipate.anticipate(
+				function(fNext)
+				{
+					this.progressTrackers.endProgressTracker(this.state.Steps[i].ProgressTracker.Hash);
+					let tmpStepTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash);
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} complete.`);
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} ${tmpStepTimingMessage}.`);
+			
+					this.progressTrackers.incrementProgressTracker(this.state.OverallProgressTracker.Hash, 1);
+					let tmpOperationTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.OverallProgressTracker.Hash);
+					this.fable.log.info(`Operation [${this.state.Metadata.UUID}] ${tmpOperationTimingMessage}.`);
+					return fNext();
+				}.bind(this));
 		}
 
 		// Wait for the anticipation to complete
 		tmpAnticipate.wait(
 			(pError) =>
 			{
-				this.state.Status.TimeEnd = +new Date();
+				if (pError)
+				{
+					this.fable.log.error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} had an error: ${pError}`, pError);
+					return fExecutionCompleteCallback(pError);
+				}
+				this.info(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} complete.`);
+				let tmpOperationTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.OverallProgressTracker.Hash);
+				this.progressTrackers.endProgressTracker(this.state.OverallProgressTracker.Hash);
+				this.fable.log.info(`Operation [${this.state.Metadata.UUID}] ${tmpOperationTimingMessage}.`);
 				return fExecutionCompleteCallback();
 			});
 	}
 
-/*
-	TODO: I've gone back and forth on whether this should be an object, JSON 
-	object prototype, or set of functions here.  Discuss with colleagues!
-*/
-	addStep(pGUIDStep, fStepFunction, pStepName, pStepDescription, pStepMetadata)
+	addStep(fStepFunction, pStepMetadata, pStepName, pStepDescription, pGUIDStep)
 	{
 		let tmpStep = {};
+
+		// GUID is optional
 		tmpStep.GUIDStep = (typeof(pGUIDStep) !== 'undefined') ? pGUIDStep : `STEP-${this.state.Steps.length}-${this.fable.DataGeneration.randomNumericString()}`;
+
+
+		// Name is optional
 		tmpStep.Name = (typeof(pStepName) !== 'undefined') ? pStepName : `Step [${tmpStep.GUIDStep}]`;
 		tmpStep.Description = (typeof(pStepDescription) !== 'undefined') ? pStepDescription : `Step execution of ${tmpStep.Name}.`;
-		// TODO: Right now this allows an Array... do we want to block that?
-		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
 
-		tmpStep.TimeStart = false;
-		tmpStep.TimeEnd = false;
+		tmpStep.ProgressTracker = this.progressTrackers.createProgressTracker(tmpStep.GUIDStep);
+
+		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
 
 		// There is an array of steps, in the Operation State itself ... push a step there
 		this.state.Steps.push(tmpStep);
 
-		this.stepMap[tmpStep.GUIDStep]
-		this.stepFunctions[tmpStep.GUIDStep] = fStepFunction;
+		this.stepMap[tmpStep.GUIDStep] = tmpStep;
 
-		this.state.Status.StepCount++;
-		return tmpStep;
-	}
+		this.stepFunctions[tmpStep.GUIDStep] = typeof(fStepFunction) == 'function' ? fStepFunction : function (fDone) { return fDone(); };
 
-	getStep(pGUIDStep)
-	{
-		if (this.stepMap.hasOwnProperty(pGUIDStep))
-		{
-			return this.stepMap[pGUIDStep];
-		}
-
-		return false;
-	}
-
-	startStep(pGUIDStep)
-	{
-		let tmpStep = this.getStep(pGUIDStep);
-
-		if (tmpStep === false)
-		{
-			return false;
-		}
-
-		tmpStep.TimeStart = +new Date();
+		this.state.Status.StepCount++;
 
 		return tmpStep;
 	}
 
-	stopStep(pGUIDStep)
+	setStepTotalOperations(pGUIDStep, pTotalOperationCount)
 	{
-		let tmpStep = this.getStep(pGUIDStep);
-
-		if (tmpStep === false)
+		if (!this.stepMap.hasOwnProperty(pGUIDStep))
 		{
-			return false;
+			return new Error(`Step [${pGUIDStep}] does not exist in operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} when attempting to set total operations to ${pTotalOperationCount}.`);
 		}
 
-		tmpStep.TimeEnd = +new Date();
-
-		return tmpStep;
+		this.progressTrackers.setProgressTrackerTotalOperations(this.stepMap[pGUIDStep].ProgressTracker.Hash, pTotalOperationCount);
 	}
 
 	writeOperationLog(pLogLevel, pLogText, pLogObject)
@@ -178,189 +214,6 @@ class FableOperation extends libFableServiceBase
 		this.writeOperationErrors(pLogText, pLogObject);
 		this.fable.log.fatal(pLogText, pLogObject);
 	}
-
-
-	/************************************************************************
-	 * BEGINNING OF -->  Telemetry Helpers
-	 */
-	createTimeStamp(pTimeStampHash)
-	{
-		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
-		this.timeStamps[tmpTimeStampHash] = +new Date();
-		return this.timeStamps[tmpTimeStampHash];
-	}
-
-	getTimeDelta(pTimeStampHash)
-	{
-		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
-		if (this.timeStamps.hasOwnProperty(tmpTimeStampHash))
-		{
-			let tmpEndTime = +new Date();
-			return tmpEndTime-this.timeStamps[tmpTimeStampHash];
-		}
-		else
-		{
-			return -1;
-		}
-	}
-
-	logTimeDelta(pTimeStampHash, pMessage)
-	{
-		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
-		let tmpMessage = (typeof(pMessage) !== 'undefined') ? pMessage : `Elapsed for ${tmpTimeStampHash}: `;
-		let tmpOperationTime = this.getTimeDelta(pTimeStampHash);
-		this.info(tmpMessage +' ('+tmpOperationTime+'ms)');
-		return tmpOperationTime;
-	}
-
-	createProgressTracker(pTotalOperations, pProgressTrackerHash)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-		let tmpTotalOperations = (typeof(pTotalOperations) == 'number') ? pTotalOperations : 100;
-
-		let tmpProgressTracker = (
-			{
-				Hash: tmpProgressTrackerHash,
-				StartTime: this.createTimeStamp(tmpProgressTrackerHash),
-				EndTime: 0,
-				CurrentTime: 0,
-				PercentComplete: -1,
-				AverageOperationTime: -1,
-				EstimatedCompletionTime: -1,
-				TotalCount: tmpTotalOperations,
-				CurrentCount:-1
-			});
-
-		this.progressTrackers[tmpProgressTrackerHash] = tmpProgressTracker;
-
-		return tmpProgressTracker;
-	}
-
-	solveProgressTrackerStatus(pProgressTrackerHash)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-
-		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
-		{
-			this.createProgressTracker(100, tmpProgressTrackerHash);
-		}
-
-		let tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
-
-		tmpProgressTracker.CurrentTime = this.getTimeDelta(tmpProgressTracker.Hash);
-
-		if ((tmpProgressTracker.CurrentCount > 0) && (tmpProgressTracker.TotalCount > 0))
-		{
-			tmpProgressTracker.PercentComplete = (tmpProgressTracker.CurrentCount / tmpProgressTracker.TotalCount) * 100.0;
-		}
-
-		if ((tmpProgressTracker.CurrentCount > 0) && (tmpProgressTracker.CurrentTime > 0))
-		{
-			tmpProgressTracker.AverageOperationTime = tmpProgressTracker.CurrentTime / tmpProgressTracker.CurrentCount;
-		}
-
-		if ((tmpProgressTracker.CurrentCount < tmpProgressTracker.TotalCount) && (tmpProgressTracker.AverageOperationTime > 0))
-		{
-			tmpProgressTracker.EstimatedCompletionTime = (tmpProgressTracker.TotalCount - tmpProgressTracker.CurrentCount) * tmpProgressTracker.AverageOperationTime;
-		}
-	}
-
-	updateProgressTrackerStatus(pProgressTrackerHash, pCurrentOperations)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-		let tmpCurrentOperations = parseInt(pCurrentOperations);
-
-		if (isNaN(tmpCurrentOperations))
-		{
-			return false;
-		}
-
-		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
-		{
-			this.createProgressTracker(100, tmpProgressTrackerHash);
-		}
-
-		this.progressTrackers[tmpProgressTrackerHash].CurrentCount = tmpCurrentOperations;
-		this.progressTrackers[tmpProgressTrackerHash].CurrentTime = this.getTimeDelta(tmpProgressTrackerHash);
-
-		this.solveProgressTrackerStatus(tmpProgressTrackerHash);
-
-		return this.progressTrackers[tmpProgressTrackerHash];
-	}
-
-	incrementProgressTrackerStatus(pProgressTrackerHash, pIncrementSize)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-		let tmpIncrementSize = parseInt(pIncrementSize);
-
-		if (isNaN(tmpIncrementSize))
-		{
-			return false;
-		}
-
-		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
-		{
-			this.createProgressTracker(100, tmpProgressTrackerHash);
-		}
-
-		this.progressTrackers[tmpProgressTrackerHash].CurrentCount = this.progressTrackers[tmpProgressTrackerHash].CurrentCount + tmpIncrementSize;
-		this.progressTrackers[tmpProgressTrackerHash].CurrentTime = this.getTimeDelta(tmpProgressTrackerHash);
-
-		this.solveProgressTrackerStatus(tmpProgressTrackerHash);
-
-		return this.progressTrackers[tmpProgressTrackerHash];
-	}
-
-	setProgressTrackerEndTime(pProgressTrackerHash, pCurrentOperations)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-		let tmpCurrentOperations = parseInt(pCurrentOperations);
-
-		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
-		{
-			return false;
-		}
-		if (!isNaN(tmpCurrentOperations))
-		{
-			this.updateProgressTrackerStatus(tmpProgressTrackerHash, tmpCurrentOperations);
-		}
-
-		this.progressTrackers[tmpProgressTrackerHash].EndTime = this.getTimeDelta(tmpProgressTrackerHash);
-
-		this.solveProgressTrackerStatus(tmpProgressTrackerHash);
-
-		return this.progressTrackers[tmpProgressTrackerHash];
-	}
-
-	printProgressTrackerStatus(pProgressTrackerHash)
-	{
-		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'DefaultProgressTracker';
-
-		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
-		{
-			this.info(`>> Progress Tracker ${tmpProgressTrackerHash} does not exist!  No stats to display.`);
-		}
-		else
-		{
-			const tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
-
-			if (tmpProgressTracker.CurrentCount < 1)
-			{
-				this.info(`>> Progress Tracker ${tmpProgressTracker.Hash} has no completed operations.  ${tmpProgressTracker.CurrentTime}ms have elapsed since it was started.`);
-			}
-			else if (tmpProgressTracker.EndTime < 1)
-			{
-				this.info(`>> Progress Tracker ${tmpProgressTracker.Hash} is ${tmpProgressTracker.PercentComplete.toFixed(3)}% completed - ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations over ${tmpProgressTracker.CurrentTime}ms (median ${tmpProgressTracker.AverageOperationTime.toFixed(3)} per).  Estimated completion in ${tmpProgressTracker.EstimatedCompletionTime.toFixed(0)}ms or ${(tmpProgressTracker.EstimatedCompletionTime / 1000 / 60).toFixed(2)}minutes`)
-			}
-			else
-			{
-				this.info(`>> Progress Tracker ${tmpProgressTracker.Hash} is done and completed ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations in ${tmpProgressTracker.EndTime}ms.`)
-			}
-		}
-	}
-	/*
-	 * END OF       -->  Logging and Telemetry Helpers
-	 ************************************************************************/
 }
 
 module.exports = FableOperation;

package/source/services/Fable-Service-ProgressTime.js

@@ -0,0 +1,159 @@
+const libFableServiceBase = require('fable-serviceproviderbase');
+
+class FableServiceProgressTime extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'ProgressTime';
+
+		this.timeStamps = {};
+	}
+
+	formatTimeDuration(pTimeDurationInMilliseconds)
+	{
+		let tmpTimeDuration = typeof(pTimeDurationInMilliseconds) == 'number' ? pTimeDurationInMilliseconds : 0;
+
+		if (pTimeDurationInMilliseconds < 0)
+		{
+			return 'unknown';
+		}
+
+		let tmpTimeDurationString = '';
+		if (tmpTimeDuration > 3600000)
+		{
+			tmpTimeDurationString += Math.floor(tmpTimeDuration/3600000)+'h ';
+			tmpTimeDuration = tmpTimeDuration % 3600000;
+		}
+		if (tmpTimeDuration > 60000)
+		{
+			tmpTimeDurationString += Math.floor(tmpTimeDuration/60000)+'m ';
+			tmpTimeDuration = tmpTimeDuration % 60000;
+		}
+		if (tmpTimeDuration > 1000)
+		{
+			tmpTimeDurationString += Math.floor(tmpTimeDuration/1000)+'s ';
+			tmpTimeDuration = tmpTimeDuration % 1000;
+		}
+		tmpTimeDurationString += Math.round(tmpTimeDuration)+'ms';
+
+		return tmpTimeDurationString;
+	}
+
+	createTimeStamp(pTimeStampHash)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		this.timeStamps[tmpTimeStampHash] = +new Date();
+		return this.timeStamps[tmpTimeStampHash];
+	}
+
+	getTimeStampValue(pTimeStampHash)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		return this.timeStamps.hasOwnProperty(tmpTimeStampHash) ? this.timeStamps[tmpTimeStampHash] : -1;
+	}
+
+	updateTimeStampValue(pTimeStampHash, pReferenceTime)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		let tmpReferenceTime = false;
+		
+		// This function allows the user to pass in either a reference time in ms, or, a hash of a timestamp.
+		if (typeof(pReferenceTime) == 'string')
+		{
+			tmpReferenceTime = this.timeStamps.hasOwnProperty(tmpReference) ? this.timeStamps[tmpReference] : false;
+		}
+		else if (typeof(pReferenceTime) == 'number')
+		{
+			tmpReferenceTime = pReferenceTime;
+		}
+		else
+		{
+			tmpReferenceTime = +new Date();
+		}
+
+		if (this.timeStamps.hasOwnProperty(tmpTimeStampHash) && tmpReferenceTime)
+		{
+			this.timeStamps[tmpTimeStampHash] = tmpReferenceTime;
+			return this.timeStamps[tmpTimeStampHash];
+		}
+		else
+		{
+			return -1;
+		}
+	}
+
+	removeTimeStamp(pTimeStampHash)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		if (this.timeStamps.hasOwnProperty(tmpTimeStampHash))
+		{
+			delete this.timeStamps[tmpTimeStampHash];
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	getTimeStampDelta(pTimeStampHash, pReferenceTime)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		let tmpReferenceTime = false;
+		
+		// This function allows the user to pass in either a reference time in ms, or, a hash of a timestamp.
+		if (typeof(pReferenceTime) == 'string')
+		{
+			tmpReferenceTime = this.timeStamps.hasOwnProperty(tmpReference) ? this.timeStamps[tmpReference] : false;
+		}
+		else if (typeof(pReferenceTime) == 'number')
+		{
+			tmpReferenceTime = pReferenceTime;
+		}
+		else
+		{
+			tmpReferenceTime = +new Date();
+		}
+
+		if (this.timeStamps.hasOwnProperty(tmpTimeStampHash) && tmpReferenceTime)
+		{
+			return tmpReferenceTime-this.timeStamps[tmpTimeStampHash];
+		}
+		else
+		{
+			return -1;
+		}
+	}
+
+	getDurationBetweenTimestamps(pTimeStampHashStart, pTimeStampHashEnd)
+	{
+		let tmpTimeStampHashStart = (typeof(pTimeStampHashStart) == 'string') ? pTimeStampHashStart : 'Default';
+		let tmpTimeStampHashEnd = (typeof(pTimeStampHashEnd) == 'string') ? pTimeStampHashEnd : 'Default';
+		if (this.timeStamps.hasOwnProperty(tmpTimeStampHashStart) && this.timeStamps.hasOwnProperty(tmpTimeStampHashEnd))
+		{
+			return this.timeStamps[tmpTimeStampHashEnd]-this.timeStamps[tmpTimeStampHashStart];
+		}
+		else
+		{
+			return -1;
+		}
+	}
+
+	getTimeStampDeltaMessage(pTimeStampHash, pMessage, pReferenceTime)
+	{
+		let tmpTimeStampHash = (typeof(pTimeStampHash) == 'string') ? pTimeStampHash : 'Default';
+		let tmpMessage = (typeof(pMessage) !== 'undefined') ? pMessage : `Elapsed for ${tmpTimeStampHash}: `;
+		let tmpOperationTime = this.getTimeStampDelta(tmpTimeStampHash, pReferenceTime);
+
+		return `${tmpMessage} ${this.formatTimeDuration(tmpOperationTime)}`;
+	}
+
+	logTimeStampDelta(pTimeStampHash, pMessage, pReferenceTime)
+	{
+		this.fable.log.info(this.getTimeStampDeltaMessage(pTimeStampHash, pMessage, pReferenceTime));
+	}
+}
+
+module.exports = FableServiceProgressTime;