@nxtedition/lib 28.0.11 → 28.0.13

package/app.js

@@ -30,7 +30,6 @@ import { makeCouch } from './couch.js'
 import { makeTemplateCompiler } from '@nxtedition/template'
 import { makeDeepstream } from './deepstream.js'
 import * as rxjs from 'rxjs'
-import rx from 'rxjs/operators'
 import hashString from './hash.js'
 import { makeTrace } from './trace.js'
 import { compose, createServer } from './http.js'
@@ -615,40 +614,40 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
     compiler = makeTemplateCompiler({ ds, logger, ...appConfig.compiler })
   }
 
-  const monitorProviders = {}
+  const monitorProviders = {
+    stats$: new rxjs.BehaviorSubject({}),
+    status$: new rxjs.BehaviorSubject({ messages: [] }),
+  }
 
-  let stats$
   if (appConfig.stats) {
+    let stats$
+
     if (typeof appConfig.stats.subscribe === 'function') {
       stats$ = appConfig.stats
     } else if (typeof appConfig.stats === 'function') {
       stats$ = rxjs.timer(0, 10e3).pipe(
-        rx.exhaustMap(() => {
+        rxjs.exhaustMap(() => {
           const ret = appConfig.stats({ ds, couch, logger })
           return ret?.then || ret?.subscribe ? ret : rxjs.of(ret)
         }),
       )
     } else if (typeof appConfig.stats === 'object') {
-      stats$ = rxjs.timer(0, 10e3).pipe(rx.map(() => appConfig.stats))
+      stats$ = rxjs.timer(0, 10e3).pipe(rxjs.map(() => appConfig.stats))
     } else {
-      stats$ = rxjs.timer(0, 10e3).pipe(rx.map(() => ({})))
+      stats$ = rxjs.timer(0, 10e3).pipe(rxjs.map(() => ({})))
     }
 
     let statsMap
 
     const startTime = Date.now()
-    stats$ = stats$.pipe(
-      rx.map((x) => ({
-        ...x,
-        uptime: Date.now() - startTime,
-        timestamp: Date.now(),
-      })),
-      rx.auditTime(1e3),
-      rx.withLatestFrom(
-        rxjs.timer(0, 1e3).pipe(
-          rx.map(() => performance.eventLoopUtilization?.()),
-          rx.pairwise(),
-          rx.map(([elu1, elu2]) => {
+
+    appDestroyers.unshift(
+      rxjs
+        .timer(0, 1e3)
+        .pipe(
+          rxjs.map(() => performance.eventLoopUtilization?.()),
+          rxjs.pairwise(),
+          rxjs.map(([elu1, elu2]) => {
             const mem = process.memoryUsage()
             const cpu = process.cpuUsage()
 
@@ -660,24 +659,27 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               arrayBuffers: mem.arrayBuffers,
               containerLimit: getContainerMemoryLimit(),
               containerUsage: getContainerMemoryUsage(),
-              totalHeapTotal: 0,
-              totalHeapUsed: 0,
-              totalExternal: 0,
-              totalArrayBuffers: 0,
             }
 
             const http = {
               userAgent,
               pending: globalThis._nxt_lib_http_pending?.size,
-              totalPending: 0,
             }
 
             const undici = {
               sockets: globalThis.__undici_sockets?.size ?? 0,
-              totalSockets: 0,
             }
 
             if (statsMap) {
+              memory.totalHeapTotal = 0
+              memory.totalHeapUsed = 0
+              memory.totalExternal = 0
+              memory.totalArrayBuffers = 0
+
+              http.totalPending = 0
+
+              undici.totalSockets = 0
+
               for (const stats of statsMap.values()) {
                 memory.totalHeapTotal += stats.memory?.heapTotal ?? 0
                 memory.totalHeapUsed += stats.memory?.heapUsed ?? 0
@@ -690,7 +692,10 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               }
             }
 
+            const now = Date.now()
             return {
+              uptime: now - startTime,
+              timestamp: now,
               ds: ds?.stats,
               couch: couch?.stats,
               lag: toobusy?.lag(),
@@ -706,45 +711,56 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               undici,
             }
           }),
-        ),
-      ),
-      rx.map(([serviceStats, appStats]) => ({
-        ...appStats,
-        [serviceName]: serviceStats,
-      })),
-      rx.retryWhen((err$) =>
-        err$.pipe(
-          rx.tap((err) => logger.error({ err }, 'monitor.stats')),
-          rx.delay(10e3),
-        ),
-      ),
-      rx.startWith({}),
-      rx.publishReplay(1),
-      rx.refCount(),
+          rxjs.withLatestFrom(stats$.pipe(rxjs.startWith({}))),
+          rxjs.map(([appStats, serviceStats]) => ({
+            ...appStats,
+            // TODO (fix): [serviceName] is not great and can collide.
+            [serviceName]: serviceStats,
+          })),
+          rxjs.retry({
+            delay(err, retryCount) {
+              logger.error({ err, retryCount }, 'monitor.stats$ failed')
+              return rxjs.timer(10e3)
+            },
+          }),
+        )
+        .subscribe(monitorProviders.stats$),
     )
 
     const statsBC = new BroadcastChannel('nxt:app:stats').unref()
+
     if (isMainThread) {
       statsMap = new Map()
       statsBC.onmessage = ({ data: { data, id } }) => {
-        statsMap.set(id, data)
+        if (data != null) {
+          statsMap.set(id, data)
+        } else {
+          statsMap.delete(id)
+        }
       }
     }
 
-    monitorProviders.stats$ = stats$
+    appDestroyers.unshift(
+      monitorProviders.stats$
+        .subscribe((stats) => {
+          statsBC.postMessage({ id: threadId, data: stats })
+        })
+        .add(() => {
+          statsBC.postMessage({ id: threadId, data: undefined })
+        }),
+    )
 
     if (process.env.NODE_ENV === 'production') {
       appDestroyers.unshift(
-        stats$.pipe(rx.auditTime(10e3)).subscribe((stats) => {
-          statsBC.postMessage({ id: threadId, data: stats })
+        monitorProviders.stats$.pipe(rxjs.auditTime(10e3)).subscribe((stats) => {
           logger.debug(stats, 'STATS')
         }),
       )
     }
   }
 
-  let status$
   if (appConfig.status) {
+    let status$
     if (appConfig.status.subscribe) {
       status$ = appConfig.status
     } else if (typeof appConfig.status === 'function') {
@@ -754,294 +770,293 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
           return ret?.then || ret?.subscribe ? ret : rxjs.of(ret)
         })
         .pipe(
-          rx.catchError((err) => rxjs.of({ warnings: [err.message] })),
-          rx.repeatWhen(() => rxjs.timer(10e3)),
+          rxjs.catchError((err) => rxjs.of({ warnings: [err.message] })),
+          rxjs.repeatWhen(() => rxjs.timer(10e3)),
         )
     } else if (appConfig.status && typeof appConfig.status === 'object') {
-      status$ = rxjs.timer(0, 10e3).pipe(rx.exhaustMap(() => appConfig.status))
+      status$ = rxjs.timer(0, 10e3).pipe(rxjs.exhaustMap(() => appConfig.status))
     } else {
       status$ = rxjs.of({})
     }
 
-    status$ = rxjs
-      .combineLatest(
-        [
-          status$.pipe(
-            rx.filter(Boolean),
-            rx.map((xs) => (Array.isArray(xs) ? { messages: xs } : xs)),
-            rx.catchError((err) => {
-              logger.error({ err }, 'monitor.status')
-              return rxjs.of([
-                {
-                  id: 'app:user_monitor_status',
-                  level: 50,
-                  code: err.code,
-                  msg: err.message,
-                },
-              ])
-            }),
-            rx.startWith([]),
-            rx.distinctUntilChanged(fp.isEqual),
-            rx.repeatWhen((complete$) => complete$.pipe(rx.delay(10e3))),
-          ),
-          stats$.pipe(
-            rx.map(({ memory, heap, utilization, undici, http }) => {
-              const messages = []
-
-              if (memory?.containerLimit) {
-                const usagePercent = (memory.containerUsage / memory.containerLimit) * 100
-                messages.push({
-                  id: 'app:container_memory_usage',
-                  level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
-                  msg: `Memory Usage: ${usagePercent.toFixed(2)}%`,
-                })
-              }
-
-              if (heap) {
-                const usagePercent = (heap.used_heap_size / heap.heap_size_limit) * 100
-                messages.push({
-                  id: 'app:heap_memory_usage',
-                  level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
-                  msg: `Heap Usage: ${usagePercent.toFixed(2)}%`,
-                })
-              }
-
-              if (utilization) {
-                const elp = utilization.utilization * 100
-                messages.push({
-                  id: 'app:event_loop_utilization',
-                  level: elp > 95 ? 50 : elp > 80 ? 40 : 30,
-                  msg: `Event Loop Utilization: ${elp.toFixed(2)}%`,
-                })
-              }
-
-              if (undici) {
-                messages.push({
-                  id: 'app:undici_upstream_sockets',
-                  level: undici.totalSockets > 8192 ? 50 : undici.totalSockets > 4096 ? 40 : 30,
-                  msg: `Undici: ${undici.totalSockets} upstream connected`,
-                })
-              }
-
-              if (http) {
-                messages.push({
-                  id: 'app:http_pending_requests',
-                  level: http.totalPending > 8192 ? 50 : http.totalPending > 4096 ? 40 : 30,
-                  msg: `HTTP: ${http.totalPending} pending requests`,
-                })
-              }
-
-              return messages
-            }),
-          ),
-          toobusy?.appLag$.pipe(
-            rx.map((lag) =>
-              lag == null
-                ? []
-                : [
-                    {
-                      id: 'app:toobusy_lag',
-                      level: lag > 1e3 ? 50 : lag > toobusy.maxLag ? 40 : 30,
-                      code: 'NXT_LAG',
-                      msg: `Lag: ${lag.toFixed(2)} ms`,
-                    },
-                  ],
+    appDestroyers.unshift(
+      rxjs
+        .combineLatest(
+          [
+            status$.pipe(
+              rxjs.filter(Boolean),
+              rxjs.map((xs) => (Array.isArray(xs) ? { messages: xs } : xs)),
+              rxjs.catchError((err) => {
+                logger.error({ err }, 'monitor.status')
+                return rxjs.of([
+                  {
+                    id: 'app:user_monitor_status',
+                    level: 50,
+                    code: err.code,
+                    msg: err.message,
+                  },
+                ])
+              }),
+              rxjs.startWith([]),
+              rxjs.distinctUntilChanged(fp.isEqual),
+              rxjs.repeatWhen((complete$) => complete$.pipe(rxjs.delay(10e3))),
             ),
-          ) ?? rxjs.of([]),
-          underPressure?.pressure$?.pipe(
-            rx.map((pressure) =>
-              pressure == null
-                ? []
-                : [
-                    {
-                      id: 'app:under_pressure',
-                      level: 40,
-                      code: 'NXT_PRESSURE',
-                      msg: `Under Pressure`,
-                    },
-                  ],
+            monitorProviders.stats$?.pipe(
+              rxjs.map(({ memory, heap, utilization, undici, http }) => {
+                const messages = []
+
+                if (memory?.containerLimit) {
+                  const usagePercent = (memory.containerUsage / memory.containerLimit) * 100
+                  messages.push({
+                    id: 'app:container_memory_usage',
+                    level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
+                    msg: `Memory Usage: ${usagePercent.toFixed(2)}%`,
+                  })
+                }
+
+                if (heap) {
+                  const usagePercent = (heap.used_heap_size / heap.heap_size_limit) * 100
+                  messages.push({
+                    id: 'app:heap_memory_usage',
+                    level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
+                    msg: `Heap Usage: ${usagePercent.toFixed(2)}%`,
+                  })
+                }
+
+                if (utilization) {
+                  const elp = utilization.utilization * 100
+                  messages.push({
+                    id: 'app:event_loop_utilization',
+                    level: elp > 95 ? 50 : elp > 80 ? 40 : 30,
+                    msg: `Event Loop Utilization: ${elp.toFixed(2)}%`,
+                  })
+                }
+
+                if (undici) {
+                  messages.push({
+                    id: 'app:undici_upstream_sockets',
+                    level: undici.totalSockets > 8192 ? 50 : undici.totalSockets > 4096 ? 40 : 30,
+                    msg: `Undici: ${undici.totalSockets} upstream connected`,
+                  })
+                }
+
+                if (http) {
+                  messages.push({
+                    id: 'app:http_pending_requests',
+                    level: http.totalPending > 8192 ? 50 : http.totalPending > 4096 ? 40 : 30,
+                    msg: `HTTP: ${http.totalPending} pending requests`,
+                  })
+                }
+
+                return messages
+              }),
             ),
-          ) ?? rxjs.of([]),
-          couch
-            ? rxjs.timer(0, 10e3).pipe(
-                rx.exhaustMap(async () => {
-                  try {
-                    await couch.up()
-                    return [
+            toobusy?.appLag$.pipe(
+              rxjs.map((lag) =>
+                lag == null
+                  ? []
+                  : [
                       {
-                        id: 'app:couch',
-                        level: 30,
-                        msg: 'Couch: connected',
+                        id: 'app:toobusy_lag',
+                        level: lag > 1e3 ? 50 : lag > toobusy.maxLag ? 40 : 30,
+                        code: 'NXT_LAG',
+                        msg: `Lag: ${lag.toFixed(2)} ms`,
                       },
-                    ]
-                  } catch (err) {
-                    return [
+                    ],
+              ),
+            ) ?? rxjs.of([]),
+            underPressure?.pressure$?.pipe(
+              rxjs.map((pressure) =>
+                pressure == null
+                  ? []
+                  : [
                       {
-                        id: 'app:couch',
+                        id: 'app:under_pressure',
                         level: 40,
-                        code: err.code,
-                        msg: 'Couch: ' + err.message,
+                        code: 'NXT_PRESSURE',
+                        msg: `Under Pressure`,
                       },
-                    ]
-                  }
-                }),
-                rx.startWith([]),
-                rx.distinctUntilChanged(fp.isEqual),
-              )
-            : rxjs.of({}),
-          ds
-            ? rxjs.fromEvent(ds, 'connectionStateChanged').pipe(
-                rxjs.map((connectionState) =>
-                  connectionState === 'OPEN'
-                    ? [
+                    ],
+              ),
+            ) ?? rxjs.of([]),
+            couch
+              ? rxjs.timer(0, 10e3).pipe(
+                  rxjs.exhaustMap(async () => {
+                    try {
+                      await couch.up()
+                      return [
                         {
-                          id: 'app:ds_connection_state',
+                          id: 'app:couch',
                           level: 30,
-                          msg: 'Deepstream: connected',
-                          data: { connectionState },
+                          msg: 'Couch: connected',
                         },
                       ]
-                    : [
+                    } catch (err) {
+                      return [
                         {
-                          id: 'app:ds_connection_state',
+                          id: 'app:couch',
                           level: 40,
-                          msg: 'Deepstream: connecting',
-                          data: { connectionState },
+                          code: err.code,
+                          msg: 'Couch: ' + err.message,
                         },
-                      ],
-                ),
+                      ]
+                    }
+                  }),
+                  rxjs.startWith([]),
+                  rxjs.distinctUntilChanged(fp.isEqual),
+                )
+              : rxjs.of({}),
+            ds
+              ? rxjs.fromEvent(ds, 'connectionStateChanged').pipe(
+                  rxjs.map((connectionState) =>
+                    connectionState === 'OPEN'
+                      ? [
+                          {
+                            id: 'app:ds_connection_state',
+                            level: 30,
+                            msg: 'Deepstream: connected',
+                            data: { connectionState },
+                          },
+                        ]
+                      : [
+                          {
+                            id: 'app:ds_connection_state',
+                            level: 40,
+                            msg: 'Deepstream: connecting',
+                            data: { connectionState },
+                          },
+                        ],
+                  ),
+                )
+              : rxjs.of([]),
+            ds
+              ? rxjs.timer(0, 10e3).pipe(
+                  rxjs.exhaustMap(async () => {
+                    const messages = []
+
+                    if (ds.stats.record.records > 100e3) {
+                      messages.push({
+                        id: 'app:ds_record_records',
+                        level: 40,
+                        code: 'NXT_DEEPSTREAM_RECORDS_RECORDS',
+                        msg: 'Deepstream: ' + ds.stats.record.records + ' records',
+                      })
+                    }
+
+                    if (ds.stats.record.pruning > 100e3) {
+                      messages.push({
+                        id: 'app:ds_record_pruning',
+                        level: 40,
+                        code: 'NXT_DEEPSTREAM_RECORDS_PRUNING',
+                        msg: 'Deepstream: ' + ds.stats.record.pruning + ' pruning',
+                      })
+                    }
+
+                    if (ds.stats.record.pending > 10e3) {
+                      messages.push({
+                        id: 'app:ds_record_pending',
+                        level: 40,
+                        code: 'NXT_DEEPSTREAM_RECORDS_PENDING',
+                        msg: 'Deepstream: ' + ds.stats.record.pending + ' pending',
+                      })
+                    }
+
+                    if (ds.stats.record.updating > 10e3) {
+                      messages.push({
+                        id: 'app:ds_record_updating',
+                        level: 40,
+                        code: 'NXT_DEEPSTREAM_RECORDS_UPDATING',
+                        msg: 'Deepstream: ' + ds.stats.record.updating + ' updating',
+                      })
+                    }
+
+                    if (ds.stats.record.patching > 10e3) {
+                      messages.push({
+                        id: 'app:ds_record_patching',
+                        level: 40,
+                        code: 'NXT_DEEPSTREAM_RECORDS_PATCHING',
+                        msg: 'Deepstream: ' + ds.stats.record.patching + ' patching',
+                      })
+                    }
+
+                    return messages
+                  }),
+                )
+              : rxjs.of([]),
+            rxjs.timer(0, 10e3),
+          ].filter(Boolean),
+        )
+        .pipe(
+          rxjs.auditTime(1e3),
+          rxjs.map(([status, lag, couch, ds]) => {
+            const messages = [
+              lag,
+              couch,
+              ds,
+              [
+                status?.messages,
+                fp.map((x) => (fp.isString(x) ? { msg: x, level: 40 } : x), status?.warnings),
+                status,
+              ].find((x) => fp.isArray(x) && !fp.isEmpty(x)) ?? [],
+            ]
+              .flat()
+              .filter((x) => fp.isPlainObject(x) && !fp.isEmpty(x))
+              .map((message) =>
+                message.msg || !message.message
+                  ? message
+                  : {
+                      ...message,
+                      message: undefined,
+                      msg: message.message,
+                    },
               )
-            : rxjs.of([]),
-          ds
-            ? rxjs.timer(0, 10e3).pipe(
-                rx.exhaustMap(async () => {
-                  const messages = []
-
-                  if (ds.stats.record.records > 100e3) {
-                    messages.push({
-                      id: 'app:ds_record_records',
-                      level: 40,
-                      code: 'NXT_DEEPSTREAM_RECORDS_RECORDS',
-                      msg: 'Deepstream: ' + ds.stats.record.records + ' records',
-                    })
-                  }
-
-                  if (ds.stats.record.pruning > 100e3) {
-                    messages.push({
-                      id: 'app:ds_record_pruning',
-                      level: 40,
-                      code: 'NXT_DEEPSTREAM_RECORDS_PRUNING',
-                      msg: 'Deepstream: ' + ds.stats.record.pruning + ' pruning',
-                    })
-                  }
-
-                  if (ds.stats.record.pending > 10e3) {
-                    messages.push({
-                      id: 'app:ds_record_pending',
-                      level: 40,
-                      code: 'NXT_DEEPSTREAM_RECORDS_PENDING',
-                      msg: 'Deepstream: ' + ds.stats.record.pending + ' pending',
-                    })
-                  }
-
-                  if (ds.stats.record.updating > 10e3) {
-                    messages.push({
-                      id: 'app:ds_record_updating',
-                      level: 40,
-                      code: 'NXT_DEEPSTREAM_RECORDS_UPDATING',
-                      msg: 'Deepstream: ' + ds.stats.record.updating + ' updating',
-                    })
-                  }
-
-                  if (ds.stats.record.patching > 10e3) {
-                    messages.push({
-                      id: 'app:ds_record_patching',
-                      level: 40,
-                      code: 'NXT_DEEPSTREAM_RECORDS_PATCHING',
-                      msg: 'Deepstream: ' + ds.stats.record.patching + ' patching',
-                    })
-                  }
-
-                  return messages
-                }),
+              .map((message) =>
+                message.id
+                  ? message
+                  : {
+                      ...message,
+                      id: hashString(
+                        [message.msg, message].find(fp.isString) ?? JSON.stringify(message),
+                      ),
+                    },
               )
-            : rxjs.of([]),
-          rxjs.timer(0, 10e3),
-        ].filter(Boolean),
-      )
-      .pipe(
-        rx.auditTime(1e3),
-        rx.map(([status, lag, couch, ds]) => {
-          const messages = [
-            lag,
-            couch,
-            ds,
-            [
-              status?.messages,
-              fp.map((x) => (fp.isString(x) ? { msg: x, level: 40 } : x), status?.warnings),
-              status,
-            ].find((x) => fp.isArray(x) && !fp.isEmpty(x)) ?? [],
-          ]
-            .flat()
-            .filter((x) => fp.isPlainObject(x) && !fp.isEmpty(x))
-            .map((message) =>
-              message.msg || !message.message
-                ? message
-                : {
-                    ...message,
-                    message: undefined,
-                    msg: message.message,
-                  },
-            )
-            .map((message) =>
-              message.id
-                ? message
-                : {
-                    ...message,
-                    id: hashString(
-                      [message.msg, message].find(fp.isString) ?? JSON.stringify(message),
-                    ),
-                  },
-            )
 
-          return { ...status, messages, timestamp: Date.now() }
-        }),
-        rx.catchError((err) => {
-          logger.error({ err }, 'monitor.status')
-          return rxjs.of({
-            messages: [{ id: 'app:monitor_status', level: 50, code: err.code, msg: err.message }],
-          })
-        }),
-        rx.repeatWhen((complete$) => complete$.pipe(rx.delay(10e3))),
-        rx.startWith({}),
-        rx.distinctUntilChanged(fp.isEqual),
-        rx.publishReplay(1),
-        rx.refCount(),
-      )
+            return { ...status, messages, timestamp: Date.now() }
+          }),
+          rxjs.catchError((err) => {
+            logger.error({ err }, 'monitor.status')
+            return rxjs.of({
+              messages: [{ id: 'app:monitor_status', level: 50, code: err.code, msg: err.message }],
+            })
+          }),
+          rxjs.repeatWhen((complete$) => complete$.pipe(rxjs.delay(10e3))),
+          rxjs.startWith({}),
+          rxjs.distinctUntilChanged(fp.isEqual),
+        )
+        .subscribe(monitorProviders.status$),
+    )
 
-    const loggerSubscription = status$
-      .pipe(rx.auditTime(1e3), rx.pluck('messages'), rx.startWith([]), rx.pairwise())
-      .subscribe(([prev, next]) => {
-        for (const { level, msg: status, ...message } of fp.differenceBy('id', next, prev)) {
-          if (level >= 50) {
-            logger.error({ ...message, status }, `status added`)
-          } else if (level >= 40) {
-            logger.warn({ ...message, status }, `status added`)
-          } else {
-            logger.info({ ...message, status }, `status added`)
+    appDestroyers.unshift(
+      monitorProviders.status$
+        .pipe(rxjs.auditTime(1e3), rxjs.pluck('messages'), rxjs.startWith([]), rxjs.pairwise())
+        .subscribe(([prev, next]) => {
+          for (const { level, msg: status, ...message } of fp.differenceBy('id', next, prev)) {
+            if (level >= 50) {
+              logger.error({ ...message, status }, `status added`)
+            } else if (level >= 40) {
+              logger.warn({ ...message, status }, `status added`)
+            } else {
+              logger.info({ ...message, status }, `status added`)
+            }
           }
-        }
 
-        for (const { level, msg: status, ...message } of fp.differenceBy('id', prev, next)) {
-          if (level >= 40) {
-            logger.info({ ...message, status }, `status removed`)
+          for (const { level, msg: status, ...message } of fp.differenceBy('id', prev, next)) {
+            if (level >= 40) {
+              logger.info({ ...message, status }, `status removed`)
+            }
           }
-        }
-      })
-
-    monitorProviders.status$ = status$
-
-    appDestroyers.unshift(loggerSubscription)
+        }),
+    )
   }
 
   if (ds && Object.keys(monitorProviders).length && appConfig.monitor !== false) {
@@ -1275,13 +1290,13 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
           try {
             if (req.method === 'GET' && req.url === '/stats') {
               res.setHeader('content-type', 'application/json')
-              res.end(JSON.stringify(stats$.value))
+              res.end(JSON.stringify(monitorProviders.stats$.value))
               return
             }
 
             if (req.method === 'GET' && req.url === '/status') {
               res.setHeader('content-type', 'application/json')
-              res.end(JSON.stringify(status$.value))
+              res.end(JSON.stringify(monitorProviders.status$.value))
               return
             }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.11",
+  "version": "28.0.13",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -52,7 +52,7 @@
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^7.1.9",
     "@nxtedition/sched": "^1.0.2",
-    "@nxtedition/template": "^1.0.9",
+    "@nxtedition/template": "^1.0.10",
     "@nxtedition/weak-cache": "^1.0.2",
     "diff": "5.2.0",
     "fast-querystring": "^1.1.2",
@@ -92,5 +92,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "0337fc7ffd76296e12c4ce91be5941c839e8c90b"
+  "gitHead": "ab3426c105b6b59a7a092a3a5ae1e563ea1253a4"
 }