// tracing.ts — load before your app
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 { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions'

const sdk = new NodeSDK({
  resource: new Resource({
    [ATTR_SERVICE_NAME]: process.env.SERVICE_NAME ?? 'unknown-service',
    [ATTR_SERVICE_VERSION]: process.env.SERVICE_VERSION ?? '0.0.0',
    'deployment.environment': process.env.NODE_ENV ?? 'development',
  }),
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://otel-collector:4318/v1/traces',
  }),
  metricReader: new PeriodicExportingMetricReader({
    exporter: new OTLPMetricExporter({
      url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://otel-collector:4318/v1/metrics',
    }),
    exportIntervalMillis: 15_000,
  }),
  instrumentations: [
    getNodeAutoInstrumentations({
      '@opentelemetry/instrumentation-fs': { enabled: false }, // too noisy
      '@opentelemetry/instrumentation-http': {
        requestHook: (span, request) => {
          span.setAttribute('http.request.body.size', request.headers['content-length'] ?? 0)
        },
      },
    }),
  ],
})

sdk.start()

process.on('SIGTERM', () => sdk.shutdown())

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

const tracer = trace.getTracer('order-service', '1.0.0')

async function processOrder(orderId: string, userId: string) {
  // Create a root span for the business operation
  return tracer.startActiveSpan('order.process', async (span) => {
    // Add business context as attributes
    span.setAttributes({
      'order.id': orderId,
      'user.id': userId,
      'order.source': 'web',
    })
    
    try {
      // Nested spans for sub-operations
      const inventory = await tracer.startActiveSpan('inventory.check', async (invSpan) => {
        const result = await checkInventory(orderId)
        invSpan.setAttribute('inventory.available', result.available)
        invSpan.end()
        return result
      })
      
      if (!inventory.available) {
        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Out of stock' })
        span.addEvent('order.rejected', { reason: 'out_of_stock' })
        throw new Error(`Order ${orderId} failed: out of stock`)
      }
      
      const payment = await tracer.startActiveSpan('payment.charge', async (paySpan) => {
        const result = await chargePayment(userId, inventory.totalAmount)
        paySpan.setAttributes({
          'payment.amount': inventory.totalAmount,
          'payment.currency': 'USD',
          'payment.method': result.method,
        })
        paySpan.end()
        return result
      })
      
      span.addEvent('order.completed', {
        'order.total': inventory.totalAmount,
        'payment.id': payment.id,
      })
      
      span.setStatus({ code: SpanStatusCode.OK })
      return { success: true, paymentId: payment.id }
      
    } catch (error) {
      span.recordException(error as Error)
      span.setStatus({ code: SpanStatusCode.ERROR })
      throw error
    } finally {
      span.end()
    }
  })
}

import { metrics } from '@opentelemetry/api'

const meter = metrics.getMeter('order-service', '1.0.0')

// Counter: monotonically increasing
const ordersProcessed = meter.createCounter('orders.processed', {
  description: 'Total number of orders processed',
  unit: '{orders}',
})

// Histogram: latency / distribution data
const orderProcessingDuration = meter.createHistogram('orders.processing.duration', {
  description: 'Time to process an order',
  unit: 'ms',
  advice: {
    explicitBucketBoundaries: [10, 50, 100, 200, 500, 1000, 2000, 5000],
  },
})

// UpDownCounter: can go up or down (e.g., queue depth)
const activeOrders = meter.createUpDownCounter('orders.active', {
  description: 'Number of orders currently being processed',
})

// Gauge: point-in-time measurement (via observable)
const orderQueueDepth = meter.createObservableGauge('orders.queue.depth', {
  description: 'Current depth of the order processing queue',
})
orderQueueDepth.addCallback((result) => {
  result.observe(getQueueDepth(), { queue: 'primary' })
})

// Usage in business logic
async function processOrder(orderId: string) {
  const startTime = Date.now()
  activeOrders.add(1, { status: 'processing' })
  
  try {
    const result = await doProcessOrder(orderId)
    ordersProcessed.add(1, { status: 'success', region: result.region })
    return result
  } catch (error) {
    ordersProcessed.add(1, { status: 'error', error_type: error.constructor.name })
    throw error
  } finally {
    orderProcessingDuration.record(Date.now() - startTime)
    activeOrders.add(-1, { status: 'processing' })
  }
}

import { logs, SeverityNumber } from '@opentelemetry/api-logs'
import { context, trace } from '@opentelemetry/api'

const logger = logs.getLogger('order-service')

function structuredLog(level: SeverityNumber, message: string, attributes: Record<string, unknown> = {}) {
  const span = trace.getActiveSpan()
  const spanContext = span?.spanContext()
  
  logger.emit({
    severityNumber: level,
    severityText: SeverityNumber[level],
    body: message,
    attributes: {
      ...attributes,
      // Automatically inject trace context for log-trace correlation
      'trace.id': spanContext?.traceId,
      'span.id': spanContext?.spanId,
      'service.name': 'order-service',
    },
    timestamp: new Date(),
  })
}

// Usage
structuredLog(SeverityNumber.INFO, 'Order payment processed', {
  'order.id': orderId,
  'payment.amount': amount,
  'payment.provider': 'stripe',
})

// Node.js continuous profiling with OTel
import { ProfilingExporter } from '@opentelemetry/exporter-profiles-otlp-http'
import { ContinuousProfiler } from '@opentelemetry/profiling'

const profiler = new ContinuousProfiler({
  exporter: new ProfilingExporter({
    url: 'http://pyroscope:4040/ingest',
  }),
  intervalMs: 10_000,       // Profile every 10 seconds
  collectCpuProfile: true,
  collectHeapProfile: true,
})

profiler.start()