Instrumenting a Temporal TypeScript application with OpenTelemetry

{
  "dependencies": {
    "@opentelemetry/auto-instrumentations-node": "^0.55.0",
    "@opentelemetry/core": "^1.30.0",
    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.57.0",
    "@opentelemetry/exporter-trace-otlp-grpc": "^0.57.0",
    "@opentelemetry/resources": "^1.30.0",
    "@opentelemetry/sdk-metrics": "^1.30.0",
    "@opentelemetry/sdk-node": "^0.57.0",
    "@opentelemetry/sdk-trace-node": "^1.30.0",
    "@opentelemetry/semantic-conventions": "^1.28.0",
    "@opentelemetry/winston-transport": "^0.11.0",
    "@temporalio/activity": "^1.13.2",
    "@temporalio/client": "^1.13.2",
    "@temporalio/interceptors-opentelemetry": "^1.13.2",
    "@temporalio/worker": "^1.13.2",
    "@temporalio/workflow": "^1.13.2"
  }
}

npm install

import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';
import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { Resource } from '@opentelemetry/resources';
import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';

// Parse authentication headers from environment
function parseHeaders(headersString: string | undefined): Record<string, string> {
  if (!headersString) return {};
  const headers: Record<string, string> = {};
  headersString.split(',').forEach((pair) => {
    const [key, value] = pair.split('=');
    if (key && value) headers[key.trim()] = value.trim();
  });
  return headers;
}

export const otlpHeaders = parseHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS);

// Set up resource with service name
const serviceName = process.env.OTEL_SERVICE_NAME || 'temporal-typescript-app';
export const resource = new Resource({
  [ATTR_SERVICE_NAME]: serviceName,
});

// Configure trace exporter (sends traces to SigNoz)
export const traceExporter = new OTLPTraceExporter({
  headers: otlpHeaders,
  timeoutMillis: 10000,
});

// Configure metric reader (sends metrics to SigNoz)
const metricReader = new PeriodicExportingMetricReader({
  exporter: new OTLPMetricExporter({
    headers: otlpHeaders,
    timeoutMillis: 10000,
  }),
});

// Initialize OpenTelemetry SDK
export const otelSdk = new NodeSDK({
  resource,
  traceExporter,
  metricReader,
  instrumentations: [getNodeAutoInstrumentations()],
});

otelSdk.start();
console.log('[OpenTelemetry] SDK initialized successfully');

import { otelSdk } from './instrumentation'; // MUST be first import
import { Client } from '@temporalio/client';
import { OpenTelemetryWorkflowClientInterceptor } from '@temporalio/interceptors-opentelemetry';

async function run() {
  try {
    const client = new Client({
      interceptors: {
        workflow: [new OpenTelemetryWorkflowClientInterceptor()],
      },
    });

    // Start a workflow
    const handle = await client.workflow.start('myWorkflow', {
      taskQueue: 'my-task-queue',
      workflowId: 'my-workflow-id',
    });

    console.log(`Started workflow: ${handle.workflowId}`);
  } finally {
    await otelSdk.shutdown(); // Clean shutdown
  }
}

run().catch(console.error);

import { otelSdk, otlpHeaders, resource, traceExporter } from './instrumentation'; // MUST be first
import { 
  DefaultLogger, 
  makeTelemetryFilterString, 
  NativeConnection, 
  Runtime, 
  Worker 
} from '@temporalio/worker';
import {
  OpenTelemetryActivityInboundInterceptor,
  OpenTelemetryActivityOutboundInterceptor,
  makeWorkflowExporter,
} from '@temporalio/interceptors-opentelemetry/lib/worker';

// Configure Temporal's runtime telemetry
Runtime.install({
  telemetryOptions: {
    metrics: {
      otel: {
        url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
        headers: otlpHeaders,
        metricsExportInterval: '10s',
      },
    },
  },
});

async function run() {
  try {
    const worker = await Worker.create({
      workflowsPath: require.resolve('./workflows'),
      taskQueue: 'my-task-queue',
      
      // Export workflow traces
      sinks: traceExporter && {
        exporter: makeWorkflowExporter(traceExporter, resource),
      },
      
      // Instrument activities
      interceptors: {
        workflowModules: [require.resolve('./workflows')],
        activity: [
          (ctx) => ({
            inbound: new OpenTelemetryActivityInboundInterceptor(ctx),
            outbound: new OpenTelemetryActivityOutboundInterceptor(ctx),
          }),
        ],
      },
    });

    await worker.run();
  } finally {
    await otelSdk.shutdown();
  }
}

run().catch(console.error);

import { WorkflowInterceptorsFactory } from '@temporalio/workflow';
import {
  OpenTelemetryInboundInterceptor,
  OpenTelemetryOutboundInterceptor,
  OpenTelemetryInternalsInterceptor,
} from '@temporalio/interceptors-opentelemetry/lib/workflow';

// Your workflow interceptors
export const interceptors: WorkflowInterceptorsFactory = () => ({
  inbound: [new OpenTelemetryInboundInterceptor()],
  outbound: [new OpenTelemetryOutboundInterceptor()],
  internals: [new OpenTelemetryInternalsInterceptor()],
});

// Example workflow
export async function myWorkflow(): Promise<string> {
  // Your workflow logic here
  return 'completed';
}