@goatlab/node-backend 0.2.6 → 0.4.0

package/README.md

@@ -62,38 +62,88 @@ const result = await cache.remember('expensive-op', 300000, async () => {
 
 ## Secret Management
 
-The `SecretService` provides secure secret management with support for multiple backends:
+The `SecretService` provides secure secret management with support for multiple backends and preloading:
 
 ```typescript
 import { SecretService } from '@goatlab/node-backend'
 
-// File-based encrypted secrets
-const fileSecrets = new SecretService('FILE', '/path/to/secrets.json')
+// File-based encrypted secrets with TTL caching
+const fileSecrets = new SecretService({
+  provider: 'FILE',
+  location: '/path/to/secrets.json',
+  encryptionKey: process.env.ENCRYPTION_KEY,
+  cacheTTL: 300000 // 5 minutes (optional, default: 5 minutes)
+})
 
 // HashiCorp Vault integration
-const vaultSecrets = new SecretService('VAULT', 'my-app/secrets')
+const vaultSecrets = new SecretService({
+  provider: 'VAULT',
+  location: 'my-app/secrets',
+  encryptionKey: process.env.ENCRYPTION_KEY
+})
 
-// Environment variables (new!)
-const envSecrets = new SecretService('ENV', 'APP') // Loads APP_* env vars
-const allEnvSecrets = new SecretService('ENV', '') // Loads all env vars
+// Environment variables
+const envSecrets = new SecretService({
+  provider: 'ENV',
+  location: 'APP', // Loads APP_* env vars
+  encryptionKey: process.env.ENCRYPTION_KEY // Now supports encryption for all providers
+})
 
-// Usage
-await fileSecrets.loadSecrets()
-const apiKey = await fileSecrets.getSecret('API_KEY')
-const config = await fileSecrets.getSecretJson('CONFIG')
+// Preload secrets for synchronous access (new!)
+await fileSecrets.preload()
+const apiKey = fileSecrets.getSecretSync('API_KEY') // Synchronous!
+const config = fileSecrets.getSecretJsonSync('CONFIG') // Synchronous!
+
+// Async operations still available
+const apiKeyAsync = await fileSecrets.getSecret('API_KEY')
+const configAsync = await fileSecrets.getSecretJson('CONFIG')
 
 // Store secrets (FILE and VAULT providers)
 await fileSecrets.storeSecrets({ API_KEY: 'secret-value' })
+
+// Manual cache cleanup
+SecretService.cleanupExpiredCache()
+
+// Dispose when done (stops file watching)
+fileSecrets.dispose()
 ```
 
 ### Secret Provider Features
 
-- **FILE**: Encrypted local file storage using AES encryption
+- **FILE**: Encrypted local file storage using AES encryption with file watching
 - **VAULT**: HashiCorp Vault integration with automatic token management  
-- **ENV**: Runtime environment variable access with optional prefix filtering
-- **Caching**: Automatic in-memory caching for improved performance
+- **ENV**: Runtime environment variable access with encryption support
+- **Preloading**: Load secrets once async, access synchronously afterward
+- **Per-Tenant Encryption**: Each tenant can have its own encryption key
+- **Automatic Invalidation**: File changes trigger automatic reload (FILE provider)
+- **TTL Caching**: Configurable time-to-live caching with automatic expiration
 - **Type Safety**: Generic type support for JSON secrets
 
+### Preloading Pattern with Container
+
+```typescript
+const container = new Container(factories, async (preload, meta) => {
+  // Create and preload secret service
+  const secretService = preload.secrets(meta.tenantId, {
+    provider: 'FILE',
+    location: meta.secretsLocation,
+    encryptionKey: meta.encryptionKey
+  })
+  
+  await secretService.preload() // Load once async
+  
+  // Use sync methods for instant access
+  const dbUrl = secretService.getSecretSync('DATABASE_URL')
+  const apiKey = secretService.getSecretSync('API_KEY')
+  
+  // Create other services with preloaded secrets
+  const database = preload.database(meta.tenantId, { url: dbUrl })
+  const api = preload.api(meta.tenantId, { apiKey })
+  
+  return { secrets: secretService, database, api }
+})
+```
+
 ## Express + tRPC Integration
 
 Helper for creating Express applications with tRPC integration:
@@ -117,6 +167,88 @@ const app = getExpressTrpcApp({
 })
 ```
 
+### Performance Features (New!)
+
+- **Optimized Compression**: Automatically skips compression for small responses (<1KB), SSE, WebSocket upgrades, and pre-compressed content
+- **Memory Monitoring**: Built-in middleware tracks heap usage and triggers garbage collection when needed
+- **Smart Rate Limiting**: Different limits for auth endpoints, API endpoints, and general routes
+
+## Container - Dependency Injection
+
+Multi-tenant dependency injection container with performance optimizations:
+
+```typescript
+import { Container } from '@goatlab/node-backend'
+
+// Define your service factories
+const factories = {
+  database: DatabaseService,
+  api: ApiService,
+  cache: CacheService
+}
+
+// Create container with initializer
+const container = new Container(factories, async (preload, tenantMeta) => {
+  const db = preload.database(tenantMeta.id, tenantMeta.dbConfig)
+  const cache = preload.cache(tenantMeta.id)
+  
+  return {
+    database: db,
+    api: preload.api(tenantMeta.id, db),
+    cache
+  }
+})
+
+// Bootstrap for a tenant
+await container.bootstrap(tenantMeta, async () => {
+  const { database, api } = container.context
+  // Use services...
+})
+
+// Batch operations (new!)
+const results = await container.bootstrapBatch([
+  { metadata: tenant1, fn: processTenant1 },
+  { metadata: tenant2, fn: processTenant2 }
+], {
+  concurrency: 10,
+  continueOnError: true,
+  onProgress: (completed, total) => console.log(`${completed}/${total}`)
+})
+
+// Batch cache invalidation (new!)
+await container.invalidateTenantBatch(['tenant1', 'tenant2', 'tenant3'])
+```
+
+### Container Features
+
+- **Multi-tenancy**: Isolated service instances per tenant
+- **Batch Operations**: Process multiple tenants in parallel with concurrency control
+- **Performance Metrics**: Built-in performance tracking and statistics
+- **Cache Management**: Efficient caching with batch invalidation support
+- **Type Safety**: Full TypeScript support with inference
+
+## Translation Service
+
+High-performance translation service with template caching:
+
+```typescript
+import { translationService } from '@goatlab/node-backend'
+
+// Translations are automatically loaded and cached
+const greeting = translationService.translate('welcome', { language: 'es' })
+
+// With template parameters
+const message = translationService.translate('user.greeting', 
+  { language: 'en' }, 
+  { name: 'John' }
+)
+
+// Performance optimized with:
+// - Compiled template caching
+// - Locale preloading at startup
+// - In-memory locale storage
+```
+
 ## Testing Utilities
 
 Comprehensive testing setup with testcontainers support:

package/dist/container/Container.d.ts

@@ -1,4 +1,4 @@
-import { ContainerOptions, InstancesStructure, PreloadStructure } from './types';
+import { ContainerOptions, InstancesStructure, PreloadStructure, BatchBootstrapOptions, BatchBootstrapResult, BatchInvalidationResult } from './types';
 /**
  * ═══════════════════════════════════════════════════════════════════════════════
  * 🏗️ MULTI-TENANT DEPENDENCY INJECTION CONTAINER
@@ -128,7 +128,7 @@ export declare class Container<Defs extends Record<string, unknown>, TenantMetad
     private readonly initializerCache;
     /**
      * High-performance metrics using Uint32Array for better JIT optimization
-     * Indices: [hits, misses, creates, ctx, proxy, initHits, resets]
+     * Indices: [hits, misses, creates, ctx, proxy, initHits, resets, batchOps, batchErrors]
      * Auto-wraps at 2^32 without overflow checks for maximum performance
      */
     private readonly metrics;
@@ -285,6 +285,85 @@ export declare class Container<Defs extends Record<string, unknown>, TenantMetad
         instances: InstancesStructure<Defs>;
         result?: T;
     }>;
+    /**
+     * Bootstrap multiple tenants in parallel with controlled concurrency
+     *
+     * This method enables efficient initialization of multiple tenants while:
+     * - Controlling concurrency to avoid overwhelming the system
+     * - Isolating errors so one failure doesn't affect others
+     * - Providing progress tracking for long-running operations
+     * - Collecting performance metrics for each operation
+     *
+     * @param tenantBatch - Array of tenant metadata and optional functions to execute
+     * @param options - Options for controlling the batch operation
+     * @returns Array of results for each tenant, including successes and failures
+     *
+     * ```typescript
+     * const results = await container.bootstrapBatch([
+     *   { metadata: tenant1Meta, fn: async () => processТenant1() },
+     *   { metadata: tenant2Meta, fn: async () => processTenant2() },
+     *   { metadata: tenant3Meta } // No function, just bootstrap
+     * ], {
+     *   concurrency: 5,
+     *   continueOnError: true,
+     *   onProgress: (completed, total) => console.log(`${completed}/${total}`)
+     * })
+     *
+     * // Process results
+     * for (const result of results) {
+     *   if (result.status === 'success') {
+     *     console.log(`Tenant ${result.metadata.id} initialized in ${result.metrics.duration}ms`)
+     *   } else {
+     *     console.error(`Tenant ${result.metadata.id} failed:`, result.error)
+     *   }
+     * }
+     * ```
+     */
+    bootstrapBatch<TMetadata = unknown, T = unknown>(tenantBatch: Array<{
+        metadata: TMetadata;
+        fn?: () => Promise<T>;
+    }>, options?: BatchBootstrapOptions<TMetadata>): Promise<Array<BatchBootstrapResult<Defs, TMetadata, T>>>;
+    /**
+     * Invalidate multiple tenant caches in batch
+     *
+     * Efficiently invalidates caches for multiple tenants with proper disposal
+     * and error handling. Useful for bulk updates or maintenance operations.
+     *
+     * @param tenantIds - Array of tenant IDs to invalidate
+     * @param reason - Optional reason for invalidation (for logging)
+     * @param distributed - Whether to propagate invalidation to other instances
+     * @returns Summary of the batch invalidation operation
+     *
+     * ```typescript
+     * const result = await container.invalidateTenantBatch(
+     *   ['tenant1', 'tenant2', 'tenant3'],
+     *   'Bulk configuration update',
+     *   true // Distribute to other instances
+     * )
+     *
+     * console.log(`Invalidated ${result.succeeded}/${result.total} tenants`)
+     * if (result.failed > 0) {
+     *   console.error('Failed invalidations:', result.errors)
+     * }
+     * ```
+     */
+    invalidateTenantBatch(tenantIds: string[], reason?: string, distributed?: boolean): Promise<BatchInvalidationResult>;
+    /**
+     * Invalidate multiple service caches in batch
+     *
+     * @param serviceTypes - Array of service types to invalidate
+     * @param reason - Optional reason for invalidation
+     * @param distributed - Whether to propagate invalidation
+     * @returns Summary of the batch invalidation operation
+     *
+     * ```typescript
+     * const result = await container.invalidateServiceBatch(
+     *   ['database', 'api.users', 'api.auth'],
+     *   'Service configuration update'
+     * )
+     * ```
+     */
+    invalidateServiceBatch(serviceTypes: string[], reason?: string, distributed?: boolean): Promise<BatchInvalidationResult>;
     /**
      * Get current performance metrics
      * Converts Uint32Array back to object format for compatibility
@@ -296,6 +375,8 @@ export declare class Container<Defs extends Record<string, unknown>, TenantMetad
         contextAccesses: number;
         proxyCacheHits: number;
         initializerCacheHits: number;
+        batchOperations: number;
+        batchErrors: number;
     };
     /**
      * Reset all performance metrics to zero
@@ -374,12 +455,15 @@ export declare class Container<Defs extends Record<string, unknown>, TenantMetad
         initializerCacheSize: number;
         initializerPromisesSize: number;
         cacheHitRatio: number;
+        batchSuccessRatio: number;
         cacheHits: number;
         cacheMisses: number;
         instanceCreations: number;
         contextAccesses: number;
         proxyCacheHits: number;
         initializerCacheHits: number;
+        batchOperations: number;
+        batchErrors: number;
     };
     /**
      * Check if there's an active tenant context

package/dist/container/Container.js

@@ -147,10 +147,10 @@ class Container {
     // ═══════════════════════════════════════════════════════════════════════════
     /**
      * High-performance metrics using Uint32Array for better JIT optimization
-     * Indices: [hits, misses, creates, ctx, proxy, initHits, resets]
+     * Indices: [hits, misses, creates, ctx, proxy, initHits, resets, batchOps, batchErrors]
      * Auto-wraps at 2^32 without overflow checks for maximum performance
      */
-    metrics = new Uint32Array(7);
+    metrics = new Uint32Array(9);
     /**
      * Metric indices for Uint32Array
      */
@@ -162,6 +162,8 @@ class Container {
         PROXIES: 4,
         INIT_HITS: 5,
         RESETS: 6,
+        BATCH_OPS: 7,
+        BATCH_ERRORS: 8
     };
     /**
      * Legacy overflow threshold for test compatibility
@@ -176,11 +178,20 @@ class Container {
         if (!this.options.enableMetrics)
             return;
         // Check for test mock of MAX_METRIC_VALUE (legacy compatibility)
-        if (this.MAX_METRIC_VALUE < 1000 && this.metrics[idx] >= this.MAX_METRIC_VALUE) {
+        if (this.MAX_METRIC_VALUE < 1000 &&
+            this.metrics[idx] >= this.MAX_METRIC_VALUE) {
             // Legacy test behavior - reset metrics when mock threshold reached
             this.resetMetrics();
             if (this.options.enableDiagnostics) {
-                const metricNames = ['cacheHits', 'cacheMisses', 'instanceCreations', 'contextAccesses', 'proxyCacheHits', 'initializerCacheHits', 'resets'];
+                const metricNames = [
+                    'cacheHits',
+                    'cacheMisses',
+                    'instanceCreations',
+                    'contextAccesses',
+                    'proxyCacheHits',
+                    'initializerCacheHits',
+                    'resets'
+                ];
                 console.warn(`Container metrics reset due to overflow protection. Metric '${metricNames[idx] || 'unknown'}' reached ${this.metrics[idx]}`);
             }
         }
@@ -213,7 +224,7 @@ class Container {
             enableDiagnostics: false,
             enableDistributedInvalidation: false,
             distributedInvalidator: undefined,
-            ...options,
+            ...options
         };
         // Pre-cache factory lookups for better performance
         this.preloadFactoryCache();
@@ -323,7 +334,7 @@ class Container {
                 }
                 // No factory found - must be a nested path, return another proxy
                 return this.createPreloadProxy(newPath);
-            },
+            }
         });
         this.proxyCache.set(path, proxy);
         return proxy;
@@ -408,7 +419,7 @@ class Container {
                         // Property exists but is undefined - this is valid (e.g., optional services)
                         return undefined;
                     }
-                    // For symbols, especially well-known symbols like Symbol.iterator, 
+                    // For symbols, especially well-known symbols like Symbol.iterator,
                     // just return undefined instead of throwing an error
                     if (typeof prop === 'symbol') {
                         return undefined;
@@ -445,7 +456,7 @@ class Container {
                 }
                 // Return value as-is (primitives, functions, Promises, arrays)
                 return value;
-            },
+            }
         });
         // Cache using WeakMap for automatic garbage collection
         this.contextProxyCache.set(obj, proxy);
@@ -463,7 +474,7 @@ class Container {
     simpleHash(str) {
         let hash = 5381;
         for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) + hash) + str.charCodeAt(i);
+            hash = (hash << 5) + hash + str.charCodeAt(i);
         }
         return (hash >>> 0).toString(36);
     }
@@ -561,6 +572,240 @@ class Container {
         }
     }
     // ═══════════════════════════════════════════════════════════════════════════
+    // BATCH OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Bootstrap multiple tenants in parallel with controlled concurrency
+     *
+     * This method enables efficient initialization of multiple tenants while:
+     * - Controlling concurrency to avoid overwhelming the system
+     * - Isolating errors so one failure doesn't affect others
+     * - Providing progress tracking for long-running operations
+     * - Collecting performance metrics for each operation
+     *
+     * @param tenantBatch - Array of tenant metadata and optional functions to execute
+     * @param options - Options for controlling the batch operation
+     * @returns Array of results for each tenant, including successes and failures
+     *
+     * ```typescript
+     * const results = await container.bootstrapBatch([
+     *   { metadata: tenant1Meta, fn: async () => processТenant1() },
+     *   { metadata: tenant2Meta, fn: async () => processTenant2() },
+     *   { metadata: tenant3Meta } // No function, just bootstrap
+     * ], {
+     *   concurrency: 5,
+     *   continueOnError: true,
+     *   onProgress: (completed, total) => console.log(`${completed}/${total}`)
+     * })
+     *
+     * // Process results
+     * for (const result of results) {
+     *   if (result.status === 'success') {
+     *     console.log(`Tenant ${result.metadata.id} initialized in ${result.metrics.duration}ms`)
+     *   } else {
+     *     console.error(`Tenant ${result.metadata.id} failed:`, result.error)
+     *   }
+     * }
+     * ```
+     */
+    async bootstrapBatch(tenantBatch, options = {}) {
+        const { concurrency = 10, continueOnError = true, timeout, onProgress } = options;
+        const results = [];
+        const total = tenantBatch.length;
+        let completed = 0;
+        let shouldAbort = false;
+        // Process tenants in chunks based on concurrency limit
+        for (let i = 0; i < total; i += concurrency) {
+            // Check if we should abort due to previous error in fail-fast mode
+            if (shouldAbort) {
+                break;
+            }
+            const chunk = tenantBatch.slice(i, i + concurrency);
+            const chunkPromises = chunk.map(async ({ metadata, fn }) => {
+                const startTime = Date.now();
+                try {
+                    // Apply timeout if specified
+                    let bootstrapPromise = this.bootstrap(metadata, fn);
+                    if (timeout) {
+                        bootstrapPromise = Promise.race([
+                            bootstrapPromise,
+                            new Promise((_, reject) => setTimeout(() => reject(new Error(`Bootstrap timeout after ${timeout}ms`)), timeout))
+                        ]);
+                    }
+                    const { instances, result } = await bootstrapPromise;
+                    const endTime = Date.now();
+                    this.inc(Container.METRIC.BATCH_OPS);
+                    return {
+                        metadata,
+                        status: 'success',
+                        instances,
+                        result,
+                        metrics: {
+                            startTime,
+                            endTime,
+                            duration: endTime - startTime
+                        }
+                    };
+                }
+                catch (error) {
+                    const endTime = Date.now();
+                    this.inc(Container.METRIC.BATCH_ERRORS);
+                    if (this.options.enableDiagnostics) {
+                        console.error(`Batch bootstrap failed for tenant:`, metadata, error);
+                    }
+                    const result = {
+                        metadata,
+                        status: 'error',
+                        error: error instanceof Error ? error : new Error(String(error)),
+                        metrics: {
+                            startTime,
+                            endTime,
+                            duration: endTime - startTime
+                        }
+                    };
+                    if (!continueOnError) {
+                        // Mark that we should abort processing
+                        shouldAbort = true;
+                    }
+                    return result;
+                }
+                finally {
+                    completed++;
+                    onProgress?.(completed, total, metadata);
+                }
+            });
+            // Wait for current chunk to complete before starting next
+            const chunkResults = await Promise.allSettled(chunkPromises);
+            // Extract results from Promise.allSettled
+            for (const settledResult of chunkResults) {
+                if (settledResult.status === 'fulfilled') {
+                    results.push(settledResult.value);
+                }
+                else if (continueOnError) {
+                    // This shouldn't happen as we handle errors above, but just in case
+                    results.push({
+                        metadata: tenantBatch[results.length].metadata,
+                        status: 'error',
+                        error: settledResult.reason,
+                        metrics: {
+                            startTime: Date.now(),
+                            endTime: Date.now(),
+                            duration: 0
+                        }
+                    });
+                }
+            }
+            // Check if we had any errors and should fail fast
+            if (!continueOnError && results.some(r => r.status === 'error')) {
+                const errorResult = results.find(r => r.status === 'error');
+                throw errorResult?.error || new Error('Batch operation failed');
+            }
+        }
+        return results;
+    }
+    /**
+     * Invalidate multiple tenant caches in batch
+     *
+     * Efficiently invalidates caches for multiple tenants with proper disposal
+     * and error handling. Useful for bulk updates or maintenance operations.
+     *
+     * @param tenantIds - Array of tenant IDs to invalidate
+     * @param reason - Optional reason for invalidation (for logging)
+     * @param distributed - Whether to propagate invalidation to other instances
+     * @returns Summary of the batch invalidation operation
+     *
+     * ```typescript
+     * const result = await container.invalidateTenantBatch(
+     *   ['tenant1', 'tenant2', 'tenant3'],
+     *   'Bulk configuration update',
+     *   true // Distribute to other instances
+     * )
+     *
+     * console.log(`Invalidated ${result.succeeded}/${result.total} tenants`)
+     * if (result.failed > 0) {
+     *   console.error('Failed invalidations:', result.errors)
+     * }
+     * ```
+     */
+    async invalidateTenantBatch(tenantIds, reason, distributed = false) {
+        const result = {
+            total: tenantIds.length,
+            succeeded: 0,
+            failed: 0,
+            errors: []
+        };
+        // Process invalidations in parallel with error isolation
+        const invalidationPromises = tenantIds.map(async (tenantId) => {
+            try {
+                if (distributed) {
+                    await this.invalidateTenantDistributed(tenantId, reason);
+                }
+                else {
+                    this.invalidateTenantLocally(tenantId, reason);
+                }
+                result.succeeded++;
+            }
+            catch (error) {
+                result.failed++;
+                result.errors.push({
+                    key: tenantId,
+                    error: error instanceof Error ? error : new Error(String(error))
+                });
+                if (this.options.enableDiagnostics) {
+                    console.error(`Failed to invalidate tenant ${tenantId}:`, error);
+                }
+            }
+        });
+        await Promise.allSettled(invalidationPromises);
+        return result;
+    }
+    /**
+     * Invalidate multiple service caches in batch
+     *
+     * @param serviceTypes - Array of service types to invalidate
+     * @param reason - Optional reason for invalidation
+     * @param distributed - Whether to propagate invalidation
+     * @returns Summary of the batch invalidation operation
+     *
+     * ```typescript
+     * const result = await container.invalidateServiceBatch(
+     *   ['database', 'api.users', 'api.auth'],
+     *   'Service configuration update'
+     * )
+     * ```
+     */
+    async invalidateServiceBatch(serviceTypes, reason, distributed = false) {
+        const result = {
+            total: serviceTypes.length,
+            succeeded: 0,
+            failed: 0,
+            errors: []
+        };
+        const invalidationPromises = serviceTypes.map(async (serviceType) => {
+            try {
+                if (distributed) {
+                    await this.invalidateServiceDistributed(serviceType, reason);
+                }
+                else {
+                    this.invalidateServiceLocally(serviceType, reason);
+                }
+                result.succeeded++;
+            }
+            catch (error) {
+                result.failed++;
+                result.errors.push({
+                    key: serviceType,
+                    error: error instanceof Error ? error : new Error(String(error))
+                });
+                if (this.options.enableDiagnostics) {
+                    console.error(`Failed to invalidate service ${serviceType}:`, error);
+                }
+            }
+        });
+        await Promise.allSettled(invalidationPromises);
+        return result;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
     // 📊 OBSERVABILITY & DEBUGGING
     // ═══════════════════════════════════════════════════════════════════════════
     /**
@@ -575,6 +820,8 @@ class Container {
             contextAccesses: this.metrics[Container.METRIC.CONTEXTS],
             proxyCacheHits: this.metrics[Container.METRIC.PROXIES],
             initializerCacheHits: this.metrics[Container.METRIC.INIT_HITS],
+            batchOperations: this.metrics[Container.METRIC.BATCH_OPS],
+            batchErrors: this.metrics[Container.METRIC.BATCH_ERRORS]
         };
     }
     /**
@@ -780,7 +1027,7 @@ class Container {
                 : managerAny.size || 0;
             stats[key] = {
                 size,
-                maxSize: this.options.cacheSize,
+                maxSize: this.options.cacheSize
             };
         }
         return stats;
@@ -794,6 +1041,8 @@ class Container {
         const totalCacheSize = Object.values(cacheStats).reduce((sum, stat) => sum + stat.size, 0);
         const hits = this.metrics[Container.METRIC.HITS];
         const misses = this.metrics[Container.METRIC.MISSES];
+        const batchOps = this.metrics[Container.METRIC.BATCH_OPS];
+        const batchErrors = this.metrics[Container.METRIC.BATCH_ERRORS];
         return {
             ...this.getMetrics(),
             cacheStats,
@@ -804,6 +1053,7 @@ class Container {
             initializerCacheSize: this.initializerCache.size,
             initializerPromisesSize: this.initializerPromises.size,
             cacheHitRatio: hits + misses > 0 ? hits / (hits + misses) : 0,
+            batchSuccessRatio: batchOps > 0 ? (batchOps - batchErrors) / batchOps : 0
         };
     }
     // ═══════════════════════════════════════════════════════════════════════════