nodejs-poolcontroller 7.3.1 → 7.6.1

package/logger/DataLogger.ts

@@ -1,433 +1,448 @@
-import { Timestamp, utils } from '../controller/Constants';
-import * as extend from 'extend';
-import * as fs from 'fs';
-import * as path from 'path';
-import { setTimeout } from 'timers';
-import * as util from 'util';
-import { logger } from './Logger';
-// One of the primary goals of the DataLogger is to keep the memory usage low when reading and writing large files.  This should allow
-// the datalogger to manage the file without putting undue pressure on the file system or the heap.  While some of these methods
-// read in the entire file, others are designed to keep only a single logger entry buffer in memory.
-export class DataLogger {
-    // Creates a new entry from the type constructor.  Javascript lacks any real way to factory up an object from a constructor so we
-    // are using a workaround that points to the constructor for the object.  Its lame but effective.
-    public static createEntry<T>(type: (new () => T), line?: string): T {
-        let entry = new type();
-        if (typeof line !== 'undefined') (entry as unknown as DataLoggerEntry).parse(line);
-        return entry;
-    }
-    // This reads the entire file into memory and is very expensive because of the buffer.  The readFromStart/End methods should be used in most cases.
-    public static readAll<T>(logFile: string, type: (new () => T)): T[] {
-        try {
-            let logPath = path.join(process.cwd(), '/logs');
-            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
-            logPath += (`/${logFile}`);
-            let lines = [];
-            if (fs.existsSync(logPath)) {
-                let buff = fs.readFileSync(logPath);
-                lines = buff.toString().split('\n');
-            }
-            let arr: T[] = [];
-            for (let i = 0; i < lines.length; i++) {
-                let entry = DataLogger.createEntry<T>(type, lines[i]);
-                arr.push(entry);
-            }
-            return arr;
-        } catch (err) { logger.error(err); }
-    }
-    // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
-    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
-    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
-    // 
-    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
-    // of the file.
-    public static async readFromEndAsync<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): Promise<T[]> {
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let newLines = ['\r', '\n'];
-            let arr: T[] = [];
-            if (fs.existsSync(logPath)) {
-                // Alright what we have created here is a method to read the data from the end of 
-                // a log file in reverse order (tail) that works for all os implementations.  It is
-                // really dumb that this isn't part of the actual file processing.
-                try {
-                    let file = await new Promise<number>((resolve, reject) => {
-                        fs.open(logPath, 'r', (err, fileNo) => {
-                            if (err) reject(err);
-                            else resolve(fileNo);
-                        });
-                    });
-                    try {
-                        let stat = await new Promise<fs.Stats>((resolve, reject) => {
-                            fs.stat(logPath, (err, data) => {
-                                if (err) reject(err);
-                                else resolve(data);
-                            });
-                        });
-                        // The file is empty.
-                        if (stat.size !== 0) {
-                            let pos = stat.size - 1;
-                            let chars = [];
-                            while (pos >= 0) {
-                                // Read a character from the file
-                                let char = await new Promise<string>((resolve, reject) => {
-                                    fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
-                                        if (err) reject(err);
-                                        else resolve(buff.toString());
-                                    });
-                                });
-                                if (!newLines.includes(char)) chars.unshift(char);
-                                // If we hit the beginning of the file or a newline from a previous
-                                // record then we shoud save off the line and read the next record.
-                                if (newLines.includes(char) || pos === 0) {
-                                    if (chars.length > 0) {
-                                        let entry = DataLogger.createEntry<T>(type, chars.join(''));
-                                        if (typeof fn === 'function') {
-                                            let rc = fn(arr.length + 1, entry, arr);
-                                            console.log(rc);
-                                            if (rc === true) arr.push(entry);
-                                            else if (rc === false) break;
-                                        }
-                                        else
-                                            arr.push(entry);
-                                    }
-                                    chars = [];
-                                }
-                                pos--;
-                            }
-                        }
-                    }
-                    catch (err) { return Promise.reject(err); }
-                    finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
-                } catch (err) { logger.error(err); }
-            }
-            return arr;
-        }
-        catch (err) { logger.error(err); }
-
-    }
-    // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
-    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
-    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
-    // 
-    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
-    // of the file.
-    public static readFromEnd<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): T[] {
-        let arr: T[] = [];
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let newLines = ['\r', '\n'];
-            if (fs.existsSync(logPath)) {
-                // Alright what we have created here is a method to read the data from the end of 
-                // a log file in reverse order (tail) that works for all os implementations.  It is
-                // really dumb that this isn't part of the actual file processing.
-                let file;
-                try {
-                    file = fs.openSync(logPath, 'r');
-                    if (file) {
-                        try {
-                            let stat = fs.statSync(logPath);
-                            // The file is empty.
-                            if (stat.size !== 0) {
-                                let pos = stat.size - 1;
-                                let chars = [];
-                                while (pos >= 0) {
-                                    // Read a character from the file
-                                    let buff = Buffer.allocUnsafe(1);
-                                    let len = fs.readSync(file, buff, 0, 1, pos);
-                                    if (len === 0) break;
-                                    let char = buff.toString();
-                                    if (!newLines.includes(char)) chars.unshift(char);
-                                    // If we hit the beginning of the file or a newline from a previous
-                                    // record then we shoud save off the line and read the next record.
-                                    if (newLines.includes(char) || pos === 0) {
-                                        if (chars.length > 0) {
-                                            let entry = DataLogger.createEntry<T>(type, chars.join(''));
-                                            if (typeof fn === 'function') {
-                                                let rc = fn(arr.length + 1, entry, arr);
-                                                if (rc === true) arr.push(entry);
-                                                else if (rc === false) break;
-                                            }
-                                            else
-                                                arr.push(entry);
-                                        }
-                                        chars = [];
-                                    }
-                                    pos--;
-                                }
-                            }
-                        }
-                        catch (err) { logger.error(`Error reading from ${logPath}: ${err.message}`); }
-                    }
-                }
-                finally { if (typeof file !== 'undefined') fs.closeSync(file); }
-            }
-        }
-        catch (err) { logger.error(`Error reading file ${logFile}: ${err.message}`); }
-        return arr;
-    }
-    // This method uses a callback to end the file read from the start of the file.  If the callback returns false then the iteration through the
-    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
-    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
-    // 
-    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
-    // of the file.
-    public static async readFromStartAsync<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): Promise<T[]> {
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let newLines = ['\r', '\n'];
-            let arr: T[] = [];
-            if (fs.existsSync(logPath)) {
-                // Alright what we have created here is a method to read the data from the end of 
-                // a log file in reverse order (tail) that works for all os implementations.  It is
-                // really dumb that this isn't part of the actual file processing.
-                try {
-                    let file = await new Promise<number>((resolve, reject) => {
-                        fs.open(logPath, 'r', (err, fileNo) => {
-                            if (err) reject(err);
-                            else resolve(fileNo);
-                        });
-                    });
-                    try {
-                        let stat = await new Promise<fs.Stats>((resolve, reject) => {
-                            fs.stat(logPath, (err, data) => {
-                                if (err) reject(err);
-                                else resolve(data);
-                            });
-                        });
-                        // The file is empty.
-                        if (stat.size !== 0) {
-                            let pos = 0;
-                            let chars = [];
-                            while (pos < stat.size) {
-                                // Read a character from the file
-                                let char = await new Promise<string>((resolve, reject) => {
-                                    fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
-                                        if (err) reject(err);
-                                        else resolve(buff.toString());
-                                    });
-                                });
-                                if (!newLines.includes(char)) chars.push(char);
-                                // If we hit the beginning of the file or a newline from a previous
-                                // record then we shoud save off the line and read the next record.
-                                if (newLines.includes(char) || pos === 0) {
-                                    if (chars.length > 0) {
-                                        let entry = DataLogger.createEntry<T>(type, chars.join(''));
-                                        if (typeof fn === 'function') {
-                                            let rc = fn(arr.length + 1, entry, arr);
-                                            if (rc === true) arr.push(entry);
-                                            else if (rc === false) break;
-                                        }
-                                        else
-                                            arr.push(entry);
-                                    }
-                                    chars = [];
-                                }
-                                pos++;
-                            }
-                        }
-                    }
-                    catch (err) { return Promise.reject(err); }
-                    finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
-                } catch (err) { logger.error(err); }
-            }
-            return arr;
-        }
-        catch (err) { logger.error(err); }
-
-    }
-
-    // This method uses a callback to end the file read from the start of the file.  If the callback returns false then the iteration through the
-    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
-    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
-    // 
-    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
-    // of the file.
-    public static readFromStart<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): T[] {
-        let arr: T[] = [];
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let newLines = ['\r', '\n'];
-            if (fs.existsSync(logPath)) {
-                // Alright what we have created here is a method to read the data from the end of 
-                // a log file in reverse order (tail) that works for all os implementations.  It is
-                // really dumb that this isn't part of the actual file processing.
-                let file;
-                try {
-                    file = fs.openSync(logPath, 'r');
-                    if (file) {
-                        try {
-                            let stat = fs.statSync(logPath);
-                            // The file is empty.
-                            if (stat.size !== 0) {
-                                let pos = 0;
-                                let chars = [];
-                                while (pos <= stat.size) {
-                                    // Read a character from the file
-                                    let buff = Buffer.allocUnsafe(1);
-                                    let len = fs.readSync(file, buff, 0, 1, pos);
-                                    if (len === 0) break;
-                                    let char = buff.toString();
-                                    if (!newLines.includes(char)) chars.push(char);
-                                    // If we hit the beginning of the file or a newline from a previous
-                                    // record then we shoud save off the line and read the next record.
-                                    if (newLines.includes(char) || pos === 0) {
-                                        if (chars.length > 0) {
-                                            let entry = DataLogger.createEntry<T>(type, chars.join(''));
-                                            if (typeof fn === 'function') {
-                                                let rc = fn(arr.length + 1, entry, arr);
-                                                console.log(rc);
-                                                if (rc === true) arr.push(entry);
-                                                else if (rc === false) break;
-                                            }
-                                            else
-                                                arr.push(entry);
-                                        }
-                                        chars = [];
-                                    }
-                                    pos++;
-                                }
-                            }
-                        }
-                        catch (err) { logger.error(`Error reading from ${logPath}: ${err.message}`); }
-                    }
-                }
-                finally { if (typeof file !== 'undefined') fs.closeSync(file); }
-            }
-        }
-        catch (err) { logger.error(`Error reading file ${logFile}: ${err.message}`); }
-        return arr;
-    }
-    public static async writeStart(logFile: string, data: any) {
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let lines = [];
-            if (fs.existsSync(logPath)) {
-                let buff = fs.readFileSync(logPath);
-                lines = buff.toString().split('\n');
-            }
-            if (typeof data === 'object')
-                lines.unshift(JSON.stringify(data));
-            else
-                lines.unshift(data.toString());
-            fs.writeFileSync(logPath, lines.join('\n'));
-        } catch (err) { logger.error(err); }
-    }
-    public static writeEnd(logFile: string, entry: DataLoggerEntry) {
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            fs.appendFileSync(logPath, entry.toLog());
-        } catch (err) { logger.error(`Error writing ${logFile}: ${err.message}`); }
-    }
-    public static async writeEndAsync(logFile: string, data: any) {
-        try {
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let s = typeof data === 'object' ? JSON.stringify(data) : data.toString();
-            await new Promise<void>((resolve, reject) => {
-                fs.appendFile(logPath, s, (err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-        } catch (err) { logger.error(`Error writing to file ${logFile}: ${err.message}`); }
-    }
-    // Reads the number of lines in reverse order from the start of the file.
-    public static async readEnd(logFile: string, maxLines: number): Promise<string[]> {
-        try {
-            // Alright what we have created here is a method to read the data from the end of 
-            // a log file in reverse order (tail) that works for all os implementations.  It is
-            // really dumb that this isn't part of the actual file processing.
-            let logPath = DataLogger.makeLogFilePath(logFile);
-            let newLines = ['\r', '\n'];
-            let lines = [];
-            if (fs.existsSync(logPath)) {
-                let stat = await new Promise<fs.Stats>((resolve, reject) => {
-                    fs.stat(logPath, (err, data) => {
-                        if (err) reject(err);
-                        else resolve(data);
-                    });
-                });
-                // The file is empty.
-                if (stat.size === 0) return lines;
-                let pos = stat.size;
-                let file = await new Promise<number>((resolve, reject) => {
-                    fs.open(logPath, 'r', (err, fileNo) => {
-                        if (err) reject(err);
-                        else resolve(fileNo);
-                    });
-                });
-                try {
-                    let line = '';
-                    while (pos >= 0 && lines.length < maxLines) {
-                        // Read a character from the file
-                        let char = await new Promise<string>((resolve, reject) => {
-                            fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
-                                if (err) reject(err);
-                                else resolve(buff.toString());
-                            });
-                        });
-                        pos--;
-                        // If we hit the beginning of the file or a newline from a previous
-                        // record then we shoud save off the line and read the next record.
-                        if (newLines.includes(char) || pos === 0) {
-                            if (line.length > 0) lines.push(line);
-                            line = '';
-                        }
-                        else line += char;
-                    }
-                } catch (err) { }
-                finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
-            }
-            return lines;
-        } catch (err) { logger.error(err); }
-    }
-    private static makeLogFilePath(logFile: string) { return `${DataLogger.ensureLogPath()}/${logFile}`; }
-    private static ensureLogPath(): string {
-        let logPath = path.join(process.cwd(), '/logs');
-        if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
-        return logPath;
-    }
-}
-export interface IDataLoggerEntry<T> {
-    createInstance(entry?: string): T,
-    parse(entry?: string): T
-}
-export class DataLoggerEntry {
-    private static dateTestISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
-    private static dateTextAjax = /^\/Date\((d|-|.*)\)[\/|\\]$/;
-    constructor(entry?: string | object) {
-        // Parse the data from the log entry if it exists.
-        if (typeof entry === 'object') entry = JSON.stringify(entry);
-        if (typeof entry === 'string') this.parse(entry);
-    }
-    public createInstance(entry?: string) { return new DataLoggerEntry(entry); }
-    public parse(entry: string) {
-        let obj = typeof entry !== 'undefined' ? JSON.parse(entry, this.dateParser) : {};
-        extend(true, this, obj);
-    }
-    protected dateParser(key, value) {
-        if (typeof value === 'string') {
-            let d = DataLoggerEntry.dateTestISO.exec(value);
-            // By parsing the date and then creating a new date from that we will get
-            // the date in the proper timezone.
-            if (d) return new Date(Date.parse(value));
-            d = DataLoggerEntry.dateTextAjax.exec(value);
-            if (d) {
-                // Not sure we will be seeing ajax dates but this is
-                // something that we may see from external sources.
-                let a = d[1].split(/[-+,.]/);
-                return new Date(a[0] ? +a[0] : 0 - +a[1]);
-            }
-        }
-        return value;
-    }
-    public toJSON() {
-        return utils.replaceProps(this, (key, value) => {
-            if (key.startsWith('_')) return undefined;
-            if (typeof value === 'undefined' || value === null) return undefined;
-            if (typeof value.getMonth === 'function') return Timestamp.toISOLocal(value);
-            return value;
-        });
-    }
-    public toLog(): string { return JSON.stringify(this) + '\n'; }
-}
+import { Timestamp, utils } from '../controller/Constants';
+import * as extend from 'extend';
+import * as fs from 'fs';
+import * as path from 'path';
+import { setTimeout } from 'timers';
+import * as util from 'util';
+import { logger } from './Logger';
+// One of the primary goals of the DataLogger is to keep the memory usage low when reading and writing large files.  This should allow
+// the datalogger to manage the file without putting undue pressure on the file system or the heap.  While some of these methods
+// read in the entire file, others are designed to keep only a single logger entry buffer in memory.
+export class DataLogger {
+    // Creates a new entry from the type constructor.  Javascript lacks any real way to factory up an object from a constructor so we
+    // are using a workaround that points to the constructor for the object.  Its lame but effective.
+    public static createEntry<T>(type: (new () => T), line?: string): T {
+        let entry = new type();
+        if (typeof line !== 'undefined') (entry as unknown as DataLoggerEntry).parse(line);
+        return entry;
+    }
+    // This reads the entire file into memory and is very expensive because of the buffer.  The readFromStart/End methods should be used in most cases.
+    public static readAll<T>(logFile: string, type: (new () => T)): T[] {
+        try {
+            let logPath = path.join(process.cwd(), '/logs');
+            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
+            logPath += (`/${logFile}`);
+            let lines = [];
+            if (fs.existsSync(logPath)) {
+                let buff = fs.readFileSync(logPath);
+                lines = buff.toString().split('\n');
+            }
+            let arr: T[] = [];
+            for (let i = 0; i < lines.length; i++) {
+                try {
+                    let entry = DataLogger.createEntry<T>(type, lines[i]);
+                    arr.push(entry);
+                } catch (err) { logger.error(`Skipping invalid dose history entry: ${err.message}`); }
+            }
+            return arr;
+        } catch (err) { logger.error(err); }
+    }
+    // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
+    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
+    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
+    // 
+    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
+    // of the file.
+    public static async readFromEndAsync<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): Promise<T[]> {
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let newLines = ['\r', '\n'];
+            let arr: T[] = [];
+            if (fs.existsSync(logPath)) {
+                console.log(`Reading logfile ${logPath}`);
+                // Alright what we have created here is a method to read the data from the end of 
+                // a log file in reverse order (tail) that works for all os implementations.  It is
+                // really dumb that this isn't part of the actual file processing.
+                try {
+                    let file = await new Promise<number>((resolve, reject) => {
+                        fs.open(logPath, 'r', (err, fileNo) => {
+                            if (err) reject(err);
+                            else resolve(fileNo);
+                        });
+                    });
+                    try {
+                        let stat = await new Promise<fs.Stats>((resolve, reject) => {
+                            fs.stat(logPath, (err, data) => {
+                                if (err) reject(err);
+                                else resolve(data);
+                            });
+                        });
+                        // The file is empty.
+                        if (stat.size !== 0) {
+                            let pos = stat.size - 1;
+                            let chars = [];
+                            while (pos >= 0) {
+                                // Read a character from the file
+                                let char = await new Promise<string>((resolve, reject) => {
+                                    fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
+                                        if (err) reject(err);
+                                        else resolve(buff.toString());
+                                    });
+                                });
+                                if (!newLines.includes(char)) chars.unshift(char);
+                                // If we hit the beginning of the file or a newline from a previous
+                                // record then we shoud save off the line and read the next record.
+                                if (newLines.includes(char) || pos === 0) {
+                                    if (chars.length > 0) {
+                                        try {
+                                            let entry = DataLogger.createEntry<T>(type, chars.join(''));
+                                            if (typeof fn === 'function') {
+                                                let rc = fn(arr.length + 1, entry, arr);
+                                                if (rc === true) arr.push(entry);
+                                                else if (rc === false) break;
+                                            }
+                                            else
+                                                arr.push(entry);
+                                        } catch (err) { logger.error(`Skipping invalid dose history entry: ${err.message}`); }
+                                    }
+                                    chars = [];
+                                }
+                                pos--;
+                            }
+                        }
+                    }
+                    catch (err) { return Promise.reject(err); }
+                    finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
+                } catch (err) { logger.error(err); }
+            }
+            return arr;
+        }
+        catch (err) { logger.error(err); }
+
+    }
+    // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
+    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
+    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
+    // 
+    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
+    // of the file.
+    public static readFromEnd<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): T[] {
+        let arr: T[] = [];
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let newLines = ['\r', '\n'];
+            if (fs.existsSync(logPath)) {
+                // Alright what we have created here is a method to read the data from the end of 
+                // a log file in reverse order (tail) that works for all os implementations.  It is
+                // really dumb that this isn't part of the actual file processing.
+                let file;
+                try {
+                    file = fs.openSync(logPath, 'r');
+                    if (file) {
+                        try {
+                            let stat = fs.statSync(logPath);
+                            // The file is empty.
+                            if (stat.size !== 0) {
+                                let pos = stat.size - 1;
+                                let chars = [];
+                                while (pos >= 0) {
+                                    // Read a character from the file
+                                    let buff = Buffer.allocUnsafe(1);
+                                    let len = fs.readSync(file, buff, 0, 1, pos);
+                                    if (len === 0) break;
+                                    let char = buff.toString();
+                                    if (!newLines.includes(char)) chars.unshift(char);
+                                    // If we hit the beginning of the file or a newline from a previous
+                                    // record then we shoud save off the line and read the next record.
+                                    if (newLines.includes(char) || pos === 0) {
+                                        if (chars.length > 0) {
+                                            try {
+                                                let entry = DataLogger.createEntry<T>(type, chars.join(''));
+                                                if (typeof fn === 'function') {
+                                                    let rc = fn(arr.length + 1, entry, arr);
+                                                    if (rc === true) arr.push(entry);
+                                                    else if (rc === false) break;
+                                                }
+                                                else
+                                                    arr.push(entry);
+                                            } catch (err) { logger.error(`Skipping invalid dose history entry: ${err.message}`); }
+                                        }
+                                        chars = [];
+                                    }
+                                    pos--;
+                                }
+                            }
+                        }
+                        catch (err) { logger.error(`Error reading from ${logPath}: ${err.message}`); }
+                    }
+                }
+                finally { if (typeof file !== 'undefined') fs.closeSync(file); }
+            }
+        }
+        catch (err) { logger.error(`Error reading file ${logFile}: ${err.message}`); }
+        return arr;
+    }
+    // This method uses a callback to end the file read from the start of the file.  If the callback returns false then the iteration through the
+    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
+    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
+    // 
+    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
+    // of the file.
+    public static async readFromStartAsync<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): Promise<T[]> {
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let newLines = ['\r', '\n'];
+            let arr: T[] = [];
+            if (fs.existsSync(logPath)) {
+                // Alright what we have created here is a method to read the data from the end of 
+                // a log file in reverse order (tail) that works for all os implementations.  It is
+                // really dumb that this isn't part of the actual file processing.
+                try {
+                    let file = await new Promise<number>((resolve, reject) => {
+                        fs.open(logPath, 'r', (err, fileNo) => {
+                            if (err) reject(err);
+                            else resolve(fileNo);
+                        });
+                    });
+                    try {
+                        let stat = await new Promise<fs.Stats>((resolve, reject) => {
+                            fs.stat(logPath, (err, data) => {
+                                if (err) reject(err);
+                                else resolve(data);
+                            });
+                        });
+                        // The file is empty.
+                        if (stat.size !== 0) {
+                            let pos = 0;
+                            let chars = [];
+                            while (pos < stat.size) {
+                                // Read a character from the file
+                                let char = await new Promise<string>((resolve, reject) => {
+                                    fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
+                                        if (err) reject(err);
+                                        else resolve(buff.toString());
+                                    });
+                                });
+                                if (!newLines.includes(char)) chars.push(char);
+                                // If we hit the beginning of the file or a newline from a previous
+                                // record then we shoud save off the line and read the next record.
+                                if (newLines.includes(char) || pos === 0) {
+                                    if (chars.length > 0) {
+                                        let entry = DataLogger.createEntry<T>(type, chars.join(''));
+                                        if (typeof fn === 'function') {
+                                            let rc = fn(arr.length + 1, entry, arr);
+                                            if (rc === true) arr.push(entry);
+                                            else if (rc === false) break;
+                                        }
+                                        else
+                                            arr.push(entry);
+                                    }
+                                    chars = [];
+                                }
+                                pos++;
+                            }
+                        }
+                    }
+                    catch (err) { return Promise.reject(err); }
+                    finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
+                } catch (err) { logger.error(err); }
+            }
+            return arr;
+        }
+        catch (err) { logger.error(err); }
+
+    }
+
+    // This method uses a callback to end the file read from the start of the file.  If the callback returns false then the iteration through the
+    // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
+    // array and the iteration will continue.  If the callback returns undefined then the entry is ignored and the iteration continues.
+    // 
+    // This allows for efficient filtering of dataLogger files from the end of the file that reduces writes by appending data and allowing efficient pruning
+    // of the file.
+    public static readFromStart<T>(logFile: string, type: (new () => T), fn?: (lineNumber: number, entry?: T, arr?: T[]) => boolean): T[] {
+        let arr: T[] = [];
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let newLines = ['\r', '\n'];
+            if (fs.existsSync(logPath)) {
+                // Alright what we have created here is a method to read the data from the end of 
+                // a log file in reverse order (tail) that works for all os implementations.  It is
+                // really dumb that this isn't part of the actual file processing.
+                let file;
+                try {
+                    file = fs.openSync(logPath, 'r');
+                    if (file) {
+                        try {
+                            let stat = fs.statSync(logPath);
+                            // The file is empty.
+                            if (stat.size !== 0) {
+                                let pos = 0;
+                                let chars = [];
+                                while (pos <= stat.size) {
+                                    // Read a character from the file
+                                    let buff = Buffer.allocUnsafe(1);
+                                    let len = fs.readSync(file, buff, 0, 1, pos);
+                                    if (len === 0) break;
+                                    let char = buff.toString();
+                                    if (!newLines.includes(char)) chars.push(char);
+                                    // If we hit the beginning of the file or a newline from a previous
+                                    // record then we shoud save off the line and read the next record.
+                                    if (newLines.includes(char) || pos === 0) {
+                                        if (chars.length > 0) {
+                                            let entry = DataLogger.createEntry<T>(type, chars.join(''));
+                                            if (typeof fn === 'function') {
+                                                let rc = fn(arr.length + 1, entry, arr);
+                                                if (rc === true) arr.push(entry);
+                                                else if (rc === false) break;
+                                            }
+                                            else
+                                                arr.push(entry);
+                                        }
+                                        chars = [];
+                                    }
+                                    pos++;
+                                }
+                            }
+                        }
+                        catch (err) { logger.error(`Error reading from ${logPath}: ${err.message}`); }
+                    }
+                }
+                finally { if (typeof file !== 'undefined') fs.closeSync(file); }
+            }
+        }
+        catch (err) { logger.error(`Error reading file ${logFile}: ${err.message}`); }
+        return arr;
+    }
+    public static async writeStart(logFile: string, data: any) {
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let lines = [];
+            if (fs.existsSync(logPath)) {
+                let buff = fs.readFileSync(logPath);
+                lines = buff.toString().split('\n');
+            }
+            if (typeof data === 'object')
+                lines.unshift(JSON.stringify(data));
+            else
+                lines.unshift(data.toString());
+            fs.writeFileSync(logPath, lines.join('\n'));
+        } catch (err) { logger.error(err); }
+    }
+    public static writeEnd(logFile: string, entry: DataLoggerEntry) {
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            fs.appendFileSync(logPath, entry.toLog());
+        } catch (err) { logger.error(`Error writing ${logFile}: ${err.message}`); }
+    }
+    public static async writeEndAsync(logFile: string, data: any) {
+        try {
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let s = typeof data === 'object' ? JSON.stringify(data) : data.toString();
+            await new Promise<void>((resolve, reject) => {
+                fs.appendFile(logPath, s, (err) => {
+                    if (err) reject(err);
+                    else resolve();
+                });
+            });
+        } catch (err) { logger.error(`Error writing to file ${logFile}: ${err.message}`); }
+    }
+    // Reads the number of lines in reverse order from the start of the file.
+    public static async readEnd(logFile: string, maxLines: number): Promise<string[]> {
+        try {
+            // Alright what we have created here is a method to read the data from the end of 
+            // a log file in reverse order (tail) that works for all os implementations.  It is
+            // really dumb that this isn't part of the actual file processing.
+            let logPath = DataLogger.makeLogFilePath(logFile);
+            let newLines = ['\r', '\n'];
+            let lines = [];
+            if (fs.existsSync(logPath)) {
+                let stat = await new Promise<fs.Stats>((resolve, reject) => {
+                    fs.stat(logPath, (err, data) => {
+                        if (err) reject(err);
+                        else resolve(data);
+                    });
+                });
+                // The file is empty.
+                if (stat.size === 0) return lines;
+                let pos = stat.size;
+                let file = await new Promise<number>((resolve, reject) => {
+                    fs.open(logPath, 'r', (err, fileNo) => {
+                        if (err) reject(err);
+                        else resolve(fileNo);
+                    });
+                });
+                try {
+                    let line = '';
+                    while (pos >= 0 && lines.length < maxLines) {
+                        // Read a character from the file
+                        let char = await new Promise<string>((resolve, reject) => {
+                            fs.read(file, Buffer.allocUnsafe(1), 0, 1, pos, (err, bytesRead, buff) => {
+                                if (err) reject(err);
+                                else resolve(buff.toString());
+                            });
+                        });
+                        pos--;
+                        // If we hit the beginning of the file or a newline from a previous
+                        // record then we shoud save off the line and read the next record.
+                        if (newLines.includes(char) || pos === 0) {
+                            if (line.length > 0) lines.push(line);
+                            line = '';
+                        }
+                        else line += char;
+                    }
+                } catch (err) { }
+                finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
+            }
+            return lines;
+        } catch (err) { logger.error(err); }
+    }
+    private static makeLogFilePath(logFile: string) { return `${DataLogger.ensureLogPath()}/${logFile}`; }
+    private static ensureLogPath(): string {
+        let logPath = path.join(process.cwd(), '/logs');
+        if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
+        return logPath;
+    }
+}
+export interface IDataLoggerEntry<T> {
+    createInstance(entry?: string): T,
+    parse(entry?: string): T
+}
+export class DataLoggerEntry {
+    private static dateTestISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
+    private static dateTextAjax = /^\/Date\((d|-|.*)\)[\/|\\]$/;
+    constructor(entry?: string | object) {
+        // Parse the data from the log entry if it exists.
+        if (typeof entry === 'object') entry = JSON.stringify(entry);
+        if (typeof entry === 'string') this.parse(entry);
+        else {
+            //console.log(`A DATALOGGER ENTRY DOES NOT HAVE A PROPER TYPE ${typeof entry} *************************************`);
+            //console.log(entry);
+        }
+    }
+    public static createInstance(entry?: string) { return new DataLoggerEntry(entry); }
+    public parse(entry: string) {
+        let obj = typeof entry !== 'undefined' ? JSON.parse(entry, this.dateParser) : {};
+        if (typeof entry === 'undefined') {
+            console.log(`A DATALOGGER ENTRY WAS NOT DEFINED *************************`);
+        }
+        else if (entry === '') {
+            console.log(`THE INCOMING DATALOGGER ENTRY WAS EMPTY ***************************`)
+        }
+        let o = extend(true, this, obj);
+    }
+    protected dateParser(key, value) {
+        if (typeof value === 'string') {
+            let d = DataLoggerEntry.dateTestISO.exec(value);
+            // By parsing the date and then creating a new date from that we will get
+            // the date in the proper timezone.
+            if (d) return new Date(Date.parse(value));
+            d = DataLoggerEntry.dateTextAjax.exec(value);
+            if (d) {
+                // Not sure we will be seeing ajax dates but this is
+                // something that we may see from external sources.
+                let a = d[1].split(/[-+,.]/);
+                return new Date(a[0] ? +a[0] : 0 - +a[1]);
+            }
+        }
+        return value;
+    }
+    public toJSON() {
+        return utils.replaceProps(this, (key, value) => {
+            if (key.startsWith('_')) return undefined;
+            if (typeof value === 'undefined' || value === null) return undefined;
+            if (typeof value.getMonth === 'function') return Timestamp.toISOLocal(value);
+            return value;
+        });
+    }
+    public toLog(): string { return JSON.stringify(this) + '\n'; }
+}