iobroker.utility-monitor 1.5.0 → 1.5.1

package/README.md

@@ -212,17 +212,17 @@ Balance:           +62,64 € → Nachzahlung
 
 ### 📈 **statistics** (Statistiken)
 
-| Datenpunkt       | Beschreibung                         |
-| ---------------- | ------------------------------------ |
-| `averageDaily`   | Durchschnittlicher Tagesverbrauch    |
-| `averageMonthly` | Durchschnittlicher Monatsverbrauch   |
-| `lastDay`        | Verbrauch **gesten** (Vortag)        |
-| `lastWeek`       | Verbrauch **letzte Woche**           |
-| `lastMonth`      | Verbrauch **letzter Monat**          |
-| `lastDayStart`   | Letzter Tages-Reset (00:00 Uhr)      |
-| `lastWeekStart`  | Letzter Wochen-Reset (Montag)        |
-| `lastMonthStart` | Letzter Monats-Reset (1. des Monats) |
-| `lastYearStart`  | Vertragsbeginn / Jahresstart         |
+| Datenpunkt       | Beschreibung                             |
+| ---------------- | ---------------------------------------- |
+| `averageDaily`   | Durchschnittlicher Tagesverbrauch        |
+| `averageMonthly` | Durchschnittlicher Monatsverbrauch       |
+| `lastDay`        | Verbrauch **gestern** (Vortag)           |
+| `lastWeek`       | Verbrauch **letzte Woche**               |
+| `lastMonth`      | Verbrauch **letzter Monat**              |
+| `lastDayStart`   | Letzter Tages-Reset (23:59 Uhr)          |
+| `lastWeekStart`  | Letzter Wochen-Reset (Sonntag 23:59)     |
+| `lastMonthStart` | Letzter Monats-Reset (letzter Tag 23:59) |
+| `lastYearStart`  | Vertragsbeginn / Jahresstart             |
 
 ---
 
@@ -308,7 +308,12 @@ Der Adapter setzt Zähler automatisch zurück:
 
 ## Changelog
 
-### 1.5.0 (2026-01-23)
+### 1.5.1 (2026-01-26)
+
+- **FIX:** 🕛 **Reset-Timing** - Automatische Resets werden nun um 23:59 Uhr ausgeführt (statt 00:00 Uhr)
+- **FIX:** Utopische Werte in Monthly/MonthlyVolume (DP Monthly)
+
+### 1.5.0 (2026-01-25)
 
 - **NEU:** 📥 **CSV Import** - Importiere historische Zählerstände einfach per Drag-and-Drop:
     - Neuer "Import"-Tab in der Konfiguration

package/io-package.json

@@ -15,58 +15,6 @@
                 "pl": "Nowość: funkcja importu CSV z obsługą przeciągnij i upuść. Nowość: tygodniowe punkty śledzenia. Naprawa: resety wykonywane teraz o 23:59. Refaktoryzacja: modułowa architektura backendu.",
                 "uk": "Нове: функція імпорту CSV з підтримкою перетягування. Нове: щотижневі точки відстеження. Виправлення: скидання тепер виконується о 23:59. Рефакторинг: модульна архітектура бекенда.",
                 "zh-cn": "新增：支持拖放的 CSV 导入功能。新增：每周跟踪点。修复：现在在 23:59 执行重置。重构：模块化后端架构。"
-            },
-            "1.4.7": {
-                "en": "Fix: Removed redundant initialization code causing state object warnings. Fix: Race conditions in multi-meter initialization. New: Support for German umlauts (ä,ö,ü,ß) in meter names.",
-                "de": "Fix: Redundanten Initialisierungscode entfernt, der State-Object-Warnungen verursachte. Fix: Race Conditions bei Multi-Meter-Initialisierung. Neu: Unterstützung für deutsche Umlaute (ä,ö,ü,ß) in Zählernamen.",
-                "ru": "Исправление: удален избыточный код инициализации, вызывавший предупреждения об объектах состояния. Исправление: состояния гонки при инициализации нескольких счетчиков. Новое: поддержка немецких умляутов (ä, ö, ü, ß) в названиях счетчиков.",
-                "pt": "Correção: código de inicialização redundante removido que causava avisos de objetos de estado. Correção: Condições de corrida na inicialização do multi-medidor. Novo: Suporte para tremas alemães (ä, ö, ü, ß) em nomes de medidores.",
-                "nl": "Fix: Overbodige initialisatiecode verwijderd die waarschuwingen voor staatsobjecten veroorzaakte. Fix: Race-omstandigheden bij initialisatie van meerdere meters. Nieuw: Ondersteuning voor Duitse umlauten (ä, ö, ü, ß) in meternamen.",
-                "fr": "Correction : suppression du code d'initialisation redondant provoquant des avertissements d'objet d'état. Correction : conditions de concurrence lors de l'initialisation de plusieurs compteurs. Nouveau : prise en charge des trémas allemands (ä, ö, ü, ß) dans les noms des compteurs.",
-                "it": "Correzione: rimosso il codice di inizializzazione ridondante che causava avvisi sugli oggetti di stato. Correzione: race condition nell'inizializzazione di più contatori. Nuovo: supporto per le dieresi tedesche (ä, ö, ü, ß) nei nomi dei contatori.",
-                "es": "Solución: se eliminó el código de inicialización redundante que causaba advertencias de objetos de estado. Solución: condiciones de carrera en la inicialización de múltiples medidores. Nuevo: soporte para diéresis alemanas (ä, ö, ü, ß) en nombres de medidores.",
-                "pl": "Naprawa: usunięto nadmiarowy kod inicjalizacji powodujący ostrzeżenia o obiektach stanu. Naprawa: wyścigi podczas inicjalizacji wielu liczników. Nowość: obsługa niemieckich umlautów (ä, ö, ü, ß) w nazwach liczników.",
-                "uk": "Виправлення: видалено надлишковий код ініціалізації, що викликав попередження про об'єкти стану. Виправлення: стан гонки при ініціалізації декількох лічильників. Нове: підтримка німецьких умляутів (ä, ö, ü, ß) у назвах лічильників.",
-                "zh-cn": "修复：删除了导致状态对象警告的冗余初始化代码。修复：多表初始化中的竞态条件。新增：支持仪表名称中的德语变音符号 (ä, ö, ü, ß)。"
-            },
-            "1.4.6": {
-                "en": "Breaking Change: Main meter now requires a name (default: 'main'). State paths changed from 'gas.*' to 'gas.METER_NAME.*'. All meters now use consistent naming structure.",
-                "de": "Breaking Change: Hauptzähler benötigt jetzt einen Namen (Standard: 'main'). State-Pfade geändert von 'gas.*' zu 'gas.METER_NAME.*'. Alle Zähler nutzen jetzt konsistente Namensstruktur.",
-                "ru": "Критическое изменение: для главного счетчика теперь требуется имя (по умолчанию — «main»). Пути состояний изменены с 'gas.*' на 'gas.METER_NAME.*'. Все счетчики теперь используют согласованную структуру именования.",
-                "pt": "Mudança estrutural: o medidor principal agora requer um nome (padrão: 'main'). Os caminhos de estado mudaram de 'gas.*' para 'gas.METER_NAME.*'. Todos os medidores agora usam uma estrutura de nomenclatura consistente.",
-                "nl": "Breaking Change: Hoofdmeter vereist nu een naam (standaard: 'main'). Staatspaden gewijzigd van 'gas.*' naar 'gas.METER_NAME.*'. Alle meters gebruiken nu een consistente naamstructuur.",
-                "fr": "Changement radical : le compteur principal nécessite désormais un nom (par défaut : 'main'). Les chemins d'état sont passés de 'gas.*' à 'gas.METER_NAME.*'. Tous los compteurs utilisent désormais une structure de dénomination cohérente.",
-                "it": "Cambiamento radicale: il contatore principale ora richiede un nome (predefinito: 'main'). I percorsi di stato sono cambiati da 'gas.*' a 'gas.METER_NAME.*'. Tutti i contatori ora utilizzano una struttura di denominazione coerente.",
-                "es": "Cambio importante: el medidor principal ahora requiere un nombre (predeterminado: 'main'). Las rutas de estado cambiaron de 'gas.*' na 'gas.METER_NAME.*'. Todos los medidores ahora utilizan una estructura de nombres consistente.",
-                "pl": "Przełomowa zmiana: licznik główny wymaga teraz nazwy (domyślnie „main”). Ścieżki stanów zmieniły się z „gas.*” na „gas.METER_NAME.*”. Wszystkie liczniki używają teraz spójnej struktury nazewnictwa.",
-                "uk": "Критична зміна: для головного лічильника тепер потрібна назва (за замовчуванням — «main»). Шляхи статусів змінено з 'gas.*' на 'gas.METER_NAME.*'. Тепер усі лічильники використовують єдину структуру назв.",
-                "zh-cn": "重大更改：主表现在需要一个名称（默认值：'main'）。状态路径从 'gas.*' 更改为 'gas.METER_NAME.*'。所有计量表现在都使用一致的命名结构。"
-            },
-            "1.4.5": {
-                "en": "Fix: Critical multi-meter cost calculation bugs (main meter sync, basicCharge/paidTotal accumulation, annualFee as fixed yearly value). Fix: Balance formula corrected. Fix: Removed duplicate initialization causing sync issues.",
-                "de": "Fix: Kritische Multi-Meter Kostenberechnungsfehler (Hauptzähler-Sync, basicCharge/paidTotal Akkumulation, Jahresgebühr als fester Jahreswert). Fix: Balance-Formel korrigiert. Fix: Doppelte Initialisierung entfernt.",
-                "ru": "Исправление: Критические ошибки расчета затрат multi-meter (синхронизация главного счетчика, накопление basicCharge/paidTotal, annualFee как фиксированное годовое значение). Исправление: Формула баланса исправлена. Исправление: Удалена дублирующая инициализация.",
-                "pt": "Correção: Bugs críticos de cálculo de custos multi-medidor (sincronização medidor principal, acumulação basicCharge/paidTotal, annualFee como valor anual fixo). Correção: Fórmula de saldo corrigida. Correção: Inicialização duplicada removida.",
-                "nl": "Fix: Kritieke multi-meter kostenberekeningsfouten (hoofdmeter sync, basicCharge/paidTotal accumulatie, annualFee als vaste jaarwaarde). Fix: Balans formule gecorrigeerd. Fix: Dubbele initialisatie verwijderd.",
-                "fr": "Correction: Bugs critiques calcul coûts multi-compteurs (sync compteur principal, accumulation basicCharge/paidTotal, annualFee comme valeur annuelle fixe). Correction: Formule de solde corrigée. Correction: Initialisation en double supprimée.",
-                "it": "Correzione: Bug critici calcolo costi multi-contatore (sync contatore principale, accumulazione basicCharge/paidTotal, annualFee come valore annuale fisso). Correzione: Formula bilancio corretta. Correzione: Inizializzazione duplicata rimossa.",
-                "es": "Corrección: Bugs críticos cálculo costos multi-medidor (sincronización medidor principal, acumulación basicCharge/paidTotal, annualFee como valor anual fijo). Corrección: Fórmula balance corregida. Corrección: Inicialización duplicada eliminada.",
-                "pl": "Naprawa: Krytyczne błędy obliczania kosztów multi-meter (synchronizacja głównego licznika, akumulacja basicCharge/paidTotal, annualFee jako stała wartość roczna). Naprawa: Formuła salda poprawiona. Naprawa: Usunięto podwójną inicjalizację.",
-                "uk": "Виправлення: Критичні помилки розрахунку витрат multi-meter (синхронізація головного лічильника, накопичення basicCharge/paidTotal, annualFee як фіксоване річне значення). Виправлення: Формула балансу виправлена. Виправлення: Видалено подвійну ініціалізацію.",
-                "zh-cn": "修复：关键多表成本计算错误（主表同步、basicCharge/paidTotal累积、annualFee作为固定年值）。修复：余额公式已更正。修复：删除重复初始化。"
-            },
-            "1.4.2": {
-                "en": "Fix: Critical multi-meter balance bug (hardcoded 12 months). Fix: TypeScript errors resolved. New: Enhanced input validation. New: Extended constants. New: Error handling wrapper.",
-                "de": "Fix: Kritischer Multi-Meter Balance-Bug (hardcodierte 12 Monate). Fix: TypeScript-Fehler behoben. Neu: Erweiterte Eingabevalidierung. Neu: Erweiterte Konstanten. Neu: Fehlerbehandlungs-Wrapper.",
-                "ru": "Исправление: Критическая ошибка баланса multi-meter (жестко заданные 12 месяцев). Исправление: Устранены ошибки TypeScript. Новое: Расширенная проверка входных данных. Новое: Расширенные константы. Новое: Обработка ошибок.",
-                "pt": "Correção: Bug crítico de saldo multi-medidor (12 meses fixos). Correção: Erros TypeScript resolvidos. Novo: Validação de entrada aprimorada. Novo: Constantes estendidas. Novo: Wrapper de tratamento de erros.",
-                "nl": "Fix: Kritieke multi-meter balans bug (hardcoded 12 maanden). Fix: TypeScript-fouten opgelost. Nieuw: Verbeterde invoervalidatie. Nieuw: Uitgebreide constanten. Nieuw: Foutafhandeling wrapper.",
-                "fr": "Correction: Bug critique de solde multi-compteurs (12 mois codés en dur). Correction: Erreurs TypeScript résolues. Nouveau: Validation d'entrée améliorée. Nouveau: Constantes étendues. Nouveau: Wrapper de gestion des erreurs.",
-                "it": "Correzione: Bug critico bilancio multi-contatore (12 mesi hardcoded). Correzione: Errori TypeScript risolti. Nuovo: Validazione input migliorata. Nuovo: Costanti estese. Nuovo: Wrapper gestione errori.",
-                "es": "Corrección: Bug crítico de saldo multi-medidor (12 meses fijos). Corrección: Errores TypeScript resueltos. Nuevo: Validación de entrada mejorada. Nuevo: Constantes extendidas. Nuevo: Wrapper manejo errores.",
-                "pl": "Naprawa: Krytyczny błąd salda multi-meter (zakodowane 12 miesięcy). Naprawa: Naprawione błędy TypeScript. Nowe: Ulepszona walidacja danych. Nowe: Rozszerzone stałe. Nowe: Wrapper obsługi błędów.",
-                "uk": "Виправлення: Критична помилка балансу multi-meter (жорстко задані 12 місяців). Виправлення: Усунено помилки TypeScript. Нове: Покращена перевірка даних. Нове: Розширені константи. Нове: Обробник помилок.",
-                "zh-cn": "修复：关键多表余额错误（硬编码12个月）。修复：解决TypeScript错误。新增：增强输入验证。新增：扩展常量。新增：错误处理包装器。"
             }
         },
         "titleLang": {

package/lib/billingManager.js

@@ -419,11 +419,96 @@ class BillingManager {
             return;
         }
 
+        // Archive data for this meter
         const year = startDate.getFullYear();
 
-        // Archive data for this meter
-        // TODO: Implement full history archiving for individual meters
-        // For now, just reset the meter
+        this.adapter.log.info(`Archiving data for ${basePath} year ${year}...`);
+
+        // Create history structure for this meter
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history`, {
+            type: 'channel',
+            common: { name: 'Historie' },
+            native: {},
+        });
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}`, {
+            type: 'channel',
+            common: { name: `Jahr ${year}` },
+            native: {},
+        });
+
+        // Get current values for archiving
+        const yearlyState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+        const totalYearlyState = await this.adapter.getStateAsync(`${basePath}.costs.totalYearly`);
+        const balanceState = await this.adapter.getStateAsync(`${basePath}.costs.balance`);
+
+        const yearly = yearlyState?.val || 0;
+        const totalYearly = totalYearlyState?.val || 0;
+        const balance = balanceState?.val || 0;
+
+        const consumptionUnit = type === 'gas' ? 'kWh' : type === 'water' ? 'm³' : 'kWh';
+
+        // Archive yearly consumption
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.yearly`, {
+            type: 'state',
+            common: {
+                name: `Jahresverbrauch ${year}`,
+                type: 'number',
+                role: 'value',
+                read: true,
+                write: false,
+                unit: consumptionUnit,
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.yearly`, yearly, true);
+
+        // Archive gas volume if applicable
+        if (type === 'gas') {
+            const yearlyVolume = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyVolume`))?.val || 0;
+            await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.yearlyVolume`, {
+                type: 'state',
+                common: {
+                    name: `Jahresverbrauch ${year} (m³)`,
+                    type: 'number',
+                    role: 'value',
+                    read: true,
+                    write: false,
+                    unit: 'm³',
+                },
+                native: {},
+            });
+            await this.adapter.setStateAsync(`${basePath}.history.${year}.yearlyVolume`, yearlyVolume, true);
+        }
+
+        // Archive total yearly costs
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.totalYearly`, {
+            type: 'state',
+            common: {
+                name: `Gesamtkosten ${year}`,
+                type: 'number',
+                role: 'value.money',
+                read: true,
+                write: false,
+                unit: '€',
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.totalYearly`, totalYearly, true);
+
+        // Archive balance
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.balance`, {
+            type: 'state',
+            common: {
+                name: `Bilanz ${year}`,
+                type: 'number',
+                role: 'value.money',
+                read: true,
+                write: false,
+                unit: '€',
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.balance`, balance, true);
 
         // Reset consumption and costs for this meter
         await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, 0, true);
@@ -539,24 +624,43 @@ class BillingManager {
             // This ensures History adapter sees clean day boundaries
             const isResetTime = nowDate.getHours() === 23 && nowDate.getMinutes() === 59;
 
-            // Helper: Check if timestamp is from today
+            // Helper: Create normalized timestamp for 23:59:00 of a given date
+            // This ensures consistent timestamps regardless of actual execution time
+            const getNormalizedResetTime = date => {
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 0, 0).getTime();
+            };
+
+            // Helper: Check if timestamp is from a valid 23:59 reset today
+            // A valid reset must be from today AND from the 23:xx hour
+            // This prevents adapter restarts (e.g. at 00:01:03) from blocking the real 23:59 reset
             const todayStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate()).getTime();
-            const isFromToday = timestamp => timestamp >= todayStart;
+            const isValidResetToday = timestamp => {
+                if (timestamp < todayStart) {
+                    return false; // Not from today
+                }
+                // Check if the timestamp was from the 23:xx hour (valid reset time)
+                const resetDate = new Date(timestamp);
+                return resetDate.getHours() === 23;
+            };
 
             // DAILY RESET: Trigger at 23:59 if today's reset hasn't happened yet
             const lastDayStart = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayStart`);
             if (lastDayStart?.val) {
                 const lastResetTime = lastDayStart.val;
-                const alreadyResetToday = isFromToday(lastResetTime);
+                const alreadyResetToday = isValidResetToday(lastResetTime);
 
                 // Reset at 23:59 if not yet reset today, OR catch up if we missed it (e.g. adapter was offline)
                 if (isResetTime && !alreadyResetToday) {
                     this.adapter.log.info(`Täglicher Reset für ${type} um 23:59`);
-                    await this.resetDailyCounters(type);
+                    await this.resetDailyCounters(type, getNormalizedResetTime(nowDate));
                 } else if (!alreadyResetToday && nowDate.getTime() > lastResetTime + 24 * 60 * 60 * 1000) {
                     // Catch-up: More than 24h since last reset (adapter was offline)
+                    // Calculate when the reset SHOULD have happened (yesterday 23:59)
+                    const yesterday = new Date(nowDate);
+                    yesterday.setDate(yesterday.getDate() - 1);
+                    const catchUpTime = getNormalizedResetTime(yesterday);
                     this.adapter.log.info(`Täglicher Reset für ${type} (Nachholung - Adapter war offline)`);
-                    await this.resetDailyCounters(type);
+                    await this.resetDailyCounters(type, catchUpTime);
                 }
             }
 
@@ -567,16 +671,24 @@ class BillingManager {
                 const isSunday = nowDate.getDay() === 0; // 0 = Sunday
 
                 // Check if we're in a new week (more than 6 days since last reset)
+                // BUT also check if the last reset was actually a valid 23:59 reset
+                // to prevent adapter restarts from blocking the real weekly reset
                 const daysSinceLastReset = (nowDate.getTime() - lastWeekTime) / (24 * 60 * 60 * 1000);
-                const needsWeeklyReset = daysSinceLastReset >= 6;
+                const lastWeekResetDate = new Date(lastWeekTime);
+                const wasValidWeeklyReset = lastWeekResetDate.getHours() === 23;
+                const needsWeeklyReset = daysSinceLastReset >= 6 || (isSunday && !wasValidWeeklyReset);
 
                 if (isSunday && isResetTime && needsWeeklyReset) {
                     this.adapter.log.info(`Wöchentlicher Reset für ${type} um 23:59`);
-                    await this.resetWeeklyCounters(type);
-                } else if (needsWeeklyReset && daysSinceLastReset > 7) {
-                    // Catch-up: More than 7 days since last reset
+                    await this.resetWeeklyCounters(type, getNormalizedResetTime(nowDate));
+                } else if (needsWeeklyReset && daysSinceLastReset >= 7) {
+                    // Catch-up: 7 or more days since last reset (was offline or missed window)
+                    // Calculate when the reset SHOULD have happened (last Sunday 23:59)
+                    const lastSunday = new Date(nowDate);
+                    lastSunday.setDate(lastSunday.getDate() - lastSunday.getDay()); // Go back to Sunday
+                    const catchUpTime = getNormalizedResetTime(lastSunday);
                     this.adapter.log.info(`Wöchentlicher Reset für ${type} (Nachholung)`);
-                    await this.resetWeeklyCounters(type);
+                    await this.resetWeeklyCounters(type, catchUpTime);
                 }
             }
 
@@ -589,14 +701,21 @@ class BillingManager {
                     const isLastDayOfMonth =
                         new Date(nowDate.getFullYear(), nowDate.getMonth() + 1, 0).getDate() === nowDate.getDate();
                     const monthChanged = nowDate.getMonth() !== lastMonthDate.getMonth();
+                    // Also check if the last reset was a valid 23:59 reset
+                    // to prevent adapter restarts from blocking the real monthly reset
+                    const wasValidMonthlyReset = lastMonthDate.getHours() === 23;
+                    const needsMonthlyReset = monthChanged || (isLastDayOfMonth && !wasValidMonthlyReset);
 
-                    if (isLastDayOfMonth && isResetTime && monthChanged) {
+                    if (isLastDayOfMonth && isResetTime && needsMonthlyReset) {
                         this.adapter.log.info(`Monatlicher Reset für ${type} um 23:59`);
-                        await this.resetMonthlyCounters(type);
+                        await this.resetMonthlyCounters(type, getNormalizedResetTime(nowDate));
                     } else if (monthChanged && nowDate.getDate() > 1) {
                         // Catch-up: We're past the 1st of a new month and haven't reset yet
+                        // Calculate when the reset SHOULD have happened (last day of previous month 23:59)
+                        const lastDayPrevMonth = new Date(nowDate.getFullYear(), nowDate.getMonth(), 0);
+                        const catchUpTime = getNormalizedResetTime(lastDayPrevMonth);
                         this.adapter.log.info(`Monatlicher Reset für ${type} (Nachholung)`);
-                        await this.resetMonthlyCounters(type);
+                        await this.resetMonthlyCounters(type, catchUpTime);
                     }
                 }
             }
@@ -638,17 +757,19 @@ class BillingManager {
                                 this.adapter.log.info(
                                     `Yearly reset for ${meterBasePath} um 23:59 (Vertragsjubiläum morgen: ${contractStartDate})`,
                                 );
-                                await this.resetYearlyCountersForMeter(type, meter);
+                                await this.resetYearlyCountersForMeter(type, meter, getNormalizedResetTime(nowDate));
 
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
                                 }
                             } else if (isPastAnniversary && needsReset) {
                                 // Catch-up: Anniversary has passed but we haven't reset yet
+                                // Use the day before anniversary 23:59 as the reset time
+                                const catchUpTime = getNormalizedResetTime(dayBeforeAnniversary);
                                 this.adapter.log.info(
                                     `Yearly reset for ${meterBasePath} (Nachholung - Jubiläum: ${contractStartDate})`,
                                 );
-                                await this.resetYearlyCountersForMeter(type, meter);
+                                await this.resetYearlyCountersForMeter(type, meter, catchUpTime);
 
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
@@ -663,15 +784,18 @@ class BillingManager {
                         if (isDecember31 && isResetTime && !needsReset) {
                             // Reset at 23:59 on Dec 31 for the upcoming year
                             this.adapter.log.info(`Yearly reset for ${meterBasePath} um 23:59 (Kalenderjahr)`);
-                            await this.resetYearlyCountersForMeter(type, meter);
+                            await this.resetYearlyCountersForMeter(type, meter, getNormalizedResetTime(nowDate));
 
                             if (meters.length > 1) {
                                 await this.adapter.multiMeterManager.updateTotalCosts(type);
                             }
                         } else if (needsReset) {
                             // Catch-up: We're in a new year but haven't reset yet
+                            // Use Dec 31 of last year 23:59 as reset time
+                            const dec31LastYear = new Date(nowDate.getFullYear() - 1, 11, 31);
+                            const catchUpTime = getNormalizedResetTime(dec31LastYear);
                             this.adapter.log.info(`Yearly reset for ${meterBasePath} (Nachholung - Kalenderjahr)`);
-                            await this.resetYearlyCountersForMeter(type, meter);
+                            await this.resetYearlyCountersForMeter(type, meter, catchUpTime);
 
                             if (meters.length > 1) {
                                 await this.adapter.multiMeterManager.updateTotalCosts(type);
@@ -687,8 +811,9 @@ class BillingManager {
      * Resets daily counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetDailyCounters(type) {
+    async resetDailyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting daily counters for ${type}`);
 
         // Get all meters for this type (main + additional meters)
@@ -736,8 +861,9 @@ class BillingManager {
 
             await this.adapter.setStateAsync(`${basePath}.costs.daily`, 0, true);
 
-            // Update lastDayStart timestamp
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastDayStart`, Date.now(), true);
+            // Update lastDayStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastDayStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
                 `${basePath}.statistics.averageDaily`,
@@ -756,8 +882,9 @@ class BillingManager {
      * Resets monthly counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetMonthlyCounters(type) {
+    async resetMonthlyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting monthly counters for ${type}`);
 
         // Get all meters for this type (main + additional meters)
@@ -803,8 +930,9 @@ class BillingManager {
 
             await this.adapter.setStateAsync(`${basePath}.costs.monthly`, 0, true);
 
-            // Update lastMonthStart timestamp
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonthStart`, Date.now(), true);
+            // Update lastMonthStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonthStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
                 `${basePath}.statistics.averageMonthly`,
@@ -867,8 +995,9 @@ class BillingManager {
      *
      * @param {string} type - Utility type
      * @param {object} meter - Meter object from multiMeterManager
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetYearlyCountersForMeter(type, meter) {
+    async resetYearlyCountersForMeter(type, meter, resetTimestamp) {
         const basePath = `${type}.${meter.name}`;
         const label = meter.displayName || meter.name;
 
@@ -884,16 +1013,18 @@ class BillingManager {
         await this.adapter.setStateAsync(`${basePath}.billing.notificationSent`, false, true);
         await this.adapter.setStateAsync(`${basePath}.billing.notificationChangeSent`, false, true);
 
-        // Update lastYearStart timestamp
-        await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, Date.now(), true);
+        // Update lastYearStart timestamp (use normalized timestamp if provided)
+        const timestamp = resetTimestamp || Date.now();
+        await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, timestamp, true);
     }
 
     /**
      * Resets weekly counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetWeeklyCounters(type) {
+    async resetWeeklyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting weekly counters for ${type}`);
 
         const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
@@ -926,7 +1057,9 @@ class BillingManager {
                 await this.adapter.setStateAsync(`${basePath}.costs.weeklyNT`, 0, true);
             }
 
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekStart`, Date.now(), true);
+            // Update lastWeekStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekStart`, timestamp, true);
         }
 
         if (meters.length > 1) {

package/lib/calculator.js

@@ -1,23 +1,34 @@
 const helpers = require('./utils/helpers');
 
 /**
- * Converts gas volume from m³ to kWh
- * Formula: kWh = m³ × Brennwert × Z-Zahl
+ * @file Calculator module for utility consumption and cost calculations.
+ * Contains functions for gas conversion, cost calculation, and tariff handling.
+ * @module calculator
+ */
+
+/**
+ * Converts gas volume from cubic meters (m³) to kilowatt-hours (kWh).
+ * The conversion uses the standard German gas billing formula:
+ * kWh = m³ × Brennwert (calorific value) × Z-Zahl (state number)
+ * Brennwert: Energy content per cubic meter, typically 9.5-11.5 kWh/m³.
+ * Z-Zahl: Correction factor for temperature and pressure differences.
  *
- * @param {number} m3 - Volume in cubic meters
- * @param {number} brennwert - Calorific value (typically ~11.5 kWh/m³)
- * @param {number} zZahl - Z-number/state number (typically ~0.95)
- * @returns {number} Energy in kWh
+ * @param {number} m3 - Gas volume in cubic meters (must be >= 0)
+ * @param {number} brennwert - Calorific value in kWh/m³ (must be > 0)
+ * @param {number} zZahl - State number (must be > 0 and <= 1)
+ * @returns {number} Energy consumption in kWh
+ * @throws {RangeError} If parameters are outside valid ranges
  */
 function convertGasM3ToKWh(m3, brennwert = 11.5, zZahl = 0.95) {
-    // Hier number zu string
     const cleanM3 = helpers.ensureNumber(m3);
     const cleanBrennwert = helpers.ensureNumber(brennwert);
     const cleanZZahl = helpers.ensureNumber(zZahl);
 
-    // Validierung der Logik (jetzt mit den konvertierten Zahlen)
+    // Validate parameters
     if (cleanM3 < 0 || cleanBrennwert <= 0 || cleanZZahl <= 0 || cleanZZahl > 1) {
-        throw new RangeError('Ungültige Parameterwerte für die Gas-Umrechnung');
+        throw new RangeError(
+            'Invalid parameters for gas conversion: m3 must be >= 0, brennwert must be > 0, zZahl must be > 0 and <= 1',
+        );
     }
 
     return cleanM3 * cleanBrennwert * cleanZZahl;
@@ -53,11 +64,14 @@ function calculateCost(consumption, price) {
 }
 
 /**
- * Checks if the current time is within the High Tariff (HT) period
+ * Checks if the current time falls within the High Tariff (HT) period.
+ * German electricity providers often offer dual-tariff rates:
+ * HT (Haupttarif): Higher rate during peak hours (typically 6:00-22:00)
+ * NT (Nebentarif): Lower rate during off-peak hours (typically 22:00-6:00)
  *
- * @param {object} config - Adapter configuration
- * @param {string} type - Utility type: 'gas' or 'strom'
- * @returns {boolean} True if current time is HT, false if NT
+ * @param {object} config - Adapter configuration object with HT/NT settings
+ * @param {string} type - Utility type identifier: 'gas', 'strom', 'wasser', or 'pv'
+ * @returns {boolean} True if current time is within HT period, false for NT
  */
 function isHTTime(config, type) {
     if (!config || !type) {

package/lib/multiMeterManager.js

@@ -307,9 +307,144 @@ class MultiMeterManager {
         // Initial cost calculation
         await this.updateCosts(type, meterName, config);
 
+        // Reconstruct weekly consumption from daily values if needed
+        await this.reconstructPeriodConsumption(type, meterName, basePath);
+
         this.adapter.log.debug(`Meter initialization completed for ${type}.${meterName}`);
     }
 
+    /**
+     * Reconstructs weekly and monthly consumption values after adapter restart
+     * This fixes data loss when adapter was offline and missed delta accumulation
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {string} basePath - State base path
+     */
+    async reconstructPeriodConsumption(type, meterName, basePath) {
+        const now = Date.now();
+
+        // Get period start timestamps
+        const lastWeekStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastWeekStart`);
+        const lastDayStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayStart`);
+
+        if (!lastWeekStartState?.val || !lastDayStartState?.val) {
+            this.adapter.log.debug(`[${basePath}] No period timestamps found, skipping reconstruction`);
+            return;
+        }
+
+        const lastWeekStart = lastWeekStartState.val;
+        const lastDayStart = lastDayStartState.val;
+
+        // Calculate days since week start
+        const daysSinceWeekStart = (now - lastWeekStart) / (24 * 60 * 60 * 1000);
+
+        // Only reconstruct if we're within a valid week (0-7 days)
+        if (daysSinceWeekStart < 0 || daysSinceWeekStart > 7) {
+            this.adapter.log.debug(
+                `[${basePath}] Week period out of range (${daysSinceWeekStart.toFixed(1)} days), skipping reconstruction`,
+            );
+            return;
+        }
+
+        // Get current consumption values
+        const weeklyState = await this.adapter.getStateAsync(`${basePath}.consumption.weekly`);
+        const dailyState = await this.adapter.getStateAsync(`${basePath}.consumption.daily`);
+        const lastDayState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDay`);
+
+        const currentWeekly = weeklyState?.val || 0;
+        const currentDaily = dailyState?.val || 0;
+        const lastDay = lastDayState?.val || 0;
+
+        // Calculate expected weekly based on lastDay values accumulated since lastWeekStart
+        // Simple approach: If daily counter was reset today and we have lastDay,
+        // weekly should be at least lastDay + currentDaily
+        const daysSinceDayReset = (now - lastDayStart) / (24 * 60 * 60 * 1000);
+
+        // If daily was reset (daysSinceDayReset < 1) and weekly seems too low
+        if (daysSinceDayReset < 1 && currentWeekly < lastDay + currentDaily) {
+            // Weekly might have missed the lastDay value
+            // This can happen if adapter restarted after daily reset
+            const reconstructedWeekly = calculator.roundToDecimals(currentWeekly + lastDay, 2);
+
+            if (reconstructedWeekly > currentWeekly) {
+                this.adapter.log.info(
+                    `[${basePath}] Reconstructing weekly: ${currentWeekly} -> ${reconstructedWeekly} (added lastDay: ${lastDay})`,
+                );
+                await this.adapter.setStateAsync(`${basePath}.consumption.weekly`, reconstructedWeekly, true);
+
+                // Also reconstruct gas volume if applicable
+                if (type === 'gas') {
+                    const weeklyVolumeState = await this.adapter.getStateAsync(`${basePath}.consumption.weeklyVolume`);
+                    const lastDayVolumeState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayVolume`);
+                    const currentWeeklyVolume = weeklyVolumeState?.val || 0;
+                    const lastDayVolume = lastDayVolumeState?.val || 0;
+
+                    if (lastDayVolume > 0) {
+                        const reconstructedWeeklyVolume = calculator.roundToDecimals(
+                            currentWeeklyVolume + lastDayVolume,
+                            4,
+                        );
+                        await this.adapter.setStateAsync(
+                            `${basePath}.consumption.weeklyVolume`,
+                            reconstructedWeeklyVolume,
+                            true,
+                        );
+                    }
+                }
+            }
+        }
+
+        // Similar logic for monthly reconstruction
+        const lastMonthStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastMonthStart`);
+        if (lastMonthStartState?.val) {
+            const lastMonthStart = lastMonthStartState.val;
+            const daysSinceMonthStart = (now - lastMonthStart) / (24 * 60 * 60 * 1000);
+
+            // Only if within valid month range (0-31 days)
+            if (daysSinceMonthStart >= 0 && daysSinceMonthStart <= 31) {
+                const monthlyState = await this.adapter.getStateAsync(`${basePath}.consumption.monthly`);
+                const currentMonthly = monthlyState?.val || 0;
+
+                // If daily was reset and monthly seems to be missing the lastDay
+                if (daysSinceDayReset < 1 && currentMonthly < lastDay + currentDaily) {
+                    const reconstructedMonthly = calculator.roundToDecimals(currentMonthly + lastDay, 2);
+
+                    if (reconstructedMonthly > currentMonthly) {
+                        this.adapter.log.info(
+                            `[${basePath}] Reconstructing monthly: ${currentMonthly} -> ${reconstructedMonthly} (added lastDay: ${lastDay})`,
+                        );
+                        await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, reconstructedMonthly, true);
+
+                        // Also reconstruct gas volume if applicable
+                        if (type === 'gas') {
+                            const monthlyVolumeState = await this.adapter.getStateAsync(
+                                `${basePath}.consumption.monthlyVolume`,
+                            );
+                            const lastDayVolumeState = await this.adapter.getStateAsync(
+                                `${basePath}.statistics.lastDayVolume`,
+                            );
+                            const currentMonthlyVolume = monthlyVolumeState?.val || 0;
+                            const lastDayVolume = lastDayVolumeState?.val || 0;
+
+                            if (lastDayVolume > 0) {
+                                const reconstructedMonthlyVolume = calculator.roundToDecimals(
+                                    currentMonthlyVolume + lastDayVolume,
+                                    4,
+                                );
+                                await this.adapter.setStateAsync(
+                                    `${basePath}.consumption.monthlyVolume`,
+                                    reconstructedMonthlyVolume,
+                                    true,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Handles sensor value updates
      *
@@ -463,6 +598,10 @@ class MultiMeterManager {
         if (recoveredValue > 0 && Math.abs(consumption - recoveredValue) < 100) {
             this.adapter.log.info(`[${basePath}] Recovered persistent baseline: ${recoveredValue}`);
             this.lastSensorValues[sensorDP] = recoveredValue;
+
+            // Validate period consumption values against spike threshold
+            // This catches cases where old consumption values are unrealistically high
+            await this._validatePeriodConsumption(type, basePath, now);
         } else {
             if (recoveredValue > 0) {
                 this.adapter.log.warn(
@@ -479,6 +618,9 @@ class MultiMeterManager {
                 await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumptionM3 || 0, true);
             }
 
+            // On baseline reset, validate and potentially reset period consumption values
+            await this._validatePeriodConsumption(type, basePath, now);
+
             if (config.initialReading > 0) {
                 await this.calculateAbsoluteYearly(type, meterName, config, consumption, consumptionM3 || 0, now);
                 await this.updateCosts(type, meterName, config);
@@ -489,6 +631,48 @@ class MultiMeterManager {
         await this.adapter.setStateAsync(`${basePath}.consumption.lastUpdate`, now, true);
     }
 
+    /**
+     * Validates period consumption values and resets them if they exceed the spike threshold.
+     * This prevents unrealistic values after adapter restart or database inconsistencies.
+     *
+     * @param {string} type - Utility type
+     * @param {string} basePath - State base path
+     * @param {number} now - Current timestamp
+     */
+    async _validatePeriodConsumption(type, basePath, now) {
+        const spikeThreshold = this.adapter.config.sensorSpikeThreshold || DEFAULT_SPIKE_THRESHOLD;
+
+        // Check and reset period consumption values that exceed the spike threshold
+        const periods = ['daily', 'weekly', 'monthly'];
+        for (const period of periods) {
+            const state = await this.adapter.getStateAsync(`${basePath}.consumption.${period}`);
+            const value = state?.val || 0;
+
+            // Get period start timestamp to calculate expected max consumption
+            const periodStartState = await this.adapter.getStateAsync(
+                `${basePath}.statistics.last${period.charAt(0).toUpperCase() + period.slice(1)}Start`,
+            );
+            const periodStart = periodStartState?.val || now;
+            const daysSincePeriodStart = (now - periodStart) / (24 * 60 * 60 * 1000);
+
+            // Calculate reasonable max: spike threshold per day * days in period
+            // Add buffer of 2x for safety
+            const maxReasonableConsumption = spikeThreshold * Math.max(1, daysSincePeriodStart) * 2;
+
+            if (value > maxReasonableConsumption) {
+                this.adapter.log.warn(
+                    `[${basePath}] Resetting ${period} consumption: ${value} exceeds reasonable max of ${maxReasonableConsumption.toFixed(0)} (${daysSincePeriodStart.toFixed(1)} days * ${spikeThreshold} threshold * 2)`,
+                );
+                await this.adapter.setStateAsync(`${basePath}.consumption.${period}`, 0, true);
+
+                // Also reset volume states for gas
+                if (type === 'gas') {
+                    await this.adapter.setStateAsync(`${basePath}.consumption.${period}Volume`, 0, true);
+                }
+            }
+        }
+    }
+
     /**
      * Handles meter reset or replacement condition
      *

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.5.1",
   "description": "Monitor gas, water, and electricity consumption with cost calculation",
   "author": {
     "name": "fischi87",