@hkdigital/lib-sveltekit 0.2.11 → 0.2.13

package/dist/classes/services/ServiceManager.js

@@ -1,1114 +1,608 @@
 /**
- * @fileoverview Service manager for coordinating service lifecycle.
+ * @fileoverview Service Manager for coordinating service lifecycle,
+ * dependencies, and health monitoring.
  *
- * The ServiceManager provides centralized registration, lifecycle management,
- * and coordination of services. It maintains a registry of all services,
- * manages dependencies between them, and provides events for global service
- * state changes.
+ * The ServiceManager handles registration, dependency resolution, startup
+ * orchestration, and coordinated shutdown of services. It provides centralized
+ * logging control and health monitoring for all registered services.
  *
  * @example
  * // Basic usage
  * import { ServiceManager } from './ServiceManager.js';
  * import DatabaseService from './services/DatabaseService.js';
- * import ApiService from './services/ApiService.js';
+ * import AuthService from './services/AuthService.js';
  *
- * // Create a service manager
- * const manager = new ServiceManager();
+ * const manager = new ServiceManager({
+ *   debug: true,
+ *   stopTimeout: 10000
+ * });
  *
- * // Register services
- * manager.register('database', new DatabaseService());
- * manager.register('api', new ApiService(), { dependencies: ['database'] });
+ * // Register services with dependencies
+ * manager.register('database', DatabaseService, {
+ *   connectionString: 'postgres://localhost/myapp'
+ * });
  *
- * // Initialize all services
- * await manager.initializeAll({
- *   database: { connectionString: 'mongodb://localhost:27017' },
- *   api: { port: 3000 }
+ * manager.register('auth', AuthService, {
+ *   secret: process.env.JWT_SECRET
+ * }, {
+ *   dependencies: ['database'] // auth depends on database
  * });
  *
- * // Start all services (respecting dependencies)
+ * // Start all services
  * await manager.startAll();
  *
- * // Listen for service events
- * manager.on('service:started', ({ service }) => {
- *   console.log(`Service ${service} started`);
+ * @example
+ * // Advanced usage with health monitoring
+ * manager.on('service:healthChanged', ({ service, healthy }) => {
+ *   if (!healthy) {
+ *     console.error(`Service ${service} became unhealthy`);
+ *   }
+ * });
+ *
+ * // Check health of all services
+ * const health = await manager.checkHealth();
+ * console.log('System health:', health);
+ *
+ * // Recover failed service
+ * manager.on('service:error', async ({ service }) => {
+ *   console.log(`Attempting to recover ${service}`);
+ *   await manager.recoverService(service);
  * });
  *
- * // Get service instance
- * const db = manager.getService('database');
- * await db.query('SELECT * FROM users');
+ * @example
+ * // Logging control
+ * // Set global log level
+ * manager.setLogLevel('*', 'DEBUG');
+ *
+ * // Set specific service log level
+ * manager.setLogLevel('database', 'ERROR');
  *
- * // Later, stop all services
- * await manager.stopAll();
+ * // Listen to all service logs
+ * manager.on('service:log', (logEvent) => {
+ *   writeToLogFile(logEvent);
+ * });
  */
 
 import { EventEmitter } from '../events';
-import { Logger, INFO } from '../logging';
+import { Logger, DEBUG, INFO, WARN } from '../logging';
 
 import {
   CREATED,
-  INITIALIZING,
-  INITIALIZED,
-  STARTING,
   RUNNING,
-  STOPPING,
-  STOPPED,
-  DESTROYING,
-  DESTROYED,
-  ERROR,
-  RECOVERING
-} from './constants.js';
+  DESTROYED
+} from './service-states.js';
 
 /**
- * @typedef {Object} ServiceEntry
- * @property {Object} instance - Service instance
- * @property {Object} config - Service configuration
- * @property {string[]} dependencies - List of service dependencies
- * @property {Function} stateChangedUnsubscribe - Unsubscribe function for state events
- * @property {Function} errorUnsubscribe - Unsubscribe function for error events
+ * @typedef {import('./typedef.js').ServiceConstructor} ServiceConstructor
+ * @typedef {import('./typedef.js').ServiceConfig} ServiceConfig
+ * @typedef {import('./typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
+ * @typedef {import('./typedef.js').ServiceManagerConfig} ServiceManagerConfig
+ * @typedef {import('./typedef.js').StopOptions} StopOptions
+ * @typedef {import('./typedef.js').ServiceEntry} ServiceEntry
+ * @typedef {import('./typedef.js').HealthCheckResult} HealthCheckResult
  */
 
 /**
- * Manager for coordinating services lifecycle
+ * Service Manager for lifecycle and dependency management
+ * @extends EventEmitter
  */
-export default class ServiceManager {
+export class ServiceManager extends EventEmitter {
   /**
-   * Create a new service manager
+   * Create a new ServiceManager instance
    *
-   * @param {Object} [options] - Manager options
-   * @param {string} [options.logLevel=INFO] - Log level for the manager
+   * @param {ServiceManagerConfig} [config={}] - Manager configuration
    */
-  constructor(options = {}) {
-    /**
-     * Map of registered services
-     * @type {Map<string, ServiceEntry>}
-     * @private
-     */
-    this.services = new Map();
+  constructor(config = {}) {
+    super();
 
-    /**
-     * Event emitter for service events
-     * @type {EventEmitter}
-     */
-    this.events = new EventEmitter();
-
-    /**
-     * Service manager logger
-     * @type {Logger}
-     */
-    this.logger = new Logger('ServiceManager', options.logLevel || INFO);
-
-    /**
-     * Service dependency graph
-     * @type {Map<string, Set<string>>}
-     * @private
-     */
-    this.dependencyGraph = new Map();
-
-    this.logger.debug('Service manager created');
-  }
+    /** @type {Map<string, ServiceEntry>} */
+    this.services = new Map();
 
-  /**
-   * Register an event handler
-   *
-   * @param {string} eventName - Event name
-   * @param {Function} handler - Event handler
-   * @returns {Function} Unsubscribe function
-   */
-  on(eventName, handler) {
-    return this.events.on(eventName, handler);
-  }
+    /** @type {Logger} */
+    this.logger = new Logger('ServiceManager', config.logLevel || INFO);
 
-  /**
-   * Remove an event handler
-   *
-   * @param {string} eventName - Event name
-   * @param {Function} handler - Event handler
-   * @returns {boolean} True if handler was removed
-   */
-  off(eventName, handler) {
-    return this.events.off(eventName, handler);
-  }
+    /** @type {ServiceManagerConfig} */
+    this.config = {
+      debug: config.debug ?? false,
+      autoStart: config.autoStart ?? false,
+      stopTimeout: config.stopTimeout || 10000,
+      logConfig: config.logConfig || {}
+    };
 
-  /**
-   * Emit an event
-   *
-   * @param {string} eventName - Event name
-   * @param {*} data - Event data
-   * @returns {boolean} True if event had listeners
-   * @private
-   */
-  _emit(eventName, data) {
-    return this.events.emit(eventName, data);
+    this._setupLogging();
   }
 
   /**
-   * Register a service
+   * Register a service class with the manager
    *
-   * @param {string} name - Service name
-   * @param {Object} instance - Service instance
-   * @param {Object} [options] - Registration options
-   * @param {string[]} [options.dependencies=[]] - Service dependencies
-   * @param {Object} [options.config={}] - Service configuration
-   * @returns {boolean} True if registration was successful
+   * @param {string} name - Unique service identifier
+   * @param {ServiceConstructor} ServiceClass - Service class constructor
+   * @param {ServiceConfig} [config={}] - Service configuration
+   * @param {ServiceRegistrationOptions} [options={}] - Registration options
    *
-   * @example
-   * manager.register('database', new DatabaseService());
-   * manager.register('api', new ApiService(), {
-   *   dependencies: ['database'],
-   *   config: { port: 3000 }
-   * });
+   * @throws {Error} If service name is already registered
    */
-  register(name, instance, options = {}) {
+  register(name, ServiceClass, config = {}, options = {}) {
     if (this.services.has(name)) {
-      this.logger.warn(`Service '${name}' already registered`);
-      return false;
+      throw new Error(`Service '${name}' already registered`);
     }
 
-    const { dependencies = [], config = {} } = options;
-
-    // Check if dependencies are valid
-    for (const dep of dependencies) {
-      if (!this.services.has(dep)) {
-        this.logger.warn(
-          `Cannot register service '${name}': missing dependency '${dep}'`
-        );
-        return false;
-      }
-    }
-
-    // Create service entry
+    /** @type {ServiceEntry} */
     const entry = {
-      instance,
+      ServiceClass,
+      instance: null,
       config,
-      dependencies,
-      stateChangedUnsubscribe: null,
-      errorUnsubscribe: null
+      dependencies: options.dependencies || [],
+      dependents: new Set(),
+      tags: options.tags || [],
+      priority: options.priority || 0
     };
 
-    // Subscribe to service events
-    entry.stateChangedUnsubscribe = instance.on('stateChanged', event => {
-      this._handleStateChanged(name, event);
-    });
-
-    entry.errorUnsubscribe = instance.on('error', event => {
-      this._handleError(name, event);
+    // Track dependents
+    entry.dependencies.forEach(dep => {
+      const depEntry = this.services.get(dep);
+      if (depEntry) {
+        depEntry.dependents.add(name);
+      }
     });
 
-    // Add to registry
     this.services.set(name, entry);
-
-    // Update dependency graph
-    this._updateDependencyGraph();
-
-    this.logger.info(`Service '${name}' registered`, { dependencies });
-    this._emit('service:registered', { service: name });
-
-    return true;
+    this.logger.debug(`Registered service '${name}'`, {
+      dependencies: entry.dependencies,
+      tags: entry.tags
+    });
   }
 
   /**
-   * Unregister a service
+   * Get or create a service instance
    *
    * @param {string} name - Service name
-   * @returns {boolean} True if unregistration was successful
    *
-   * @example
-   * manager.unregister('api');
+   * @returns {import('./typedef.js').ServiceBase|null}
+   *   Service instance or null if not found
    */
-  unregister(name) {
+  get(name) {
     const entry = this.services.get(name);
     if (!entry) {
-      this.logger.warn(`Service '${name}' not registered`);
-      return false;
-    }
-
-    // Check if other services depend on this one
-    for (const [serviceName, serviceEntry] of this.services.entries()) {
-      if (serviceEntry.dependencies.includes(name)) {
-        this.logger.error(
-          `Cannot unregister service '${name}': ` +
-          `'${serviceName}' depends on it`
-        );
-        return false;
-      }
+      this.logger.warn(`Service '${name}' not found`);
+      return null;
     }
 
-    // Clean up event subscriptions
-    if (entry.stateChangedUnsubscribe) {
-      entry.stateChangedUnsubscribe();
-    }
+    if (!entry.instance) {
+      try {
+        entry.instance = new entry.ServiceClass(name);
 
-    if (entry.errorUnsubscribe) {
-      entry.errorUnsubscribe();
-    }
-
-    // Remove from registry
-    this.services.delete(name);
+        // Apply log level
+        const logLevel = this._getServiceLogLevel(name);
+        if (logLevel) {
+          entry.instance.setLogLevel(logLevel);
+        }
 
-    // Update dependency graph
-    this._updateDependencyGraph();
+        // Forward events
+        this._attachServiceEvents(name, entry.instance);
 
-    this.logger.info(`Service '${name}' unregistered`);
-    this._emit('service:unregistered', { service: name });
+        this.logger.debug(`Created instance for '${name}'`);
+      } catch (error) {
+        this.logger.error(`Failed to create instance for '${name}'`, error);
+        return null;
+      }
+    }
 
-    return true;
+    return entry.instance;
   }
 
   /**
-   * Get a service instance
+   * Initialize a service
    *
    * @param {string} name - Service name
-   * @returns {Object|null} Service instance or null if not found
    *
-   * @example
-   * const db = manager.getService('database');
-   * await db.query('SELECT * FROM users');
+   * @returns {Promise<boolean>} True if initialization succeeded
    */
-  getService(name) {
-    const entry = this.services.get(name);
-    return entry ? entry.instance : null;
-  }
+  async initService(name) {
+    const instance = this.get(name);
+    if (!instance) return false;
 
-  /**
-   * Initialize a specific service
-   *
-   * @param {string} name - Service name
-   * @param {Object} [config] - Service configuration (overrides config from
-   *                            registration)
-   * @returns {Promise<boolean>} True if initialization was successful
-   *
-   * @example
-   * await manager.initializeService('database', {
-   *   connectionString: 'mongodb://localhost:27017'
-   * });
-   */
-  async initializeService(name, config) {
     const entry = this.services.get(name);
-    if (!entry) {
-      this.logger.error(`Cannot initialize unknown service '${name}'`);
-      return false;
-    }
-
-    // Merge configs if provided
-    const mergedConfig = config
-      ? { ...entry.config, ...config }
-      : entry.config;
-
-    this.logger.debug(`Initializing service '${name}'`);
-    const result = await entry.instance.initialize(mergedConfig);
-
-    if (result) {
-      this.logger.info(`Service '${name}' initialized`);
-    } else {
-      this.logger.error(`Service '${name}' initialization failed`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Initialize all registered services
-   *
-   * @param {Object} [configs] - Configuration map for services
-   * @returns {Promise<boolean>} True if all services initialized successfully
-   *
-   * @example
-   * await manager.initializeAll({
-   *   database: { connectionString: 'mongodb://localhost:27017' },
-   *   api: { port: 3000 }
-   * });
-   */
-  async initializeAll(configs = {}) {
-    let allSuccessful = true;
-
-    this.logger.info('Initializing all services');
-
-    for (const [name, entry] of this.services.entries()) {
-      const config = configs[name] || entry.config;
-      const success = await this.initializeService(name, config);
-
-      if (!success) {
-        allSuccessful = false;
-      }
-    }
-
-    if (allSuccessful) {
-      this.logger.info('All services initialized successfully');
-    } else {
-      this.logger.error('Some services failed to initialize');
-    }
-
-    return allSuccessful;
+    return await instance.initialize(entry.config);
   }
 
   /**
-   * Start a specific service and its dependencies
+   * Start a service and its dependencies
    *
    * @param {string} name - Service name
-   * @returns {Promise<boolean>} True if start was successful
    *
-   * @example
-   * await manager.startService('api');
+   * @returns {Promise<boolean>} True if service started successfully
    */
   async startService(name) {
     const entry = this.services.get(name);
     if (!entry) {
-      this.logger.error(`Cannot start unknown service '${name}'`);
+      this.logger.warn(`Cannot start unregistered service '${name}'`);
       return false;
     }
 
-    // Check if service is already running
-    if (entry.instance.state === RUNNING) {
-      this.logger.debug(`Service '${name}' is already running`);
-      return true;
-    }
-
     // Start dependencies first
-    for (const depName of entry.dependencies) {
-      const depEntry = this.services.get(depName);
-
-      if (!depEntry) {
-        this.logger.error(
-          `Cannot start service '${name}': ` +
-          `dependency '${depName}' not found`
-        );
-        return false;
-      }
-
-      if (depEntry.instance.state !== RUNNING) {
-        const success = await this.startService(depName);
-        if (!success) {
+    for (const dep of entry.dependencies) {
+      if (!await this.isRunning(dep)) {
+        this.logger.debug(`Starting dependency '${dep}' for '${name}'`);
+        const started = await this.startService(dep);
+        if (!started) {
           this.logger.error(
-            `Cannot start service '${name}': ` +
-            `dependency '${depName}' failed to start`
+            `Failed to start dependency '${dep}' for '${name}'`
           );
           return false;
         }
       }
     }
 
-    // Start this service
-    this.logger.debug(`Starting service '${name}'`);
-    const result = await entry.instance.start();
+    const instance = this.get(name);
+    if (!instance) return false;
 
-    if (result) {
-      this.logger.info(`Service '${name}' started`);
-    } else {
-      this.logger.error(`Service '${name}' failed to start`);
+    // Initialize if needed
+    if (instance.state === CREATED || instance.state === DESTROYED) {
+      const initialized = await this.initService(name);
+      if (!initialized) return false;
     }
 
-    return result;
+    return await instance.start();
   }
 
   /**
-   * Start all services in dependency order
+   * Stop a service
    *
-   * @returns {Promise<boolean>} True if all services started successfully
+   * @param {string} name - Service name
+   * @param {StopOptions} [options={}] - Stop options
    *
-   * @example
-   * await manager.startAll();
+   * @returns {Promise<boolean>} True if service stopped successfully
    */
-  async startAll() {
-    let allSuccessful = true;
-    const started = new Set();
-
-    this.logger.info('Starting all services');
-
-    // Get dependency ordered list
-    const orderedServices = this._getStartOrder();
+  async stopService(name, options = {}) {
+    const instance = this.get(name);
+    if (!instance) {
+      this.logger.warn(`Cannot stop unregistered service '${name}'`);
+      return true; // Already stopped
+    }
 
-    // Start services in order
-    for (const name of orderedServices) {
-      if (started.has(name)) {
-        continue; // Already started as a dependency
+    // Check dependents
+    const entry = this.services.get(name);
+    if (!options.force && entry && entry.dependents.size > 0) {
+      const runningDependents = [];
+      for (const dep of entry.dependents) {
+        if (await this.isRunning(dep)) {
+          runningDependents.push(dep);
+        }
       }
 
-      const success = await this.startService(name);
-
-      if (success) {
-        started.add(name);
-      } else {
-        allSuccessful = false;
-        this.logger.error(`Failed to start service '${name}'`);
+      if (runningDependents.length > 0) {
+        this.logger.warn(
+          `Cannot stop '${name}' - required by: ${runningDependents.join(', ')}`
+        );
+        return false;
       }
     }
 
-    if (allSuccessful) {
-      this.logger.info('All services started successfully');
-    } else {
-      this.logger.error('Some services failed to start');
-    }
-
-    return allSuccessful;
+    return await instance.stop(options);
   }
 
   /**
-   * Stop a specific service and services that depend on it
+   * Recover a service from error state
    *
    * @param {string} name - Service name
-   * @param {Object} [options] - Stop options
-   * @param {boolean} [options.force=false] - Force stop even with dependents
-   * @returns {Promise<boolean>} True if stop was successful
    *
-   * @example
-   * await manager.stopService('database');
+   * @returns {Promise<boolean>} True if recovery succeeded
    */
-  async stopService(name, options = {}) {
-    const { force = false } = options;
-    const entry = this.services.get(name);
+  async recoverService(name) {
+    const instance = this.get(name);
+    if (!instance) return false;
 
-    if (!entry) {
-      this.logger.error(`Cannot stop unknown service '${name}'`);
-      return false;
-    }
-
-    // Check if already stopped
-    if (entry.instance.state !== RUNNING) {
-      this.logger.debug(`Service '${name}' is not running`);
-      return true;
-    }
+    return await instance.recover();
+  }
 
-    // Find services that depend on this one
-    const dependents = [];
-    for (const [serviceName, serviceEntry] of this.services.entries()) {
-      if (serviceEntry.dependencies.includes(name) &&
-          serviceEntry.instance.state === RUNNING) {
-        dependents.push(serviceName);
-      }
-    }
+  /**
+   * Start all registered services in dependency order
+   *
+   * @returns {Promise<Object<string, boolean>>} Map of service results
+   */
+  async startAll() {
+    this.logger.info('Starting all services');
 
-    // If there are dependents, stop them first or fail if not forced
-    if (dependents.length > 0) {
-      if (!force) {
-        this.logger.error(
-          `Cannot stop service '${name}': ` +
-          `other services depend on it: ${dependents.join(', ')}`
-        );
-        return false;
-      }
+    // Sort by priority and dependencies
+    const sorted = this._topologicalSort();
+    const results = new Map();
 
-      this.logger.warn(
-        `Force stopping service '${name}' with dependents: ` +
-        dependents.join(', ')
-      );
+    for (const name of sorted) {
+      const success = await this.startService(name);
+      results.set(name, success);
 
-      // Stop all dependents first
-      for (const dependent of dependents) {
-        const success = await this.stopService(dependent, { force });
-        if (!success) {
-          this.logger.error(
-            `Failed to stop dependent service '${dependent}'`
-          );
-          return false;
+      if (!success) {
+        this.logger.error(`Failed to start '${name}', stopping`);
+        // Mark remaining services as not started
+        for (const remaining of sorted) {
+          if (!results.has(remaining)) {
+            results.set(remaining, false);
+          }
         }
+        break;
       }
     }
 
-    // Stop this service
-    this.logger.debug(`Stopping service '${name}'`);
-    const result = await entry.instance.stop();
-
-    if (result) {
-      this.logger.info(`Service '${name}' stopped`);
-    } else {
-      this.logger.error(`Service '${name}' failed to stop`);
-    }
-
-    return result;
+    return Object.fromEntries(results);
   }
 
   /**
    * Stop all services in reverse dependency order
    *
-   * @param {Object} [options] - Stop options
-   * @param {boolean} [options.force=false] - Force stop even with errors
-   * @returns {Promise<boolean>} True if all services stopped successfully
+   * @param {StopOptions} [options={}] - Stop options
    *
-   * @example
-   * await manager.stopAll();
+   * @returns {Promise<Object<string, boolean>>} Map of service results
    */
   async stopAll(options = {}) {
-    const { force = false } = options;
-    let allSuccessful = true;
-
     this.logger.info('Stopping all services');
 
-    // Get reverse dependency order
-    const orderedServices = this._getStartOrder().reverse();
-
-    // Stop services in reverse order
-    for (const name of orderedServices) {
-      const entry = this.services.get(name);
-
-      if (entry.instance.state === RUNNING) {
-        const success = await this.stopService(name, { force: true });
+    const stopOptions = {
+      timeout: options.timeout || this.config.stopTimeout,
+      force: options.force || false
+    };
 
-        if (!success) {
-          this.logger.error(`Failed to stop service '${name}'`);
-          allSuccessful = false;
+    // Stop in reverse order
+    const sorted = this._topologicalSort().reverse();
+    const results = new Map();
+
+    // Handle global timeout if specified
+    if (stopOptions.timeout > 0) {
+      const timeoutPromise = new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error('Global shutdown timeout')),
+          stopOptions.timeout
+        )
+      );
 
-          if (!force) {
-            break;
+      try {
+        // Race between stopping all services and timeout
+        await Promise.race([
+          this._stopAllSequentially(sorted, results, stopOptions),
+          timeoutPromise
+        ]);
+      } catch (error) {
+        if (error.message === 'Global shutdown timeout') {
+          this.logger.error('Global shutdown timeout reached');
+          // Mark any remaining services as failed
+          for (const name of sorted) {
+            if (!results.has(name)) {
+              results.set(name, false);
+            }
           }
+        } else {
+          throw error;
         }
       }
-    }
-
-    if (allSuccessful) {
-      this.logger.info('All services stopped successfully');
     } else {
-      this.logger.error('Some services failed to stop');
+      // No timeout, just stop sequentially
+      await this._stopAllSequentially(sorted, results, stopOptions);
     }
 
-    return allSuccessful;
+    return Object.fromEntries(results);
   }
 
   /**
-   * Destroy a service and remove it from the manager
-   *
-   * @param {string} name - Service name
-   * @param {Object} [options] - Destroy options
-   * @param {boolean} [options.force=false] - Force destroy even with dependents
-   * @returns {Promise<boolean>} True if service was destroyed
+   * Stop services sequentially
    *
-   * @example
-   * await manager.destroyService('api');
+   * @private
+   * @param {string[]} serviceNames - Ordered list of service names
+   * @param {Map<string, boolean>} results - Results map to populate
+   * @param {StopOptions} options - Stop options
    */
-  async destroyService(name, options = {}) {
-    const { force = false } = options;
-    const entry = this.services.get(name);
-
-    if (!entry) {
-      this.logger.error(`Cannot destroy unknown service '${name}'`);
-      return false;
-    }
-
-    // If running, stop first
-    if (entry.instance.state === RUNNING) {
-      const stopSuccess = await this.stopService(name, { force });
-      if (!stopSuccess) {
-        return false;
+  async _stopAllSequentially(serviceNames, results, options) {
+    for (const name of serviceNames) {
+      try {
+        const success = await this.stopService(name, options);
+        results.set(name, success);
+      } catch (error) {
+        this.logger.error(`Error stopping '${name}'`, error);
+        results.set(name, false);
       }
     }
-
-    // Check for dependents
-    const dependents = [];
-    for (const [serviceName, serviceEntry] of this.services.entries()) {
-      if (serviceEntry.dependencies.includes(name)) {
-        dependents.push(serviceName);
-      }
-    }
-
-    if (dependents.length > 0 && !force) {
-      this.logger.error(
-        `Cannot destroy service '${name}': ` +
-        `other services depend on it: ${dependents.join(', ')}`
-      );
-      return false;
-    }
-
-    // Destroy the service
-    this.logger.debug(`Destroying service '${name}'`);
-    const result = await entry.instance.destroy();
-
-    if (result) {
-      this.logger.info(`Service '${name}' destroyed`);
-
-      // Unregister after successful destruction
-      this.unregister(name);
-    } else {
-      this.logger.error(`Service '${name}' failed to destroy`);
-    }
-
-    return result;
   }
 
   /**
-   * Destroy all services and shutdown the manager
+   * Get health status for all services
    *
-   * @param {Object} [options] - Destroy options
-   * @param {boolean} [options.force=false] - Force destroy even with errors
-   * @returns {Promise<boolean>} True if all services were destroyed
-   *
-   * @example
-   * await manager.destroyAll();
+   * @returns {Promise<HealthCheckResult>} Health status for all services
    */
-  async destroyAll(options = {}) {
-    const { force = false } = options;
-    let allSuccessful = true;
-
-    this.logger.info('Destroying all services');
+  async checkHealth() {
+    const health = {};
 
-    // Get reverse dependency order
-    const orderedServices = this._getStartOrder().reverse();
-
-    // Destroy services in reverse order
-    for (const name of orderedServices) {
-      if (this.services.has(name)) {
-        const success = await this.destroyService(name, { force: true });
-
-        if (!success) {
-          this.logger.error(`Failed to destroy service '${name}'`);
-          allSuccessful = false;
-
-          if (!force) {
-            break;
-          }
-        }
+    for (const [name, entry] of this.services) {
+      if (entry.instance) {
+        health[name] = await entry.instance.getHealth();
+      } else {
+        health[name] = {
+          name,
+          state: 'NOT_CREATED',
+          healthy: false
+        };
       }
     }
 
-    // Clean up
-    this.services.clear();
-    this.dependencyGraph.clear();
-    this.events.removeAllListeners();
-
-    this.logger.info('Service manager shut down');
-
-    return allSuccessful;
+    return health;
   }
 
   /**
-   * Recover a service and its dependencies from error state
+   * Check if a service is currently running
    *
    * @param {string} name - Service name
-   * @param {Object} [options] - Recovery options
-   * @param {boolean} [options.recursive=true] - Recursively recover dependencies
-   * @param {boolean} [options.autoStart=true] - Auto-start service after recovery
-   * @returns {Promise<boolean>} True if recovery was successful
-   *
-   * @example
-   * // Recover a service and its dependencies
-   * await manager.recoverService('api');
    *
-   * // Recover just this service without auto-starting
-   * await manager.recoverService('database', {
-   *   recursive: false,
-   *   autoStart: false
-   * });
+   * @returns {Promise<boolean>} True if service is running
    */
-  async recoverService(name, options = {}) {
-    const {
-      recursive = true,
-      autoStart = true
-    } = options;
-
-    const entry = this.services.get(name);
-
-    if (!entry) {
-      this.logger.error(`Cannot recover unknown service '${name}'`);
-      return false;
-    }
-
-    // Only proceed if service is in ERROR state
-    if (entry.instance.state !== ERROR) {
-      this.logger.debug(
-        `Service '${name}' is not in ERROR state (current: ${entry.instance.state})`
-      );
-      return true; // Not an error, already in a valid state
-    }
-
-    // First recover dependencies if needed
-    if (recursive) {
-      // Build dependency recovery order
-      const recoveryOrder = [];
-      const visited = new Set();
-
-      const visitDependencies = (serviceName) => {
-        if (visited.has(serviceName)) return;
-        visited.add(serviceName);
-
-        const deps = this.services.get(serviceName)?.dependencies || [];
-        for (const dep of deps) {
-          visitDependencies(dep);
-        }
-
-        recoveryOrder.push(serviceName);
-      };
-
-      // Visit all dependencies first
-      for (const dep of entry.dependencies) {
-        visitDependencies(dep);
-      }
-
-      // Recover dependencies in the correct order
-      for (const depName of recoveryOrder) {
-        if (depName === name) continue; // Skip self
-
-        const depEntry = this.services.get(depName);
-        if (!depEntry) continue;
-
-        if (depEntry.instance.state === ERROR) {
-          this.logger.info(
-            `Recovering dependency '${depName}' for service '${name}'`
-          );
-
-          const success = await this.recoverService(depName, options);
-          if (!success) {
-            this.logger.error(
-              `Failed to recover dependency '${depName}' for '${name}'`
-            );
-            return false;
-          }
-        }
-      }
-    }
-
-    // Now recover this service
-    this.logger.debug(`Recovering service '${name}'`);
-    const result = await entry.instance.recover();
-
-    if (!result) {
-      this.logger.error(`Failed to recover service '${name}'`);
-      return false;
-    }
-
-    this.logger.info(`Service '${name}' recovered successfully`);
-
-    // Auto-start if requested and all dependencies are running
-    if (autoStart) {
-      const canStart = entry.dependencies.every(dep => {
-        const depEntry = this.services.get(dep);
-        return depEntry && depEntry.instance.state === RUNNING;
-      });
-
-      if (canStart) {
-        this.logger.debug(`Auto-starting recovered service '${name}'`);
-        return await this.startService(name);
-      }
-    }
-
-    return true;
+  async isRunning(name) {
+    const instance = this.get(name);
+    return instance ? instance.state === RUNNING : false;
   }
 
   /**
-   * Recover all services in dependency order
-   *
-   * @param {Object} [options] - Recovery options
-   * @param {boolean} [options.autoStart=true] - Auto-start services after recovery
-   * @returns {Promise<boolean>} True if all recoveries were successful
+   * Set log level for a service or globally
    *
-   * @example
-   * // Recover all services and auto-start them
-   * await manager.recoverAll();
-   *
-   * // Recover all services without auto-starting
-   * await manager.recoverAll({ autoStart: false });
+   * @param {string} name - Service name or '*' for global
+   * @param {string} level - Log level to set
    */
-  async recoverAll(options = {}) {
-    let allSuccessful = true;
-    const { autoStart = true } = options;
-
-    this.logger.info('Recovering all services');
-
-    // Find services in ERROR state
-    const errorServices = [];
-    for (const [name, entry] of this.services.entries()) {
-      if (entry.instance.state === ERROR) {
-        errorServices.push(name);
-      }
-    }
-
-    if (errorServices.length === 0) {
-      this.logger.info('No services in ERROR state');
-      return true;
-    }
-
-    // Get dependency ordered list
-    const orderedServices = this._getStartOrder();
-
-    // Recover services in order
-    for (const name of orderedServices) {
-      const entry = this.services.get(name);
-
-      if (entry.instance.state === ERROR) {
-        const success = await this.recoverService(name, {
-          recursive: false, // Already handling order here
-          autoStart
-        });
-
-        if (!success) {
-          allSuccessful = false;
-          this.logger.error(`Failed to recover service '${name}'`);
+  setLogLevel(name, level) {
+    if (name === '*') {
+      // Global level
+      this.config.logConfig.globalLevel = level;
+
+      // Apply to all existing services
+      // eslint-disable-next-line no-unused-vars
+      for (const [_, entry] of this.services) {
+        if (entry.instance) {
+          entry.instance.setLogLevel(level);
         }
       }
-    }
-
-    if (allSuccessful) {
-      this.logger.info('All services recovered successfully');
-
-      // If auto-start enabled, start services that weren't auto-started
-      if (autoStart) {
-        await this.startAll();
-      }
-    } else {
-      this.logger.error('Some services failed to recover');
-    }
-
-    return allSuccessful;
-  }
-
-  /**
-   * Set log level for a specific service or all services
-   *
-   * @param {string} level - New log level
-   * @param {string} [serviceName] - Service to set level for, or all if omitted
-   * @returns {boolean} True if level was set successfully
-   *
-   * @example
-   * // Set level for specific service
-   * manager.setLogLevel(DEBUG, 'database');
-   *
-   * // Set level for all services including manager
-   * manager.setLogLevel(INFO);
-   */
-  setLogLevel(level, serviceName) {
-    if (serviceName) {
-      // Set for specific service
-      const entry = this.services.get(serviceName);
-      if (!entry) {
-        this.logger.error(`Cannot set log level for unknown service '${serviceName}'`);
-        return false;
-      }
-
-      return entry.instance.setLogLevel(level);
     } else {
-      // Set for all services and manager
-      let allSuccess = true;
-
-      // Set for the manager
-      if (!this.logger.setLevel(level)) {
-        allSuccess = false;
+      // Service-specific level
+      if (!this.config.logConfig.serviceLevels) {
+        this.config.logConfig.serviceLevels = {};
       }
+      this.config.logConfig.serviceLevels[name] = level;
 
-      // Set for all services
-      for (const [name, entry] of this.services.entries()) {
-        if (!entry.instance.setLogLevel(level)) {
-          this.logger.warn(`Failed to set log level for service '${name}'`);
-          allSuccess = false;
-        }
+      // Apply to existing instance
+      const instance = this.get(name);
+      if (instance) {
+        instance.setLogLevel(level);
       }
-
-      return allSuccess;
     }
   }
 
   /**
-   * Get the names of all registered services
+   * Get all services with a specific tag
    *
-   * @returns {string[]} List of service names
+   * @param {string} tag - Tag to filter by
    *
-   * @example
-   * const services = manager.getServiceNames();
-   * console.log(`Registered services: ${services.join(', ')}`);
+   * @returns {string[]} Array of service names
    */
-  getServiceNames() {
-    return Array.from(this.services.keys());
-  }
-
-  /**
-   * Get service status information
-   *
-   * @param {string} [name] - Service name, or all if omitted
-   * @returns {Object|Array|null} Service status or null if not found
-   *
-   * @example
-   * // Get status for all services
-   * const allStatus = manager.getServiceStatus();
-   *
-   * // Get status for specific service
-   * const dbStatus = manager.getServiceStatus('database');
-   * console.log(`Database state: ${dbStatus.state}`);
-   */
-  getServiceStatus(name) {
-    if (name) {
-      // Get status for specific service
-      const entry = this.services.get(name);
-      if (!entry) {
-        return null;
-      }
-
-      return {
-        name,
-        state: entry.instance.state,
-        dependencies: entry.dependencies,
-        error: entry.instance.error ? entry.instance.error.message : null
-      };
-    } else {
-      // Get status for all services
-      const statuses = [];
-
-      for (const [name, entry] of this.services.entries()) {
-        statuses.push({
-          name,
-          state: entry.instance.state,
-          dependencies: entry.dependencies,
-          error: entry.instance.error ? entry.instance.error.message : null
-        });
+  getServicesByTag(tag) {
+    const services = [];
+    for (const [name, entry] of this.services) {
+      if (entry.tags.includes(tag)) {
+        services.push(name);
       }
-
-      return statuses;
     }
+    return services;
   }
 
   // Private methods
 
   /**
-   * Handle state change events from services
+   * Setup logging configuration based on config.dev
    *
    * @private
-   * @param {string} serviceName - Service name
-   * @param {Object} event - State change event
    */
-  _handleStateChanged(serviceName, event) {
-    const { oldState, newState } = event;
-
-    this.logger.debug(
-      `Service '${serviceName}' state changed: ${oldState} -> ${newState}`
-    );
-
-    // Emit specific state events
-    this._emit('service:stateChanged', {
-      service: serviceName,
-      oldState,
-      newState
-    });
+  _setupLogging() {
+    // Set default log levels based on config.debug flag
+    if (this.config.debug) {
+      this.config.logConfig.defaultLevel = DEBUG;
+    } else {
+      this.config.logConfig.defaultLevel = WARN;
+    }
 
-    // Emit events for specific states
-    if (newState === INITIALIZED) {
-      this._emit('service:initialized', { service: serviceName });
-    } else if (newState === RUNNING) {
-      this._emit('service:started', { service: serviceName });
-    } else if (newState === STOPPED) {
-      this._emit('service:stopped', { service: serviceName });
-    } else if (newState === DESTROYED) {
-      this._emit('service:destroyed', { service: serviceName });
-    } else if (newState === ERROR) {
-      this._emit('service:error', {
-        service: serviceName,
-        error: this.services.get(serviceName).instance.error
-      });
-    } else if (newState === RECOVERING) {
-      this._emit('service:recovering', { service: serviceName });
+    // Apply config
+    if (this.config.logConfig.globalLevel) {
+      this.logger.setLevel(this.config.logConfig.globalLevel);
     }
   }
 
   /**
-   * Handle error events from services
+   * Get the appropriate log level for a service
    *
    * @private
-   * @param {string} serviceName - Service name
-   * @param {Object} event - Error event
-   */
-  _handleError(serviceName, event) {
-    const { operation, error } = event;
-
-    this.logger.error(
-      `Service '${serviceName}' error during ${operation}`,
-    );
-
-    this._emit('service:error', {
-      service: serviceName,
-      operation,
-      error
-    });
-  }
-
-  /**
-   * Update the dependency graph
+   * @param {string} name - Service name
    *
-   * @private
+   * @returns {string|undefined} Log level or undefined
    */
-  _updateDependencyGraph() {
-    this.dependencyGraph.clear();
+  _getServiceLogLevel(name) {
+    const config = this.config.logConfig;
 
-    // Add all services to the graph
-    for (const name of this.services.keys()) {
-      this.dependencyGraph.set(name, new Set());
+    // Check in order of precedence:
+    // 1. Global level (overrides everything)
+    if (config.globalLevel) {
+      return config.globalLevel;
     }
 
-    // Add dependencies
-    for (const [name, entry] of this.services.entries()) {
-      for (const dep of entry.dependencies) {
-        this.dependencyGraph.get(name).add(dep);
-      }
+    // 2. Service-specific level
+    if (config.serviceLevels?.[name]) {
+      return config.serviceLevels[name];
     }
 
-    // Check for circular dependencies
-    this._checkForCircularDependencies();
+    // 3. Don't use defaultLevel as it might be too restrictive
+    // Return undefined to let the service use its own default
+    return undefined;
   }
 
   /**
-   * Check for circular dependencies in the graph
+   * Attach event listeners to forward service events
    *
    * @private
+   * @param {string} name - Service name
+   * @param {import('./typedef.js').ServiceBase} instance
+   *   Service instance
    */
-  _checkForCircularDependencies() {
-    const visited = new Set();
-    const recursionStack = new Set();
-
-    const checkNode = (node) => {
-      if (!visited.has(node)) {
-        visited.add(node);
-        recursionStack.add(node);
-
-        const dependencies = this.dependencyGraph.get(node);
-        if (dependencies) {
-          for (const dep of dependencies) {
-            if (!visited.has(dep) && checkNode(dep)) {
-              return true;
-            } else if (recursionStack.has(dep)) {
-              this.logger.error(
-                `Circular dependency detected: ` +
-                `'${node}' -> '${dep}'`
-              );
-              return true;
-            }
-          }
-        }
-      }
+  _attachServiceEvents(name, instance) {
+    // Forward service events
+    instance.on('stateChanged', (data) => {
+      this.emit('service:stateChanged', { ...data, service: name });
+    });
 
-      recursionStack.delete(node);
-      return false;
-    };
+    instance.on('healthChanged', (data) => {
+      this.emit('service:healthChanged', { ...data, service: name });
+    });
 
-    for (const node of this.dependencyGraph.keys()) {
-      if (checkNode(node)) {
-        break;
-      }
-    }
+    instance.on('error', (data) => {
+      this.emit('service:error', { ...data, service: name });
+    });
+
+    // Forward log events
+    instance.logger.on('log', (logEvent) => {
+      this.emit('service:log', { ...logEvent, service: name });
+    });
   }
 
   /**
-   * Get optimal service start order based on dependencies
+   * Sort services by dependencies using topological sort
    *
    * @private
-   * @returns {string[]} Services in dependency order
+   *
+   * @returns {string[]} Service names in dependency order
+   * @throws {Error} If circular dependencies are detected
    */
-  _getStartOrder() {
+  _topologicalSort() {
+    const sorted = [];
     const visited = new Set();
-    const result = [];
+    const visiting = new Set();
 
-    const visit = (node) => {
-      if (visited.has(node)) return;
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        throw new Error(`Circular dependency detected involving '${name}'`);
+      }
 
-      visited.add(node);
+      visiting.add(name);
 
-      const dependencies = this.dependencyGraph.get(node);
-      if (dependencies) {
-        for (const dep of dependencies) {
+      const entry = this.services.get(name);
+      if (entry) {
+        for (const dep of entry.dependencies) {
           visit(dep);
         }
       }
 
-      result.push(node);
+      visiting.delete(name);
+      visited.add(name);
+      sorted.push(name);
     };
 
-    // Visit all nodes
-    for (const node of this.dependencyGraph.keys()) {
-      visit(node);
+    // Visit all services
+    for (const name of this.services.keys()) {
+      visit(name);
     }
 
-    return result;
+    return sorted;
   }
 }
+
+export default ServiceManager;