// tracing.ts - Load FIRST before any other imports
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';

const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'my-service',
    [SemanticResourceAttributes.SERVICE_VERSION]: '1.0.0',
    [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV,
  }),
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT + '/v1/traces',
  }),
  metricReader: new PeriodicExportingMetricReader({
    exporter: new OTLPMetricExporter({
      url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT + '/v1/metrics',
    }),
    exportIntervalMillis: 60000,
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start();

process.on('SIGTERM', () => {
  sdk.shutdown().then(() => process.exit(0));
});

import { trace, SpanStatusCode, context } from '@opentelemetry/api';

const tracer = trace.getTracer('my-service');

async function processOrder(orderId: string) {
  // Create a span
  return tracer.startActiveSpan('processOrder', async (span) => {
    try {
      // Add attributes
      span.setAttribute('order.id', orderId);
      span.setAttribute('order.type', 'standard');
      
      // Add event
      span.addEvent('order.validation.started');
      
      const result = await validateOrder(orderId);
      
      span.addEvent('order.validation.completed', {
        'validation.result': result.valid,
      });
      
      if (!result.valid) {
        span.setStatus({
          code: SpanStatusCode.ERROR,
          message: 'Order validation failed',
        });
        throw new Error('Invalid order');
      }
      
      // Nested span
      await tracer.startActiveSpan('chargePayment', async (paymentSpan) => {
        paymentSpan.setAttribute('payment.method', 'card');
        await chargeCustomer(orderId);
        paymentSpan.end();
      });
      
      span.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (error) {
      span.recordException(error);
      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      throw error;
    } finally {
      span.end();
    }
  });
}

import { metrics } from '@opentelemetry/api';

const meter = metrics.getMeter('my-service');

// Counter - for counting things
const requestCounter = meter.createCounter('http_requests_total', {
  description: 'Total HTTP requests',
});

// Histogram - for measuring distributions
const latencyHistogram = meter.createHistogram('http_request_duration_ms', {
  description: 'HTTP request latency in milliseconds',
  unit: 'ms',
});

// Gauge - for current values
const activeConnections = meter.createObservableGauge('active_connections', {
  description: 'Number of active connections',
});

activeConnections.addCallback((result) => {
  result.observe(connectionPool.activeCount, { pool: 'main' });
});

// Usage
function handleRequest(req, res) {
  const startTime = Date.now();
  
  requestCounter.add(1, {
    method: req.method,
    route: req.route.path,
  });
  
  res.on('finish', () => {
    latencyHistogram.record(Date.now() - startTime, {
      method: req.method,
      route: req.route.path,
      status_code: res.statusCode,
    });
  });
}

import { context, propagation, trace } from '@opentelemetry/api';

// Extract context from incoming request
function extractContext(req) {
  return propagation.extract(context.active(), req.headers);
}

// Inject context to outgoing request
async function callExternalService(data) {
  const headers = {};
  propagation.inject(context.active(), headers);
  
  return fetch('https://external-service.com/api', {
    method: 'POST',
    headers: {
      ...headers,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(data),
  });
}

// Express middleware
app.use((req, res, next) => {
  const ctx = extractContext(req);
  context.with(ctx, () => next());
});

import { propagation, context, baggage } from '@opentelemetry/api';

// Set baggage
function setRequestBaggage(tenantId: string, userId: string) {
  const bag = baggage.setEntry(
    baggage.setEntry(baggage.active(), 'tenant.id', { value: tenantId }),
    'user.id',
    { value: userId }
  );
  return baggage.setActiveBaggage(bag);
}

// Read baggage
function getTenantId(): string | undefined {
  return baggage.getEntry(baggage.active(), 'tenant.id')?.value;
}