edge-impulse-linux 1.11.0 → 1.12.0

package/build/cli-common/aws-iotcore-connector.js

@@ -1,12 +1,252 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AWSIoTCoreConnector = void 0;
+exports.AWSIoTCoreConnector = exports.MetricsCollector = exports.ModelInfo = exports.ThresholdFilter = void 0;
 const client_iot_data_plane_1 = require("@aws-sdk/client-iot-data-plane");
-const fs_1 = __importDefault(require("fs"));
-const PREFIX = '\x1b[34m[AWS_IOTCORE]\x1b[0m';
+const client_s3_1 = require("@aws-sdk/client-s3");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+const PREFIX = '\x1b[34m[AWS_IOTCORE_CONNECTOR]\x1b[0m';
+// maximum size of IoTCore Message
+const IOTCORE_MAX_PAYLOAD = 131072;
+// number of digits to the right of the decimal...
+const NUM_PLACES = 6;
+// Default metrics collector interval in MS
+const DEFAULT_METRICS_COLLECTION_TIME_MS = 60000; // 60 seconds
+// Default polling interval in MS
+const DEFAULT_POLLING_TIME_MS = 2500; // 2.5 seconds
+// Default Threshold value
+const DEFAULT_THRESHOLD_VALUE = 0.70; // 70% confidence minimum
+// Default Threshold Criteria
+const DEFAULT_THRESHOLD_CRITERIA = "ge"; // ">="
+// threshold filter class
+class ThresholdFilter {
+    constructor(opts) {
+        this._confidenceThreshold = opts.default_threshold;
+        this._confidenceThresholdCriteria = opts.threshold_criteria;
+        this._enabled = this.sanizeYesNo(process.env.EI_ENABLE_THRESHOLD_LIMIT);
+    }
+    // sanitize yes/no options
+    sanizeYesNo(value) {
+        if (value !== undefined && value !== "") {
+            if (value.toLowerCase() === "yes") {
+                return "yes";
+            }
+            if (value.toLowerCase() === "no") {
+                return "no";
+            }
+        }
+        return "no";
+    }
+    // get the confidence threshold
+    getConfidenceThreshold() {
+        return this._confidenceThreshold;
+    }
+    // confirm confidence threshold in bounds
+    confidenceThresholdValueInBounds(threshold) {
+        return (threshold > 0 && threshold <= 1.0);
+    }
+    // set the confidence threshold
+    setConfidenceThreshold(threshold) {
+        this._confidenceThreshold = threshold;
+        return this.getConfidenceThreshold();
+    }
+    // get the confidence criteria
+    getConfidenceCriteria() {
+        return this._confidenceThresholdCriteria;
+    }
+    // set the confidence criteria
+    setConfidenceCriteria(criteria) {
+        this._confidenceThresholdCriteria = criteria.toLowerCase();
+        return this.getConfidenceCriteria();
+    }
+    // enable the filter
+    enable() {
+        this._enabled = "yes";
+    }
+    // disable the filter
+    disable() {
+        this._enabled = "no";
+    }
+    // meets criteria?
+    meetsThresholdCriteria(threshold) {
+        let result = false;
+        if (this._confidenceThresholdCriteria === "gt") {
+            result = (threshold > this._confidenceThreshold);
+        }
+        if (this._confidenceThresholdCriteria === "ge") {
+            result = (threshold >= this._confidenceThreshold);
+        }
+        if (this._confidenceThresholdCriteria === "eq") {
+            result = (threshold === this._confidenceThreshold);
+        }
+        if (this._confidenceThresholdCriteria === "le") {
+            result = (threshold <= this._confidenceThreshold);
+        }
+        if (this._confidenceThresholdCriteria === "lt") {
+            result = (threshold < this._confidenceThreshold);
+        }
+        return result;
+    }
+    // valid criteria
+    validCriteria(criteria) {
+        return (criteria !== undefined && criteria !== "" &&
+            ((criteria.toLowerCase() === "gt") ||
+                (criteria.toLowerCase() === "ge") ||
+                (criteria.toLowerCase() === "eq") ||
+                (criteria.toLowerCase() === "le") ||
+                (criteria.toLowerCase() === "lt")));
+    }
+    // filter enabled
+    enabled() {
+        return (this._enabled === "yes");
+    }
+    // get threshold filter config info as JSON
+    json() {
+        return {
+            "enabled": this._enabled,
+            "confidence_threshold": this._confidenceThreshold,
+            "threshold_criteria": this._confidenceThresholdCriteria,
+        };
+    }
+}
+exports.ThresholdFilter = ThresholdFilter;
+;
+// model info class
+class ModelInfo {
+    constructor(opts) {
+        this._modelName = opts.model_name;
+        this._modelVersion = opts.model_version;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this._modelParams = opts.model_params;
+    }
+    // get model name
+    getModelName() {
+        return this._modelName;
+    }
+    // get model version
+    getModelVersion() {
+        return this._modelVersion;
+    }
+    // get model params
+    getModelParams() {
+        return this._modelParams;
+    }
+    // get model info as JSON
+    json() {
+        return {
+            "model_name": this._modelName,
+            "model_version": this._modelVersion,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            "model_params": this._modelParams,
+        };
+    }
+}
+exports.ModelInfo = ModelInfo;
+// metrics collector class
+class MetricsCollector {
+    constructor() {
+        this._count = 0;
+        this._sumConfidences = 0;
+        this._sumSquaredConfidences = 0;
+        this._meanConfidenceTrend = "flat";
+    }
+    // get the average confidence
+    getMeanConfidence() {
+        if (this._sumConfidences > 0 && this._count > 0) {
+            return (this._sumConfidences / this._count);
+        }
+        return 0.0;
+    }
+    // reset
+    reset() {
+        this._count = 0;
+        this._sumConfidences = 0;
+        this._sumSquaredConfidences = 0;
+        this._meanConfidenceTrend = "flat";
+        return { "metrics_reset": "OK" };
+    }
+    // update the conference average stat
+    updateConfidenceMean(confidence) {
+        // get the previous confidence
+        const prevMeanConfidence = this.getMeanConfidence();
+        // add the confidence
+        this._sumConfidences += confidence;
+        this._sumSquaredConfidences += (confidence * confidence);
+        ++this._count;
+        const newAdverageConfidence = this.getMeanConfidence();
+        // update the average confidence trend
+        const trend = newAdverageConfidence - prevMeanConfidence;
+        if (trend > 0) {
+            this._meanConfidenceTrend = "incr";
+        }
+        if (trend === 0) {
+            this._meanConfidenceTrend = "flat";
+        }
+        if (trend < 0) {
+            this._meanConfidenceTrend = "decr";
+        }
+    }
+    // update metrics
+    updateConfidenceMetrics(confidences) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        for (let i = 0; i < confidences.length; ++i) {
+            // update confidence average
+            // eslint-disable-next-line @stylistic/max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+            this.updateConfidenceMean(confidences[i]);
+        }
+    }
+    // get metrics as a JSON
+    json() {
+        return {
+            "mean_confidence": Number(this.getMeanConfidence().toFixed(NUM_PLACES)),
+            "standard_deviation": Number(this.getStandardDeviation().toFixed(NUM_PLACES)),
+            "confidence_trend": this._meanConfidenceTrend,
+            "details": {
+                "n": this._count,
+                "sum_confidences": Number(this._sumConfidences.toFixed(NUM_PLACES)),
+                "sum_confidences_squared": Number(this._sumSquaredConfidences.toFixed(NUM_PLACES)),
+            },
+            "ts": Date.now(),
+            "id": (0, uuid_1.v4)(),
+        };
+    }
+    // get the standard deviation
+    getStandardDeviation() {
+        if (this._sumSquaredConfidences > 0 && this._count > 0) {
+            const mean = this.getMeanConfidence();
+            return Math.sqrt((this._sumSquaredConfidences / this._count) - (mean * mean));
+        }
+        return 0.0;
+    }
+}
+exports.MetricsCollector = MetricsCollector;
+;
+// Primary AWS IoTCore Connector/Processor class
 class AWSIoTCoreConnector {
     constructor(opts) {
         this._notSilent = (!opts.silentArgv);
@@ -18,17 +258,155 @@ class AWSIoTCoreConnector {
         this._iot = undefined;
         this._connected = false;
         this._delayCountdown = 0;
-        this._iotcoreQoS = Number(process.env.EI_IOTCORE_QOS);
-        this._poolSleepTimeMS = Number(process.env.EI_IOTCORE_POLL_SLEEP_TIME_MS);
+        this._iotcoreQoS = this.sanitizeQoS(Number(process.env.EI_IOTCORE_QOS));
         this._opts = opts;
+        // sanitize the poll sleep time number
+        this._poolSleepTimeMS = Number(process.env.EI_IOTCORE_POLL_SLEEP_TIME_MS);
+        if (this._poolSleepTimeMS === undefined
+            || Number.isNaN(this._poolSleepTimeMS)
+            || this._poolSleepTimeMS <= 100) {
+            console.log(PREFIX + ": no polling sleep time specified. Defaulting to "
+                + DEFAULT_POLLING_TIME_MS + "ms...");
+            this._poolSleepTimeMS = DEFAULT_POLLING_TIME_MS;
+        }
         // We can slow down the publication to IoTCore to save IoTCore message cost$.
         // set "iotcore_backoff" in Greengrass component config to "n" > 0 to enable
-        // countdown backoff... "-1" to disable... (default: "10")
-        this._delayInferences = Number(process.env.EI_OUTPUT_BACKOFF_COUNT);
+        // countdown backoff... "-1" to disable... (default: "-1")
+        this._delayInferences = this.sanitizeDelayInferences(Number(process.env.EI_OUTPUT_BACKOFF_COUNT));
         // optional write to file configuration
-        this._enableWriteToFile = process.env.EI_ENABLE_WRITE_TO_FILE;
-        this._writeToFileDir = process.env.EI_FILE_WRITE_DIRECTORY;
+        this._enableWriteToFile = this.sanizeYesNo(process.env.EI_ENABLE_WRITE_TO_FILE);
+        this._writeToFileDir = this.sanitizeString(process.env.EI_FILE_WRITE_DIRECTORY);
+        // optional write to S3 configuration
+        this._enableWriteToS3 = this.sanizeYesNo(process.env.EI_ENABLE_WRITE_TO_S3);
+        this._s3Bucket = this.sanitizeString(process.env.EI_S3_BUCKET);
+        // initalize the threshold filter
+        this.initThresholdFilter();
+        // sanitize and inititalize the metrics collector
+        this._metricsDispatchSleepTimeMS = Number(process.env.EI_IOTCORE_METRICS_DISPATCH_TIME_MS);
+        if (this._metricsDispatchSleepTimeMS === undefined
+            || Number.isNaN(this._metricsDispatchSleepTimeMS)
+            || this._metricsDispatchSleepTimeMS <= 100) {
+            console.log(PREFIX + ": no metrics sleep time specified. Defaulting to "
+                + DEFAULT_METRICS_COLLECTION_TIME_MS + "ms...");
+            this._metricsDispatchSleepTimeMS = DEFAULT_METRICS_COLLECTION_TIME_MS;
+        }
+        this.initMetricsCollector();
+    }
+    // sanitize string
+    sanitizeString(value) {
+        if (value !== undefined && value !== "") {
+            return value;
+        }
+        return "__none__";
+    }
+    // sanitize delay inferences
+    sanitizeDelayInferences(value) {
+        if (value !== undefined && !Number.isNaN(value)) {
+            if (value <= 0) {
+                return -1;
+            }
+            return value;
+        }
+        return -1;
+    }
+    // sanitize QoS
+    sanitizeQoS(value) {
+        if (value !== undefined && !Number.isNaN(value) && value > 0 && value < 4) {
+            return value;
+        }
+        return 0;
+    }
+    // sanitize yes/no options
+    sanizeYesNo(value) {
+        if (value !== undefined && value !== "") {
+            if (value.toLowerCase() === "yes") {
+                return "yes";
+            }
+            if (value.toLowerCase() === "no") {
+                return "no";
+            }
+        }
+        return "no";
+    }
+    // sanitize threshold value
+    sanitizeThresholdValue(value) {
+        if (!Number.isNaN(value) && value > 0 && value <= 1.0) {
+            return value;
+        }
+        return DEFAULT_THRESHOLD_VALUE;
+    }
+    // sanitize threshold criteria
+    sanitizeThresholdCriteria(value) {
+        if (value !== undefined && value !== "" &&
+            (value === "gt" ||
+                value === "ge" ||
+                value === "eq" ||
+                value === "le" ||
+                value === "lt")) {
+            return value;
+        }
+        return DEFAULT_THRESHOLD_CRITERIA;
     }
+    // initialize the optional threshold confidence filter
+    initThresholdFilter() {
+        const opts = {
+            default_threshold: this.sanitizeThresholdValue(Number(process.env.EI_DEFAULT_THRESHOLD)),
+            threshold_criteria: this.sanitizeThresholdCriteria(process.env.EI_THRESHOLD_CRITERIA),
+        };
+        this._thresholdFilter = new ThresholdFilter(opts);
+    }
+    // initialize the model info object instance
+    initModelInfo(modelName, modelVersion, modelParams) {
+        const opts = {
+            model_name: modelName,
+            model_version: modelVersion,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            model_params: modelParams,
+        };
+        this._modelInfo = new ModelInfo(opts);
+    }
+    // initialize the metrics collector
+    initMetricsCollector() {
+        this._metricsCollector = new MetricsCollector();
+    }
+    // command identifiers
+    isRestartCommand(command) {
+        return (command === "restart");
+    }
+    isEnableThresholdFilterCommand(command) {
+        return (command === "enable_threshold_filter");
+    }
+    isDisableThresholdFilterCommand(command) {
+        return (command === "disable_threshold_filter");
+    }
+    isSetThresholdFilterCriteriaCommand(command) {
+        return (command === "set_threshold_filter_criteria");
+    }
+    isGetThresholdFilterCriteriaCommand(command) {
+        return (command === "get_threshold_filter_criteria");
+    }
+    isGetThresholdFilterConfidenceCommand(command) {
+        return (command === "get_threshold_filter_confidence");
+    }
+    isSetThresholdFilterConfidenceCommand(command) {
+        return (command === "set_threshold_filter_confidence");
+    }
+    isGetThresholdFilterConfigCommand(command) {
+        return (command === "get_threshold_filter_config");
+    }
+    isGetModelInfoCommand(command) {
+        return (command === "get_model_info");
+    }
+    isClearCatchCommand(command) {
+        return (command === "clear_cache");
+    }
+    isClearFileInCacheCommand(command) {
+        return (command === "clear_cache_file");
+    }
+    isResetMetricsCommand(command) {
+        return (command === "reset_metrics");
+    }
+    // IoTCore topic creation
     createTopics() {
         // Inference result topic
         this._inferenceOutputTopic = process.env.EI_INFERENCE_OUTPUT_TOPIC;
@@ -38,6 +416,22 @@ class AWSIoTCoreConnector {
         this._commandInputTopic = process.env.EI_COMMAND_INPUT_TOPIC;
         this._commandOutputTopic = process.env.EI_COMMAND_OUTPUT_TOPIC;
     }
+    // initialize the S3 processor
+    async s3Init() {
+        if (this._enableWriteToS3 === "yes") {
+            try {
+                this._s3Client = await new client_s3_1.S3Client(this._clientConfig);
+            }
+            catch (err) {
+                // unable to allocate
+                if (this._notSilent) {
+                    // not connected.. so connect to IoTCore
+                    console.log(PREFIX + " EI: ERROR - Unable to allocate S3Client with exception: " + err);
+                }
+            }
+        }
+    }
+    // connect to AWS IoTCore
     async connect() {
         if (this._iot === undefined) {
             if (this._notSilent) {
@@ -51,6 +445,10 @@ class AWSIoTCoreConnector {
                 this._iot = await new client_iot_data_plane_1.IoTDataPlaneClient(this._clientConfig);
                 // we are connected!
                 this._connected = true;
+                // manage S3 connection as well
+                await this.s3Init();
+                // send startup status/timestamp
+                await this.sendCommandResult({ "status": "started", "ts": Date.now(), "id": (0, uuid_1.v4)() });
             }
             catch (err) {
                 // unable to allocate
@@ -71,6 +469,7 @@ class AWSIoTCoreConnector {
     isConnected() {
         return this._connected;
     }
+    // is the inference result empty?
     isEmptyInference(payload, key) {
         if (payload && key in payload) {
             const value = payload[key];
@@ -84,9 +483,19 @@ class AWSIoTCoreConnector {
         }
         return true;
     }
-    async launchCommandReceiver() {
-        await this.listenForCommands(this._commandInputTopic, this._poolSleepTimeMS);
+    // launch all async tasks
+    async launchAsyncTasks() {
+        // launch the metrics dispatcher
+        console.log(PREFIX + " Launching metrics collector...");
+        // eslint-disable-next-line  @typescript-eslint/no-floating-promises
+        this.dispatchMetricsCollector(this._metricsOutputTopic, this._metricsDispatchSleepTimeMS);
+        // launch the command receiver
+        console.log(PREFIX + " Launching command receiver...");
+        // eslint-disable-next-line  @typescript-eslint/no-floating-promises
+        this.dispatchCommandListener(this._commandInputTopic, this._poolSleepTimeMS);
+        // XXX add more async tasks here...
     }
+    // clear retained queue in IoTCore
     async clearRetainedQueue(cmd_topic) {
         try {
             if (this._iot !== undefined) {
@@ -101,17 +510,43 @@ class AWSIoTCoreConnector {
             // ignore
         }
     }
-    isRestartCommand(command) {
-        return (command === "restart");
-    }
+    // restart the runner handler
     processRestartCommand() {
         // announce
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        console.log("EI: Restarting Service: " + this._opts.appName + "...");
+        console.log(PREFIX + " processRestartCommand(): Restarting Runner: " + this._opts.appName + "...");
         // send ourselves a single to gracefully shutdown...
         process.kill(process.pid, "SIGINT");
     }
-    async listenForCommands(commandInputTopic, longPollSleepMS) {
+    // metrics collector process
+    async dispatchMetricsCollector(metricsOutputTopic, sleepMS) {
+        while (this.isConnected() === true) {
+            try {
+                if (this._iot !== undefined && this._metricsCollector !== undefined) {
+                    // publish the current metrics
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    // eslint-disable-next-line  @typescript-eslint/no-floating-promises
+                    this.sendModelMetrics(this._metricsCollector.json());
+                }
+            }
+            catch (err) {
+                // ignore
+            }
+            // Sleep
+            await new Promise(resolve => setTimeout(resolve, sleepMS));
+        }
+        // WARN
+        console.log(PREFIX + " dispatchMetricsCollector() WARNING: process loop has halted...");
+    }
+    // reset metrics collection
+    resetMetrics() {
+        if (this._metricsCollector !== undefined) {
+            return this._metricsCollector.reset();
+        }
+        return { "metrics_reset": "OK" };
+    }
+    // command listener/processor process
+    async dispatchCommandListener(commandInputTopic, longPollSleepMS) {
         while (this.isConnected() === true) {
             // Long Poll via GetRetainedMessageCommand()...
             try {
@@ -125,25 +560,172 @@ class AWSIoTCoreConnector {
                         await this.clearRetainedQueue(commandInputTopic);
                         // ensure we have a received command...
                         if (rcvdCmd !== undefined) {
-                            // Process the received command
+                            // COMMAND: restart the runner
                             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                             if (this.isRestartCommand((rcvdCmd.cmd)) === true) {
+                                // send confirmation
+                                console.log(PREFIX + " dispatchCommandListener(): restarting runner process...");
+                                await this.sendCommandResult({ "restart": "OK" });
                                 // process the restart command...
                                 this.processRestartCommand();
                             }
-                            // more commands supported here over time...
-                            // default case
+                            // COMMAND: get the threshold filter confidence threshold value
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isGetThresholdFilterConfidenceCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // send the confidence threshold
+                                console.log(PREFIX + " dispatchCommandListener(): getting threshold filter confidence setting...");
+                                await this.sendCommandResult({ "confidence_threshold": this._thresholdFilter.getConfidenceThreshold() });
+                            }
+                            // COMMAND: set the threshold filter criteria value
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isSetThresholdFilterConfidenceCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                if (this._thresholdFilter.confidenceThresholdValueInBounds(rcvdCmd.value)) {
+                                    // set the confidence threshold
+                                    console.log(PREFIX +
+                                        " dispatchCommandListener(): Setting threshold filter confidence threshold to:  " +
+                                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                        rcvdCmd.value);
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                    this._thresholdFilter.setConfidenceThreshold(rcvdCmd.value);
+                                }
+                                else {
+                                    // confidence threshold must be 0 < x <= 1.0
+                                    console.log(PREFIX +
+                                        " dispatchCommandListener(): Unable to set threshold filter confidence threshold to:  " +
+                                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                        rcvdCmd.value + "... Threshold value must be 0 < x < 1.0. No changes made.");
+                                }
+                                // send the command result
+                                await this.sendCommandResult({ "confidence_threshold": this._thresholdFilter.getConfidenceThreshold() });
+                            }
+                            // COMMAND: get the threshold filter criteria value
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isGetThresholdFilterCriteriaCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // ssend the command result
+                                console.log(PREFIX + " dispatchCommandListener(): getting threshold criteria setting...");
+                                await this.sendCommandResult({ "criteria": this._thresholdFilter.getConfidenceCriteria() });
+                            }
+                            // COMMAND: set the threshold filter criteria value
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isSetThresholdFilterCriteriaCommand((rcvdCmd.cmd)) === true &&
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                this._thresholdFilter !== undefined && rcvdCmd.value !== undefined) {
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                if (this._thresholdFilter.validCriteria(rcvdCmd.value) === true) {
+                                    // set the confidence criteria
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                    console.log(PREFIX + " dispatchCommandListener(): Setting threshold criteria to:  " + rcvdCmd.value);
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                    this._thresholdFilter.setConfidenceCriteria(rcvdCmd.value);
+                                    // send the confidence criteria
+                                    await this.sendCommandResult({ "criteria": this._thresholdFilter.getConfidenceCriteria() });
+                                }
+                                else {
+                                    // log the error
+                                    console.log(PREFIX + " dispatchCommandListener(): Unable to set threshold criteria to:  " +
+                                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                        rcvdCmd.value + " (not recognized). Sending current critiera");
+                                    // send the confidence criteria
+                                    await this.sendCommandResult({ "criteria": this._thresholdFilter.getConfidenceCriteria() });
+                                }
+                            }
+                            // COMMAND: enable threshold filter
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isEnableThresholdFilterCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // display the new config
+                                console.log(PREFIX + " dispatchCommandListener(): enabling threshold filter...");
+                                this._thresholdFilter.enable();
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "threshold_filter_config": this._thresholdFilter.json() });
+                            }
+                            // COMMAND: disable threshold filter
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isDisableThresholdFilterCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // display the new config
+                                console.log(PREFIX + " dispatchCommandListener(): disabling threshold filter...");
+                                this._thresholdFilter.disable();
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "threshold_filter_config": this._thresholdFilter.json() });
+                            }
+                            // COMMAND: get the threshold filter config info
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isGetThresholdFilterConfigCommand((rcvdCmd.cmd)) === true &&
+                                this._thresholdFilter !== undefined) {
+                                // get model info
+                                console.log(PREFIX + " dispatchCommandListener(): getting current threshold filter config...");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "threshold_filter_config": this._thresholdFilter.json() });
+                            }
+                            // COMMAND: get the model info
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isGetModelInfoCommand((rcvdCmd.cmd)) === true &&
+                                this._modelInfo !== undefined) {
+                                // get model info
+                                console.log(PREFIX + " dispatchCommandListener(): getting current model information...");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "model_info": this._modelInfo.json() });
+                            }
+                            // COMMAND: clear the cache
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isClearCatchCommand((rcvdCmd.cmd)) === true &&
+                                this._modelInfo !== undefined) {
+                                // set the confidence threshold
+                                console.log(PREFIX + " dispatchCommandListener(): Clearing inference file/json cache...");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                const result = await this.cacheClear();
+                                // send the command result
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "clear_cache": result });
+                            }
+                            // COMMAND: clear specified file within the cache
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isClearFileInCacheCommand((rcvdCmd.cmd)) === true &&
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                this._modelInfo !== undefined && rcvdCmd.value !== undefined) {
+                                // set the confidence threshold
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                console.log(PREFIX +
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                                    " dispatchCommandListener(): Clearing inference file/json from cache. UUID: " + (rcvdCmd.value));
+                                // eslint-disable-next-line @stylistic/max-len
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+                                const result = await this.cacheClearInferenceAndImageByUUID((rcvdCmd.value));
+                                // send the command result
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult({ "clear_cache_file": result });
+                            }
+                            // COMMAND: reset the metrics counters
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            else if (this.isResetMetricsCommand((rcvdCmd.cmd)) === true &&
+                                this._metricsCollector !== undefined) {
+                                // set the confidence threshold
+                                console.log(PREFIX + " dispatchCommandListener(): Resetting metrics collection...");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                const result = await this.resetMetrics();
+                                // send the command result
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                await this.sendCommandResult(result);
+                            }
+                            // XXX COMMAND: more commands supported here over time...
+                            // COMMAND: default case - unrecognized command...ignore.
                             else {
                                 // command not supported/understood... so ignore
                                 if (this._notSilent === true) {
-                                    console.log("EI: listenForCommands() Command: " + JSON.stringify(rcvdCmd) + " not supported/understood. Ignoring...");
+                                    console.log(PREFIX + " dispatchCommandListener() Command: " + JSON.stringify(rcvdCmd) +
+                                        " not supported/understood. Ignoring...");
                                 }
                             }
                         }
                         else {
                             // empty/null command... just ignore
                             if (this._notSilent === true) {
-                                console.log("EI: listenForCommands() Command is empty/null. Ignoring...");
+                                console.log(PREFIX + " dispatchCommandListener() Command is empty/null. Ignoring...");
                             }
                         }
                     }
@@ -151,7 +733,7 @@ class AWSIoTCoreConnector {
                 else {
                     if (this._notSilent === true) {
                         // Connected but null command object
-                        console.log("listenForCommands(): WARNING Status states connected() but iotcore handle is NULL!");
+                        console.log(PREFIX + " dispatchCommandListener(): WARNING Status states connected() but iotcore handle is NULL!");
                     }
                 }
             }
@@ -162,7 +744,50 @@ class AWSIoTCoreConnector {
             await new Promise(resolve => setTimeout(resolve, longPollSleepMS));
         }
     }
-    // FUTURE: XXX
+    // send a command's results
+    async sendCommandResult(payload) {
+        if (this._iot !== undefined && this.isConnected() === true &&
+            this._commandOutputTopic !== undefined && this._commandOutputTopic.length > 0) {
+            // build the command result
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const result = { "result": payload };
+            // publish!
+            try {
+                // send the command result
+                await this._iot.send(new client_iot_data_plane_1.PublishCommand({
+                    topic: this._commandOutputTopic,
+                    qos: this._iotcoreQoS,
+                    retain: false,
+                    payload: Buffer.from(JSON.stringify(result))
+                }));
+            }
+            catch (err) {
+                if (this._notSilent === true) {
+                    // exception during send()...
+                    console.log(PREFIX + " sendCommandResult() ERROR: IoTDataPlaneClient.send() errored with exception: " + err);
+                }
+            }
+        }
+        else if (this._iot !== undefined && this.isConnected() === true) {
+            // no command result topic
+            if (this._notSilent) {
+                console.log(PREFIX + " sendCommandResult() ERROR: No command output topic specified in configuration... not sending result.");
+            }
+        }
+        else {
+            // not connected
+            if (this._notSilent) {
+                console.log(PREFIX + " sendCommandResult() ERROR: Not connected to IoTCore... not sending command result.");
+            }
+        }
+    }
+    // update confidence metrics
+    updateInferenceMetrics(confidences) {
+        if (this._metricsCollector !== undefined) {
+            this._metricsCollector.updateConfidenceMetrics(confidences);
+        }
+    }
+    // publish our model metrics
     async sendModelMetrics(payload) {
         if (this._iot !== undefined && this.isConnected() === true &&
             this._metricsOutputTopic !== undefined && this._metricsOutputTopic.length > 0) {
@@ -179,107 +804,373 @@ class AWSIoTCoreConnector {
             catch (err) {
                 if (this._notSilent === true) {
                     // exception during send()...
-                    console.log(PREFIX + " EI: sendModelMetrics() ERROR - IoTDataPlaneClient.send() errored with exception: " + err);
+                    console.log(PREFIX + " sendModelMetrics() ERROR: IoTDataPlaneClient.send() errored with exception: " + err);
                 }
             }
         }
         else if (this._iot !== undefined && this.isConnected() === true) {
             // no model metrics topic
             if (this._notSilent) {
-                console.log(PREFIX + " EI: ERROR - No model metrics topic specified in configuration... not sending inference.");
+                console.log(PREFIX + " sendModelMetrics() ERROR: No model metrics topic specified in configuration... not sending model metrics.");
             }
         }
         else {
             // not connected
             if (this._notSilent) {
-                console.log(PREFIX + " EI: ERROR - Not connected to IoTCore... not sending mdoel metrics.");
+                console.log(PREFIX + " sendModelMetrics() ERROR: Not connected to IoTCore... not sending model metrics.");
             }
         }
     }
+    // OPTION: cache inference image and inference json to local directory on edge device...
     async saveToFile(payload, imgAsJpg) {
         // construct the filename...
         const filenameBase = this._writeToFileDir + "/" + payload.id;
         const imageFilename = filenameBase + ".img";
         const infFilename = filenameBase + ".json";
+        let result = "OK";
         // INFERENCE: write out to disk...
-        fs_1.default.writeFile(infFilename, JSON.stringify(payload), function (writeErr) {
+        fs.writeFile(infFilename, JSON.stringify(payload), function (writeErr) {
             if (writeErr) {
-                console.log(writeErr);
+                console.log(PREFIX + " saveToFile(): Error in writing out file: " + infFilename + " Error: " + writeErr);
+                result = "FAILED";
             }
         });
         // IMAGE: write out to disk...
-        fs_1.default.writeFile(imageFilename, imgAsJpg, function (writeErr) {
+        fs.writeFile(imageFilename, imgAsJpg, function (writeErr) {
             if (writeErr) {
-                console.log(writeErr);
+                console.log(PREFIX + " saveToFile(): Error in writing out file: " + imageFilename + " Error: " + writeErr);
+                result = "FAILED";
             }
         });
+        return result;
+    }
+    // create the prefix used to store the inference/image into the S3 bucket
+    createS3Prefix() {
+        var _a, _b;
+        return ((_a = this._modelInfo) === null || _a === void 0 ? void 0 : _a.getModelName()) + "_" + ((_b = this._modelInfo) === null || _b === void 0 ? void 0 : _b.getModelVersion()) + "/";
+    }
+    // OPTION: cache inference image and inference json to S3 bucket
+    async saveToS3(payload, imgAsJpg) {
+        // construct the filenames...
+        const basePath = this.createS3Prefix();
+        const imageFilename = basePath + payload.id + ".img";
+        const infFilename = basePath + payload.id + ".json";
+        let result = "OK";
+        // Create the S3 bucket if it doesn't exist.
+        if (this._s3Client !== undefined) {
+            try {
+                await this._s3Client.send(new client_s3_1.CreateBucketCommand({ Bucket: this._s3Bucket }));
+            }
+            catch (err) {
+                if (this._notSilent) {
+                    // exception during send()...
+                    console.log(PREFIX + " saveToS3() ERROR: s3_client.send(CreateBucket) errored with exception: " + err);
+                    result = "FAILED";
+                }
+            }
+            // Upload the image file to S3.
+            try {
+                await this._s3Client.send(new client_s3_1.PutObjectCommand({
+                    Bucket: this._s3Bucket,
+                    Key: imageFilename,
+                    Body: imgAsJpg,
+                }));
+            }
+            catch (err) {
+                if (this._notSilent) {
+                    // exception during send()...
+                    console.log(PREFIX + " saveToS3() ERROR: s3_client.send(PutObjectImageFile) errored with exception: " + err);
+                    result = "FAILED";
+                }
+            }
+            // Upload the inference file to S3.
+            try {
+                await this._s3Client.send(new client_s3_1.PutObjectCommand({
+                    Bucket: this._s3Bucket,
+                    Key: infFilename,
+                    Body: JSON.stringify(payload),
+                }));
+            }
+            catch (err) {
+                if (this._notSilent) {
+                    // exception during send()...
+                    console.log(PREFIX + " saveToS3() ERROR: s3_client.send(PutObjectInferenceFile) errored with exception: " + err);
+                    result = "FAILED";
+                }
+            }
+        }
+        return result;
+    }
+    // process option to delete cache file (local) identified by its uuid
+    async localFileCacheClearFileByUUID(uuid) {
+        // construct the filenames...
+        const filenameBase = this._writeToFileDir + "/" + uuid;
+        const imageFilename = filenameBase + ".img";
+        const infFilename = filenameBase + ".json";
+        let result = "OK";
+        // delete the files
+        if (fs.existsSync(imageFilename)) {
+            try {
+                await fs.unlinkSync(imageFilename);
+            }
+            catch (err) {
+                console.log(PREFIX + " localFileCacheClearFileByUUID(): unable to remove file: " + imageFilename + " Exception: " + err);
+                result = "FAILED";
+            }
+        }
+        else {
+            // file does not exist
+            console.log(PREFIX + "localFileCacheClearFileByUUID(): unable to remove file: " + imageFilename + " does not exist");
+            result = "FAILED";
+        }
+        if (fs.existsSync(infFilename)) {
+            try {
+                await fs.unlinkSync(infFilename);
+            }
+            catch (err) {
+                console.log(PREFIX + " localFileCacheClearFileByUUID(): unable to remove file: " + infFilename + " Exception: " + err);
+                result = "FAILED";
+            }
+        }
+        else {
+            // file does not exist
+            console.log(PREFIX + "localFileCacheClearFileByUUID(): unable to remove file: " + infFilename + " does not exist");
+            result = "FAILED";
+        }
+        return result;
+    }
+    // process option to delete cache file (s3) identified by its uuid
+    async s3CacheClearByUUID(uuid) {
+        var _a, _b;
+        let result = "OK";
+        let found = false;
+        const basePath = ((_a = this._modelInfo) === null || _a === void 0 ? void 0 : _a.getModelName()) + "_" + ((_b = this._modelInfo) === null || _b === void 0 ? void 0 : _b.getModelVersion()) + "/";
+        if (this._s3Client !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const bucketParams = { Bucket: this._s3Bucket, Prefix: basePath };
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const { Contents } = (await this._s3Client.send(new client_s3_1.ListObjectsV2Command(bucketParams)));
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                for (let index = 0; index < Contents.length; index++) {
+                    // eslint-disable-next-line @stylistic/max-len
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    if (Contents[index].Key.includes(uuid) === true) {
+                        // found the file... delete it.
+                        found = true;
+                        // eslint-disable-next-line @stylistic/max-len
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                        const delCommand = { Bucket: this._s3Bucket, Key: Contents[index].Key };
+                        console.log(PREFIX + " s3CacheClearByUUID(): Deleting: " + JSON.stringify(delCommand));
+                        await this._s3Client.send(new client_s3_1.DeleteObjectCommand(delCommand));
+                    }
+                }
+            }
+            catch (err) {
+                console.log(PREFIX + " s3CacheClearByUUID(): caught exception while clearing file in S3 cache: " +
+                    err + " Bucket: " + this._s3Bucket + " Base Path: " + basePath + " UUID: " + uuid);
+                result = "FAILED";
+            }
+            // make sure we found something
+            if (!found) {
+                console.log(PREFIX + " s3CacheClearByUUID(): Unable to delete file with UUID: " + uuid + " No matching files found in: " + this._s3Bucket + "/" + basePath);
+                result = "FAILED";
+            }
+        }
+        return result;
+    }
+    // clear the local directory/file cache
+    async localFileCacheClear() {
+        let result = "OK";
+        try {
+            const files = await fs.readdirSync(this._writeToFileDir);
+            for (const file of files) {
+                const filePath = path.join(this._writeToFileDir, file);
+                if (fs.existsSync(filePath)) {
+                    try {
+                        await fs.unlinkSync(filePath);
+                    }
+                    catch (err) {
+                        console.log(PREFIX + " localFileCacheClear(): unable to remove file: " + filePath + " Exception: " + err);
+                        result = "FAILED";
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.log(PREFIX + " localFileCacheClear(): exception caught while clearing local file cache: " + err + " Directory: " + this._writeToFileDir);
+            result = "FAILED";
+        }
+        return result;
+    }
+    // clear the S3 cache
+    async s3CacheClear() {
+        var _a, _b;
+        // construct the filenames...
+        const basePath = ((_a = this._modelInfo) === null || _a === void 0 ? void 0 : _a.getModelName()) + "_" + ((_b = this._modelInfo) === null || _b === void 0 ? void 0 : _b.getModelVersion()) + "/";
+        // Create the S3 bucket if it doesn't exist.
+        if (this._s3Client !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const bucketParams = { Bucket: this._s3Bucket, Prefix: basePath };
+            try {
+                const listCommand = new client_s3_1.ListObjectsV2Command(bucketParams);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const { Contents } = (await this._s3Client.send(listCommand));
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                for (let index = 0; index < Contents.length; index++) {
+                    // eslint-disable-next-line @stylistic/max-len
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                    const delCommand = { Bucket: this._s3Bucket, Key: Contents[index].Key };
+                    await this._s3Client.send(new client_s3_1.DeleteObjectCommand(delCommand));
+                }
+            }
+            catch (err) {
+                console.log(PREFIX + " s3CacheClear(): caught exception while clearing S3 cache: " +
+                    err + " Bucket: " + this._s3Bucket + " Base Path: " + basePath);
+                return "FAILED";
+            }
+        }
+        return "OK";
+    }
+    // process option to cache inference image and inference json...
+    async cacheInferenceImageAndJSON(payload, imgAsJpg) {
+        let result = { "local": "OK", "s3": "OK", "uuid": payload.id };
+        // cache to local directory/file (optional)
+        if (this._enableWriteToFile !== undefined && this._enableWriteToFile === "yes" && imgAsJpg !== undefined) {
+            result.local = await this.saveToFile(payload, imgAsJpg);
+        }
+        // cache to S3 (optional)
+        if (this._enableWriteToS3 !== undefined && this._enableWriteToS3 === "yes" && imgAsJpg !== undefined) {
+            result.s3 = await this.saveToS3(payload, imgAsJpg);
+        }
+        return result;
+    }
+    // process option to delete inference image + json from cache via its uuid...
+    async cacheClearInferenceAndImageByUUID(uuid) {
+        let result = { "local": "OK", "s3": "OK", "uuid": uuid };
+        // clear local directory/file cache
+        if (this._enableWriteToFile !== undefined && this._enableWriteToFile === "yes") {
+            console.log(PREFIX + " cacheClearInferenceAndImageByUUID(): Clearing file(s) locally cached prefixed by UUID: " + uuid);
+            result.local = await this.localFileCacheClearFileByUUID(uuid);
+        }
+        // clear the S3 cache
+        if (this._enableWriteToS3 !== undefined && this._enableWriteToS3 === "yes") {
+            console.log(PREFIX + " cacheClearInferenceAndImageByUUID(): Clearing file(s) in S3 prefixed by UUID: " + uuid);
+            result.s3 = await this.s3CacheClearByUUID(uuid);
+        }
+        return result;
+    }
+    // process command to clear the inference image and inference json cache...
+    async cacheClear() {
+        let result = { "local": "OK", "s3": "OK" };
+        // clear local directory/file cache
+        if (this._enableWriteToFile !== undefined && this._enableWriteToFile === "yes") {
+            console.log(PREFIX + " cacheClear(): Clearing local file cache...");
+            result.local = await this.localFileCacheClear();
+        }
+        // clear the S3 cache
+        if (this._enableWriteToS3 !== undefined && this._enableWriteToS3 === "yes") {
+            console.log(PREFIX + " cacheClear(): Clearing S3 cache...");
+            result.s3 = await this.s3CacheClear();
+        }
+        return result;
     }
-    async sendInference(payload, key, imgAsJpg) {
+    // send inference to IoTCore (optionally add Base64 encoded inference image if not too big...)
+    async sendInference(meanConfidence, payload, key, imgAsJpg) {
         if (this._iot !== undefined && this.isConnected() === true &&
             this._inferenceOutputTopic !== undefined && this._inferenceOutputTopic.length > 0) {
             if (this.isEmptyInference(payload, key)) {
                 // empty inference ... so save money and don't publish
             }
             else {
+                // add the s3 bucket info if enabled
+                payload.s3_bucket = "unset";
+                payload.s3_prefix = "unset";
+                if (this._enableWriteToS3 !== undefined &&
+                    this._enableWriteToS3 === "yes" && this._s3Bucket !== undefined) {
+                    payload.s3_bucket = this._s3Bucket;
+                    payload.s3_prefix = this.createS3Prefix();
+                }
+                // set the payload
+                const data = Buffer.from(JSON.stringify(payload));
+                // default publish check
+                let doPublish = true;
+                // check if we are using confidence threshold to control publication
+                if (this._thresholdFilter !== undefined && this._thresholdFilter.enabled() === true) {
+                    doPublish = (this._thresholdFilter.meetsThresholdCriteria(meanConfidence));
+                }
+                // Check if the data length exceeds the max payload allowed by IoTCore...
+                if (data.length >= IOTCORE_MAX_PAYLOAD) {
+                    console.log(PREFIX + " sendInference() WARNING: IoTCore message length "
+                        + data.length + " bytes is larger than the maximum allowed payload size of "
+                        + IOTCORE_MAX_PAYLOAD + " bytes!  Message may not be published.");
+                }
+                // process the inference send...
                 if (this._delayInferences > 0) {
                     ++this._delayCountdown;
                     if (this._delayCountdown >= this._delayInferences) {
                         // reset:
                         this._delayCountdown = 0;
+                        // publish if directed to...
+                        if (doPublish === true) {
+                            // publish!
+                            try {
+                                // send the publication
+                                await this._iot.send(new client_iot_data_plane_1.PublishCommand({
+                                    topic: this._inferenceOutputTopic,
+                                    qos: this._iotcoreQoS,
+                                    payload: data
+                                }));
+                                // cache the inference image as configured
+                                if (imgAsJpg !== undefined) {
+                                    await this.cacheInferenceImageAndJSON(payload, imgAsJpg);
+                                }
+                            }
+                            catch (err) {
+                                if (this._notSilent) {
+                                    // exception during send()...
+                                    console.log(PREFIX + " sendInference() ERROR: IoTDataPlaneClient.send() exception: " + err);
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    // publish if directed to...
+                    if (doPublish === true) {
                         // publish!
                         try {
                             // send the publication
                             await this._iot.send(new client_iot_data_plane_1.PublishCommand({
                                 topic: this._inferenceOutputTopic,
                                 qos: this._iotcoreQoS,
-                                payload: Buffer.from(JSON.stringify(payload))
+                                payload: data
                             }));
-                            // write to file (optional)
-                            if (this._enableWriteToFile !== undefined && this._enableWriteToFile === "yes" && imgAsJpg !== undefined) {
-                                await this.saveToFile(payload, imgAsJpg);
+                            // publish the inference image as configured
+                            if (imgAsJpg !== undefined) {
+                                await this.cacheInferenceImageAndJSON(payload, imgAsJpg);
                             }
                         }
                         catch (err) {
                             if (this._notSilent) {
                                 // exception during send()...
-                                console.log(PREFIX + " EI: sendInference() ERROR - IoTDataPlaneClient.send() errored with exception: " + err);
+                                console.log(PREFIX + " ERROR: IoTDataPlaneClient.send() exception: " + err);
                             }
                         }
                     }
                 }
-                else {
-                    // publish!
-                    try {
-                        // send the publication
-                        await this._iot.send(new client_iot_data_plane_1.PublishCommand({
-                            topic: this._inferenceOutputTopic,
-                            qos: this._iotcoreQoS,
-                            payload: Buffer.from(JSON.stringify(payload))
-                        }));
-                        // write to file (optional)
-                        if (this._enableWriteToFile !== undefined && this._enableWriteToFile === "yes" && imgAsJpg !== undefined) {
-                            await this.saveToFile(payload, imgAsJpg);
-                        }
-                    }
-                    catch (err) {
-                        if (this._notSilent) {
-                            // exception during send()...
-                            console.log(PREFIX + " EI: ERROR - IoTDataPlaneClient.send() errored with exception: " + err);
-                        }
-                    }
-                }
             }
         }
         else if (this._iot !== undefined && this.isConnected() === true) {
             // no publication topic
             if (this._notSilent) {
-                console.log(PREFIX + " EI: ERROR - No model inference publication topic specified in configuration... not sending inference results.");
+                console.log(PREFIX + " ERROR: No model inference publication topic specified in configuration... not sending inference results.");
             }
         }
         else {
             // not connected
             if (this._notSilent) {
-                console.log(PREFIX + " EI: ERROR - Not connected to IoTCore... not sending inference.");
+                console.log(PREFIX + " ERROR: Not connected to IoTCore... not sending inference.");
             }
         }
     }