@bitblit/ratchet-aws 4.0.80-alpha

package/dist/cjs/batch/aws-batch-background-processor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsBatchBackgroundProcessor = void 0;
+const luxon_1 = require("luxon");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class AwsBatchBackgroundProcessor {
+    constructor(batchRatchet, validTaskNames) {
+        this.batchRatchet = batchRatchet;
+        this.validTaskNames = validTaskNames;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.batchRatchet, 'batchRatchet');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.batchRatchet.batchClient, 'batchRatchet.batchClient');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultJobDefinition, 'batchRatchet.defaultJobDefinition');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultQueueName, 'batchRatchet.defaultQueueName');
+    }
+    async scheduleBackgroundTask(taskName, data = {}, meta = {}) {
+        if (this.validTaskNames &&
+            this.validTaskNames.length &&
+            (!ratchet_common_1.StringRatchet.trimToNull(taskName) || !this.validTaskNames.includes(taskName))) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot start task %s - not found in valid task list', taskName);
+        }
+        ratchet_common_1.Logger.info('Submitting background task to AWS batch: %s %j %s', taskName, data, this.batchRatchet.defaultQueueName);
+        let rval = null;
+        const jobName = `${this.batchRatchet.defaultJobDefinition}-${taskName}_${luxon_1.DateTime.utc().toFormat('yyyy-MM-dd-HH-mm')}`;
+        const options = {
+            jobName: jobName,
+            jobDefinition: this.batchRatchet.defaultJobDefinition,
+            jobQueue: this.batchRatchet.defaultQueueName,
+            parameters: {
+                taskName,
+                taskData: JSON.stringify(data),
+                taskMetadata: JSON.stringify(meta),
+            },
+        };
+        try {
+            rval = await this.batchRatchet.scheduleJob(options);
+            ratchet_common_1.Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Cannot submit batch job taskName: %s jobDef: %s queue: %s jobName: %s data: %j', taskName, this.batchRatchet.defaultJobDefinition, this.batchRatchet.defaultQueueName, jobName, data, err);
+        }
+        return rval;
+    }
+}
+exports.AwsBatchBackgroundProcessor = AwsBatchBackgroundProcessor;

package/dist/cjs/batch/aws-batch-ratchet.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsBatchRatchet = void 0;
+const client_batch_1 = require("@aws-sdk/client-batch");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class AwsBatchRatchet {
+    constructor(_batchClient, _defaultQueueName, _defaultJobDefinition) {
+        this._batchClient = _batchClient;
+        this._defaultQueueName = _defaultQueueName;
+        this._defaultJobDefinition = _defaultJobDefinition;
+    }
+    get batchClient() {
+        return this._batchClient;
+    }
+    get defaultQueueName() {
+        return this._defaultQueueName;
+    }
+    get defaultJobDefinition() {
+        return this._defaultJobDefinition;
+    }
+    async scheduleJob(options) {
+        ratchet_common_1.Logger.info('Submitting batch job %s', options.jobName);
+        try {
+            const rval = await this._batchClient.send(new client_batch_1.SubmitJobCommand(options));
+            ratchet_common_1.Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+            return rval;
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Cannot submit batch job %s: %s', options.jobName, err);
+        }
+        return null;
+    }
+    async jobCountInState(jobStatus, queueName = this.defaultQueueName) {
+        const all = await this.listJobs(queueName, jobStatus);
+        return all.length;
+    }
+    async listJobs(queueName = this.defaultQueueName, jobStatus = null) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(queueName, 'queueName');
+        let rval = [];
+        const request = {
+            jobQueue: queueName,
+            jobStatus: jobStatus,
+            nextToken: null,
+        };
+        ratchet_common_1.Logger.info('Fetching %j', request);
+        do {
+            ratchet_common_1.Logger.info('Pulling page...');
+            const tmp = await this._batchClient.send(new client_batch_1.ListJobsCommand(request));
+            rval = rval.concat(tmp.jobSummaryList);
+            request.nextToken = tmp.nextToken;
+        } while (request.nextToken);
+        return rval;
+    }
+}
+exports.AwsBatchRatchet = AwsBatchRatchet;

package/dist/cjs/build/ratchet-aws-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetAwsInfo = void 0;
+class RatchetAwsInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetAwsInfo = RatchetAwsInfo;

package/dist/cjs/cache/dynamo-db-storage-provider.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDbStorageProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class DynamoDbStorageProvider {
+    constructor(dynamo, opts) {
+        this.dynamo = dynamo;
+        this.opts = opts;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.dynamo, 'dynamo');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.opts, 'opts');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.opts.tableName, 'opts.tableName');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.opts.hashKeyName, 'opts.hashKeyName');
+        ratchet_common_1.RequireRatchet.true(!this.opts.useRangeKeys || (!!this.opts.rangeKeyName && !!this.opts.hashKeyValue), 'invalid range configuration');
+    }
+    static createDefaultOptions() {
+        const rval = {
+            tableName: 'simple-cache',
+            useRangeKeys: false,
+            hashKeyName: 'cache-key',
+            rangeKeyName: null,
+            hashKeyValue: null,
+        };
+        return rval;
+    }
+    createKeyObject(cacheKey) {
+        const keys = {};
+        if (this.opts.useRangeKeys) {
+            keys[this.opts.hashKeyName] = this.opts.hashKeyValue;
+            keys[this.opts.rangeKeyName] = cacheKey;
+        }
+        else {
+            keys[this.opts.hashKeyName] = cacheKey;
+        }
+        return keys;
+    }
+    cleanDynamoFieldsFromObjectInPlace(rval) {
+        if (rval) {
+            delete rval[this.opts.hashKeyName];
+            if (this.opts.rangeKeyName) {
+                delete rval[this.opts.rangeKeyName];
+            }
+            if (this.opts.dynamoExpiresColumnName) {
+                delete rval[this.opts.dynamoExpiresColumnName];
+            }
+        }
+    }
+    extractKeysFromObject(rval) {
+        let keys = null;
+        if (rval) {
+            keys = {};
+            if (this.opts.useRangeKeys) {
+                keys[this.opts.hashKeyName] = this.opts.hashKeyValue;
+                keys[this.opts.rangeKeyName] = rval.cacheKey;
+            }
+            else {
+                keys[this.opts.hashKeyName] = rval.cacheKey;
+            }
+        }
+        return keys;
+    }
+    async readFromCache(cacheKey) {
+        const dKey = this.createKeyObject(cacheKey);
+        const rval = await this.dynamo.simpleGet(this.opts.tableName, dKey);
+        this.cleanDynamoFieldsFromObjectInPlace(rval);
+        return rval;
+    }
+    async storeInCache(value) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(value, 'value');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(value.cacheKey, 'value.cacheKey');
+        const toSave = Object.assign({}, value, this.createKeyObject(value.cacheKey));
+        if (this.opts.dynamoExpiresColumnName && value.expiresEpochMS) {
+            toSave[this.opts.dynamoExpiresColumnName] = Math.floor(value.expiresEpochMS / 1000);
+        }
+        const wrote = await this.dynamo.simplePut(this.opts.tableName, toSave);
+        return !!wrote;
+    }
+    async removeFromCache(cacheKey) {
+        await this.dynamo.simpleDelete(this.opts.tableName, this.createKeyObject(cacheKey));
+    }
+    async clearCache() {
+        const allValues = await this.readAll();
+        const allKeys = allValues.map((a) => this.extractKeysFromObject(a));
+        const rval = await this.dynamo.deleteAllInBatches(this.opts.tableName, allKeys, 25);
+        return rval;
+    }
+    async readAll() {
+        let rval = null;
+        if (this.opts.useRangeKeys) {
+            const qry = {
+                TableName: this.opts.tableName,
+                KeyConditionExpression: '#cacheKey = :cacheKey',
+                ExpressionAttributeNames: {
+                    '#cacheKey': this.opts.hashKeyName,
+                },
+                ExpressionAttributeValues: {
+                    ':cacheKey': this.opts.hashKeyValue,
+                },
+            };
+            rval = await this.dynamo.fullyExecuteQuery(qry);
+        }
+        else {
+            const scan = {
+                TableName: this.opts.tableName,
+            };
+            rval = await this.dynamo.fullyExecuteScan(scan);
+        }
+        rval.forEach((r) => this.cleanDynamoFieldsFromObjectInPlace(r));
+        return rval;
+    }
+}
+exports.DynamoDbStorageProvider = DynamoDbStorageProvider;

package/dist/cjs/cache/s3-storage-provider.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class S3StorageProvider {
+    constructor(s3CacheRatchet, prefix) {
+        this.s3CacheRatchet = s3CacheRatchet;
+        this.prefix = prefix;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.s3CacheRatchet, 's3CacheRatchet');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(this.s3CacheRatchet.getDefaultBucket(), 's3CacheRatchet.defaultBucket');
+    }
+    keyToPath(cacheKey) {
+        let rval = ratchet_common_1.StringRatchet.trimToEmpty(this.prefix);
+        if (rval.length > 0 && !rval.endsWith('/')) {
+            rval += '/';
+        }
+        rval += cacheKey;
+        return rval;
+    }
+    async readFromCache(cacheKey) {
+        const rval = await this.s3CacheRatchet.fetchCacheFileAsObject(this.keyToPath(cacheKey));
+        return rval;
+    }
+    async storeInCache(value) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(value, 'value');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(value.cacheKey, 'value.cacheKey');
+        const tmp = await this.s3CacheRatchet.writeObjectToCacheFile(this.keyToPath(value.cacheKey), value);
+        return !!tmp;
+    }
+    async removeFromCache(cacheKey) {
+        await this.s3CacheRatchet.removeCacheFile(this.keyToPath(cacheKey));
+    }
+    async clearCache() {
+        const keys = await this.s3CacheRatchet.directChildrenOfPrefix(this.keyToPath(''));
+        const removed = await Promise.all(keys.map((k) => this.removeFromCache(k)));
+        return keys.length;
+    }
+    async readAll() {
+        const keys = await this.s3CacheRatchet.directChildrenOfPrefix(this.keyToPath(''));
+        const rval = await Promise.all(keys.map((k) => this.readFromCache(k)));
+        return rval;
+    }
+}
+exports.S3StorageProvider = S3StorageProvider;

package/dist/cjs/cache/simple-cache-object-wrapper.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cache/simple-cache-read-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cache/simple-cache-storage-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cache/simple-cache.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCache = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class SimpleCache {
+    constructor(provider, defaultTimeToLiveMS = 1000 * 60) {
+        this.provider = provider;
+        this.defaultTimeToLiveMS = defaultTimeToLiveMS;
+    }
+    createDefaultReadOptions() {
+        return {
+            maxStalenessMS: null,
+            timeToLiveMS: this.defaultTimeToLiveMS,
+            cacheNullValues: false,
+        };
+    }
+    async fetchWrapper(cacheKey, producer, opts = this.createDefaultReadOptions()) {
+        ratchet_common_1.Logger.silly('Fetching %s', cacheKey);
+        const now = new Date().getTime();
+        let rval = await this.provider.readFromCache(cacheKey);
+        if (rval && rval.expiresEpochMS < now) {
+            ratchet_common_1.Logger.debug('Object found, but expired - removing');
+            rval = null;
+        }
+        if (rval && opts && opts.maxStalenessMS && now - rval.createdEpochMS > opts.maxStalenessMS) {
+            ratchet_common_1.Logger.debug('Object found by too stale - removing');
+            rval = null;
+        }
+        if (!rval) {
+            ratchet_common_1.Logger.debug('%s not found in cache, generating', cacheKey);
+            const tmp = await producer();
+            if (tmp || (opts === null || opts === void 0 ? void 0 : opts.cacheNullValues)) {
+                ratchet_common_1.Logger.debug('Writing %j to cache');
+                rval = {
+                    cacheKey: cacheKey,
+                    createdEpochMS: now,
+                    expiresEpochMS: opts && opts.timeToLiveMS ? now + opts.timeToLiveMS : null,
+                    value: tmp,
+                    generated: false,
+                };
+                await this.provider.storeInCache(rval);
+                rval.generated = true;
+            }
+        }
+        return rval;
+    }
+    async fetch(cacheKey, producer, opts = null) {
+        const wrapper = await this.fetchWrapper(cacheKey, producer, opts);
+        return wrapper ? wrapper.value : null;
+    }
+    async removeFromCache(cacheKey, returnOldValue) {
+        let rval = null;
+        if (returnOldValue) {
+            rval = await this.fetchWrapper(cacheKey, () => null);
+        }
+        await this.provider.removeFromCache(cacheKey);
+        return rval;
+    }
+    async clearCache() {
+        return this.provider.clearCache();
+    }
+    async readAll() {
+        return this.provider.readAll();
+    }
+}
+exports.SimpleCache = SimpleCache;

package/dist/cjs/cloudwatch/cloud-watch-log-group-ratchet.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogGroupRatchet = void 0;
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class CloudWatchLogGroupRatchet {
+    constructor(logGroup, awsCWLogs = new client_cloudwatch_logs_1.CloudWatchLogsClient({ region: 'us-east-1' })) {
+        this.logGroup = logGroup;
+        this.awsCWLogs = awsCWLogs;
+    }
+    async readLogStreams(startTimestamp = null, endTimestamp = null) {
+        const params = {
+            logGroupName: this.logGroup,
+            orderBy: 'LastEventTime',
+        };
+        const rval = [];
+        do {
+            ratchet_common_1.Logger.debug('Pulling more log streams (%d found so far)', rval.length);
+            const temp = await this.awsCWLogs.send(new client_cloudwatch_logs_1.DescribeLogStreamsCommand(params));
+            temp.logStreams.forEach((s) => {
+                if (s.lastEventTimestamp !== null) {
+                    if (!startTimestamp || s.lastEventTimestamp >= startTimestamp) {
+                        if (!endTimestamp || s.firstEventTimestamp <= endTimestamp) {
+                            rval.push(s);
+                        }
+                    }
+                }
+            });
+            params.nextToken = temp.nextToken;
+        } while (!!params.nextToken);
+        ratchet_common_1.Logger.debug('Found %d total, returning', rval.length);
+        return rval;
+    }
+    async readLogStreamNames(startTimestamp = null, endTimestamp = null) {
+        const streams = await this.readLogStreams(startTimestamp, endTimestamp);
+        const rval = streams.map((s) => s.logStreamName);
+        return rval;
+    }
+    async readEvents(filter, startTimestamp = null, endTimestamp = null, sortEvents = true, maxEvents = null) {
+        const sw = new ratchet_common_2.StopWatch();
+        const params = {
+            logGroupName: this.logGroup,
+            endTime: endTimestamp,
+            startTime: startTimestamp,
+        };
+        if (filter) {
+            params.filterPattern = filter;
+        }
+        ratchet_common_1.Logger.debug('Reading log events matching : %j', params);
+        let rval = [];
+        do {
+            ratchet_common_1.Logger.debug('Pulling more log events (%d found so far) : %s', rval.length, sw.dump());
+            const temp = await this.awsCWLogs.send(new client_cloudwatch_logs_1.FilterLogEventsCommand(params));
+            rval = rval.concat(temp.events);
+            params.nextToken = temp.nextToken;
+        } while (!!params.nextToken && (!maxEvents || rval.length < maxEvents));
+        ratchet_common_1.Logger.debug('Found %d total in %s', rval.length, sw.dump());
+        if (sortEvents) {
+            ratchet_common_1.Logger.debug('Sorting events by timestamp');
+            rval = rval.sort((a, b) => {
+                let rval = a.timestamp - b.timestamp;
+                if (rval === 0) {
+                    rval = a.message.localeCompare(b.message);
+                }
+                return rval;
+            });
+        }
+        sw.log();
+        return rval;
+    }
+}
+exports.CloudWatchLogGroupRatchet = CloudWatchLogGroupRatchet;

package/dist/cjs/cloudwatch/cloud-watch-logs-ratchet.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogsRatchet = void 0;
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class CloudWatchLogsRatchet {
+    constructor(cloudwatchLogs = null) {
+        this.cwLogs = cloudwatchLogs ? cloudwatchLogs : new client_cloudwatch_logs_1.CloudWatchLogsClient({ region: 'us-east-1' });
+    }
+    async removeEmptyOrOldLogStreams(logGroupName, maxToRemove = 1000, oldestEventEpochMS = null) {
+        ratchet_common_1.Logger.info('Removing empty streams from %s, oldest event epoch MS : %d', logGroupName, oldestEventEpochMS);
+        const streamSearchParams = {
+            logGroupName: logGroupName,
+            orderBy: 'LastEventTime',
+        };
+        const oldestEventTester = oldestEventEpochMS || 1;
+        let totalStreams = 0;
+        const removedStreams = [];
+        const failedRemovedStreams = [];
+        let waitPerDescribe = 10;
+        do {
+            ratchet_common_1.Logger.debug('Executing search for streams');
+            try {
+                const streams = await this.cwLogs.send(new client_cloudwatch_logs_1.DescribeLogStreamsCommand(streamSearchParams));
+                totalStreams += streams.logStreams.length;
+                ratchet_common_1.Logger.debug('Found %d streams (%d so far, %d to delete)', streams.logStreams.length, totalStreams, removedStreams.length);
+                for (let i = 0; i < streams.logStreams.length && removedStreams.length < maxToRemove; i++) {
+                    const st = streams.logStreams[i];
+                    if (!st.firstEventTimestamp) {
+                        removedStreams.push(st);
+                    }
+                    else if (st.lastEventTimestamp < oldestEventTester) {
+                        removedStreams.push(st);
+                    }
+                }
+                streamSearchParams['nextToken'] = streams.nextToken;
+            }
+            catch (err) {
+                const oldWait = waitPerDescribe;
+                waitPerDescribe = Math.min(1000, waitPerDescribe * 1.5);
+                ratchet_common_1.Logger.info('Caught while describing %s, increasing wait between deletes (was %d, now %d)', err, oldWait, waitPerDescribe);
+            }
+        } while (!!streamSearchParams['nextToken'] && removedStreams.length < maxToRemove);
+        ratchet_common_1.Logger.info('Found %d streams to delete', removedStreams.length);
+        let waitPer = 10;
+        for (let i = 0; i < removedStreams.length; i++) {
+            const delParams = {
+                logGroupName: logGroupName,
+                logStreamName: removedStreams[i].logStreamName,
+            };
+            const type = removedStreams[i].storedBytes === 0 ? 'empty' : 'old';
+            ratchet_common_1.Logger.info('Removing %s stream %s', type, removedStreams[i].logStreamName);
+            let removed = false;
+            let retry = 0;
+            while (!removed && retry < CloudWatchLogsRatchet.MAX_DELETE_RETRIES) {
+                try {
+                    await this.cwLogs.send(new client_cloudwatch_logs_1.DeleteLogStreamCommand(delParams));
+                    removed = true;
+                    await ratchet_common_2.PromiseRatchet.wait(waitPer);
+                }
+                catch (err) {
+                    retry++;
+                    const oldWait = waitPer;
+                    waitPer = Math.min(1000, waitPer * 1.5);
+                    ratchet_common_1.Logger.info('Caught %s, increasing wait between deletes and retrying (wait was %d, now %d) (Retry %d of %d)', err, oldWait, waitPer, retry, CloudWatchLogsRatchet.MAX_DELETE_RETRIES);
+                }
+            }
+            if (!removed) {
+                failedRemovedStreams.push(removedStreams[i]);
+            }
+        }
+        ratchet_common_1.Logger.warn('Failed to remove streams : %j', failedRemovedStreams);
+        return removedStreams;
+    }
+    async findOldestEventTimestampInGroup(logGroupName) {
+        const stream = await this.findStreamWithOldestEventInGroup(logGroupName);
+        return stream ? stream.firstEventTimestamp : null;
+    }
+    async findStreamWithOldestEventInGroup(logGroupName) {
+        ratchet_common_1.Logger.info('Finding oldest event in : %s', logGroupName);
+        let rval = null;
+        try {
+            const streamSearchParams = {
+                logGroupName: logGroupName,
+                orderBy: 'LastEventTime',
+            };
+            let totalStreams = 0;
+            do {
+                ratchet_common_1.Logger.debug('Executing search for streams');
+                const streams = await this.cwLogs.send(new client_cloudwatch_logs_1.DescribeLogStreamsCommand(streamSearchParams));
+                totalStreams += streams.logStreams.length;
+                ratchet_common_1.Logger.debug('Found %d streams (%d so far)', streams.logStreams.length, totalStreams);
+                streams.logStreams.forEach((s) => {
+                    if (s.firstEventTimestamp && (rval === null || s.firstEventTimestamp < rval.firstEventTimestamp)) {
+                        rval = s;
+                    }
+                });
+                streamSearchParams['nextToken'] = streams.nextToken;
+            } while (!!streamSearchParams['nextToken']);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Error attempting to find oldest event in group : %s : %s', logGroupName, err, err);
+        }
+        return rval;
+    }
+    async findLogGroups(prefix) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(prefix);
+        const params = {
+            logGroupNamePrefix: prefix,
+        };
+        let rval = [];
+        do {
+            ratchet_common_1.Logger.info('%d found, pulling log groups : %j', rval.length, params);
+            const res = await this.cwLogs.send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand(params));
+            rval = rval.concat(res.logGroups);
+            params.nextToken = res.nextToken;
+        } while (!!params.nextToken);
+        return rval;
+    }
+    async removeLogGroups(groups) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(groups);
+        const rval = [];
+        for (let i = 0; i < groups.length; i++) {
+            try {
+                ratchet_common_1.Logger.info('Deleting %j', groups[i]);
+                const req = {
+                    logGroupName: groups[i].logGroupName,
+                };
+                await this.cwLogs.send(new client_cloudwatch_logs_1.DeleteLogGroupCommand(req));
+                rval.push(true);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Failure to delete %j : %s', groups[i], err);
+                rval.push(false);
+            }
+        }
+        return rval;
+    }
+    async removeLogGroupsWithPrefix(prefix) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(prefix);
+        ratchet_common_3.RequireRatchet.true(ratchet_common_4.StringRatchet.trimToEmpty(prefix).length > 0);
+        ratchet_common_1.Logger.info('Removing log groups with prefix %s', prefix);
+        const groups = await this.findLogGroups(prefix);
+        return await this.removeLogGroups(groups);
+    }
+    async fullyExecuteInsightsQuery(sqr) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(sqr);
+        ratchet_common_1.Logger.debug('Starting insights query : %j', sqr);
+        const resp = await this.cwLogs.send(new client_cloudwatch_logs_1.StartQueryCommand(sqr));
+        ratchet_common_1.Logger.debug('Got query id %j', resp);
+        let rval = null;
+        let delayMS = 100;
+        while (!rval || ['Running', 'Scheduled'].includes(rval.status)) {
+            rval = await this.cwLogs.send(new client_cloudwatch_logs_1.GetQueryResultsCommand({ queryId: resp.queryId }));
+            await ratchet_common_2.PromiseRatchet.wait(delayMS);
+            delayMS *= 2;
+            ratchet_common_1.Logger.info('Got : %j', rval);
+        }
+        return rval;
+    }
+    async abortInsightsQuery(queryId) {
+        let rval = null;
+        if (!!queryId) {
+            rval = await this.cwLogs.send(new client_cloudwatch_logs_1.StopQueryCommand({ queryId: queryId }));
+        }
+        return rval;
+    }
+}
+exports.CloudWatchLogsRatchet = CloudWatchLogsRatchet;
+CloudWatchLogsRatchet.MAX_DELETE_RETRIES = 5;

package/dist/cjs/cloudwatch/cloud-watch-metrics-ratchet.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchMetricsRatchet = void 0;
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const cloud_watch_metrics_unit_1 = require("../model/cloud-watch-metrics-unit");
+const luxon_1 = require("luxon");
+class CloudWatchMetricsRatchet {
+    constructor(cloudWatch = null) {
+        this.cw = cloudWatch ? cloudWatch : new client_cloudwatch_1.CloudWatchClient({ region: 'us-east-1', apiVersion: '2010-08-01' });
+    }
+    async writeSingleMetric(namespace, metric, dims, unit = cloud_watch_metrics_unit_1.CloudWatchMetricsUnit.None, value, timestampDate = new Date(), highResolution = false) {
+        const cwDims = [];
+        if (!!dims && dims.length > 0) {
+            dims.forEach((d) => {
+                cwDims.push({ Name: d.key, Value: d.value });
+            });
+        }
+        const storageResolution = highResolution ? 1 : 60;
+        const metricData = {
+            Namespace: namespace,
+            MetricData: [
+                {
+                    MetricName: metric,
+                    Dimensions: cwDims,
+                    Unit: String(unit),
+                    Value: value,
+                    Timestamp: timestampDate,
+                    StorageResolution: storageResolution,
+                },
+            ],
+        };
+        ratchet_common_1.Logger.silly('Writing metric to cw : %j', metricData);
+        const result = await this.cw.send(new client_cloudwatch_1.PutMetricDataCommand(metricData));
+        ratchet_common_1.Logger.silly('Result: %j', result);
+        return result;
+    }
+    async writeDynamoCountAsMinuteLevelMetric(req) {
+        ratchet_common_1.Logger.info('Publishing %s / %s metric for %s UTC', req.namespace, req.metric, req.minuteUTC);
+        if (!!req.scan && !!req.query) {
+            throw new Error('Must send query or scan, but not both');
+        }
+        if (!req.scan && !req.query) {
+            throw new Error('You must specify either a scan or a query');
+        }
+        const cnt = !!req.query
+            ? await req.dynamoRatchet.fullyExecuteQueryCount(req.query)
+            : await req.dynamoRatchet.fullyExecuteScanCount(req.scan);
+        ratchet_common_1.Logger.debug('%s / %s for %s are %j', req.namespace, req.metric, req.minuteUTC, cnt);
+        const parseDateString = req.minuteUTC.split(' ').join('T') + ':00Z';
+        const parseDate = luxon_1.DateTime.fromISO(parseDateString).toJSDate();
+        const metricRes = await this.writeSingleMetric(req.namespace, req.metric, req.dims, cloud_watch_metrics_unit_1.CloudWatchMetricsUnit.Count, cnt.count, parseDate, false);
+        ratchet_common_1.Logger.debug('Metrics response: %j', metricRes);
+        return cnt.count;
+    }
+}
+exports.CloudWatchMetricsRatchet = CloudWatchMetricsRatchet;

package/dist/cjs/daemon/daemon-like.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/daemon/daemon-process-create-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/daemon/daemon-process-state-public-token.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });