@ogcio/o11y-sdk-node 0.6.2 → 0.7.1

package/README.md

@@ -7,13 +7,13 @@ The NodeJS observability sdk is a npm package used to setup and implement opente
 pnpm
 
 ```bash
-  pnpm i --save @ogcio/o11y-sdk-node
+pnpm i --save @ogcio/o11y-sdk-node
 ```
 
 npm
 
 ```bash
-  npm i @ogcio/o11y-sdk-node
+npm i @ogcio/o11y-sdk-node
 ```
 
 ## Usage
@@ -357,11 +357,13 @@ export type SDKLogLevel =
 
 ### Config
 
-| Parameter       | Type              | Description                                                                                              |
-| :-------------- | :---------------- | :------------------------------------------------------------------------------------------------------- |
-| `collectorUrl`  | `string`          | **Required**. The opentelemetry collector entrypoint url, if null, instrumentation will not be activated |
-| `serviceName`   | `string`          | Name of your application used for the collector to group logs                                            |
-| `diagLogLevel`  | `SDKLogLevel`     | Diagnostic log level for the internal runtime instrumentation                                            |
-| `collectorMode` | `single \| batch` | Signals sending mode, default is batch for performance                                                   |
-| `enableFS`      | `boolean`         | Flag to enable or disable the tracing for node:fs module                                                 |
-| `protocol`      | `string`          | Type of the protocol used to send signals                                                                |
+| Parameter                    | Type                       | Description                                                                                                       |
+| :--------------------------- | :------------------------- | :---------------------------------------------------------------------------------------------------------------- |
+| `collectorUrl`               | `string`                   | **Required**. The opentelemetry collector entrypoint url, if null, instrumentation will not be activated          |
+| `serviceName`                | `string`                   | Name of your application used for the collector to group logs                                                     |
+| `diagLogLevel`               | `SDKLogLevel`              | Diagnostic log level for the internal runtime instrumentation                                                     |
+| `collectorMode`              | `single \| batch`          | Signals sending mode, default is batch for performance                                                            |
+| `enableFS`                   | `boolean`                  | **Deprecated**. Use `autoInstrumentationConfig` instead. Flag to enable or disable the tracing for node:fs module |
+| `autoInstrumentationConfig`  | `InstrumentationConfigMap` | Configuration object for auto instrumentations. Default: `{"@opentelemetry/instrumentation-fs":{enabled:false}}`  |
+| `additionalInstrumentations` | `Instrumentation[]`        | Additional custom instrumentations to be added to the NodeSDK. Default: `[]`                                      |
+| `protocol`                   | `string`                   | Type of the protocol used to send signals                                                                         |

package/dist/sdk-core/lib/utils/data-structures.js

@@ -33,7 +33,7 @@ export function _recursiveObjectClean(value, source, redactors) {
         value == null) {
         return value;
     }
-    if (value instanceof Uint8Array) {
+    if (ArrayBuffer.isView(value)) {
         try {
             const decoded = decoder.decode(value);
             const sanitized = _cleanStringPII(decoded, source, redactors);

package/dist/sdk-node/index.d.ts

@@ -3,6 +3,7 @@ import buildNodeInstrumentation from "./lib/instrumentation.node.js";
 export type * from "./lib/index.js";
 export type { NodeSDK };
 export { buildNodeInstrumentation as instrumentNode };
+export * from "./lib/processor/on-ending-hook-span-processor.js";
 export * from "./lib/metrics.js";
 export * from "./lib/traces.js";
 export * from "../sdk-core/index.js";

package/dist/sdk-node/index.js

@@ -1,5 +1,6 @@
 import buildNodeInstrumentation from "./lib/instrumentation.node.js";
 export { buildNodeInstrumentation as instrumentNode };
+export * from "./lib/processor/on-ending-hook-span-processor.js";
 export * from "./lib/metrics.js";
 export * from "./lib/traces.js";
 export * from "../sdk-core/index.js";

package/dist/sdk-node/lib/config-manager.js

@@ -3,6 +3,31 @@ export const setNodeSdkConfig = (config) => {
     nodeSDKConfig = config;
 };
 export const getNodeSdkConfig = () => {
-    // Ensure getters do not edit config.
-    return nodeSDKConfig ? JSON.parse(JSON.stringify(nodeSDKConfig)) : undefined;
+    if (!nodeSDKConfig) {
+        return undefined;
+    }
+    // Create a shallow copy and handle non-serializable properties separately.
+    // Properties like additionalInstrumentations, grpcMetadata, and detection.custom
+    // contain class instances with circular references that cannot be JSON serialized.
+    const { additionalInstrumentations, grpcMetadata, autoInstrumentationConfig, detection, ...serializableConfig } = nodeSDKConfig;
+    // Deep clone the serializable portion of the config
+    const clonedConfig = JSON.parse(JSON.stringify(serializableConfig));
+    // Re-attach non-serializable properties by reference (they should be read-only)
+    if (additionalInstrumentations) {
+        clonedConfig.additionalInstrumentations = additionalInstrumentations;
+    }
+    if (grpcMetadata) {
+        clonedConfig.grpcMetadata = grpcMetadata;
+    }
+    if (autoInstrumentationConfig) {
+        clonedConfig.autoInstrumentationConfig = autoInstrumentationConfig;
+    }
+    if (detection) {
+        // Clone detection but keep custom redactors by reference
+        clonedConfig.detection = {
+            ...detection,
+            custom: detection.custom,
+        };
+    }
+    return clonedConfig;
 };

package/dist/sdk-node/lib/exporter/console.js

@@ -9,6 +9,7 @@ export default function buildConsoleExporters(config) {
             ..._spansProcessorConfig(config),
         ],
         metrics: new metrics.PeriodicExportingMetricReader({
+            exportIntervalMillis: config.metrics?.exportIntervalMs,
             exporter: new metrics.ConsoleMetricExporter(),
         }),
         logs: [

package/dist/sdk-node/lib/exporter/grpc.js

@@ -24,6 +24,7 @@ export default async function buildGrpcExporters(config) {
             ..._spansProcessorConfig(config),
         ],
         metrics: new metrics.PeriodicExportingMetricReader({
+            exportIntervalMillis: config.metrics?.exportIntervalMs,
             exporter: new PIIExporterDecorator(new OTLPMetricExporter({
                 url: `${config.collectorUrl}`,
                 compression: CompressionAlgorithm.GZIP,

package/dist/sdk-node/lib/exporter/http.js

@@ -20,6 +20,7 @@ export default function buildHttpExporters(config) {
             ..._spansProcessorConfig(config),
         ],
         metrics: new metrics.PeriodicExportingMetricReader({
+            exportIntervalMillis: config.metrics?.exportIntervalMs,
             exporter: new PIIExporterDecorator(new OTLPMetricExporter({
                 url: `${config.collectorUrl}/v1/metrics`,
                 compression: CompressionAlgorithm.GZIP,

package/dist/sdk-node/lib/exporter/processor-config.d.ts

@@ -3,5 +3,6 @@ import { EnrichLogProcessor } from "../processor/enrich-logger-processor.js";
 import { EnrichSpanProcessor } from "../processor/enrich-span-processor.js";
 import { NextJsLogProcessor } from "../processor/nextjs-logger-processor.js";
 import { NextJsSpanProcessor } from "../processor/nextjs-span-processor.js";
-export declare function _spansProcessorConfig(config: NodeSDKConfig): (EnrichSpanProcessor | NextJsSpanProcessor)[];
+import { PseudoProfilingSpanProcessor } from "../processor/pseudo-profiling-span-processor.js";
+export declare function _spansProcessorConfig(config: NodeSDKConfig): (EnrichSpanProcessor | NextJsSpanProcessor | PseudoProfilingSpanProcessor)[];
 export declare function _logsProcessorConfig(config: NodeSDKConfig): (EnrichLogProcessor | NextJsLogProcessor)[];

package/dist/sdk-node/lib/exporter/processor-config.js

@@ -2,12 +2,17 @@ import { EnrichLogProcessor } from "../processor/enrich-logger-processor.js";
 import { EnrichSpanProcessor } from "../processor/enrich-span-processor.js";
 import { NextJsLogProcessor } from "../processor/nextjs-logger-processor.js";
 import { NextJsSpanProcessor } from "../processor/nextjs-span-processor.js";
+import { PseudoProfilingSpanProcessor } from "../processor/pseudo-profiling-span-processor.js";
 export function _spansProcessorConfig(config) {
     const _processor = [];
     _processor.push(new NextJsSpanProcessor());
     if (config.spanAttributes) {
         _processor.push(new EnrichSpanProcessor(config.spanAttributes));
     }
+    if (config.pseudoProfiling?.enabled) {
+        // Pseudo-profiling span processor should always be the last one in the chain
+        _processor.push(new PseudoProfilingSpanProcessor());
+    }
     return _processor;
 }
 export function _logsProcessorConfig(config) {

package/dist/sdk-node/lib/index.d.ts

@@ -1,5 +1,7 @@
 import type { Metadata } from "@grpc/grpc-js";
 import { BasicRedactor } from "../../sdk-core/lib/redaction/basic-redactor.js";
+import { InstrumentationConfigMap } from "@opentelemetry/auto-instrumentations-node";
+import { Instrumentation } from "@opentelemetry/instrumentation";
 export interface NodeSDKConfig {
     /**
      * The opentelemetry collector entrypoint GRPC url.
@@ -52,12 +54,31 @@ export interface NodeSDKConfig {
      * @default 1
      */
     traceRatio?: number;
+    metrics?: {
+        /**
+         * Delay in milliseconds for the metric reader to initiate metric collection.
+         *
+         * @default 60_000
+         */
+        exportIntervalMs?: number;
+    };
     /**
      * Flag to enable or disable the tracing for node:fs module
      *
      * @default false disabling `instrumentation-fs` because it bloating the traces
+     * @deprecated This option will be removed in a future version and is currently and replaced by the autoInstrumentationConfig option.
      */
     enableFS?: boolean;
+    /**
+     * Configuration object for auto instrumentations.
+     * @default {"@opentelemetry/instrumentation-fs":{enabled:false}}
+     */
+    autoInstrumentationConfig?: InstrumentationConfigMap;
+    /**
+     * Additional custom instrumentations to be added to the NodeSDK
+     * @default []
+     */
+    additionalInstrumentations?: Instrumentation[];
     /**
      * Protocol used to send signals.
      *
@@ -95,6 +116,17 @@ export interface NodeSDKConfig {
          */
         custom?: BasicRedactor[];
     };
+    /**
+     * Configuration for the pseudo-profiling span processor
+     * @default {enabled:false}
+     */
+    pseudoProfiling?: {
+        /**
+         * Enable/Disable pseudo-profiling span processor
+         * @default false
+         */
+        enabled: boolean;
+    };
 }
 export interface SamplerCondition {
     type: "endsWith" | "includes" | "equals";

package/dist/sdk-node/lib/instrumentation.node.js

@@ -35,11 +35,6 @@ export default async function buildNodeInstrumentation(config) {
     });
     diag.setLogger(new DiagConsoleLogger(), config.diagLogLevel ? DiagLogLevel[config.diagLogLevel] : DiagLogLevel.INFO);
     try {
-        const nodeSdkInstrumentation = getNodeAutoInstrumentations({
-            "@opentelemetry/instrumentation-fs": {
-                enabled: config.enableFS ?? false,
-            },
-        });
         let exporter;
         if (config.protocol === "http") {
             exporter = buildHttpExporters(config);
@@ -60,7 +55,14 @@ export default async function buildNodeInstrumentation(config) {
             logRecordProcessors: exporter.logs,
             sampler: mainSampler,
             textMapPropagator: new W3CTraceContextPropagator(),
-            instrumentations: [nodeSdkInstrumentation],
+            instrumentations: [
+                getNodeAutoInstrumentations(config.autoInstrumentationConfig ?? {
+                    "@opentelemetry/instrumentation-fs": {
+                        enabled: config.enableFS ?? false, // TODO: remove enableFS in future versions
+                    },
+                }),
+                ...(config.additionalInstrumentations ?? []),
+            ],
         });
         sdk.start();
         console.log("NodeJS OpenTelemetry instrumentation started successfully.");

package/dist/sdk-node/lib/processor/nextjs-span-processor.d.ts

@@ -1,8 +1,6 @@
 import { Context } from "@opentelemetry/api";
-import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-export declare class NextJsSpanProcessor implements SpanProcessor {
-    forceFlush(): Promise<void>;
-    onStart(span: Span, _context: Context): void;
-    onEnd(_span: ReadableSpan): void;
-    shutdown(): Promise<void>;
+import { Span } from "@opentelemetry/sdk-trace-base";
+import { OnEndingHookSpanProcessor } from "./on-ending-hook-span-processor.js";
+export declare class NextJsSpanProcessor extends OnEndingHookSpanProcessor {
+    onEnding(span: Span, _context: Context): void;
 }

package/dist/sdk-node/lib/processor/nextjs-span-processor.js

@@ -1,25 +1,41 @@
 import { SpanStatusCode } from "@opentelemetry/api";
-export class NextJsSpanProcessor {
-    forceFlush() {
-        return Promise.resolve();
-    }
-    onStart(span, _context) {
+import { OnEndingHookSpanProcessor } from "./on-ending-hook-span-processor.js";
+export class NextJsSpanProcessor extends OnEndingHookSpanProcessor {
+    onEnding(span, _context) {
+        // ref. https://grafana.com/docs/grafana-cloud/monitor-applications/frontend-observability/quickstart/nextjs/#instrument-the-nextjs-backend
+        if (span.name.startsWith("GET /_next/static")) {
+            span.updateName("GET /_next/static");
+        }
+        else if (span.name.startsWith("GET /_next/data")) {
+            span.updateName("GET /_next/data");
+        }
         if (span.status.code !== SpanStatusCode.ERROR)
             return;
-        let index = -1;
-        do {
-            index = span.events.findIndex((e) => typeof e.attributes?.["exception.message"] === "string" &&
-                e.attributes["exception.message"] === "NEXT_REDIRECT");
-            if (index !== -1) {
-                span.setStatus({ code: SpanStatusCode.OK });
-                span.events.splice(index, 1);
+        const events = span.events;
+        let cleaned = 0;
+        let exceptions = 0;
+        for (let i = 0; i < events.length; i++) {
+            // Required only for NexJS v14
+            if (events[i].name == "exception") {
+                exceptions++;
+                if (typeof events[i].attributes?.["exception.message"] === "string" &&
+                    events[i].attributes?.["exception.message"] === "NEXT_REDIRECT") {
+                    events.splice(i, 1);
+                    cleaned++;
+                    i--;
+                }
             }
-        } while (index !== -1);
-    }
-    onEnd(_span) {
-        return;
-    }
-    shutdown() {
-        return Promise.resolve();
+        }
+        const status = {
+            ...span.status,
+            code: cleaned === exceptions ? SpanStatusCode.UNSET : span.status.code,
+        };
+        if (cleaned) {
+            span.setAttribute("o11y.sdk.nextjs.lifecycle.redirect.cleaned", true);
+        }
+        span.setStatus(status);
+        Object.assign(span, {
+            events,
+        });
     }
 }

package/dist/sdk-node/lib/processor/on-ending-hook-span-processor.d.ts

@@ -0,0 +1,37 @@
+import { Context } from "@opentelemetry/api";
+import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+/**
+ * A SpanProcessor that provides a hook to execute custom logic
+ * just before a span is ended.
+ *
+ * This allows for capturing or modifying span data at the precise moment
+ * the span is about to be finished, while it is still writable.
+ *
+ * Usage:
+ * Extend this class and implement the onEnding method with custom logic.
+ * Override the onStart method if needed to set up any required state.
+ * The onEnding method will be called just before the span's end() method
+ * is invoked.
+ *
+ * Example:
+ * ```typescript
+ * class CustomSpanProcessor extends OnEndingHookSpanProcessor {
+ *  onEnding(span: Span, context: Context): void {
+ *     // Custom logic to execute before the span ends
+ *     span.setAttribute("custom.attribute", "value");
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class OnEndingHookSpanProcessor implements SpanProcessor {
+    /**
+     * Hook method called just before a span is ended.
+     * @param span The span that is about to end.
+     * @param context The context in which the span is ending.
+     */
+    abstract onEnding(span: Span, context: Context): void;
+    onStart(span: Span, _context: Context): void;
+    onEnd(_span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/sdk-node/lib/processor/on-ending-hook-span-processor.js

@@ -0,0 +1,41 @@
+/**
+ * A SpanProcessor that provides a hook to execute custom logic
+ * just before a span is ended.
+ *
+ * This allows for capturing or modifying span data at the precise moment
+ * the span is about to be finished, while it is still writable.
+ *
+ * Usage:
+ * Extend this class and implement the onEnding method with custom logic.
+ * Override the onStart method if needed to set up any required state.
+ * The onEnding method will be called just before the span's end() method
+ * is invoked.
+ *
+ * Example:
+ * ```typescript
+ * class CustomSpanProcessor extends OnEndingHookSpanProcessor {
+ *  onEnding(span: Span, context: Context): void {
+ *     // Custom logic to execute before the span ends
+ *     span.setAttribute("custom.attribute", "value");
+ *   }
+ * }
+ * ```
+ */
+export class OnEndingHookSpanProcessor {
+    onStart(span, _context) {
+        // Store the original end method
+        const originalEnd = span.end.bind(span);
+        // Wrap the end method to inject custom logic before ending the span
+        span.end = (endTime) => {
+            this.onEnding(span, _context);
+            originalEnd(endTime);
+        };
+    }
+    onEnd(_span) { }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+}

package/dist/sdk-node/lib/processor/pseudo-profiling-span-processor.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from "@opentelemetry/api";
+import type { Span } from "@opentelemetry/sdk-trace-base";
+import { OnEndingHookSpanProcessor } from "./on-ending-hook-span-processor.js";
+/**
+ * A SpanProcessor that captures pseudo-profiling data (CPU time and memory usage)
+ * for each span and adds them as span attributes.
+ *
+ * This processor wraps the span's end() method to capture profiling metrics
+ * just before the span is marked as ended, while the span is still writable.
+ */
+export declare class PseudoProfilingSpanProcessor extends OnEndingHookSpanProcessor {
+    private _spanProfilingData;
+    onStart(span: Span, _context: Context): void;
+    onEnding(span: Span, _context: Context): void;
+    /**
+     * Captures profiling data and sets attributes on the span.
+     * Called just before the span is ended, while it's still writable.
+     */
+    private _captureProfilingData;
+}

package/dist/sdk-node/lib/processor/pseudo-profiling-span-processor.js

@@ -0,0 +1,60 @@
+import { OnEndingHookSpanProcessor } from "./on-ending-hook-span-processor.js";
+const PROFILING_ATTRIBUTE_PREFIX = "profiling";
+/**
+ * A SpanProcessor that captures pseudo-profiling data (CPU time and memory usage)
+ * for each span and adds them as span attributes.
+ *
+ * This processor wraps the span's end() method to capture profiling metrics
+ * just before the span is marked as ended, while the span is still writable.
+ */
+export class PseudoProfilingSpanProcessor extends OnEndingHookSpanProcessor {
+    _spanProfilingData = new WeakMap();
+    onStart(span, _context) {
+        super.onStart(span, _context);
+        const cpuUsageStart = process.cpuUsage();
+        const memoryUsageStart = process.memoryUsage();
+        // Store profiling data
+        this._spanProfilingData.set(span, {
+            cpuUsageStart,
+            memoryUsageStart,
+        });
+    }
+    onEnding(span, _context) {
+        this._captureProfilingData(span);
+    }
+    /**
+     * Captures profiling data and sets attributes on the span.
+     * Called just before the span is ended, while it's still writable.
+     */
+    _captureProfilingData(span) {
+        const profilingData = this._spanProfilingData.get(span);
+        if (!profilingData) {
+            return;
+        }
+        const { cpuUsageStart, memoryUsageStart } = profilingData;
+        const cpuUsageEnd = process.cpuUsage(cpuUsageStart);
+        const memoryUsageEnd = process.memoryUsage();
+        const memoryDelta = {
+            heapUsed: memoryUsageEnd.heapUsed - memoryUsageStart.heapUsed,
+            heapTotal: memoryUsageEnd.heapTotal - memoryUsageStart.heapTotal,
+            external: memoryUsageEnd.external - memoryUsageStart.external,
+            rss: memoryUsageEnd.rss - memoryUsageStart.rss,
+            arrayBuffers: memoryUsageEnd.arrayBuffers - memoryUsageStart.arrayBuffers,
+        };
+        // CPU time in microseconds
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.cpu.user_time_us`, cpuUsageEnd.user);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.cpu.system_time_us`, cpuUsageEnd.system);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.cpu.total_time_us`, cpuUsageEnd.user + cpuUsageEnd.system);
+        // Memory delta in bytes
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.heap_used_delta_bytes`, memoryDelta.heapUsed);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.heap_total_delta_bytes`, memoryDelta.heapTotal);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.external_delta_bytes`, memoryDelta.external);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.rss_delta_bytes`, memoryDelta.rss);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.array_buffers_delta_bytes`, memoryDelta.arrayBuffers);
+        // Absolute memory values at span end (useful for overall monitoring)
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.heap_used_bytes`, memoryUsageEnd.heapUsed);
+        span.setAttribute(`${PROFILING_ATTRIBUTE_PREFIX}.memory.heap_total_bytes`, memoryUsageEnd.heapTotal);
+        // Clean up the WeakMap entry
+        this._spanProfilingData.delete(span);
+    }
+}

package/dist/sdk-node/lib/url-sampler.js

@@ -7,7 +7,9 @@ export class UrlSampler {
         this._nextSampler = nextSampler;
     }
     shouldSample(_context, traceId, _spanName, _spanKind, attributes, _links) {
-        const url = attributes["http.target"]?.toString();
+        // Check both http.target and url.path (@fastify/otel) attributes
+        const url = attributes["http.target"]?.toString() ||
+            attributes["url.path"]?.toString();
         if (url) {
             for (const condition of this._samplerCondition) {
                 if ((condition.type === "equals" && url === condition.url) ||

package/dist/sdk-node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ogcio/o11y-sdk-node",
-    "version": "0.6.2",
+    "version": "0.7.1",
     "description": "Opentelemetry standard instrumentation SDK for NodeJS based project",
     "main": "dist/index.js",
     "type": "module",
@@ -9,8 +9,11 @@
         "test": "vitest",
         "prepublishOnly": "pnpm i && rm -rf dist && tsc -p tsconfig.json",
         "test:unit": "vitest --project unit",
-        "test:integration": "pnpm --filter @ogcio/o11y run prepare:integration && vitest --project integration",
-        "test:integration:dryrun": "vitest --project integration"
+        "test:integration": "pnpm test:integration:setup && pnpm test:integration:run && pnpm test:integration:assert && pnpm test:integration:teardown",
+        "test:integration:setup": "sh ./test/integration/setup.sh integration",
+        "test:integration:run": "pnpm --filter @ogcio/o11y run prepare:integration",
+        "test:integration:assert": "vitest --project integration",
+        "test:integration:teardown": "sh ./test/integration/teardown.sh integration"
     },
     "exports": {
         ".": "./dist/sdk-node/index.js",
@@ -30,10 +33,10 @@
     "author": "team:ogcio/observability",
     "license": "ISC",
     "dependencies": {
-        "@grpc/grpc-js": "1.14.0",
+        "@grpc/grpc-js": "1.14.3",
         "@opentelemetry/api": "1.9.0",
         "@opentelemetry/api-logs": "0.208.0",
-        "@opentelemetry/auto-instrumentations-node": "0.67.0",
+        "@opentelemetry/auto-instrumentations-node": "0.67.2",
         "@opentelemetry/core": "2.2.0",
         "@opentelemetry/exporter-logs-otlp-grpc": "0.208.0",
         "@opentelemetry/exporter-logs-otlp-http": "0.208.0",
@@ -50,11 +53,11 @@
         "@opentelemetry/sdk-trace-base": "2.2.0"
     },
     "devDependencies": {
-        "@types/node": "24.10.0",
-        "@vitest/coverage-v8": "4.0.7",
-        "tsx": "4.20.6",
+        "@types/node": "25.0.2",
+        "@vitest/coverage-v8": "4.0.15",
+        "tsx": "4.21.0",
         "typescript": "5.9.3",
-        "vitest": "4.0.7"
+        "vitest": "4.0.15"
     },
     "engines": {
         "node": ">=20.6.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogcio/o11y-sdk-node",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Opentelemetry standard instrumentation SDK for NodeJS based project",
   "main": "dist/index.js",
   "type": "module",
@@ -22,10 +22,10 @@
   "author": "team:ogcio/observability",
   "license": "ISC",
   "dependencies": {
-    "@grpc/grpc-js": "1.14.0",
+    "@grpc/grpc-js": "1.14.3",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "0.208.0",
-    "@opentelemetry/auto-instrumentations-node": "0.67.0",
+    "@opentelemetry/auto-instrumentations-node": "0.67.2",
     "@opentelemetry/core": "2.2.0",
     "@opentelemetry/exporter-logs-otlp-grpc": "0.208.0",
     "@opentelemetry/exporter-logs-otlp-http": "0.208.0",
@@ -42,11 +42,11 @@
     "@opentelemetry/sdk-trace-base": "2.2.0"
   },
   "devDependencies": {
-    "@types/node": "24.10.0",
-    "@vitest/coverage-v8": "4.0.7",
-    "tsx": "4.20.6",
+    "@types/node": "25.0.2",
+    "@vitest/coverage-v8": "4.0.15",
+    "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.7"
+    "vitest": "4.0.15"
   },
   "engines": {
     "node": ">=20.6.0"
@@ -55,7 +55,10 @@
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "test": "vitest",
     "test:unit": "vitest --project unit",
-    "test:integration": "pnpm --filter @ogcio/o11y run prepare:integration && vitest --project integration",
-    "test:integration:dryrun": "vitest --project integration"
+    "test:integration": "pnpm test:integration:setup && pnpm test:integration:run && pnpm test:integration:assert && pnpm test:integration:teardown",
+    "test:integration:setup": "sh ./test/integration/setup.sh integration",
+    "test:integration:run": "pnpm --filter @ogcio/o11y run prepare:integration",
+    "test:integration:assert": "vitest --project integration",
+    "test:integration:teardown": "sh ./test/integration/teardown.sh integration"
   }
 }