Context Management

import { Context, Span } from '@opentelemetry/api';

/**
 * RPC protocol types
 */
enum RPCType {
  HTTP = 'http'
}

/**
 * HTTP metadata type
 */
type HTTPMetadata = {
  type: RPCType.HTTP;
  route?: string;
  span: Span;
};

/**
 * RPC metadata type (currently supports HTTP metadata)
 */
type RPCMetadata = HTTPMetadata;

/**
 * Store RPC metadata in context
 * @param context - OpenTelemetry context
 * @param meta - RPC metadata to store
 * @returns New context with RPC metadata
 */
function setRPCMetadata(context: Context, meta: RPCMetadata): Context;

/**
 * Retrieve RPC metadata from context
 * @param context - OpenTelemetry context
 * @returns RPC metadata or undefined if not set
 */
function getRPCMetadata(context: Context): RPCMetadata | undefined;

/**
 * Remove RPC metadata from context
 * @param context - OpenTelemetry context
 * @returns New context without RPC metadata
 */
function deleteRPCMetadata(context: Context): Context;

import {
  setRPCMetadata,
  getRPCMetadata,
  deleteRPCMetadata,
  RPCType
} from "@opentelemetry/core";
import { context } from "@opentelemetry/api";

// Store HTTP request metadata
const httpMetadata = {
  type: RPCType.HTTP,
  method: "GET",
  url: "https://api.example.com/users",
  statusCode: 200,
  userAgent: "MyApp/1.0"
};

// Add metadata to current context
const contextWithMetadata = setRPCMetadata(context.active(), httpMetadata);

// Process request with metadata context
context.with(contextWithMetadata, () => {
  // Retrieve metadata within this context
  const metadata = getRPCMetadata(context.active());
  
  if (metadata) {
    console.log("Processing request:", metadata.method, metadata.url);
    console.log("Status code:", metadata.statusCode);
  }
  
  // Spans created in this context will have access to RPC metadata
  const span = trace.getTracer("my-service").startSpan("process-request");
  
  // Add RPC metadata as span attributes
  if (metadata) {
    span.setAttributes({
      "rpc.method": metadata.method,
      "rpc.url": metadata.url,
      "rpc.status_code": metadata.statusCode
    });
  }
  
  span.end();
});

// Remove metadata from context
const cleanContext = deleteRPCMetadata(contextWithMetadata);
const shouldBeUndefined = getRPCMetadata(cleanContext);
console.log(shouldBeUndefined); // undefined

/**
 * Disable tracing for the given context
 * @param context - OpenTelemetry context
 * @returns New context with tracing suppressed
 */
function suppressTracing(context: Context): Context;

/**
 * Re-enable tracing for the given context
 * @param context - OpenTelemetry context  
 * @returns New context with tracing enabled
 */
function unsuppressTracing(context: Context): Context;

/**
 * Check if tracing is suppressed in the given context
 * @param context - OpenTelemetry context
 * @returns True if tracing is suppressed, false otherwise
 */
function isTracingSuppressed(context: Context): boolean;

import {
  suppressTracing,
  unsuppressTracing,
  isTracingSuppressed
} from "@opentelemetry/core";
import { context, trace } from "@opentelemetry/api";

// Suppress tracing for internal operations
function performInternalOperation() {
  const suppressedContext = suppressTracing(context.active());
  
  return context.with(suppressedContext, () => {
    // This operation won't create spans
    console.log("Tracing suppressed:", isTracingSuppressed(context.active())); // true
    
    // Any spans created here will be non-recording
    const span = trace.getTracer("internal").startSpan("internal-op");
    console.log("Span is recording:", span.isRecording()); // false
    span.end();
    
    return "operation complete";
  });
}

// Suppress tracing for health check endpoints
function handleHealthCheck(request: any, response: any) {
  const suppressedContext = suppressTracing(context.active());
  
  context.with(suppressedContext, () => {
    // Health checks don't need tracing
    response.json({ status: "healthy", timestamp: Date.now() });
  });
}

// Conditional tracing suppression
function handleRequest(request: any) {
  let currentContext = context.active();
  
  // Suppress tracing for certain endpoints
  if (request.path === "/health" || request.path === "/metrics") {
    currentContext = suppressTracing(currentContext);
  }
  
  return context.with(currentContext, () => {
    const isTracing = !isTracingSuppressed(context.active());
    console.log(`Tracing enabled for ${request.path}:`, isTracing);
    
    // Process request
    const span = trace.getTracer("api").startSpan(`${request.method} ${request.path}`);
    
    try {
      // Handle request logic
      return processRequest(request);
    } finally {
      span.end();
    }
  });
}

// Re-enable tracing in suppressed context
function forceTracing() {
  const suppressedContext = suppressTracing(context.active());
  
  context.with(suppressedContext, () => {
    console.log("Tracing suppressed:", isTracingSuppressed(context.active())); // true
    
    // Force enable tracing for this specific operation
    const enabledContext = unsuppressTracing(context.active());
    
    context.with(enabledContext, () => {
      console.log("Tracing enabled:", !isTracingSuppressed(context.active())); // true
      
      // This span will be recorded
      const span = trace.getTracer("forced").startSpan("important-operation");
      console.log("Span is recording:", span.isRecording()); // true
      span.end();
    });
  });
}

import {
  setRPCMetadata,
  getRPCMetadata,
  suppressTracing,
  isTracingSuppressed,
  RPCType
} from "@opentelemetry/core";
import { context, trace, propagation } from "@opentelemetry/api";

// Middleware for HTTP request processing
function createRequestContext(request: any) {
  let currentContext = context.active();
  
  // Add RPC metadata
  const rpcMetadata = {
    type: RPCType.HTTP,
    method: request.method,
    url: request.url,
    headers: request.headers,
    remoteAddress: request.connection?.remoteAddress
  };
  
  currentContext = setRPCMetadata(currentContext, rpcMetadata);
  
  // Suppress tracing for certain requests
  const suppressedPaths = ["/health", "/metrics", "/favicon.ico"];
  if (suppressedPaths.includes(request.path)) {
    currentContext = suppressTracing(currentContext);
  }
  
  return currentContext;
}

// Process request with context
function handleIncomingRequest(request: any, response: any) {
  // Extract trace context from headers
  const extractedContext = propagation.extract(context.active(), request.headers);
  
  context.with(extractedContext, () => {
    // Create request-specific context
    const requestContext = createRequestContext(request);
    
    context.with(requestContext, () => {
      // Check if tracing is enabled
      const tracingEnabled = !isTracingSuppressed(context.active());
      
      // Get RPC metadata
      const rpcMetadata = getRPCMetadata(context.active());
      
      console.log(`Processing ${rpcMetadata?.method} ${rpcMetadata?.url}`);
      console.log(`Tracing enabled: ${tracingEnabled}`);
      
      // Create span if tracing is enabled
      const span = trace.getTracer("http-server").startSpan(`${request.method} ${request.path}`);
      
      if (span.isRecording() && rpcMetadata) {
        span.setAttributes({
          "http.method": rpcMetadata.method,
          "http.url": rpcMetadata.url,
          "http.remote_addr": rpcMetadata.remoteAddress
        });
      }
      
      try {
        // Process the request
        const result = processRequest(request);
        
        if (span.isRecording()) {
          span.setStatus({ code: SpanStatusCode.OK });
        }
        
        response.json(result);
      } catch (error) {
        if (span.isRecording()) {
          span.recordException(error);
          span.setStatus({ 
            code: SpanStatusCode.ERROR,
            message: error.message
          });
        }
        
        response.status(500).json({ error: "Internal server error" });
      } finally {
        span.end();
      }
    });
  });
}

// Helper function to create instrumentation that respects context
function instrumentFunction<T extends Function>(fn: T, name: string): T {
  return ((...args: any[]) => {
    // Check if tracing is suppressed
    if (isTracingSuppressed(context.active())) {
      // Execute without instrumentation
      return fn.apply(this, args);
    }
    
    // Execute with instrumentation
    const span = trace.getTracer("auto-instrument").startSpan(name);
    
    try {
      const result = fn.apply(this, args);
      
      // Handle promises
      if (result && typeof result.then === "function") {
        return result.catch((error: any) => {
          span.recordException(error);
          span.setStatus({ code: SpanStatusCode.ERROR });
          throw error;
        }).finally(() => {
          span.end();
        });
      }
      
      span.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (error) {
      span.recordException(error);
      span.setStatus({ code: SpanStatusCode.ERROR });
      throw error;
    } finally {
      if (!result || typeof result.then !== "function") {
        span.end();
      }
    }
  }) as any;
}