How to add multiple processors to tracing sdk in Nodejs Opentelemetry NodeSDK?

[sanasz91mdev]

Hello,

Is there a way i can add multiple processors while setting up Opentelemetry in Node.js? There seems no way to do so in NodeSDK in opentelemetry-js/sdk-node pack

const opentelemetry = require("@opentelemetry/sdk-node");
const { getNodeAutoInstrumentations } = require("@opentelemetry/auto-instrumentations-node");
const { JaegerExporter } = require("@opentelemetry/exporter-jaeger");
const { Resource } = require("@opentelemetry/resources");
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
const { SimpleSpanProcessor } = require("@opentelemetry/sdk-trace-base");
const { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");

function start(appName) {
    var exporter = new JaegerExporter();
    const sdk = new opentelemetry.NodeSDK({
        resource: new Resource({
            [SemanticResourceAttributes.SERVICE_NAME]: appName,
        }),
        instrumentations: [getNodeAutoInstrumentations()],
        traceExporter: exporter,
        spanProcessor: new SimpleSpanProcessor(exporter),
    });
    sdk.pro
    sdk.start();
}


module.exports = { start }

Is there any other way by which i can add multiple processors via Code? ... I do not want to use OpenTelemetry Collector.

[dyladan]

It can be done if you set up the SDK components manually by creating a tracer provider and calling addSpanProcessor on it multiple times, then registering it using api.tracing.setGlobalTracerProvider

[swantzter]

Hi, is there any example of this? When I try to do this I get a bunch of errors like Error: @opentelemetry/api: Attempted duplicate registration of API: trace

Here's what I'm currently trying to do in tracing.js required with node --require ./tracing.js .:

const { NodeSDK, api, tracing, node, resources } = require('@opentelemetry/sdk-node')
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
const { SequelizeInstrumentation } = require('opentelemetry-instrumentation-sequelize')
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-grpc')
const { AWSXRayPropagator } = require('@opentelemetry/propagator-aws-xray')
const { AWSXRayIdGenerator } = require('@opentelemetry/id-generator-aws-xray')
const { awsEcsDetector } = require('@opentelemetry/resource-detector-aws')

const traceProvider = new node.NodeTracerProvider({
  idGenerator: new AWSXRayIdGenerator()
})
traceProvider.register({
  propagator: new AWSXRayPropagator()
})

// add OTLP exporter
const traceExporter = new OTLPTraceExporter({
  // port configured in the Collector config, defaults to 4317
  url: 'localhost:4317'
})
traceProvider.addSpanProcessor(new tracing.BatchSpanProcessor(traceExporter))
api.trace.setGlobalTracerProvider(traceProvider)

const sdk = new NodeSDK({
  serviceName: pkgJson.name,
  instrumentations: [
    getNodeAutoInstrumentations(),
    new SequelizeInstrumentation()
  ],
  resourceDetectors: [resources.envDetector, resources.processDetector, awsEcsDetector]
})

sdk.start()

[legendecas]

You don't need to create the NodeSDK again when you are creating your own tracer provider. The key here is that you'll need to setup the resource detection and instrumentation registration manually:

const api = require('@opentelemetry/api');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { detectResource } = require('@opentelemetry/resources');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
const { SequelizeInstrumentation } = require('opentelemetry-instrumentation-sequelize')
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-grpc')
const { AWSXRayPropagator } = require('@opentelemetry/propagator-aws-xray')
const { AWSXRayIdGenerator } = require('@opentelemetry/id-generator-aws-xray')
const { awsEcsDetector } = require('@opentelemetry/resource-detector-aws')

(async function setup() {
  const resource = await detectResource({
    detectors: [resources.envDetector, resources.processDetector, awsEcsDetector]
  });
  const traceProvider = new node.NodeTracerProvider({
    resource,
    idGenerator: new AWSXRayIdGenerator()
  })
  traceProvider.register({
    propagator: new AWSXRayPropagator()
  })

  // add OTLP exporter
  const traceExporter = new OTLPTraceExporter({
    // port configured in the Collector config, defaults to 4317
    url: 'localhost:4317'
  })
  traceProvider.addSpanProcessor(new tracing.BatchSpanProcessor(traceExporter))
  api.trace.setGlobalTracerProvider(traceProvider)

  registerInstrumentations([
    getNodeAutoInstrumentations(),
    new SequelizeInstrumentation()
  ])
})();

[swantzter]

Fair, yeah this is what I eventually moved too. A little bit of a shame because I wanted to use the NodeSDK as far as possible to avoid having to make changes if new things are introduced to it down the line

[sanasz91mdev]

@swantzter you can use NodeSDK ... this is how i have done it:

I basically implemented my own Processor RedactionProcessor that implements SpanProcessor and then i registered it as follows

const opentelemetry = require("@opentelemetry/sdk-node");
const { getNodeAutoInstrumentations } = require("@opentelemetry/auto-instrumentations-node");
const { JaegerExporter } = require("@opentelemetry/exporter-jaeger");
const { Resource } = require("@opentelemetry/resources");
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
const { BasicTracerProvider } = require("@opentelemetry/sdk-trace-base");
const { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");
const { RedactionProcessor } = require('./redaction-processor');
const { trace } = require('@opentelemetry/api');


function start(appName) {
    const exporter = new JaegerExporter();
    const provider = new BasicTracerProvider({
        resource: new Resource({
            [SemanticResourceAttributes.SERVICE_NAME]: appName,
        }),
    });
    provider.addSpanProcessor(new RedactionProcessor());
    provider.addSpanProcessor(new BatchSpanProcessor(exporter));
    provider.register();
    trace.setGlobalTracerProvider(provider);
    const sdk = new opentelemetry.NodeSDK({
        traceExporter: exporter,
        instrumentations: [getNodeAutoInstrumentations()],
    });
    sdk.start();
}

trace.setGlobalTracerProvider(provider); ----- > This make sure that Node SDK uses both the processors that are added to provider

[sanasz91mdev]

@dyladan Thanks, i have figured this out :)

[danielkhan]

Given that this is a common use case, would it be feasible to let spanProcessor take an array optionally?

[clesleycode]

Can confirm this would be useful for us!

[WesleyYue]

There's finally a sane API for this! #4454