@onebun/core 0.2.15 → 0.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -43,13 +43,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "effect": "^3.13.10",
-    "arktype": "^2.0.0",
-    "@onebun/logger": "^0.2.1",
     "@onebun/envs": "^0.2.2",
+    "@onebun/logger": "^0.2.2",
     "@onebun/metrics": "^0.2.2",
     "@onebun/requests": "^0.2.1",
-    "@onebun/trace": "^0.2.1"
+    "@onebun/trace": "^0.2.3",
+    "@opentelemetry/api": "^1.9.1",
+    "arktype": "^2.0.0",
+    "effect": "^3.13.10"
   },
   "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
@@ -503,7 +521,12 @@ export class OneBunApplication<QA extends import('../queue/types').QueueAdapterC
       // Create the root module AFTER config is initialized and QueueService proxy is registered,
       // so services can safely use this.config.get() in their constructors
       // and inject QueueService in any module depth.
-      this.rootModule = OneBunModule.create(this.moduleClass, this.loggerLayer, this.config);
+      this.rootModule = OneBunModule.create(
+        this.moduleClass, this.loggerLayer, this.config,
+        this.options.tracing?.traceAll
+          ? { traceAll: true, traceFilter: this.options.tracing.traceFilter }
+          : undefined,
+      );
 
       // Register test provider overrides (must happen before setup() so controllers receive mocks)
       if (this.options._testProviders) {
@@ -1744,6 +1767,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 +1792,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/module/controller.ts

@@ -1,9 +1,12 @@
+import { trace } from '@opentelemetry/api';
+
 import type { IConfig, OneBunAppConfig } from './config.interface';
 import type {
   OneBunRequest,
   SseEvent,
   SseOptions,
 } from '../types';
+import type { Span } from '@opentelemetry/api';
 import type { Context } from 'effect';
 
 import type { SyncLogger } from '@onebun/logger';
@@ -134,6 +137,14 @@ export class Controller {
     this.logger.debug(`Controller ${className} initialized`);
   }
 
+  /**
+   * Get the currently active OpenTelemetry span.
+   * Returns undefined when no span is active.
+   */
+  protected get span(): Span | undefined {
+    return trace.getActiveSpan();
+  }
+
   /**
    * Get a service instance by tag
    * @param tag - The service tag

package/src/module/module.ts

@@ -14,6 +14,11 @@ import {
   makeLogger,
   type SyncLogger,
 } from '@onebun/logger';
+import {
+  applyAutoTrace,
+  shouldAutoTrace,
+  type TraceFilterOptions,
+} from '@onebun/trace';
 
 import {
   autoDetectDependencies,
@@ -48,6 +53,7 @@ import {
   getServiceTag,
 } from './service';
 
+
 /**
  * Global services registry
  * Stores services from modules marked with @Global() decorator
@@ -127,11 +133,17 @@ export class OneBunModule implements ModuleInstance {
    */
   private resolvedAncestorMiddleware: Function[] = [];
 
+  /**
+   * Tracing options for auto-trace (traceAll + filters)
+   */
+  private readonly tracingOptions?: { traceAll?: boolean; traceFilter?: TraceFilterOptions };
+
   constructor(
     private moduleClass: Function,
     private loggerLayer?: Layer.Layer<never, never, unknown>,
     config?: IConfig<OneBunAppConfig>,
     ancestorMiddleware?: Function[],
+    tracingOptions?: { traceAll?: boolean; traceFilter?: TraceFilterOptions },
   ) {
     // Initialize logger with module class name as context
     const effectLogger = Effect.runSync(
@@ -144,6 +156,7 @@ export class OneBunModule implements ModuleInstance {
     ) as Logger;
     this.logger = createSyncLogger(effectLogger);
     this.config = config ?? new NotInitializedConfig();
+    this.tracingOptions = tracingOptions;
     this.ancestorMiddlewareClasses = ancestorMiddleware ?? [];
 
     // Read module-level middleware from OnModuleConfigure interface
@@ -230,7 +243,10 @@ export class OneBunModule implements ModuleInstance {
 
         // Pass the logger layer, config, and accumulated middleware class refs to child modules
         const accumulatedMiddleware = [...this.ancestorMiddlewareClasses, ...this.ownMiddlewareClasses];
-        const childModule = new OneBunModule(importModule, this.loggerLayer, this.config, accumulatedMiddleware);
+        const childModule = new OneBunModule(
+          importModule, this.loggerLayer, this.config,
+          accumulatedMiddleware, this.tracingOptions,
+        );
         this.childModules.push(childModule);
 
         // Merge layers
@@ -426,6 +442,14 @@ export class OneBunModule implements ModuleInstance {
           });
         }
 
+        // Apply auto-tracing if enabled
+        if (
+          this.tracingOptions &&
+          shouldAutoTrace(provider, provider.name, !!this.tracingOptions.traceAll, this.tracingOptions.traceFilter)
+        ) {
+          applyAutoTrace(serviceInstance, provider.name, this.tracingOptions.traceFilter);
+        }
+
         this.serviceInstances.set(serviceMetadata.tag, serviceInstance);
         createdServices.add(provider.name);
         this.logger.debug(
@@ -633,6 +657,17 @@ export class OneBunModule implements ModuleInstance {
         controller.initializeController(this.logger, this.config);
       }
 
+      // Apply auto-tracing if enabled
+      if (
+        this.tracingOptions &&
+        shouldAutoTrace(
+          controllerClass, controllerClass.name,
+          !!this.tracingOptions.traceAll, this.tracingOptions.traceFilter,
+        )
+      ) {
+        applyAutoTrace(controller, controllerClass.name, this.tracingOptions.traceFilter);
+      }
+
       this.controllerInstances.set(controllerClass, controller);
 
       // Inject all services into controller (for legacy compatibility)
@@ -1145,9 +1180,10 @@ export class OneBunModule implements ModuleInstance {
     moduleClass: Function,
     loggerLayer?: Layer.Layer<never, never, unknown>,
     config?: IConfig<OneBunAppConfig>,
+    tracingOptions?: { traceAll?: boolean; traceFilter?: TraceFilterOptions },
   ): ModuleInstance {
     // Using console.log here because we don't have access to the logger instance yet
     // The instance will create its own logger in the constructor
-    return new OneBunModule(moduleClass, loggerLayer, config);
+    return new OneBunModule(moduleClass, loggerLayer, config, undefined, tracingOptions);
   }
 }

package/src/module/service.ts

@@ -1,3 +1,4 @@
+import { trace } from '@opentelemetry/api';
 import {
   Context,
   Effect,
@@ -5,6 +6,7 @@ import {
 } from 'effect';
 
 import type { IConfig, OneBunAppConfig } from './config.interface';
+import type { Span } from '@opentelemetry/api';
 
 import type { SyncLogger } from '@onebun/logger';
 
@@ -22,7 +24,7 @@ const META_SERVICES = new Map<
  * Services extending BaseService will have logger and config available
  * immediately after super() in the constructor (via ambient init context),
  * as well as through the initializeService fallback method.
- * 
+ *
  * @param tag - Optional Effect Context tag for the service
  */
 export function Service<T>(tag?: Context.Tag<T, T>) {
@@ -170,6 +172,21 @@ export class BaseService {
     return this._initialized;
   }
 
+  /**
+   * Get the currently active OpenTelemetry span.
+   * Returns undefined when no span is active (e.g. outside of @Traced context).
+   *
+   * The returned Span has a fully synchronous API:
+   * - `span.setAttribute(key, value)`
+   * - `span.setAttributes({ key: value })`
+   * - `span.addEvent(name, attributes?)`
+   * - `span.recordException(error)`
+   * - `span.setStatus({ code, message })`
+   */
+  protected get span(): Span | undefined {
+    return trace.getActiveSpan();
+  }
+
   /**
    * Run an effect with error handling
    * @param effect - The effect to run

package/src/types.ts

@@ -385,6 +385,47 @@ export interface ApplicationOptions<QA extends QueueAdapterConstructor<any> = Qu
      */
     traceDatabaseQueries?: boolean;
 
+    /**
+     * Auto-trace all async methods on services and controllers.
+     * When enabled, all async methods are wrapped in spans without
+     * requiring @Traced() on each method.
+     *
+     * Priority: method-level decorators > class-level > this setting.
+     * Use @NoTrace() to opt out, @TraceAll() on a class to opt in
+     * when traceAll is false.
+     *
+     * @defaultValue false
+     */
+    traceAll?: boolean;
+
+    /**
+     * Filter options for traceAll. Only effective when traceAll is true.
+     */
+    traceFilter?: {
+      /**
+       * Only trace async methods. Sync methods are skipped.
+       * @defaultValue true
+       */
+      asyncOnly?: boolean;
+
+      /**
+       * Additional method names to exclude from auto-tracing
+       * (on top of built-in exclusions like lifecycle hooks and base class methods).
+       */
+      excludeMethods?: string[];
+
+      /**
+       * Class name glob patterns to include (e.g. ['*Service', '*Repository']).
+       * When set, only matching classes are auto-traced.
+       */
+      includeClasses?: string[];
+
+      /**
+       * Class name glob patterns to exclude (e.g. ['HealthController']).
+       */
+      excludeClasses?: string[];
+    };
+
     /**
      * Custom attributes to add to all spans
      */