Remove lifecycle component healthchecks

Author: Antman261

README.md

@@ -34,7 +34,6 @@ class DatabasePool extends LifecycleComponent {
   async close(){
     await this.pool.end();
   }
-  checkHealth: undefined; // Optionally, can implement a health check for a component.
 }
 export const db = new DatabasePool();
 ```
@@ -57,7 +56,6 @@ const parentComponent = new (class ParentComponent extends LifecycleComponent {
   async close(){
     await this.closeChildComponents();
   }
-  checkHealth: undefined;
 })();
 
 const lifecycle = new Lifecycle(); 

src/LifecycleComponent.ts

@@ -1,21 +1,16 @@
 /**
  * Define a lifecycle component to be managed by the lifecycle manager
  */
-
 export abstract class LifecycleComponent {
   #components: LifecycleComponent[] = [];
   /**
-   * Lifecycle manager will call `start` once per process lifetime. Each component's start method will be called in the sequence they were registered. Implement your component's
+   * Lifecycle manager will call `start` once per process lifetime. Each component's start method will be called in the sequence they were registered.
    */
   abstract start(): Promise<unknown>;
   /**
    * Lifecycle manager will call close once per process lifetime, in the reverse order the components are registered
    */
   abstract close(): Promise<unknown>;
-  /**
-   * Called by lifecycle manager to check the health of the component. Return true for healthy. If implemented, the lifecycle manager will call `start()` again if the component's health check returns false
-   */
-  abstract checkHealth?(): Promise<boolean>;
   /**
    * Register a child component of a lifecycle component to guarantee that its children are started in the order they are registered, and closed in the reverse order. The implementer of the lifecycle component is responsible for calling startChildComponents and closeChildComponents during start and close, respectively.
    */
@@ -34,6 +29,9 @@ export abstract class LifecycleComponent {
   async closeChildComponents(): Promise<void> {
     for (const component of this.#components.toReversed()) await component.close();
   }
+  /**
+   * Return the registered components of the lifecycle
+   */
   getChildren(): Readonly<LifecycleComponent[]> {
     return [...this.#components];
   }

src/componentClass.test.ts

@@ -14,13 +14,12 @@ class DatabasePool extends LifecycleComponent {
   close() {
     return delay(1);
   }
-  checkHealth: undefined;
 }
 
 Deno.test('Lifecycle component as a class', async () => {
   const db = new DatabasePool();
   const [actual, actualEvent] = setupEvents();
-  const lc = new Lifecycle({ healthCheckIntervalMs: 50 });
+  const lc = new Lifecycle();
   lc.register(db);
 
   lc.on(...actualEvent('componentStarted'));
@@ -50,7 +49,6 @@ const parent = new (class ParentComponent extends LifecycleComponent {
     await this.closeChildComponents();
     events.push('parent.closed');
   }
-  checkHealth: undefined;
 })();
 const childOne = new (class extends LifecycleComponent {
   async start() {
@@ -64,7 +62,6 @@ const childOne = new (class extends LifecycleComponent {
     await delay(1);
     events.push('childOne.closed');
   }
-  checkHealth: undefined;
 })();
 const childTwo = new (class extends LifecycleComponent {
   async start() {
@@ -78,7 +75,6 @@ const childTwo = new (class extends LifecycleComponent {
     await delay(1);
     events.push('childTwo.closed');
   }
-  checkHealth: undefined;
 })();
 
 Deno.test('lifecycle component manages child lifecycle components', async () => {

src/lifecycle.test.ts

@@ -2,11 +2,8 @@ import { delay } from '@std/async';
 import { expect } from '@std/expect';
 import { Lifecycle } from './lifecycle.ts';
 import {
-  CrashingTestComponentOne,
-  CrashingTestComponentTwo,
   createChecks,
   setupEvents,
-  TestComponentFour,
   TestComponentOne,
   TestComponentThree,
   TestComponentTwo,
@@ -15,7 +12,7 @@ import {
 Deno.test('LifeCycle', async ({ step }) => {
   await step('can start & close a lifecycle', async () => {
     const { checks, passCheck } = createChecks();
-    const lc = new Lifecycle({ healthCheckIntervalMs: 50 });
+    const lc = new Lifecycle();
     lc.on('starting', passCheck('didStart'));
     lc.on('running', passCheck('didRun'));
     lc.on('closing', passCheck('didClosing'));
@@ -31,7 +28,7 @@ Deno.test('LifeCycle', async ({ step }) => {
   });
   await step('start and close lifecycle components', async () => {
     const [actual, actualEvent] = setupEvents();
-    const lc = new Lifecycle({ healthCheckIntervalMs: 50 });
+    const lc = new Lifecycle();
     lc.register(new TestComponentOne());
     lc.register(new TestComponentTwo());
     lc.register(new TestComponentThree());
@@ -55,45 +52,4 @@ Deno.test('LifeCycle', async ({ step }) => {
       'componentClosed TestComponentOne',
     ]);
   });
-  await step('restarts crashed life cycle component', async () => {
-    const [actual, actualEvent] = setupEvents();
-    const lc = new Lifecycle({ healthCheckIntervalMs: 1 });
-
-    lc.register(new TestComponentOne());
-    lc.register(new TestComponentTwo());
-    lc.register(new CrashingTestComponentOne());
-    lc.register(new TestComponentFour());
-    lc.register(new CrashingTestComponentTwo());
-    lc.on(...actualEvent('componentStarted'));
-    lc.on(...actualEvent('componentClosing'));
-    lc.on(...actualEvent('componentClosed'));
-    lc.on(...actualEvent('componentRestarting'));
-    lc.on(...actualEvent('componentRestarted'));
-    await lc.start();
-    await delay(15);
-    await lc.close(false);
-    await delay(30);
-    console.log(actual);
-    expect(actual).toEqual([
-      'componentStarted TestComponentOne',
-      'componentStarted TestComponentTwo',
-      'componentStarted CrashingTestComponentOne',
-      'componentStarted TestComponentFour',
-      'componentStarted CrashingTestComponentTwo',
-      'componentRestarting CrashingTestComponentOne',
-      'componentRestarted CrashingTestComponentOne',
-      'componentRestarting CrashingTestComponentTwo',
-      'componentRestarted CrashingTestComponentTwo',
-      'componentClosing CrashingTestComponentTwo',
-      'componentClosed CrashingTestComponentTwo',
-      'componentClosing TestComponentFour',
-      'componentClosed TestComponentFour',
-      'componentClosing CrashingTestComponentOne',
-      'componentClosed CrashingTestComponentOne',
-      'componentClosing TestComponentTwo',
-      'componentClosed TestComponentTwo',
-      'componentClosing TestComponentOne',
-      'componentClosed TestComponentOne',
-    ]);
-  });
 });

src/lifecycle.ts

@@ -1,43 +1,28 @@
 import { isDefined } from '@antman/bool';
-import { delay } from '@std/async/delay';
 import { EventEmitter } from 'node:events';
 import type { LifecycleComponent } from './LifecycleComponent.ts';
 
-/**
- * Define the options for the lifecycle manager
- */
-export type LifecycleOptions = {
-  /**
-   * Define the frequency of component health check cycles. Note: This is the interval in which the lifecycle manager will begin polling each component's status -- the interval begins once each component has returned its status. Components returning their status in a promise can delay subsequent health checks.
-   */
-  healthCheckIntervalMs?: number;
-};
 const statuses = [
   'pending',
   'starting',
   'running',
   'closing',
   'closed',
 ] as const;
-type Status = 'pending' | 'starting' | 'running' | 'closing' | 'closed';
+type Status = (typeof statuses)[number];
 
-const defaultOptions = { healthCheckIntervalMs: 600 };
 const componentEvents = [
   'componentStarted',
   'componentClosing',
   'componentClosed',
-  'componentRestarting',
-  'componentRestarted',
 ] as const;
 type ComponentEvent = (typeof componentEvents)[number];
 const isComponentEvent = (e: string | undefined): e is ComponentEvent =>
   componentEvents.includes(e as ComponentEvent);
-type EventMap = Record<Status | 'healthChecked', []> & {
+type EventMap = Record<Status, []> & {
   componentStarted: [string];
   componentClosing: [string];
   componentClosed: [string];
-  componentRestarting: [string];
-  componentRestarted: [string];
 };
 /**
  * Manages the clean startup and shutdown of a process and its components.
@@ -48,8 +33,6 @@ export class Lifecycle {
   #emitter = new EventEmitter<EventMap>();
   #status: Status;
   #components: LifecycleComponent[];
-  #healthCheckInterval: number;
-  #healthCheckPromise: PromiseWithResolvers<void>;
   #setStatus(v: Status): void {
     this.#status = v;
     this.#emit(v);
@@ -77,16 +60,9 @@ export class Lifecycle {
       this.#emitter.on(event, (name: string) => cb(event, name))
     );
   }
-  constructor(opt: LifecycleOptions = defaultOptions) {
-    const { healthCheckIntervalMs } = { ...defaultOptions, ...opt };
+  constructor() {
     this.#status = 'pending';
     this.#components = [];
-    this.#healthCheckInterval = healthCheckIntervalMs;
-    this.#healthCheckPromise = Promise.withResolvers();
-  }
-
-  get status(): Status {
-    return this.#status;
   }
 
   /**
@@ -110,16 +86,10 @@ export class Lifecycle {
   public start = async (): Promise<void> => {
     this.#setStatus('starting');
     for (const component of this.#components) {
-      await this.#startComponent(component);
+      await component.start();
+      this.#emit('componentStarted', component.constructor.name);
     }
     Deno.addSignalListener('SIGTERM', this.close);
-    (async () => {
-      do {
-        await delay(this.#healthCheckInterval);
-        await this.#checkComponentHealth();
-      } while (this.status === 'running');
-      this.#healthCheckPromise.resolve();
-    })();
     this.#setStatus('running');
   };
 
@@ -137,32 +107,14 @@ export class Lifecycle {
     Deno.removeSignalListener('SIGTERM', this.close);
     this.#setStatus('closing');
 
-    await this.#healthCheckPromise.promise;
     const components = this.#components.toReversed();
-
-    for (const component of components) await this.#closeComponent(component);
+    for (const component of components) {
+      this.#emit('componentClosing', component.constructor.name);
+      await component.close();
+      this.#emit('componentClosed', component.constructor.name);
+    }
 
     this.#setStatus('closed');
     shouldExit && Deno.exit(0);
   };
-  async #startComponent(component: LifecycleComponent): Promise<void> {
-    await component.start();
-    this.#emit('componentStarted', component.constructor.name);
-  }
-  async #closeComponent(component: LifecycleComponent): Promise<void> {
-    this.#emit('componentClosing', component.constructor.name);
-    await component.close();
-    this.#emit('componentClosed', component.constructor.name);
-  }
-  async #restartComponent(component: LifecycleComponent): Promise<void> {
-    this.#emit('componentRestarting', component.constructor.name);
-    await (component.start)();
-    this.#emit('componentRestarted', component.constructor.name);
-  }
-  async #checkComponentHealth(): Promise<void> {
-    for (const component of this.#components) {
-      if ((await component.checkHealth?.() ?? true) === false) await this.#restartComponent(component);
-    }
-    this.#emit('healthChecked');
-  }
 }

src/testUtil.ts

@@ -14,8 +14,6 @@ export const createChecks = () => {
 
 type EventName =
   | 'componentStarted'
-  | 'componentRestarting'
-  | 'componentRestarted'
   | 'componentClosing'
   | 'componentClosed';
 type Event = `${EventName} ${string}`;
@@ -32,7 +30,6 @@ export class TestComponentOne extends LifecycleComponent {
   async close() {
     await delay(1);
   }
-  checkHealth: undefined;
 }
 
 export class TestComponentTwo extends LifecycleComponent {
@@ -42,7 +39,6 @@ export class TestComponentTwo extends LifecycleComponent {
   async close() {
     await delay(1);
   }
-  checkHealth: undefined;
 }
 export class TestComponentThree extends LifecycleComponent {
   async start() {
@@ -51,7 +47,6 @@ export class TestComponentThree extends LifecycleComponent {
   async close() {
     await delay(1);
   }
-  checkHealth: undefined;
 }
 export class TestComponentFour extends LifecycleComponent {
   async start() {
@@ -60,45 +55,6 @@ export class TestComponentFour extends LifecycleComponent {
   async close() {
     await delay(1);
   }
-  checkHealth: undefined;
-}
-export class CrashingTestComponentOne extends LifecycleComponent {
-  crashAfterMs: number;
-  hasCrashed = false;
-  constructor(crashAfterMs = 10) {
-    super();
-    this.crashAfterMs = crashAfterMs;
-  }
-  async start() {
-    this.hasCrashed = false;
-    await delay(1);
-    delay(this.crashAfterMs).then(() => (this.hasCrashed = true));
-  }
-  async close() {
-    await delay(1);
-  }
-  checkHealth() {
-    return Promise.resolve(!this.hasCrashed);
-  }
-}
-export class CrashingTestComponentTwo extends LifecycleComponent {
-  crashAfterMs: number;
-  hasCrashed = false;
-  constructor(crashAfterMs = 10) {
-    super();
-    this.crashAfterMs = crashAfterMs;
-  }
-  async start() {
-    this.hasCrashed = false;
-    await delay(1);
-    delay(this.crashAfterMs).then(() => (this.hasCrashed = true));
-  }
-  async close() {
-    await delay(1);
-  }
-  checkHealth() {
-    return Promise.resolve(!this.hasCrashed);
-  }
 }
 
 export const setupEvents = (): [Events, EventTracker] => {