@scrypted/server 0.123.21 → 0.123.23

package/python/cluster_setup.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import os
+from asyncio.events import AbstractEventLoop
+from collections.abc import Mapping
+from typing import Any
+
+import rpc
+import rpc_reader
+from typing import TypedDict
+
+class ClusterObject(TypedDict):
+    id: str
+    address: str
+    port: int
+    proxyId: str
+    sourceKey: str
+    sha256: str
+
+def isClusterAddress(address: str):
+    return not address or address == os.environ.get("SCRYPTED_CLUSTER_ADDRESS", None)
+
+def getClusterPeerKey(address: str, port: int):
+    return f"{address}:{port}"
+class ClusterSetup():
+    def __init__(self, loop: AbstractEventLoop, peer: rpc.RpcPeer):
+        self.loop = loop
+        self.peer = peer
+        self.clusterId: str = None
+        self.clusterSecret: str = None
+        self.clusterAddress: str = None
+        self.clusterPort: int = None
+        self.SCRYPTED_CLUSTER_ADDRESS: str = None
+        self.clusterPeers: Mapping[str, asyncio.Future[rpc.RpcPeer]] = {}
+
+    async def resolveObject(self, id: str, sourceKey: str):
+        sourcePeer: rpc.RpcPeer = (
+            self.peer
+            if not sourceKey
+            else await rpc.maybe_await(self.clusterPeers.get(sourceKey, None))
+        )
+        if not sourcePeer:
+            return
+        return sourcePeer.localProxyMap.get(id, None)
+
+    async def connectClusterObject(self, o: ClusterObject):
+        sha256 = self.computeClusterObjectHash(o)
+        if sha256 != o["sha256"]:
+            raise Exception("secret incorrect")
+        return await self.resolveObject(o.get('proxyId', None), o.get('sourceKey', None))
+
+    def onProxySerialization(self, peer: rpc.RpcPeer, value: Any, sourceKey: str = None):
+        properties: dict = rpc.RpcPeer.prepareProxyProperties(value) or {}
+        clusterEntry = properties.get("__cluster", None)
+        proxyId: str
+        existing = peer.localProxied.get(value, None)
+        if existing:
+            proxyId = existing["id"]
+        else:
+            proxyId = (
+                clusterEntry and clusterEntry.get("proxyId", None)
+            ) or rpc.RpcPeer.generateId()
+
+        if clusterEntry:
+            if (
+                isClusterAddress(clusterEntry.get("address", None))
+                and self.clusterPort == clusterEntry["port"]
+                and sourceKey != clusterEntry.get("sourceKey", None)
+            ):
+                clusterEntry = None
+
+        if not clusterEntry:
+            clusterEntry: ClusterObject = {
+                "id": self.clusterId,
+                "proxyId": proxyId,
+                "address": self.SCRYPTED_CLUSTER_ADDRESS,
+                "port": self.clusterPort,
+                "sourceKey": sourceKey,
+            }
+            clusterEntry["sha256"] = self.computeClusterObjectHash(clusterEntry)
+            properties["__cluster"] = clusterEntry
+
+        return proxyId, properties
+
+    async def initializeCluster(self, options: dict):
+        if self.clusterPort:
+            return
+        self.clusterId = options["clusterId"]
+        self.clusterSecret = options["clusterSecret"]
+        self.SCRYPTED_CLUSTER_ADDRESS = os.environ.get("SCRYPTED_CLUSTER_ADDRESS", None)
+
+        async def handleClusterClient(
+            reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+        ):
+            clusterPeerAddress, clusterPeerPort = writer.get_extra_info("peername")
+            clusterPeerKey = getClusterPeerKey(clusterPeerAddress, clusterPeerPort)
+            rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
+            peer: rpc.RpcPeer
+            peer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
+                self.loop, rpcTransport
+            )
+            # set all params from self.peer
+            for key, value in self.peer.params.items():
+                peer.params[key] = value
+            peer.onProxySerialization = lambda value: self.onProxySerialization(
+                peer, value, clusterPeerKey
+            )
+            future: asyncio.Future[rpc.RpcPeer] = asyncio.Future()
+            future.set_result(peer)
+            self.clusterPeers[clusterPeerKey] = future
+            peer.params["connectRPCObject"] = lambda o: self.connectClusterObject(o)
+            try:
+                await peerReadLoop()
+            except:
+                pass
+            finally:
+                self.clusterPeers.pop(clusterPeerKey)
+                peer.kill("cluster client killed")
+                writer.close()
+
+        listenAddress = "0.0.0.0" if self.SCRYPTED_CLUSTER_ADDRESS else "127.0.0.1"
+        clusterRpcServer = await asyncio.start_server(
+            handleClusterClient, listenAddress, 0
+        )
+        self.clusterPort = clusterRpcServer.sockets[0].getsockname()[1]
+        self.peer.onProxySerialization = lambda value: self.onProxySerialization(self.peer, value, None)
+        del self.peer.params["initializeCluster"]
+
+    def computeClusterObjectHash(self, o: ClusterObject) -> str:
+        m = hashlib.sha256()
+        m.update(
+            bytes(
+                f"{o['id']}{o.get('address') or ''}{o['port']}{o.get('sourceKey', None) or ''}{o['proxyId']}{self.clusterSecret}",
+                "utf8",
+            )
+        )
+        return base64.b64encode(m.digest()).decode("utf-8")
+
+    def ensureClusterPeer(self, address: str, port: int):
+        if isClusterAddress(address):
+            address = "127.0.0.1"
+        clusterPeerKey = getClusterPeerKey(address, port)
+        clusterPeerPromise = self.clusterPeers.get(clusterPeerKey)
+        if clusterPeerPromise:
+            return clusterPeerPromise
+
+        async def connectClusterPeer():
+            try:
+                reader, writer = await asyncio.open_connection(address, port)
+                sourceAddress, sourcePort = writer.get_extra_info("sockname")
+                if (
+                    sourceAddress != self.SCRYPTED_CLUSTER_ADDRESS
+                    and sourceAddress != "127.0.0.1"
+                ):
+                    print("source address mismatch", sourceAddress)
+                rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
+                clusterPeer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
+                    self.loop, rpcTransport
+                )
+                # set all params from self.peer
+                for key, value in self.peer.params.items():
+                    clusterPeer.params[key] = value
+                clusterPeer.onProxySerialization = (
+                    lambda value: self.clusterSetup.onProxySerialization(
+                        clusterPeer, value, clusterPeerKey
+                    )
+                )
+            except:
+                self.clusterPeers.pop(clusterPeerKey)
+                raise
+
+            async def run_loop():
+                try:
+                    await peerReadLoop()
+                except:
+                    pass
+                finally:
+                    self.clusterPeers.pop(clusterPeerKey)
+
+            asyncio.run_coroutine_threadsafe(run_loop(), self.loop)
+            return clusterPeer
+
+        clusterPeerPromise = self.loop.create_task(connectClusterPeer())
+
+        self.clusterPeers[clusterPeerKey] = clusterPeerPromise
+        return clusterPeerPromise
+
+    async def connectRPCObject(self, value):
+        __cluster = getattr(value, "__cluster")
+        if type(__cluster) is not dict:
+            return value
+
+        clusterObject: ClusterObject = __cluster
+
+        if clusterObject.get("id", None) != self.clusterId:
+            return value
+
+        address = clusterObject.get("address", None)
+        port = clusterObject["port"]
+        proxyId = clusterObject["proxyId"]
+        if port == self.clusterPort:
+            return await self.connectRPCObject(clusterObject)
+
+        clusterPeerPromise = self.ensureClusterPeer(address, port)
+
+        try:
+            clusterPeer = await clusterPeerPromise
+            weakref = clusterPeer.remoteWeakProxies.get(proxyId, None)
+            existing = weakref() if weakref else None
+            if existing:
+                return existing
+
+            peerConnectRPCObject = clusterPeer.tags.get("connectRPCObject")
+            if not peerConnectRPCObject:
+                peerConnectRPCObject = await clusterPeer.getParam(
+                    "connectRPCObject"
+                )
+                clusterPeer.tags["connectRPCObject"] = peerConnectRPCObject
+            newValue = await peerConnectRPCObject(clusterObject)
+            if not newValue:
+                raise Exception("rpc object not found?")
+            return newValue
+        except Exception as e:
+            return value

package/python/plugin_remote.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 import gc
-import hashlib
 import inspect
 import multiprocessing
 import multiprocessing.connection
@@ -19,39 +17,27 @@ from asyncio.futures import Future
 from asyncio.streams import StreamReader, StreamWriter
 from collections.abc import Mapping
 from io import StringIO
-from typing import Any, Optional, Set, Tuple, TypedDict, Callable, Coroutine
+from typing import Any, Callable, Coroutine, Optional, Set, Tuple, TypedDict
 
 import plugin_volume as pv
 import rpc
 import rpc_reader
 import scrypted_python.scrypted_sdk.types
+from cluster_setup import ClusterSetup
 from plugin_pip import install_with_pip, need_requirements, remove_pip_dirs
 from scrypted_python.scrypted_sdk import PluginFork, ScryptedStatic
-from scrypted_python.scrypted_sdk.types import (
-    Device,
-    DeviceManifest,
-    EventDetails,
-    ScryptedInterface,
-    ScryptedInterfaceMethods,
-    ScryptedInterfaceProperty,
-    Storage,
-)
+from scrypted_python.scrypted_sdk.types import (Device, DeviceManifest,
+                                                EventDetails,
+                                                ScryptedInterface,
+                                                ScryptedInterfaceMethods,
+                                                ScryptedInterfaceProperty,
+                                                Storage)
 
 SCRYPTED_REQUIREMENTS = """
 ptpython
 wheel
 """.strip()
 
-
-class ClusterObject(TypedDict):
-    id: str
-    address: str
-    port: int
-    proxyId: str
-    sourceKey: str
-    sha256: str
-
-
 class SystemDeviceState(TypedDict):
     lastEventTime: int
     stateTime: int
@@ -553,214 +539,6 @@ class DeviceManager(scrypted_python.scrypted_sdk.types.DeviceManager):
     def getDeviceStorage(self, nativeId: str = None) -> Storage:
         return self.nativeIds.get(nativeId, None)
 
-
-def isClusterAddress(address: str):
-    return not address or address == os.environ.get("SCRYPTED_CLUSTER_ADDRESS", None)
-
-def getClusterPeerKey(address: str, port: int):
-    return f"{address}:{port}"
-
-class ClusterSetup():
-    def __init__(self, loop: AbstractEventLoop, peer: rpc.RpcPeer):
-        self.loop = loop
-        self.peer = peer
-        self.clusterId: str = None
-        self.clusterSecret: str = None
-        self.clusterAddress: str = None
-        self.clusterPort: int = None
-        self.SCRYPTED_CLUSTER_ADDRESS: str = None
-        self.clusterPeers: Mapping[str, asyncio.Future[rpc.RpcPeer]] = {}
-
-    async def resolveObject(self, id: str, sourceKey: str):
-        sourcePeer: rpc.RpcPeer = (
-            self.peer
-            if not sourceKey
-            else await rpc.maybe_await(self.clusterPeers.get(sourceKey, None))
-        )
-        if not sourcePeer:
-            return
-        return sourcePeer.localProxyMap.get(id, None)
-
-    async def connectClusterObject(self, o: ClusterObject):
-        sha256 = self.computeClusterObjectHash(o)
-        if sha256 != o["sha256"]:
-            raise Exception("secret incorrect")
-        return await self.resolveObject(o.get('proxyId', None), o.get('sourceKey', None))
-
-    def onProxySerialization(self, peer: rpc.RpcPeer, value: Any, sourceKey: str = None):
-        properties: dict = rpc.RpcPeer.prepareProxyProperties(value) or {}
-        clusterEntry = properties.get("__cluster", None)
-        proxyId: str
-        existing = peer.localProxied.get(value, None)
-        if existing:
-            proxyId = existing["id"]
-        else:
-            proxyId = (
-                clusterEntry and clusterEntry.get("proxyId", None)
-            ) or rpc.RpcPeer.generateId()
-
-        if clusterEntry:
-            if (
-                isClusterAddress(clusterEntry.get("address", None))
-                and self.clusterPort == clusterEntry["port"]
-                and sourceKey != clusterEntry.get("sourceKey", None)
-            ):
-                clusterEntry = None
-
-        if not clusterEntry:
-            clusterEntry: ClusterObject = {
-                "id": self.clusterId,
-                "proxyId": proxyId,
-                "address": self.SCRYPTED_CLUSTER_ADDRESS,
-                "port": self.clusterPort,
-                "sourceKey": sourceKey,
-            }
-            clusterEntry["sha256"] = self.computeClusterObjectHash(clusterEntry)
-            properties["__cluster"] = clusterEntry
-
-        return proxyId, properties
-
-    async def initializeCluster(self, options: dict):
-        if self.clusterPort:
-            return
-        self.clusterId = options["clusterId"]
-        self.clusterSecret = options["clusterSecret"]
-        self.SCRYPTED_CLUSTER_ADDRESS = os.environ.get("SCRYPTED_CLUSTER_ADDRESS", None)
-
-        async def handleClusterClient(
-            reader: asyncio.StreamReader, writer: asyncio.StreamWriter
-        ):
-            clusterPeerAddress, clusterPeerPort = writer.get_extra_info("peername")
-            clusterPeerKey = getClusterPeerKey(clusterPeerAddress, clusterPeerPort)
-            rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
-            peer: rpc.RpcPeer
-            peer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
-                self.loop, rpcTransport
-            )
-            # set all params from self.peer
-            for key, value in self.peer.params.items():
-                peer.params[key] = value
-            peer.onProxySerialization = lambda value: self.onProxySerialization(
-                peer, value, clusterPeerKey
-            )
-            future: asyncio.Future[rpc.RpcPeer] = asyncio.Future()
-            future.set_result(peer)
-            self.clusterPeers[clusterPeerKey] = future
-            peer.params["connectRPCObject"] = lambda o: self.connectClusterObject(o)
-            try:
-                await peerReadLoop()
-            except:
-                pass
-            finally:
-                self.clusterPeers.pop(clusterPeerKey)
-                peer.kill("cluster client killed")
-                writer.close()
-
-        listenAddress = "0.0.0.0" if self.SCRYPTED_CLUSTER_ADDRESS else "127.0.0.1"
-        clusterRpcServer = await asyncio.start_server(
-            handleClusterClient, listenAddress, 0
-        )
-        self.clusterPort = clusterRpcServer.sockets[0].getsockname()[1]
-        self.peer.onProxySerialization = lambda value: self.onProxySerialization(self.peer, value, None)
-        del self.peer.params["initializeCluster"]
-
-    def computeClusterObjectHash(self, o: ClusterObject) -> str:
-        m = hashlib.sha256()
-        m.update(
-            bytes(
-                f"{o['id']}{o.get('address') or ''}{o['port']}{o.get('sourceKey', None) or ''}{o['proxyId']}{self.clusterSecret}",
-                "utf8",
-            )
-        )
-        return base64.b64encode(m.digest()).decode("utf-8")
-
-    def ensureClusterPeer(self, address: str, port: int):
-        if isClusterAddress(address):
-            address = "127.0.0.1"
-        clusterPeerKey = getClusterPeerKey(address, port)
-        clusterPeerPromise = self.clusterPeers.get(clusterPeerKey)
-        if clusterPeerPromise:
-            return clusterPeerPromise
-
-        async def connectClusterPeer():
-            try:
-                reader, writer = await asyncio.open_connection(address, port)
-                sourceAddress, sourcePort = writer.get_extra_info("sockname")
-                if (
-                    sourceAddress != self.SCRYPTED_CLUSTER_ADDRESS
-                    and sourceAddress != "127.0.0.1"
-                ):
-                    print("source address mismatch", sourceAddress)
-                rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
-                clusterPeer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
-                    self.loop, rpcTransport
-                )
-                # set all params from self.peer
-                for key, value in self.peer.params.items():
-                    clusterPeer.params[key] = value
-                clusterPeer.onProxySerialization = (
-                    lambda value: self.clusterSetup.onProxySerialization(
-                        clusterPeer, value, clusterPeerKey
-                    )
-                )
-            except:
-                self.clusterPeers.pop(clusterPeerKey)
-                raise
-
-            async def run_loop():
-                try:
-                    await peerReadLoop()
-                except:
-                    pass
-                finally:
-                    self.clusterPeers.pop(clusterPeerKey)
-
-            asyncio.run_coroutine_threadsafe(run_loop(), self.loop)
-            return clusterPeer
-
-        clusterPeerPromise = self.loop.create_task(connectClusterPeer())
-
-        self.clusterPeers[clusterPeerKey] = clusterPeerPromise
-        return clusterPeerPromise
-
-    async def connectRPCObject(self, value):
-        __cluster = getattr(value, "__cluster")
-        if type(__cluster) is not dict:
-            return value
-
-        clusterObject: ClusterObject = __cluster
-
-        if clusterObject.get("id", None) != self.clusterId:
-            return value
-
-        address = clusterObject.get("address", None)
-        port = clusterObject["port"]
-        proxyId = clusterObject["proxyId"]
-        if port == self.clusterPort:
-            return await self.connectRPCObject(clusterObject)
-
-        clusterPeerPromise = self.ensureClusterPeer(address, port)
-
-        try:
-            clusterPeer = await clusterPeerPromise
-            weakref = clusterPeer.remoteWeakProxies.get(proxyId, None)
-            existing = weakref() if weakref else None
-            if existing:
-                return existing
-
-            peerConnectRPCObject = clusterPeer.tags.get("connectRPCObject")
-            if not peerConnectRPCObject:
-                peerConnectRPCObject = await clusterPeer.getParam(
-                    "connectRPCObject"
-                )
-                clusterPeer.tags["connectRPCObject"] = peerConnectRPCObject
-            newValue = await peerConnectRPCObject(clusterObject)
-            if not newValue:
-                raise Exception("rpc object not found?")
-            return newValue
-        except Exception as e:
-            return value
-
 class PluginRemote:
     def __init__(
         self, clusterSetup: ClusterSetup, api, pluginId: str, hostInfo, loop: AbstractEventLoop
@@ -769,8 +547,6 @@ class PluginRemote:
         self.nativeIds: Mapping[str, DeviceStorage] = {}
         self.mediaManager: MediaManager
         self.consoles: Mapping[str, Future[Tuple[StreamReader, StreamWriter]]] = {}
-        self.ptimeSum = 0
-        self.allMemoryStats = {}
         self.peer = clusterSetup.peer
         self.clusterSetup = clusterSetup
         self.api = api
@@ -977,8 +753,6 @@ class PluginRemote:
         self.deviceManager = DeviceManager(self.nativeIds, self.systemManager)
         self.mediaManager = MediaManager(await self.api.getMediaManager())
 
-        await self.start_stats_runner(zipAPI.updateStats)
-
         try:
             from scrypted_sdk import sdk_init2  # type: ignore
 
@@ -1023,7 +797,6 @@ class PluginRemote:
                             # traceback.print_exc()
                             print("fork read loop exited")
                         finally:
-                            self.allMemoryStats.pop(forkPeer)
                             parent_conn.close()
                             rpcTransport.executor.shutdown()
                             pluginFork.worker.kill()
@@ -1041,10 +814,7 @@ class PluginRemote:
                     forkOptions["debug"] = debug
 
                     class PluginZipAPI:
-                        async def updateStats(stats):
-                            self.ptimeSum += stats["cpu"]["user"]
-                            self.allMemoryStats[forkPeer] = stats
-                        
+
                         async def getZip(self):
                             return await zipAPI.getZip()
 
@@ -1140,39 +910,6 @@ class PluginRemote:
             return [self.replPort, os.getenv("SCRYPTED_CLUSTER_ADDRESS", None)]
         raise Exception(f"unknown service {name}")
 
-    async def start_stats_runner(self, update_stats):
-        def stats_runner():
-            ptime = round(time.process_time() * 1000000) + self.ptimeSum
-            try:
-                import psutil
-
-                process = psutil.Process(os.getpid())
-                heapTotal = process.memory_info().rss
-            except:
-                try:
-                    import resource
-
-                    heapTotal = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-                except:
-                    heapTotal = 0
-
-            for _, stats in self.allMemoryStats.items():
-                heapTotal += stats["memoryUsage"]["heapTotal"]
-
-            stats = {
-                "cpu": {
-                    "user": ptime,
-                    "system": 0,
-                },
-                "memoryUsage": {
-                    "heapTotal": heapTotal,
-                },
-            }
-            asyncio.run_coroutine_threadsafe(update_stats(stats), self.loop)
-            self.loop.call_later(10, stats_runner)
-
-        stats_runner()
-
 
 async def plugin_async_main(
     loop: AbstractEventLoop, rpcTransport: rpc_reader.RpcTransport

package/src/plugin/plugin-api.ts

@@ -1,6 +1,5 @@
 import type { Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, MediaManager, MediaObject, ScryptedDevice, ScryptedInterfaceDescriptor, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState } from '@scrypted/types';
 import type { AccessControls } from './acl';
-import type { PluginStats } from './plugin-remote-stats';
 
 export interface PluginLogger {
     log(level: string, message: string): Promise<void>;
@@ -170,8 +169,8 @@ export interface PluginRemoteLoadZipOptions {
 
 export class PluginZipAPI {
     constructor(
-        public getZip: () => Promise<Buffer>,
-        public updateStats: (stats: PluginStats) => Promise<void>) {
+        public getZip: () => Promise<Buffer>
+    ) {
     }
 }
 

package/src/plugin/plugin-host.ts

@@ -4,13 +4,13 @@ import * as io from 'engine.io';
 import fs from 'fs';
 import os from 'os';
 import WebSocket from 'ws';
+import { setupCluster } from '../cluster/cluster-setup';
 import { Plugin } from '../db-types';
 import { IOServer, IOServerSocket } from '../io';
 import { Logger } from '../logger';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { createRpcSerializer } from '../rpc-serializer';
 import { ScryptedRuntime } from '../runtime';
-import { setupCluster } from '../cluster/cluster-setup';
 import { sleep } from '../sleep';
 import { AccessControls } from './acl';
 import { MediaManagerHostImpl } from './media';
@@ -20,7 +20,6 @@ import { PluginDebug } from './plugin-debug';
 import { PluginHostAPI } from './plugin-host-api';
 import { LazyRemote } from './plugin-lazy-remote';
 import { setupPluginRemote } from './plugin-remote';
-import { PluginStats } from './plugin-remote-stats';
 import { WebSocketConnection } from './plugin-remote-websocket';
 import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
 import { createClusterForkWorker, needsClusterForkWorker } from './runtime/cluster-fork.worker';
@@ -60,8 +59,6 @@ export class PluginHost {
     api: PluginHostAPI;
     pluginName: string;
     packageJson: any;
-    lastStats: number;
-    stats: PluginStats;
     killed = false;
     consoleServer: Promise<ConsoleServer>;
     zipHash: string;
@@ -259,12 +256,7 @@ export class PluginHost {
                 // original implementation sent the zipBuffer, sending the zipFile name now.
                 // can switch back for non-local plugins.
                 const modulePromise = remote.loadZip(this.packageJson,
-                    // the plugin is expected to send process stats every 10 seconds.
-                    // this can be used as a check for liveness.
-                    new PluginZipAPI(async () => fs.promises.readFile(this.zipFile), async (stats: PluginStats) => {
-                        this.lastStats = Date.now();
-                        this.stats = stats;
-                    }),
+                    new PluginZipAPI(async () => fs.promises.readFile(this.zipFile)),
                     loadZipOptions);
                 // allow garbage collection of the zip buffer
                 const module = await modulePromise;
@@ -414,7 +406,7 @@ export class PluginHost {
             const now = Date.now();
             // plugin may take a while to install, so wait 10 minutes.
             // after that, require 1 minute checkins.
-            if (!this.lastStats || !lastPong) {
+            if (!lastPong) {
                 if (now - startupTime > 10 * 60 * 1000) {
                     const logger = await this.api.getLogger(undefined);
                     logger.log('e', 'plugin failed to start in a timely manner. restarting.');
@@ -422,11 +414,6 @@ export class PluginHost {
                 }
                 return;
             }
-            if (!pluginDebug && (this.lastStats + 60000 < now)) {
-                const logger = await this.api.getLogger(undefined);
-                logger.log('e', 'plugin is not reporting stats. restarting.');
-                this.api.requestRestart();
-            }
             if (!pluginDebug && (lastPong + 60000 < now)) {
                 const logger = await this.api.getLogger(undefined);
                 logger.log('e', 'plugin is not responding to ping. restarting.');