Instrumenting a Temporal TypeScript application with OpenTelemetry

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

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';
import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';

// Parse authentication headers from environment variables
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 to send traces to SigNoz
const traceExporter = new OTLPTraceExporter({
  headers: otlpHeaders,
  timeoutMillis: 10000,
});

export const spanProcessor = new BatchSpanProcessor(traceExporter);

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

// Initialize and start the OpenTelemetry SDK
export function setupOtelSdk(): NodeSDK {
  const otelSdk = new NodeSDK({
    resource,
    spanProcessors: [spanProcessor],
    metricReader,
    instrumentations: [getNodeAutoInstrumentations()],
  });

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

import { DefaultLogger, Worker, Runtime, makeTelemetryFilterString } from '@temporalio/worker';
import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry';
import { setupOtelSdk, resource, spanProcessor, otlpHeaders } from './instrumentation';
import * as activities from './activities';

// Configure Temporal's runtime telemetry
function initializeRuntime() {
  Runtime.install({
    logger: new DefaultLogger('WARN'),
    telemetryOptions: {
      metrics: {
        otel: {
          url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
          headers: otlpHeaders,
          metricsExportInterval: '1s',
        },
      },
      logging: {
        forward: {},
        filter: makeTelemetryFilterString({ core: 'INFO', other: 'INFO' }),
      },
    },
  });
}

async function run() {
  const otelSdk = setupOtelSdk();
  initializeRuntime();

  // OpenTelemetryPlugin configures interceptors and sinks for tracing
  const plugins = [new OpenTelemetryPlugin({ resource, spanProcessor })];

  try {
    const worker = await Worker.create({
      workflowsPath: require.resolve('./workflows'),
      activities,
      taskQueue: 'my-task-queue',
      plugins,
    });

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

run().catch(console.error);

import { setupOtelSdk, resource, spanProcessor } from './instrumentation';
import { Connection, Client } from '@temporalio/client';
import { loadClientConnectConfig } from '@temporalio/envconfig';
import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry';

async function run() {
  const otelSdk = setupOtelSdk();

  try {
    const config = loadClientConnectConfig();
    const connection = await Connection.connect(config.connectionOptions);

    // OpenTelemetryPlugin registers tracing interceptors for client calls
    const plugins = spanProcessor ? [new OpenTelemetryPlugin({ resource, spanProcessor })] : [];

    const client = new Client({
      connection,
      plugins,
    });

    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();
  }
}

run().catch(console.error);

import { proxyActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { greet } = proxyActivities<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export async function myWorkflow(name: string): Promise<string> {
  return await greet(name);
}

export async function greet(name: string): Promise<string> {
  return `Hello, ${name}!`;
}