@adonisjs/otel 1.0.0-next.0 → 1.0.0-next.2

package/build/configure.js

@@ -19,7 +19,7 @@ export async function configure(command) {
      */
     await codemods.makeUsingStub(stubsRoot, 'config.stub', {});
     /**
-     * Publish the bin/otel.ts file
+     * Publish the otel.ts file
      */
     await codemods.makeUsingStub(stubsRoot, 'otel.stub', {});
     /**
@@ -36,7 +36,7 @@ export async function configure(command) {
             ' * OpenTelemetry initialization - MUST be the first import',
             ' * @see https://opentelemetry.io/docs/languages/js/getting-started/nodejs/',
             ' */',
-            `import './otel.js'`,
+            `import '../otel.js'`,
             '',
         ]);
         await serverFile.save();

package/build/providers/otel_provider.js

@@ -15,7 +15,6 @@ export default class OtelProvider {
     #registerExceptionHandler() {
         const originalReport = ExceptionHandler.prototype.report;
         ExceptionHandler.macro('report', async function (error, ctx) {
-            // @ts-expect-error - protected method
             const httpError = this.toHttpError(error);
             if (!this.shouldReport(httpError))
                 return;

package/build/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const E_OTEL_CONFIG: new (args: [configPath: string], options?: ErrorOptions) => import("@poppinss/utils").Exception;
+export declare const E_OTEL_CONFIG_INVALID: new (args: [configPath: string], options?: ErrorOptions) => import("@poppinss/utils").Exception;

package/build/src/errors.js

@@ -0,0 +1,3 @@
+import { createError } from '@poppinss/utils';
+export const E_OTEL_CONFIG = createError('Failed to load OpenTelemetry config at "%s". Make sure the file exists and has no syntax errors.', 'E_OTEL_CONFIG');
+export const E_OTEL_CONFIG_INVALID = createError('OpenTelemetry config at "%s" must export a configuration object.', 'E_OTEL_CONFIG_INVALID');

package/build/src/helpers.js

@@ -131,12 +131,6 @@ export function setUser(user) {
         attributes[ATTR_USER_EMAIL] = user.email;
     if (user.role)
         attributes[ATTR_USER_ROLES] = [user.role];
-    // Add any extra custom attributes
-    for (const [key, value] of Object.entries(user)) {
-        if (!['id', 'email', 'role'].includes(key) && value !== undefined) {
-            attributes[`user.${key}`] = String(value);
-        }
-    }
     span.setAttributes(attributes);
 }
 /**

package/build/src/instrumentations/container.d.ts

@@ -0,0 +1,52 @@
+import type { Span } from '@opentelemetry/api';
+import type { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import type { ContainerMakeTracingData } from '@adonisjs/core/types/container';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { TracingChannelSubscribers } from 'node:diagnostics_channel';
+/**
+ * OpenTelemetry instrumentation for AdonisJS IoC Container.
+ *
+ * Creates spans for `container.make()` calls, tracking dependency resolution.
+ * Spans are only created when there is an active parent context to avoid
+ * orphan traces during application boot.
+ *
+ * Span name: `container.make {bindingName}`
+ * Attributes: `container.binding`
+ */
+export declare class ContainerInstrumentation extends InstrumentationBase {
+    protected subscribed: boolean;
+    protected spans: WeakMap<object, Span>;
+    protected handlers?: TracingChannelSubscribers<ContainerMakeTracingData>;
+    constructor(config?: InstrumentationConfig);
+    /**
+     * Required by InstrumentationBase. Returns undefined since we use
+     * diagnostics_channel instead of module patching.
+     */
+    protected init(): undefined;
+    /**
+     * Extracts a human-readable name from a container binding.
+     */
+    protected getBindingName(binding: unknown): string;
+    /**
+     * Called when container.make() starts. Creates a new span if there's a parent context.
+     */
+    protected handleStart(message: ContainerMakeTracingData): void;
+    /**
+     * Called when container.make() completes successfully. Ends the span.
+     */
+    protected handleAsyncEnd(message: ContainerMakeTracingData): void;
+    /**
+     * Called when container.make() throws. Records the exception and ends the span.
+     */
+    protected handleError(message: ContainerMakeTracingData & {
+        error: unknown;
+    }): void;
+    /**
+     * Subscribes to the container tracing channel.
+     */
+    enable(): void;
+    /**
+     * Unsubscribes from the container tracing channel and cleans up.
+     */
+    disable(): void;
+}

package/build/src/instrumentations/container.js

@@ -0,0 +1,102 @@
+import { context, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { tracingChannels } from '@adonisjs/core/container';
+/**
+ * OpenTelemetry instrumentation for AdonisJS IoC Container.
+ *
+ * Creates spans for `container.make()` calls, tracking dependency resolution.
+ * Spans are only created when there is an active parent context to avoid
+ * orphan traces during application boot.
+ *
+ * Span name: `container.make {bindingName}`
+ * Attributes: `container.binding`
+ */
+export class ContainerInstrumentation extends InstrumentationBase {
+    subscribed = false;
+    spans = new WeakMap();
+    handlers;
+    constructor(config = {}) {
+        super('@adonisjs/instrumentation-container', '1.0.0', config);
+    }
+    /**
+     * Required by InstrumentationBase. Returns undefined since we use
+     * diagnostics_channel instead of module patching.
+     */
+    init() {
+        return undefined;
+    }
+    /**
+     * Extracts a human-readable name from a container binding.
+     */
+    getBindingName(binding) {
+        if (typeof binding === 'string')
+            return binding;
+        if (typeof binding === 'symbol')
+            return binding.description || 'symbol';
+        if (typeof binding === 'function')
+            return binding.name || 'anonymous';
+        return 'unknown';
+    }
+    /**
+     * Called when container.make() starts. Creates a new span if there's a parent context.
+     */
+    handleStart(message) {
+        const parentContext = context.active();
+        if (!trace.getSpan(parentContext))
+            return;
+        const bindingName = this.getBindingName(message.binding);
+        const span = this.tracer.startSpan(`container.make ${bindingName}`, { kind: SpanKind.INTERNAL, attributes: { 'container.binding': bindingName } }, parentContext);
+        this.spans.set(message, span);
+    }
+    /**
+     * Called when container.make() completes successfully. Ends the span.
+     */
+    handleAsyncEnd(message) {
+        const span = this.spans.get(message);
+        if (!span)
+            return;
+        span.end();
+        this.spans.delete(message);
+    }
+    /**
+     * Called when container.make() throws. Records the exception and ends the span.
+     */
+    handleError(message) {
+        const span = this.spans.get(message);
+        if (!span)
+            return;
+        if (message.error instanceof Error) {
+            span.recordException(message.error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: message.error.message });
+        }
+        span.end();
+        this.spans.delete(message);
+    }
+    /**
+     * Subscribes to the container tracing channel.
+     */
+    enable() {
+        if (this.subscribed)
+            return;
+        this.subscribed = true;
+        this.handlers = {
+            start: (message) => this.handleStart(message),
+            end: () => { },
+            asyncStart: () => { },
+            asyncEnd: (message) => this.handleAsyncEnd(message),
+            error: (message) => this.handleError(message),
+        };
+        tracingChannels.containerMake.subscribe(this.handlers);
+    }
+    /**
+     * Unsubscribes from the container tracing channel and cleans up.
+     */
+    disable() {
+        if (!this.subscribed || !this.handlers)
+            return;
+        tracingChannels.containerMake.unsubscribe(this.handlers);
+        this.subscribed = false;
+        this.handlers = undefined;
+        this.spans = new WeakMap();
+    }
+}

package/build/src/instrumentations/events.d.ts

@@ -0,0 +1,52 @@
+import type { Span } from '@opentelemetry/api';
+import type { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import type { TracingChannelSubscribers } from 'node:diagnostics_channel';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { AllowedEventTypes, EventDispatchData } from '@adonisjs/core/types/events';
+/**
+ * OpenTelemetry instrumentation for AdonisJS Event Emitter.
+ *
+ * Creates spans for `emitter.emit()` calls, tracking event dispatch and listeners execution.
+ * Spans are only created when there is an active parent context to avoid
+ * orphan traces during application boot.
+ *
+ * Span name: `event.dispatch {eventName}`
+ * Attributes: `event.name`
+ */
+export declare class EventsInstrumentation extends InstrumentationBase {
+    protected subscribed: boolean;
+    protected spans: WeakMap<object, Span>;
+    protected handlers?: TracingChannelSubscribers<EventDispatchData>;
+    constructor(config?: InstrumentationConfig);
+    /**
+     * Required by InstrumentationBase. Returns undefined since we use
+     * diagnostics_channel instead of module patching.
+     */
+    protected init(): undefined;
+    /**
+     * Extracts a human-readable name from an event.
+     */
+    protected getEventName(event: AllowedEventTypes): string;
+    /**
+     * Called when emitter.emit() starts. Creates a new span if there's a parent context.
+     */
+    protected handleStart(message: EventDispatchData): void;
+    /**
+     * Called when emitter.emit() completes successfully. Ends the span.
+     */
+    protected handleAsyncEnd(message: EventDispatchData): void;
+    /**
+     * Called when a listener throws. Records the exception and ends the span.
+     */
+    protected handleError(message: EventDispatchData & {
+        error: unknown;
+    }): void;
+    /**
+     * Subscribes to the events tracing channel.
+     */
+    enable(): void;
+    /**
+     * Unsubscribes from the events tracing channel and cleans up.
+     */
+    disable(): void;
+}

package/build/src/instrumentations/events.js

@@ -0,0 +1,104 @@
+import { context, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { tracingChannels } from '@adonisjs/core/events';
+/**
+ * OpenTelemetry instrumentation for AdonisJS Event Emitter.
+ *
+ * Creates spans for `emitter.emit()` calls, tracking event dispatch and listeners execution.
+ * Spans are only created when there is an active parent context to avoid
+ * orphan traces during application boot.
+ *
+ * Span name: `event.dispatch {eventName}`
+ * Attributes: `event.name`
+ */
+export class EventsInstrumentation extends InstrumentationBase {
+    subscribed = false;
+    spans = new WeakMap();
+    handlers;
+    constructor(config = {}) {
+        super('@adonisjs/instrumentation-events', '1.0.0', config);
+    }
+    /**
+     * Required by InstrumentationBase. Returns undefined since we use
+     * diagnostics_channel instead of module patching.
+     */
+    init() {
+        return undefined;
+    }
+    /**
+     * Extracts a human-readable name from an event.
+     */
+    getEventName(event) {
+        if (typeof event === 'string')
+            return event;
+        if (typeof event === 'symbol')
+            return event.description || 'symbol';
+        if (typeof event === 'number')
+            return String(event);
+        if (typeof event === 'function')
+            return event.name || 'anonymous';
+        return 'unknown';
+    }
+    /**
+     * Called when emitter.emit() starts. Creates a new span if there's a parent context.
+     */
+    handleStart(message) {
+        const parentContext = context.active();
+        if (!trace.getSpan(parentContext))
+            return;
+        const eventName = this.getEventName(message.event);
+        const span = this.tracer.startSpan(`event.dispatch ${eventName}`, { kind: SpanKind.INTERNAL, attributes: { 'event.name': eventName } }, parentContext);
+        this.spans.set(message, span);
+    }
+    /**
+     * Called when emitter.emit() completes successfully. Ends the span.
+     */
+    handleAsyncEnd(message) {
+        const span = this.spans.get(message);
+        if (!span)
+            return;
+        span.end();
+        this.spans.delete(message);
+    }
+    /**
+     * Called when a listener throws. Records the exception and ends the span.
+     */
+    handleError(message) {
+        const span = this.spans.get(message);
+        if (!span)
+            return;
+        if (message.error instanceof Error) {
+            span.recordException(message.error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: message.error.message });
+        }
+        span.end();
+        this.spans.delete(message);
+    }
+    /**
+     * Subscribes to the events tracing channel.
+     */
+    enable() {
+        if (this.subscribed)
+            return;
+        this.subscribed = true;
+        this.handlers = {
+            start: (message) => this.handleStart(message),
+            end: () => { },
+            asyncStart: () => { },
+            asyncEnd: (message) => this.handleAsyncEnd(message),
+            error: (message) => this.handleError(message),
+        };
+        tracingChannels.eventDispatch.subscribe(this.handlers);
+    }
+    /**
+     * Unsubscribes from the events tracing channel and cleans up.
+     */
+    disable() {
+        if (!this.subscribed || !this.handlers)
+            return;
+        tracingChannels.eventDispatch.unsubscribe(this.handlers);
+        this.subscribed = false;
+        this.handlers = undefined;
+        this.spans = new WeakMap();
+    }
+}

package/build/src/start.d.ts

@@ -5,14 +5,14 @@
  * to enable auto-instrumentation:
  *
  * ```ts
- * // bin/otel.ts
+ * // otel.ts
  * import { init } from '@adonisjs/otel/init'
  * await init(import.meta.dirname)
  * ```
  *
  * Then import it first in bin/server.ts:
  * ```ts
- * import './otel.js'
+ * import '../otel.js'
  * ```
  */
 export declare function init(dirname: string): Promise<void>;

package/build/src/start.js

@@ -5,29 +5,41 @@
  * to enable auto-instrumentation:
  *
  * ```ts
- * // bin/otel.ts
+ * // otel.ts
  * import { init } from '@adonisjs/otel/init'
  * await init(import.meta.dirname)
  * ```
  *
  * Then import it first in bin/server.ts:
  * ```ts
- * import './otel.js'
+ * import '../otel.js'
  * ```
  */
 import { createAddHookMessageChannel } from 'import-in-the-middle';
 import { register } from 'node:module';
 import { join } from 'node:path';
-export async function init(dirname) {
-    // Setup import-in-the-middle hooks for auto-instrumentation
+import { E_OTEL_CONFIG, E_OTEL_CONFIG_INVALID } from './errors.js';
+async function loadConfig(path) {
+    return await import(path)
+        .then((mod) => mod.default || mod)
+        .catch((error) => {
+        throw new E_OTEL_CONFIG([path], { cause: error });
+    });
+}
+function setupHooks() {
     const { registerOptions, waitForAllMessagesAcknowledged } = createAddHookMessageChannel();
     register('import-in-the-middle/hook.mjs', import.meta.url, registerOptions);
+    return waitForAllMessagesAcknowledged;
+}
+export async function init(dirname) {
+    // Setup import-in-the-middle hooks for auto-instrumentation
+    const waitForAllMessagesAcknowledged = setupHooks();
     // Import SDK functions after hooks are registered
     const { OtelManager } = await import('./otel.js');
-    const configPath = join(dirname, '../config/otel.ts');
-    const config = await import(configPath).then((mod) => mod.default || mod);
+    const configPath = join(dirname, 'config/otel.js');
+    const config = await loadConfig(configPath);
     if (!config)
-        throw new Error(`Otel configuration not found at ${configPath}`);
+        throw new E_OTEL_CONFIG_INVALID([configPath]);
     // Check if OTEL is enabled
     if (!OtelManager.isEnabled(config))
         return;

package/build/src/types/index.d.ts

@@ -30,13 +30,6 @@ export interface OtelConfig extends Partial<Omit<NodeSDKConfiguration, 'resource
      * This option is ignored if `sampler` is explicitly provided.
      *
      * @default 1.0
-     *
-     * @example
-     * ```ts
-     * defineConfig({
-     *   samplingRatio: 0.1, // Sample 10% of traces in production
-     * })
-     * ```
      */
     samplingRatio?: number;
     /**
@@ -46,13 +39,6 @@ export interface OtelConfig extends Partial<Omit<NodeSDKConfiguration, 'resource
      * to help with local development and debugging.
      *
      * @default false
-     *
-     * @example
-     * ```ts
-     * defineConfig({
-     *   debug: true, // Print spans to console
-     * })
-     * ```
      */
     debug?: boolean;
     /**
@@ -122,7 +108,6 @@ export interface UserContextResult {
     id: string | number;
     email?: string;
     role?: string;
-    [key: string]: unknown;
 }
 /**
  * Configuration for automatic user context extraction
@@ -147,7 +132,6 @@ export interface UserContext {
     id: string | number;
     email?: string;
     role?: string;
-    [key: string]: unknown;
 }
 /**
  * Headers carrier type for context propagation

package/build/stubs/otel.stub

@@ -1,5 +1,5 @@
 {{{
-  exports({ to: app.makePath('bin/otel.ts') })
+  exports({ to: app.makePath('otel.ts') })
 }}}
 /**
  * OpenTelemetry initialization file.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/otel",
   "description": "OpenTelemetry integration for AdonisJS with sensible defaults and zero-config setup",
-  "version": "1.0.0-next.0",
+  "version": "1.0.0-next.2",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -22,7 +22,9 @@
     "./helpers": "./build/src/helpers.js",
     "./decorators": "./build/src/decorators.js",
     "./otel_provider": "./build/providers/otel_provider.js",
-    "./otel_middleware": "./build/src/middleware/otel_middleware.js"
+    "./otel_middleware": "./build/src/middleware/otel_middleware.js",
+    "./instrumentations/container": "./build/src/instrumentations/container.js",
+    "./instrumentations/events": "./build/src/instrumentations/events.js"
   },
   "scripts": {
     "clean": "del-cli build",
@@ -64,12 +66,13 @@
     "@opentelemetry/sdk-node": "^0.208.0",
     "@opentelemetry/sdk-trace-base": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
+    "@poppinss/utils": "^6.10.1",
     "import-in-the-middle": "^2.0.0"
   },
   "devDependencies": {
     "@adonisjs/assembler": "^7.8.2",
     "@adonisjs/auth": "^9.5.1",
-    "@adonisjs/core": "^6.19.1",
+    "@adonisjs/core": "^7.0.0-next.14",
     "@adonisjs/eslint-config": "2.1.2",
     "@adonisjs/prettier-config": "^1.4.5",
     "@adonisjs/tsconfig": "^1.4.1",
@@ -77,6 +80,7 @@
     "@japa/runner": "^4.4.0",
     "@opentelemetry/context-async-hooks": "^2.2.0",
     "@opentelemetry/core": "^2.2.0",
+    "@release-it/conventional-changelog": "^10.0.0",
     "@sentry/node": "^10.30.0",
     "@swc/core": "^1.15.3",
     "@types/node": "^20.19.26",
@@ -84,14 +88,13 @@
     "copyfiles": "^2.4.1",
     "del-cli": "^7.0.0",
     "eslint": "^9.39.1",
-    "@release-it/conventional-changelog": "^10.0.0",
-    "release-it": "^19.0.0",
     "prettier": "^3.7.4",
+    "release-it": "^19.0.0",
     "ts-node-maintained": "^10.9.6",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^6.2.0"
+    "@adonisjs/core": "^6.2.0 || ^7.0.0"
   },
   "publishConfig": {
     "access": "public",