Managed Service for OpenTelemetry:Submit trace data from a Node.js application

Step 1: Install dependencies

cd auto-instrumentation
npm init -y
npm install express axios

Step 2: Install OpenTelemetry packages

npm install --save @opentelemetry/api @opentelemetry/auto-instrumentations-node

Step 3: Create the application

The following example creates a basic Express server with two routes:

"use strict";

const axios = require("axios").default;
const express = require("express");
const app = express();

app.get("/", async (req, res) => {
  const result = await axios.get("http://localhost:7001/hello");
  return res.status(201).send(result.data);
});

app.get("/hello", async (req, res) => {
  console.log("hello world!")
  res.json({ code: 200, msg: "success" });
});

app.use(express.json());

app.listen(7001, () => {
  console.log("Listening on http://localhost:7001");
});

Step 4: Set environment variables and start the application

Set the following environment variables, then start the application:

export OTEL_TRACES_EXPORTER="otlp"
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="<your-endpoint>"
export OTEL_NODE_RESOURCE_DETECTORS="env,host,os"
export OTEL_SERVICE_NAME="<your-service-name>"
export NODE_OPTIONS="--require @opentelemetry/auto-instrumentations-node/register"
node main.js

Replace the following placeholders with your actual values:

The following table describes each environment variable:

For details on all available OpenTelemetry environment variables, see Automatic Instrumentation Configuration.

Step 5: Generate trace data

Send a request to generate traces:

curl localhost:7001/hello

After the request completes, the SDK exports trace data to Managed Service for OpenTelemetry.

Step 1: Add OpenTelemetry dependencies

Add the following dependencies to your package.json file:

"dependencies": {
    "@opentelemetry/api": "^1.0.4",
    "@opentelemetry/exporter-trace-otlp-grpc": "^0.27.0",
    "@opentelemetry/instrumentation": "^0.27.0",
    "@opentelemetry/instrumentation-express": "^0.27.0",
    "@opentelemetry/instrumentation-http": "^0.27.0",
    "@opentelemetry/resources": "^1.0.1",
    "@opentelemetry/sdk-trace-base": "^1.0.1",
    "@opentelemetry/sdk-trace-node": "^1.0.1"
}

Step 2: Create the tracer provider

const { Resource } = require("@opentelemetry/resources");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
const {
  SemanticResourceAttributes,
} = require("@opentelemetry/semantic-conventions");

const provider = new NodeTracerProvider({
  resource: new Resource({
    [SemanticResourceAttributes.HOST_NAME]: require("os").hostname(),
    // Replace "opentelemetry-express" with your service name
    [SemanticResourceAttributes.SERVICE_NAME]: "opentelemetry-express",
  }),
});

Step 3: Register framework instrumentations

Register HTTP and Express instrumentations to trace incoming and outgoing requests automatically:

const { registerInstrumentations } = require("@opentelemetry/instrumentation");
const { HttpInstrumentation } = require("@opentelemetry/instrumentation-http");
const {
  ExpressInstrumentation,
} = require("@opentelemetry/instrumentation-express");

registerInstrumentations({
  tracerProvider: provider,
  instrumentations: [new HttpInstrumentation(), ExpressInstrumentation],
});

To instrument other Node.js frameworks, see the OpenTelemetry auto-instrumentations-node package for available plugins.

Step 4: Configure the exporter

Configure an OTLP exporter over gRPC to send trace data to Managed Service for OpenTelemetry:

const metadata = new grpc.Metadata();
metadata.set("Authentication", "<your-token>");

const exporter = new OTLPTraceExporter({ url: "<your-endpoint>", metadata });
provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
provider.register();

Replace the following placeholders with your actual values:

Step 5 (optional): Add custom events and attributes

Attach events and attributes to the current span for application-specific context:

const api = require("@opentelemetry/api");
const currentSpan = api.trace.getSpan(api.context.active());

// Add a timestamped event
currentSpan.addEvent("timestamp", { value: Date.now() });

// Add a custom attribute
currentSpan.setAttribute("tagKey-01", "tagValue-01");

For more on the OpenTelemetry tracing API, see the OpenTelemetry JS getting started guide.

Application does not appear in the console

• Verify that OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (automatic) or the url parameter in OTLPTraceExporter (manual) matches the endpoint from the console.

• Confirm network connectivity to the endpoint. If your application runs outside Alibaba Cloud, use the public endpoint instead of the VPC endpoint.

• Make sure your application has received at least one request. OpenTelemetry buffers spans before exporting them.

• For manual instrumentation, confirm the tracer provider is initialized before any application imports. Incorrect initialization order causes missing spans.

Enable debug logging

Set the OpenTelemetry log level to debug to inspect SDK behavior:

export OTEL_LOG_LEVEL=debug

Restart the application and check the console output for span export logs and errors. A successful export produces log entries similar to:

@opentelemetry/api: Registered a global for diag v1.x.x
...
items to be sent [{"traceId":"...","spanId":"...","name":"GET /hello",...}]

If no span entries appear, verify that your application has processed at least one request and that the endpoint is reachable.