OpenTelemetry Community Day 2025 gathered observability practitioners to discuss distributed tracing infrastructure. UUID v7 emerged as a complementary trace ID format: its timestamp prefix makes application-level trace IDs self-describing — no tracing backend query needed to determine when a trace started. See UUID v7 in Microservices for the broader distributed systems context.

Event details

ConferenceOpenTelemetry Community Day 2025
DateOctober 22, 2025
LocationChicago, IL, USA (co-located with KubeCon NA 2025)
FocusUUID v7 as application-level trace and correlation IDs alongside OTel spans

Key sessions

UUID v7 as OTel span attribute (Node.js)

import { trace, context } from '@opentelemetry/api';
import { v7 as uuidv7 } from 'uuid';

// Add UUID v7 correlation ID as an OTel span attribute
async function processOrder(orderId: string) {
  const tracer = trace.getTracer('order-service');
  const correlationId = uuidv7(); // Application-level trace ID

  return tracer.startActiveSpan('process-order', async (span) => {
    // Attach UUID v7 to span — survives log aggregation and API responses
    span.setAttribute('app.correlation.id', correlationId);
    span.setAttribute('app.order.id', orderId);

    try {
      const result = await doProcess(orderId);
      return result;
    } finally {
      span.end();
    }
  });
}

UUID v7 as W3C TraceContext-compatible ID

// UUID v7 can seed a W3C TraceContext trace ID
// W3C format: 32 lowercase hex chars (no hyphens)
function uuidV7ToTraceId(uuidV7: string): string {
  return uuidV7.replace(/-/g, ''); // 32-char hex, UUID v7 top bits are timestamp
}

function traceIdToUuidV7(traceId: string): string {
  return [
    traceId.slice(0, 8),
    traceId.slice(8, 12),
    traceId.slice(12, 16),
    traceId.slice(16, 20),
    traceId.slice(20),
  ].join('-');
}

// Usage with OTel propagator
import { W3CTraceContextPropagator } from '@opentelemetry/core';
const propagator = new W3CTraceContextPropagator();
// Inject trace ID derived from UUID v7 into outgoing HTTP headers

Cross-service correlation with UUID v7

// Service A: generate UUID v7 correlation ID, attach to OTel and HTTP
const correlationId = uuidv7();

// OTel span attribute
span.setAttribute('correlation.id', correlationId);

// HTTP header to downstream services
headers['X-Correlation-ID'] = correlationId;

// Service B: extract and propagate
const correlationId = req.headers['x-correlation-id'];
span.setAttribute('correlation.id', correlationId);

// Extract timing from UUID v7 without the tracing backend
const createdMs = parseInt(correlationId.replace(/-/g, '').slice(0, 12), 16);
const requestAge = Date.now() - createdMs; // ms since Service A generated the ID
console.log(`Request age at Service B: ${requestAge}ms`);

Comparing UUID v7 to W3C TraceContext format

PropertyUUID v7W3C TraceContext
Length36 chars (canonical) / 32 hex32 hex chars in traceparent
Timestamp48-bit Unix msNone
Random bits74128
StandardRFC 9562W3C TR
Sort orderChronologicalRandom
Self-describingYes (timestamp embedded)No

See UUID Bit Fields for the bit layout details.

Conference takeaways

  1. UUID v7 ≠ OTel span ID — span IDs are 64-bit; use UUID v7 as a span attribute
  2. UUID v7 as W3C trace ID seed — strip hyphens to get a 32-char hex string compatible with traceparent
  3. Self-describing traces — UUID v7 timestamp eliminates tracing-backend queries for basic timing
  4. Log correlation without backends — UUID v7 in log lines enables cross-service correlation from log files alone
  5. Complement, not replace — UUID v7 complements OTel’s automatic instrumentation; it does not replace it

Further reading

External references

Frequently asked questions

How does UUID v7 compare to W3C TraceContext trace IDs?

W3C TraceContext trace IDs are 128-bit random values encoded as 32 lowercase hex characters (without hyphens). UUID v7 is also 128 bits but adds a 48-bit timestamp prefix and uses the canonical 36-character hyphenated format. UUID v7 can serve as a W3C TraceContext-compatible trace ID by stripping hyphens: uuid.replace(/-/g, ''). The advantage is that UUID v7 trace IDs encode the request initiation time — useful when the tracing backend is unavailable. See UUID v7 in Microservices.

Can I use UUID v7 as an OpenTelemetry span ID?

OpenTelemetry span IDs are 64-bit (8 bytes), not 128-bit. UUID v7 is 128-bit and cannot be used directly as an OTel span ID. However, UUID v7 works well as an OTel span attribute: attach it as span.setAttribute('app.correlation.id', uuidv7()). This gives application-level correlation that complements OTel's automatic span tracking. See UUID v7 in Microservices.

How does UUID v7 help when a tracing backend is unavailable?

UUID v7 trace IDs are self-describing — the 48-bit timestamp prefix encodes when the trace started. When a tracing backend (Jaeger, Zipkin, Tempo) is unavailable or log export fails, UUID v7 trace IDs in application logs still reveal request timing and ordering. Two services can correlate their logs by matching UUID v7 trace IDs without querying a central trace store.