OpenTelemetry Node SDK

import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import type { NodeTracerConfig } from "@opentelemetry/sdk-trace-node";

const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

// Classes and functions
import { 
  AlwaysOffSampler, AlwaysOnSampler, BasicTracerProvider,
  BatchSpanProcessor, ConsoleSpanExporter, InMemorySpanExporter,
  NoopSpanProcessor, ParentBasedSampler, RandomIdGenerator,
  SamplingDecision, SimpleSpanProcessor, TraceIdRatioBasedSampler
} from "@opentelemetry/sdk-trace-node";

// Types
import type { 
  BatchSpanProcessorBrowserConfig, BufferConfig, GeneralLimits,
  IdGenerator, ReadableSpan, Sampler, SamplingResult,
  SDKRegistrationConfig, Span, SpanExporter, SpanLimits,
  SpanProcessor, TimedEvent, TracerConfig
} from "@opentelemetry/sdk-trace-node";

import { NodeTracerProvider, ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

// Create NodeTracerProvider with automatic AsyncLocalStorage context management
const provider = new NodeTracerProvider();

// Add span processor
provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));

// Register automatically sets up:
// - AsyncLocalStorageContextManager for async context propagation
// - W3C Trace Context and Baggage propagators
provider.register();

// Traces will now automatically propagate across async operations
// without manual context passing

/**
 * NodeTracerProvider extends BasicTracerProvider with Node.js-specific functionality.
 * Automatically configures AsyncLocalStorage for context management and W3C propagators.
 */
class NodeTracerProvider extends BasicTracerProvider {
  /**
   * Creates a new NodeTracerProvider instance
   * @param config - Optional configuration (same as TracerConfig from base SDK)
   */
  constructor(config?: NodeTracerConfig);

  /**
   * Register this TracerProvider for use with the OpenTelemetry API.
   * Automatically sets up:
   * - Global tracer provider
   * - AsyncLocalStorageContextManager (unless null is provided)
   * - W3C Trace Context and Baggage propagators (unless null is provided)
   * @param config - Configuration object for SDK registration
   */
  register(config?: SDKRegistrationConfig): void;
}

/**
 * Configuration for NodeTracerProvider - identical to TracerConfig from base SDK
 */
type NodeTracerConfig = TracerConfig;

/**
 * Configuration for SDK registration controlling context manager and propagator setup
 */
interface SDKRegistrationConfig {
  /** 
   * Context manager for trace context across async operations
   * - undefined: Uses AsyncLocalStorageContextManager (default)
   * - null: No context manager setup
   * - ContextManager: Custom context manager
   */
  contextManager?: ContextManager | null;
  /** 
   * Propagator for trace context in requests
   * - undefined: Uses W3C Trace Context + Baggage propagators (default) 
   * - null: No propagator setup
   * - TextMapPropagator: Custom propagator
   */
  propagator?: TextMapPropagator | null;
}

import { NodeTracerProvider, ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

// Create provider - AsyncLocalStorage context management is automatic
const provider = new NodeTracerProvider();
provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));

// Register sets up everything needed for Node.js tracing
provider.register();

// Traces now automatically propagate across async operations

import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';

const provider = new NodeTracerProvider();

// Use custom context manager
const customContextManager = new AsyncLocalStorageContextManager();
provider.register({ 
  contextManager: customContextManager,
  // propagator: undefined uses default W3C propagators
});

import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';

const provider = new NodeTracerProvider();

// Register without automatic context manager or propagator setup
provider.register({ 
  contextManager: null,  // No context manager
  propagator: null       // No propagators
});

// Manual setup would be required in this case

import { trace, SpanStatusCode } from '@opentelemetry/api';
import { NodeTracerProvider, ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

// Setup
const provider = new NodeTracerProvider();
provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
provider.register(); // Automatic AsyncLocalStorage setup

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

// Parent span
tracer.startActiveSpan('parent-operation', async (parentSpan) => {
  
  // Child spans automatically inherit context across async operations
  await new Promise(resolve => {
    setTimeout(() => {
      tracer.startActiveSpan('child-operation', (childSpan) => {
        // This span is automatically linked to parent
        childSpan.setStatus({ code: SpanStatusCode.OK });
        childSpan.end();
        resolve(undefined);
      });
    }, 100);
  });
  
  parentSpan.setStatus({ code: SpanStatusCode.OK });
  parentSpan.end();
});