nextjs - 💡(How to fix) Fix Telemetry broken when serverExternalPackages used for external telemetry package after upgrade from next15 next v16.0.2 [1 comments, 2 participants]

import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
import { HostMetrics } from "@opentelemetry/host-metrics";
import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
import { NodeSDK } from "@opentelemetry/sdk-node";
import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
import { BaseInstrumentation } from "./base";
import { InstrumentationConfig } from "./types";
import { DeploymentMetrics } from "./metrics/deployment-metrics";
import { HandlesAndRequestsMetrics } from "./metrics/handles-and-requests-metrics";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { ExpressLayerType } from "@opentelemetry/instrumentation-express";
import { PrismaInstrumentation } from "@prisma/instrumentation";
import { BullMQInstrumentation } from "@appsignal/opentelemetry-instrumentation-bullmq";

interface Startable {
  start(): void;
}

export class NodeInstrumentation extends BaseInstrumentation {
  private sdk: NodeSDK;
  private components: Startable[] = [];

  constructor(config: InstrumentationConfig) {
    super(config);
    this.sdk = this.initializeNodeSDK(config);
    this.components.push(this.sdk);
  }

  private initializeNodeSDK(config: InstrumentationConfig): NodeSDK {
    return new NodeSDK({
      sampler: config.tracerProvider?.sampler,
      spanProcessors: [
        ...(config.tracerProvider?.spanProcessors ?? []),
        this.defaultSpanProcessor(),
      ],
      contextManager: config.contextManager,
      textMapPropagator: config.textMapPropagator,
      metricReader: new PeriodicExportingMetricReader({
        exporter: new OTLPMetricExporter(this.exporterConfigs.metrics),
      }),
      logRecordProcessors: [
        new BatchLogRecordProcessor(
          new OTLPLogExporter(this.exporterConfigs.logs)
        ),
      ],
      instrumentations: [
        getNodeAutoInstrumentations({
          "@opentelemetry/instrumentation-http": {
            ignoreIncomingRequestHook: (request) => {
              return (
                this.config.ignoreUrls?.some((pattern) =>
                  request.url?.match(pattern)
                ) ?? false
              );
            },
            ...this.config.httpInstrumentation,
          },
          "@opentelemetry/instrumentation-express": {
            ignoreLayers: this.config.ignoreUrls,
            requestHook: (span, info) => {
              if (info.layerType === ExpressLayerType.REQUEST_HANDLER) {
                const route = info.route || info.request.route?.path;

                span.setAttribute("http.route", route);
                span.setAttribute("http.target", route);
              }
            },
          },
        }),
        ...(this.config.instrumentations ?? []),
      ],
      resource: this.resource,
    });
  }

  withPinoInstrumentation(): this {
    registerInstrumentations({
      instrumentations: [new PinoInstrumentation()],
    });
    return this;
  }

  withBullMQInstrumentation(options?: Record<string, unknown>): this {
    registerInstrumentations({
      instrumentations: [new BullMQInstrumentation(options)],
    });
    return this;
  }

  withPrismaInstrumentation(options?: Record<string, unknown>): this {
    registerInstrumentations({
      instrumentations: [new PrismaInstrumentation(options)],
    });
    return this;
  }

  withHostMetrics(): this {
    const hostMetrics = new HostMetrics({
      meterProvider: this.getMeterProvider(),
    });

    console.log("hostMetrics", hostMetrics);

    this.components.push(hostMetrics);

    return this;
  }

  withDeploymentMetrics(): this {
    const deploymentMetrics = new DeploymentMetrics({
      meterProvider: this.getMeterProvider(),
    });

    this.components.push(deploymentMetrics);

    return this;
  }

  withHandlesAndRequestsMetrics(): this {
    const handlesAndRequestsMetrics = new HandlesAndRequestsMetrics({
      meterProvider: this.getMeterProvider(),
    });

    this.components.push(handlesAndRequestsMetrics);

    return this;
  }

  start(): void {
    if (this.config.debug) {
      console.log("Starting OpenTelemetry Node Instrumentation");
    }

    try {
      this.components.forEach((component) => component.start());

      if (this.config.debug) {
        console.log("OpenTelemetry Node SDK started successfully");
      }
    } catch (error) {
      console.error("Failed to start OpenTelemetry SDK:", error);
      throw error;
    }
  }

  async shutdown(): Promise<void> {
    if (this.config.debug) {
      console.log("Shutting down OpenTelemetry Node Instrumentation");
    }

    try {
      await this.sdk.shutdown();

      if (this.config.debug) {
        console.log("OpenTelemetry Node SDK shut down successfully");
      }
    } catch (error) {
      console.error("Failed to shut down OpenTelemetry SDK:", error);
      throw error;
    }
  }
}

---

Next.js Version: 16.0.3 (upgraded from 15.5.6)
Node.js Version: 24.11.0
OpenTelemetry API: 1.9.0
Package Manager: pnpm 10.20.0
Build Tool: Turbopack (default in Next.js 16)
Custom Instrumentation: @customrepo/instrumentation (local package)