@adonisjs/otel 1.1.3 → 1.2.1

package/README.md

@@ -27,12 +27,9 @@ In order to ensure that the AdonisJS community is welcoming to all, please revie
 AdonisJS OpenTelemetry is open-sourced software licensed under the [MIT license](LICENSE.md).
 
 [gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/otel/checks.yml?style=for-the-badge
-[gh-workflow-url]: https://github.com/adonisjs/otel/actions/workflows/checks.yml "Github action"
-
+[gh-workflow-url]: https://github.com/adonisjs/otel/actions/workflows/checks.yml 'Github action'
 [npm-image]: https://img.shields.io/npm/v/@adonisjs/otel/latest.svg?style=for-the-badge&logo=npm
-[npm-url]: https://www.npmjs.com/package/@adonisjs/otel/v/latest "npm"
-
+[npm-url]: https://www.npmjs.com/package/@adonisjs/otel/v/latest 'npm'
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
-
 [license-url]: LICENSE.md
 [license-image]: https://img.shields.io/github/license/adonisjs/otel?style=for-the-badge

package/build/configure.d.ts

@@ -1,2 +1,2 @@
-import ConfigureCommand from '@adonisjs/core/commands/configure';
+import type ConfigureCommand from '@adonisjs/core/commands/configure';
 export declare function configure(command: ConfigureCommand): Promise<void>;

package/build/index.d.ts

@@ -1,6 +1,7 @@
 export { configure } from './configure.js';
 export { defineConfig } from './src/define_config.js';
 export { OtelManager } from './src/otel.js';
+export { destinations } from './src/destinations.js';
 /**
  * Re-export OTLP exporters so users don't need to install those 100 packages
  * from OpenTelemetry just to get the exporters.

package/build/index.js

@@ -9,6 +9,7 @@
 export { configure } from './configure.js';
 export { defineConfig } from './src/define_config.js';
 export { OtelManager } from './src/otel.js';
+export { destinations } from './src/destinations.js';
 /**
  * Re-export OTLP exporters so users don't need to install those 100 packages
  * from OpenTelemetry just to get the exporters.

package/build/src/debug.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/destination_manager.d.ts

@@ -0,0 +1,30 @@
+import type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
+import type { DestinationMap } from './types/destinations.js';
+/**
+ * OTel SDK primitives built from configured destinations.
+ *
+ * These arrays are merged inside `OtelManager` with user-provided SDK options.
+ */
+export interface DestinationPipelines {
+    spanProcessors?: NonNullable<NodeSDKConfiguration['spanProcessors']>;
+    metricReaders?: NonNullable<NodeSDKConfiguration['metricReaders']>;
+    logRecordProcessors?: NonNullable<NodeSDKConfiguration['logRecordProcessors']>;
+}
+/**
+ * Transforms high-level `destinations` config into concrete OTel exporters/processors.
+ */
+export declare class DestinationManager {
+    #private;
+    readonly destinations: DestinationMap;
+    /**
+     * @param destinations Destination map from `OtelConfig.destinations`.
+     */
+    constructor(destinations: DestinationMap | undefined);
+    /**
+     * Build span processors, metric readers and log processors for every enabled destination.
+     *
+     * One destination can receive all signals or only a subset via `signals`.
+     * Multiple destinations create multiple exporters, enabling fan-out.
+     */
+    buildPipelines(): DestinationPipelines;
+}

package/build/src/destination_manager.js

@@ -0,0 +1,134 @@
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import debug from './debug.js';
+/**
+ * Transforms high-level `destinations` config into concrete OTel exporters/processors.
+ */
+export class DestinationManager {
+    destinations;
+    /**
+     * @param destinations Destination map from `OtelConfig.destinations`.
+     */
+    constructor(destinations) {
+        if (!destinations) {
+            this.destinations = {};
+            return;
+        }
+        this.destinations = destinations;
+    }
+    #resolveSignals(destination) {
+        if (destination.signals === 'all') {
+            return new Set(['traces', 'metrics', 'logs']);
+        }
+        return new Set(destination.signals);
+    }
+    /**
+     * Resolve the final endpoint for one signal.
+     *
+     * Priority:
+     * 1) `destination.endpoints[signal]`
+     * 2) `destination.endpoint` + `/v1/{signal}`
+     * 3) `undefined` (OTel exporter applies env/default fallback)
+     */
+    #resolveEndpoint(destination, signal) {
+        const signalEndpoint = destination.endpoints?.[signal];
+        if (signalEndpoint)
+            return signalEndpoint;
+        if (destination.endpoint) {
+            return `${destination.endpoint.replace(/\/$/, '')}/v1/${signal}`;
+        }
+        return undefined;
+    }
+    /**
+     * Batch processor options shared by trace and logs processors.
+     */
+    #resolveBatchProcessorConfig(destination) {
+        return {
+            ...(destination.maxExportBatchSize !== undefined && {
+                maxExportBatchSize: destination.maxExportBatchSize,
+            }),
+            ...(destination.scheduledDelayMillis !== undefined && {
+                scheduledDelayMillis: destination.scheduledDelayMillis,
+            }),
+            ...(destination.exportTimeoutMillis !== undefined && {
+                exportTimeoutMillis: destination.exportTimeoutMillis,
+            }),
+            ...(destination.maxQueueSize !== undefined && {
+                maxQueueSize: destination.maxQueueSize,
+            }),
+        };
+    }
+    /**
+     * Build span processors, metric readers and log processors for every enabled destination.
+     *
+     * One destination can receive all signals or only a subset via `signals`.
+     * Multiple destinations create multiple exporters, enabling fan-out.
+     */
+    buildPipelines() {
+        const spanProcessors = [];
+        const metricReaders = [];
+        const logRecordProcessors = [];
+        for (const [destinationKey, destination] of Object.entries(this.destinations)) {
+            if (!destination.enabled)
+                continue;
+            const signals = this.#resolveSignals(destination);
+            const destinationName = destination.name ?? destinationKey;
+            const headers = destination.headers;
+            const timeoutMillis = destination.timeoutMillis;
+            const concurrencyLimit = destination.concurrencyLimit;
+            const compression = destination.compression;
+            const batchProcessorConfig = this.#resolveBatchProcessorConfig(destination);
+            if (signals.has('traces')) {
+                const url = this.#resolveEndpoint(destination, 'traces');
+                const exporter = new OTLPTraceExporter({
+                    ...(url && { url }),
+                    ...(headers && { headers }),
+                    ...(timeoutMillis !== undefined && { timeoutMillis }),
+                    ...(concurrencyLimit !== undefined && { concurrencyLimit }),
+                    ...(compression !== undefined && { compression }),
+                });
+                spanProcessors.push(new BatchSpanProcessor(exporter, batchProcessorConfig));
+            }
+            if (signals.has('metrics')) {
+                const url = this.#resolveEndpoint(destination, 'metrics');
+                const exporter = new OTLPMetricExporter({
+                    ...(url && { url }),
+                    ...(headers && { headers }),
+                    ...(timeoutMillis !== undefined && { timeoutMillis }),
+                    ...(concurrencyLimit !== undefined && { concurrencyLimit }),
+                    ...(compression !== undefined && { compression }),
+                });
+                metricReaders.push(new PeriodicExportingMetricReader({
+                    exporter,
+                    ...(destination.metricExportIntervalMillis !== undefined && {
+                        exportIntervalMillis: destination.metricExportIntervalMillis,
+                    }),
+                    ...(destination.metricExportTimeoutMillis !== undefined && {
+                        exportTimeoutMillis: destination.metricExportTimeoutMillis,
+                    }),
+                }));
+            }
+            if (signals.has('logs')) {
+                const url = this.#resolveEndpoint(destination, 'logs');
+                const exporter = new OTLPLogExporter({
+                    ...(url && { url }),
+                    ...(headers && { headers }),
+                    ...(timeoutMillis !== undefined && { timeoutMillis }),
+                    ...(concurrencyLimit !== undefined && { concurrencyLimit }),
+                    ...(compression !== undefined && { compression }),
+                });
+                logRecordProcessors.push(new BatchLogRecordProcessor(exporter, batchProcessorConfig));
+            }
+            debug('configured destination "%s" for signals: %O', destinationName, [...signals]);
+        }
+        return {
+            spanProcessors: spanProcessors.length > 0 ? spanProcessors : undefined,
+            metricReaders: metricReaders.length > 0 ? metricReaders : undefined,
+            logRecordProcessors: logRecordProcessors.length > 0 ? logRecordProcessors : undefined,
+        };
+    }
+}

package/build/src/destinations.d.ts

@@ -0,0 +1,22 @@
+import type { OtlpDestinationConfig, OtlpDestinationOptions } from './types/destinations.js';
+/**
+ * Create an OTLP destination config with sensible defaults.
+ *
+ * Defaults:
+ * - `enabled: true`
+ * - `signals: 'all'`
+ */
+export declare function otlp(options: OtlpDestinationOptions): OtlpDestinationConfig;
+/**
+ * Helper namespace for destination factories.
+ *
+ * @example
+ * ```ts
+ * destinations: {
+ *   lgtm: destinations.otlp({ endpoint: 'http://localhost:4318', signals: 'all' }),
+ * }
+ * ```
+ */
+export declare const destinations: {
+    otlp: typeof otlp;
+};

package/build/src/destinations.js

@@ -0,0 +1,28 @@
+/**
+ * Create an OTLP destination config with sensible defaults.
+ *
+ * Defaults:
+ * - `enabled: true`
+ * - `signals: 'all'`
+ */
+export function otlp(options) {
+    return {
+        type: 'otlp',
+        ...options,
+        enabled: options.enabled ?? true,
+        signals: options.signals ?? 'all',
+    };
+}
+/**
+ * Helper namespace for destination factories.
+ *
+ * @example
+ * ```ts
+ * destinations: {
+ *   lgtm: destinations.otlp({ endpoint: 'http://localhost:4318', signals: 'all' }),
+ * }
+ * ```
+ */
+export const destinations = {
+    otlp,
+};

package/build/src/errors.d.ts

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

package/build/src/errors.js

@@ -1,3 +1,3 @@
-import { createError } from '@poppinss/utils';
+import { createError } from '@poppinss/utils/exception';
 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/instrumentations/container.d.ts

@@ -2,7 +2,7 @@ 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';
+import { type TracingChannelSubscribers } from 'node:diagnostics_channel';
 /**
  * OpenTelemetry instrumentation for AdonisJS IoC Container.
  *

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

@@ -2,7 +2,7 @@ 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';
+import { type AllowedEventTypes, type EventDispatchData } from '@adonisjs/core/types/events';
 /**
  * OpenTelemetry instrumentation for AdonisJS Event Emitter.
  *

package/build/src/otel.js

@@ -1,11 +1,12 @@
 import { getNodeAutoInstrumentations, } from '@opentelemetry/auto-instrumentations-node';
 import { resourceFromAttributes } from '@opentelemetry/resources';
 import { NodeSDK } from '@opentelemetry/sdk-node';
-import { ConsoleSpanExporter, ParentBasedSampler, SimpleSpanProcessor, TraceIdRatioBasedSampler, } from '@opentelemetry/sdk-trace-base';
+import { BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, SimpleSpanProcessor, TraceIdRatioBasedSampler, } from '@opentelemetry/sdk-trace-base';
 import { ATTR_HTTP_ROUTE, ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from '@opentelemetry/semantic-conventions';
 import { ATTR_DEPLOYMENT_ENVIRONMENT_NAME, ATTR_SERVICE_INSTANCE_ID, } from '@opentelemetry/semantic-conventions/incubating';
 import { HttpContext } from '@adonisjs/core/http';
 import { HttpUrlFilter } from './http_url_filter.js';
+import { DestinationManager } from './destination_manager.js';
 import debug from './debug.js';
 /**
  * OpenTelemetry SDK manager for AdonisJS.
@@ -205,21 +206,88 @@ export class OtelManager {
             processors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
         return processors.length > 0 ? processors : undefined;
     }
+    /**
+     * Build destination pipelines from the `destinations` config.
+     */
+    #buildDestinationPipelines() {
+        return new DestinationManager(this.#config.destinations).buildPipelines();
+    }
+    /**
+     * Whether we should preserve legacy trace exporter settings when destinations add traces.
+     */
+    #shouldPreserveTraceExporter(destinationSpanProcessors) {
+        const hasDestinationTraceProcessors = (destinationSpanProcessors?.length ?? 0) > 0;
+        const hasExplicitSpanProcessors = (this.#config.spanProcessors?.length ?? 0) > 0;
+        return hasDestinationTraceProcessors && !hasExplicitSpanProcessors;
+    }
+    /**
+     * Merge configured span processors with destination trace processors.
+     */
+    #mergeSpanProcessors(destinationSpanProcessors) {
+        const spanProcessors = [
+            ...(this.#buildSpanProcessors() ?? []),
+            ...(destinationSpanProcessors ?? []),
+        ];
+        /**
+         * When destinations add trace span processors, NodeSDK ignores `traceExporter`
+         * and deprecated `spanProcessor`. Re-inject them to preserve existing behavior.
+         */
+        if (this.#shouldPreserveTraceExporter(destinationSpanProcessors)) {
+            if (this.#config.traceExporter) {
+                spanProcessors.unshift(new BatchSpanProcessor(this.#config.traceExporter));
+            }
+            if (this.#config.spanProcessor) {
+                spanProcessors.unshift(this.#config.spanProcessor);
+            }
+        }
+        return spanProcessors.length > 0 ? spanProcessors : undefined;
+    }
+    /**
+     * Merge configured metric readers with destination metric readers.
+     */
+    #mergeMetricReaders(destinationMetricReaders) {
+        const metricReaders = [
+            ...(this.#config.metricReaders ?? []),
+            ...(destinationMetricReaders ?? []),
+        ];
+        return metricReaders.length > 0 ? metricReaders : undefined;
+    }
+    /**
+     * Merge configured log record processors with destination log processors.
+     */
+    #mergeLogRecordProcessors(destinationLogRecordProcessors) {
+        const logRecordProcessors = [
+            ...(this.#config.logRecordProcessors ?? []),
+            ...(destinationLogRecordProcessors ?? []),
+        ];
+        return logRecordProcessors.length > 0 ? logRecordProcessors : undefined;
+    }
+    /**
+     * Return NodeSDK user config without internal-only keys.
+     */
+    #getNodeSdkUserConfig() {
+        const sdkConfig = { ...this.#config };
+        delete sdkConfig.destinations;
+        return sdkConfig;
+    }
     /**
      * Create the NodeSDK instance with all configuration
      */
     #createSdk() {
-        const resource = this.#buildResource();
-        const instrumentations = this.#buildInstrumentations();
+        const destinationPipelines = this.#buildDestinationPipelines();
         const sampler = this.#buildSampler();
-        const spanProcessors = this.#buildSpanProcessors();
+        const spanProcessors = this.#mergeSpanProcessors(destinationPipelines.spanProcessors);
+        const metricReaders = this.#mergeMetricReaders(destinationPipelines.metricReaders);
+        const logRecordProcessors = this.#mergeLogRecordProcessors(destinationPipelines.logRecordProcessors);
         return new NodeSDK({
-            ...this.#config,
-            resource,
+            ...this.#getNodeSdkUserConfig(),
+            resource: this.#buildResource(),
             serviceName: this.serviceName,
-            instrumentations,
+            instrumentations: this.#buildInstrumentations(),
             ...(sampler && { sampler }),
             ...(spanProcessors && { spanProcessors }),
+            ...(metricReaders && { metricReaders }),
+            ...(logRecordProcessors && { logRecordProcessors }),
         });
     }
     /**

package/build/src/start.js

@@ -15,12 +15,21 @@
  * import '../otel.js'
  * ```
  */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { createAddHookMessageChannel } from 'import-in-the-middle';
 import { register } from 'node:module';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { E_OTEL_CONFIG, E_OTEL_CONFIG_INVALID } from './errors.js';
 async function loadConfig(path) {
-    return await import(path)
+    return await import(__rewriteRelativeImportExtension(pathToFileURL(path).href))
         .then((mod) => mod.default || mod)
         .catch((error) => {
         throw new E_OTEL_CONFIG([path], { cause: error });

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

@@ -0,0 +1,66 @@
+import type { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import type { BufferConfig } from '@opentelemetry/sdk-trace-base';
+export type DestinationSignal = 'traces' | 'metrics' | 'logs';
+export type DestinationSignals = 'all' | DestinationSignal[];
+type OtlpExporterConfig = NonNullable<ConstructorParameters<typeof OTLPTraceExporter>[0]>;
+type DestinationBatchConfig = Pick<BufferConfig, 'maxExportBatchSize' | 'scheduledDelayMillis' | 'exportTimeoutMillis' | 'maxQueueSize'>;
+export interface OtlpDestinationOptions extends DestinationBatchConfig {
+    /**
+     * Optional label used in debug logs.
+     */
+    name?: string;
+    /**
+     * Enable/disable this destination.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Signals to export to this destination.
+     * @default 'all'
+     */
+    signals?: DestinationSignals;
+    /**
+     * OTLP base endpoint. Signal paths are appended automatically:
+     * - /v1/traces
+     * - /v1/metrics
+     * - /v1/logs
+     */
+    endpoint?: string;
+    /**
+     * Per-signal OTLP endpoints. When set, it overrides `endpoint` for that signal.
+     */
+    endpoints?: Partial<Record<DestinationSignal, string>>;
+    /**
+     * Additional headers sent with each OTLP request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds.
+     */
+    timeoutMillis?: number;
+    /**
+     * Optional maximum number of pending HTTP requests.
+     */
+    concurrencyLimit?: number;
+    /**
+     * OTLP payload compression algorithm.
+     * @default 'none'
+     */
+    compression?: OtlpExporterConfig['compression'];
+    /**
+     * Metrics export interval for this destination.
+     */
+    metricExportIntervalMillis?: number;
+    /**
+     * Metrics export timeout for this destination.
+     */
+    metricExportTimeoutMillis?: number;
+}
+export interface OtlpDestinationConfig extends OtlpDestinationOptions {
+    type: 'otlp';
+    enabled: boolean;
+    signals: DestinationSignals;
+}
+export type DestinationConfig = OtlpDestinationConfig;
+export type DestinationMap = Record<string, DestinationConfig>;
+export {};

package/build/src/types/destinations.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,10 @@
 import type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
 import type { HttpContext } from '@adonisjs/core/http';
+import type { DestinationMap } from './destinations.js';
 export type { InstrumentationValue, CustomInstrumentationValue, HttpInstrumentationConfig, PinoInstrumentationConfig, InstrumentationsConfig, } from './instrumentations.js';
 export type { SpanOptions } from './decorators.js';
 export { hiddenFields, type HiddenField, type OtelLoggingPresetOptions } from './logging.js';
+export type { DestinationConfig, DestinationMap, DestinationSignal, DestinationSignals, OtlpDestinationConfig, OtlpDestinationOptions, } from './destinations.js';
 import type { InstrumentationsConfig } from './instrumentations.js';
 /**
  * Configuration for @adonisjs/otel
@@ -83,6 +85,14 @@ export interface OtelConfig extends Partial<Omit<NodeSDKConfiguration, 'resource
      * ```
      */
     instrumentations?: InstrumentationsConfig;
+    /**
+     * Configure one or many OTLP destinations and fan-out telemetry to each one.
+     *
+     * Keys are destination identifiers (for example: `lgtm`, `secondary`).
+     * Each destination can target all signals (`traces`, `metrics`, `logs`)
+     * or only a subset.
+     */
+    destinations?: DestinationMap;
     /**
      * Configure automatic user context extraction in the middleware.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/otel",
   "description": "OpenTelemetry integration for AdonisJS with sensible defaults and zero-config setup",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -43,7 +43,7 @@
     "format": "prettier --write .",
     "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
     "pretest": "npm run lint",
-    "test": "c8 npm run quick:test",
+    "test": "npm run quick:test",
     "prebuild": "npm run lint && npm run clean",
     "build": "tsc",
     "checks": "npm run lint && npm run typecheck && npm run test",
@@ -67,46 +67,56 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.67.2",
-    "@opentelemetry/core": "^2.2.0",
-    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.208.0",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.208.0",
-    "@opentelemetry/instrumentation": "^0.208.0",
-    "@opentelemetry/resources": "^2.2.0",
-    "@opentelemetry/sdk-metrics": "^2.2.0",
-    "@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"
+    "@opentelemetry/auto-instrumentations-node": "^0.70.0",
+    "@opentelemetry/core": "^2.5.1",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.212.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.212.0",
+    "@opentelemetry/instrumentation": "^0.212.0",
+    "@opentelemetry/resources": "^2.5.1",
+    "@opentelemetry/sdk-metrics": "^2.5.1",
+    "@opentelemetry/sdk-node": "^0.212.0",
+    "@opentelemetry/sdk-trace-base": "^2.5.1",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
+    "@poppinss/utils": "^7.0.0",
+    "import-in-the-middle": "^3.0.0"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^7.8.2",
-    "@adonisjs/auth": "^9.5.1",
-    "@adonisjs/core": "^7.0.0-next.14",
-    "@adonisjs/eslint-config": "2.1.2",
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/auth": "^10.0.0",
+    "@adonisjs/core": "^7.0.0",
+    "@adonisjs/eslint-config": "3.0.0",
     "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/tsconfig": "^1.4.1",
-    "@japa/assert": "^4.1.1",
-    "@japa/runner": "^4.4.0",
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@japa/assert": "^4.2.0",
+    "@japa/runner": "^5.3.0",
     "@julr/otel-instrumentation-clickhouse": "^1.0.2",
-    "@opentelemetry/context-async-hooks": "^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",
-    "c8": "^10.1.3",
+    "@opentelemetry/context-async-hooks": "^2.5.1",
+    "@release-it/conventional-changelog": "^10.0.5",
+    "@sentry/node": "^10.40.0",
+    "@swc/core": "^1.15.13",
+    "@types/node": "^25.3.0",
+    "c8": "^11.0.0",
     "copyfiles": "^2.4.1",
     "del-cli": "^7.0.0",
-    "eslint": "^9.39.1",
-    "prettier": "^3.7.4",
-    "release-it": "^19.0.0",
+    "eslint": "^10.0.2",
+    "prettier": "^3.8.1",
+    "release-it": "^19.2.4",
     "ts-node-maintained": "^10.9.6",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/auth": "^10.0.0",
     "@adonisjs/core": "^6.2.0 || ^7.0.0 || ^7.0.0-next.27"
   },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    },
+    "@adonisjs/auth": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "provenance": true,
     "access": "public"