Added Collector and Agent, but path doesn't seem to go through any of them.

[Nathan-Bernardo]

Problem

I added a collector gateway and collector agent to my docker compose file. I expect paths to go through the agent and collector, but it doesn't seem to be the case. I was expecting in the "Process" box in Jaeger to find component.name1: agent and test.key: gateway to verify that the collector and agent were set up correctly.

Setup

collector-agent.yml

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

exporters:
  otlp:
    endpoint: "collector-gateway:4320"
    insecure: true
  logging:
    loglevel: info

processors:
  batch:
    timeout: 1s
  resource:
    attributes:
      - key: component.name1
        value: "agent"
        action: insert

extensions:
  health_check:

service:
  extensions: [health_check]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch, resource]
      exporters: [logging, otlp]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging, otlp]

collector-gateway.yml

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4319
      grpc:
        endpoint: 0.0.0.0:4320

processors:
  batch:
    timeout: 1s
  resource:
    attributes:
      - key: test.key
        value: "gateway"
        action: insert

exporters:
  logging:
    loglevel: info
  jaeger:
    endpoint: jaeger:14250
    tls:
      insecure: true

extensions:
  health_check:
  pprof:
    endpoint: :1888
  zpages:
    endpoint: :55679

service:
  extensions: [pprof, zpages, health_check]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch, resource]
      exporters: [logging, jaeger]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]

docker-compose.yml

version: '3'
services:
  ...
  jaeger:
    image: jaegertracing/all-in-one:latest
    restart: always
    ports:
      - 5775:5775
      - 6831:6831
      - 6832:6832
      - 5778:5778
      - 16686:16686
      - 14268:14268
      - 14250:14250
      - 9411:9411
    environment:
      - COLLECTOR_ZIPKIN=:9411
      - COLLECTOR_OTLP_ENABLED=true
  collector-gateway:
    image: otel/opentelemetry-collector:0.70.0
    volumes:
      - ./config/collector-gateway.yml:/etc/otel-collector-config.yaml
    command: ["--config=/etc/otel-collector-config.yaml"]
    ports:
      - 1888:1888
      - 8888:8888
      - 13133:13133
      - 4320:4320
      - 4319:4319
      - 55670:55679
  collector-agent:
    image: otel/opentelemetry-collector:0.29.0
    volumes:
      - ./config/collector-agent.yml:/etc/otel-collector-config.yaml
    command: ["--config=/etc/otel-collector-config.yaml"]
    ports:
      # - "1888:1888"   # pprof extension
      # - "13133:13133" # health_check extension
      - "4318:4318" # OTLP HTTP receiver
      # - "55670:55679" # zpages extension

Here is my tracer file.
tracer.ts

import {
  envDetector,
  processDetector,
  Resource,
} from '@opentelemetry/resources';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
import * as opentelemetry from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { dockerCGroupV1Detector } from '@opentelemetry/resource-detector-docker';

const traceExporter = new OTLPTraceExporter({
  url: 'http://jaeger:4318/v1/traces',
});

const sdk = new opentelemetry.NodeSDK({
  traceExporter,
  instrumentations: [
    getNodeAutoInstrumentations({
      '@opentelemetry/instrumentation-express': {
        requestHook: (span, reqInfo) => {
          span.setAttribute(
            'request-headers',
            JSON.stringify(reqInfo.request.headers),
          );
        },
      },
      '@opentelemetry/instrumentation-fs': {
        enabled: false,
      },
    }),
  ],
  resourceDetectors: [envDetector, processDetector, dockerCGroupV1Detector],
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'item_service',
  }),
});

sdk
  .start()
  .then(() => console.log('Tracing initialized'))
  .catch((error) => console.log('Error initializing tracing', error));

// gracefully shut down the SDK on process exit
process.on('SIGTERM', () => {
  sdk
    .shutdown()
    .then(() => console.log('Tracing terminated'))
    .catch((error) => console.log('Error terminating tracing', error))
    .finally(() => process.exit(0));
});

export default sdk;

Here is where I initialize my tracer.
main.ts

import tracer from './tracer';
tracer.start();

import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
import { AppModule } from './app.module';
import helmet from 'helmet';

async function bootstrap() {
  const logger = new Logger('Item:bootstrap');
  const app = await NestFactory.create(AppModule);
  app.use(helmet());
  app.setGlobalPrefix('api/v1');
  const microservice = app.connectMicroservice({
    transport: Transport.NATS,
    options: {
      servers: ['nats://nats:4222'],
    },
  });

  await app.startAllMicroservices();
  logger.verbose('Microservice is starting');
  await app.listen(8080, () => {
    logger.verbose('Listening to port 9010');
  });
}
bootstrap();

Discussion

I'm building a microservice application to test out OpenTelemetry and Jaeger. I'm trying to learn how to deploy this to production, and that requires me adding a collector and agent. Any advice would be much appreciated. Thank you in advance!