@onebun/core 0.2.14 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -45,11 +45,11 @@
   "dependencies": {
     "effect": "^3.13.10",
     "arktype": "^2.0.0",
-    "@onebun/logger": "^0.2.1",
+    "@onebun/logger": "^0.2.2",
     "@onebun/envs": "^0.2.2",
     "@onebun/metrics": "^0.2.2",
     "@onebun/requests": "^0.2.1",
-    "@onebun/trace": "^0.2.1"
+    "@onebun/trace": "^0.2.2"
   },
   "devDependencies": {
     "bun-types": "^1.3.8",

package/src/application/application.ts

@@ -20,6 +20,7 @@ import {
   LoggerService,
   makeLogger,
   makeLoggerFromOptions,
+  shutdownLogger,
   type SyncLogger,
 } from '@onebun/logger';
 import {
@@ -295,9 +296,26 @@ export class OneBunApplication<QA extends import('../queue/types').QueueAdapterC
 
     // Use provided logger layer, or create from options, or use default
     // Priority: loggerLayer > loggerOptions > env variables > NODE_ENV defaults
+    // Auto-populate OTLP resource attributes from tracing config if available
+    const loggerOptions = this.options.loggerOptions
+      ? {
+        ...this.options.loggerOptions,
+        otlpResourceAttributes: this.options.loggerOptions.otlpResourceAttributes ?? (
+          this.options.loggerOptions.otlpEndpoint && this.options.tracing
+            ? {
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              'service.name': this.options.tracing.serviceName ?? 'onebun-service',
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              'service.version': this.options.tracing.serviceVersion ?? '1.0.0',
+            }
+            : undefined
+        ),
+      }
+      : undefined;
+
     this.loggerLayer = this.options.loggerLayer
-      ?? (this.options.loggerOptions
-        ? makeLoggerFromOptions(this.options.loggerOptions)
+      ?? (loggerOptions
+        ? makeLoggerFromOptions(loggerOptions)
         : makeLogger());
 
     // Initialize logger with application class name as context
@@ -1744,6 +1762,12 @@ export class OneBunApplication<QA extends import('../queue/types').QueueAdapterC
       this.logger.debug('HTTP server stopped');
     }
 
+    // Shutdown trace service — flush pending spans before module destroy
+    if (this.traceService?.shutdown) {
+      this.logger.debug('Shutting down trace service');
+      await this.traceService.shutdown();
+    }
+
     // Call onModuleDestroy lifecycle hook
     if (this.rootModule?.callOnModuleDestroy) {
       this.logger.debug('Calling onModuleDestroy hooks');
@@ -1763,6 +1787,9 @@ export class OneBunApplication<QA extends import('../queue/types').QueueAdapterC
     }
 
     this.logger.info('OneBun application stopped');
+
+    // Shutdown logger transport LAST — flush OTLP log batches after final log message
+    await shutdownLogger();
   }
 
   /**

package/src/queue/decorators.test.ts

@@ -189,6 +189,48 @@ describe('queue-decorators', () => {
       expect(handlers[0].propertyKey).toBe('handleReady');
     });
 
+    it('should support multiple @OnQueueReady handlers in one class', () => {
+      class TestService {
+        @OnQueueReady()
+        handleReady1() {}
+
+        @OnQueueReady()
+        handleReady2() {}
+      }
+
+      const handlers = getLifecycleHandlers(TestService, 'ON_READY');
+      expect(handlers.length).toBe(2);
+      expect(handlers[0].propertyKey).toBe('handleReady1');
+      expect(handlers[1].propertyKey).toBe('handleReady2');
+    });
+
+    it('should return empty array when no @OnQueueReady handlers', () => {
+      class TestService {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        handle() {}
+      }
+
+      const handlers = getLifecycleHandlers(TestService, 'ON_READY');
+      expect(handlers.length).toBe(0);
+    });
+
+    it('should not mix @OnQueueReady with other lifecycle metadata', () => {
+      class TestService {
+        @OnQueueReady()
+        handleReady() {}
+
+        @OnQueueError()
+        handleError(_error: Error) {}
+      }
+
+      const readyHandlers = getLifecycleHandlers(TestService, 'ON_READY');
+      const errorHandlers = getLifecycleHandlers(TestService, 'ON_ERROR');
+      expect(readyHandlers.length).toBe(1);
+      expect(readyHandlers[0].propertyKey).toBe('handleReady');
+      expect(errorHandlers.length).toBe(1);
+      expect(errorHandlers[0].propertyKey).toBe('handleError');
+    });
+
     it('should register @OnQueueError handler', () => {
       class TestService {
         @OnQueueError()

package/src/queue/queue.service.test.ts

@@ -13,6 +13,7 @@ import {
 import type { Message } from './types';
 
 import { InMemoryQueueAdapter } from './adapters/memory.adapter';
+import { OnQueueReady, Subscribe } from './decorators';
 import { QueueService } from './queue.service';
 
 describe('QueueService', () => {
@@ -341,6 +342,161 @@ describe('QueueService', () => {
     });
   });
 
+  describe('registerService lifecycle', () => {
+    test('should call @OnQueueReady handler when queue starts', async () => {
+      let readyCalled = false;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCalled = true;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      expect(readyCalled).toBe(false);
+
+      await service.start();
+      expect(readyCalled).toBe(true);
+    });
+
+    test('should allow publishing from @OnQueueReady handler', async () => {
+      const received: Message[] = [];
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          service.publish('init.ready', { status: 'ok' });
+        }
+
+        @Subscribe('init.ready')
+        handleInit(_message: Message) {}
+      }
+
+      const instance = new TestService();
+
+      // Subscribe before start so the handler is in place
+      await service.subscribe('init.ready', async (message) => {
+        received.push(message);
+      });
+
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(received.length).toBe(1);
+      expect(received[0].data).toEqual({ status: 'ok' });
+    });
+
+    test('should call multiple @OnQueueReady handlers in order', async () => {
+      const callOrder: string[] = [];
+
+      class TestService {
+        @OnQueueReady()
+        handleReady1() {
+          callOrder.push('first');
+        }
+
+        @OnQueueReady()
+        handleReady2() {
+          callOrder.push('second');
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(callOrder).toEqual(['first', 'second']);
+    });
+
+    test('should call @OnQueueReady with correct this binding', async () => {
+      let capturedValue: string | null = null as string | null;
+
+      class TestService {
+        readonly name = 'test-service';
+
+        @OnQueueReady()
+        handleReady() {
+          capturedValue = this.name;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(capturedValue).toBe('test-service');
+    });
+
+    test('should call @OnQueueReady again after stop() and start()', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      await service.stop();
+      await service.start();
+      expect(readyCount).toBe(2);
+    });
+
+    test('should call @OnQueueReady on adapter reconnect', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      // Simulate reconnect without stopping the service
+      await adapter.disconnect();
+      await adapter.connect();
+      expect(readyCount).toBe(2);
+    });
+
+    test('should not call @OnQueueReady on adapter reconnect when service is stopped', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      await service.stop();
+
+      // Reconnect while service is stopped — handler should NOT fire
+      await adapter.connect();
+      expect(readyCount).toBe(1);
+    });
+
+  });
+
   describe('error handling', () => {
     test('should handle subscription errors gracefully', async () => {
       await service.start();

package/src/queue/queue.service.ts

@@ -56,6 +56,8 @@ export class QueueService {
   private subscriptions: Subscription[] = [];
   private started = false;
   private config: QueueConfig;
+  private onReadyHandlers: Array<() => void> = [];
+  private adapterOnReadyRegistered = false;
 
   constructor(config: QueueConfig) {
     this.config = config;
@@ -86,11 +88,28 @@ export class QueueService {
       await this.adapter.connect();
     }
 
+    // Register adapter-level onReady listener once for reconnection scenarios
+    if (!this.adapterOnReadyRegistered) {
+      this.adapter.on('onReady', () => {
+        if (this.started) {
+          for (const handler of this.onReadyHandlers) {
+            handler();
+          }
+        }
+      });
+      this.adapterOnReadyRegistered = true;
+    }
+
     if (this.scheduler) {
       this.scheduler.start();
     }
 
     this.started = true;
+
+    // Call @OnQueueReady handlers — queue is fully ready at this point
+    for (const handler of this.onReadyHandlers) {
+      handler();
+    }
   }
 
   /**
@@ -359,7 +378,7 @@ export class QueueService {
     const onReadyHandlers = getMetadata(QUEUE_METADATA.ON_READY, serviceClass) || [];
     for (const handler of onReadyHandlers) {
       const method = serviceInstance[handler.propertyKey].bind(serviceInstance);
-      this.on('onReady', method);
+      this.onReadyHandlers.push(method);
     }
 
     const onErrorHandlers = getMetadata(QUEUE_METADATA.ON_ERROR, serviceClass) || [];