iobroker.utility-monitor 1.5.0 → 1.6.1

package/lib/utils/helpers.js

@@ -166,6 +166,59 @@ async function safeSetObjectNotExists(adapter, id, obj) {
     }
 }
 
+/**
+ * Safe execution wrapper for async operations with error handling.
+ * Catches errors and logs them without crashing the adapter.
+ *
+ * @param {object} adapter - Adapter instance
+ * @param {Function} fn - Async function to execute
+ * @param {string} context - Context description for error logging
+ * @param {any} fallback - Fallback value to return on error
+ * @returns {Promise<any>} Result of fn() or fallback on error
+ */
+async function safeExecute(adapter, fn, context, fallback = null) {
+    try {
+        return await fn();
+    } catch (error) {
+        if (adapter && adapter.log) {
+            adapter.log.error(`[${context}] ${error.message}`);
+        }
+        return fallback;
+    }
+}
+
+/**
+ * Debounce function to limit execution frequency
+ *
+ * @param {Function} fn - Function to debounce
+ * @param {number} delay - Delay in milliseconds
+ * @returns {Function} Debounced function
+ */
+function debounce(fn, delay) {
+    let timeoutId;
+    return function (...args) {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => fn.apply(this, args), delay);
+    };
+}
+
+/**
+ * Validates that a value is within a specified range
+ *
+ * @param {number} value - Value to validate
+ * @param {number} min - Minimum allowed value
+ * @param {number} max - Maximum allowed value
+ * @param {number} [defaultValue] - Default value if out of range
+ * @returns {number} Validated value or default
+ */
+function validateRange(value, min, max, defaultValue = min) {
+    const num = ensureNumber(value);
+    if (num < min || num > max) {
+        return defaultValue;
+    }
+    return num;
+}
+
 module.exports = {
     ensureNumber,
     roundToDecimals,
@@ -175,4 +228,7 @@ module.exports = {
     getMonthsDifference,
     normalizeMeterName,
     safeSetObjectNotExists,
+    safeExecute,
+    debounce,
+    validateRange,
 };

package/lib/utils/stateCache.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * StateCache - Provides caching for adapter state operations.
+ * Reduces database queries by caching state values during update cycles.
+ */
+class StateCache {
+    /**
+     * Creates a new StateCache instance
+     *
+     * @param {object} adapter - ioBroker adapter instance
+     * @param {object} [options] - Configuration options
+     * @param {number} [options.maxAge] - Maximum cache age in milliseconds (default: 60s)
+     * @param {number} [options.maxSize] - Maximum number of cached entries
+     */
+    constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.cache = new Map();
+        this.maxAge = options.maxAge || 60000;
+        this.maxSize = options.maxSize || 1000;
+        this.hits = 0;
+        this.misses = 0;
+    }
+
+    /**
+     * Gets a state value, using cache if available
+     *
+     * @param {string} id - State ID
+     * @returns {Promise<any>} State value or null
+     */
+    async get(id) {
+        const cached = this.cache.get(id);
+        const now = Date.now();
+
+        if (cached && now - cached.timestamp < this.maxAge) {
+            this.hits++;
+            return cached.value;
+        }
+
+        this.misses++;
+        const state = await this.adapter.getStateAsync(id);
+        const value = state?.val ?? null;
+
+        this._set(id, value);
+        return value;
+    }
+
+    /**
+     * Gets a state object (with val, ack, ts), using cache if available
+     *
+     * @param {string} id - State ID
+     * @returns {Promise<object|null>} State object or null
+     */
+    async getState(id) {
+        const cached = this.cache.get(`${id}_state`);
+        const now = Date.now();
+
+        if (cached && now - cached.timestamp < this.maxAge) {
+            this.hits++;
+            return cached.value;
+        }
+
+        this.misses++;
+        const state = await this.adapter.getStateAsync(id);
+
+        this._set(`${id}_state`, state);
+        if (state) {
+            this._set(id, state.val);
+        }
+        return state;
+    }
+
+    /**
+     * Sets a state value and updates cache
+     *
+     * @param {string} id - State ID
+     * @param {any} value - Value to set
+     * @param {boolean} ack - Acknowledge flag
+     * @returns {Promise<void>}
+     */
+    async set(id, value, ack = true) {
+        await this.adapter.setStateAsync(id, value, ack);
+        this._set(id, value);
+    }
+
+    /**
+     * Internal method to add to cache
+     *
+     * @param {string} id - State ID
+     * @param {any} value - Value to cache
+     */
+    _set(id, value) {
+        // Evict oldest entries if cache is full
+        if (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            this.cache.delete(oldestKey);
+        }
+
+        this.cache.set(id, {
+            value,
+            timestamp: Date.now(),
+        });
+    }
+
+    /**
+     * Clears the entire cache.
+     * Should be called at the end of each update cycle.
+     */
+    clear() {
+        this.cache.clear();
+    }
+
+    /**
+     * Invalidates a specific cache entry
+     *
+     * @param {string} id - State ID to invalidate
+     */
+    invalidate(id) {
+        this.cache.delete(id);
+        this.cache.delete(`${id}_state`);
+    }
+
+    /**
+     * Gets cache statistics
+     *
+     * @returns {object} Cache statistics
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? `${((this.hits / total) * 100).toFixed(1)}%` : '0%',
+            size: this.cache.size,
+        };
+    }
+
+    /**
+     * Resets cache statistics
+     */
+    resetStats() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+}
+
+module.exports = StateCache;

package/main.js

@@ -125,14 +125,10 @@ class UtilityMonitor extends utils.Adapter {
                 for (const meter of additionalMeters) {
                     if (meter && meter.name) {
                         if (!meter.contractStart) {
-                            this.log.warn(
-                                `${type.label} Zähler "${meter.name}": Kein Vertragsbeginn konfiguriert!`,
-                            );
+                            this.log.warn(`${type.label} Zähler "${meter.name}": Kein Vertragsbeginn konfiguriert!`);
                         }
                         if (!meter.sensorDP) {
-                            this.log.warn(
-                                `${type.label} Zähler "${meter.name}": Kein Sensor-Datenpunkt konfiguriert!`,
-                            );
+                            this.log.warn(`${type.label} Zähler "${meter.name}": Kein Sensor-Datenpunkt konfiguriert!`);
                         }
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.utility-monitor",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Monitor gas, water, and electricity consumption with cost calculation",
   "author": {
     "name": "fischi87",