Գնահատել նախագիծը
← Բոլոր հրապարակումները

OpenTelemetry համատեքստի փոխանցումը Virtual Threads և Structured Concurrency-ի հետ

Իմացեք, թե ինչպես փոխանցել OpenTelemetry համատեքստը՝ Virtual Threads և Structured Concurrency-ի հետ աշխատելիս։

7 րոպե
JavaOpenTelemetryԴիտարկելիությունVirtual ThreadsStructured Concurrency

OpenTelemetry-ում Context-ը առանցքային տարր է. այն պահում է ընթացիկ կանչերի շղթայի մետատվյալները, օրինակ՝ այդ պահին աշխատող trace-ը։ Շնորհիվ դրա՝ մի քանի span-եր կարելի է կապել մեկ տրամաբանական միավորի մեջ։

Լռելյայն Java OpenTelemetry SDK-ը Context-ը փոխանցում է ThreadLocal-ների միջոցով։ Արդյո՞ք դա շարունակում է սպասվածի պես աշխատել Java 21+-ի Virtual Threads-ի և Structured Concurrency-ի հետ։ Իսկ եթե ոչ, ի՞նչն է սխալ գնում։

Հաջորդական կանչեր

Կսկսենք հաջորդական կանչերի պարզ սցենարից, որոնցից յուրաքանչյուրը span է սկսում։ Թելեր դեռ խաղի մեջ չկան, բայց այն օգտակար հիմք կլինի։

Ստորև բերված օրինակում ծնող մեթոդը սկսում է ծնող span և կանչում է երկու ներդրված մեթոդ, որոնցից յուրաքանչյուրը սկսում է իր սեփական ներդրված span-ը։ Ահա կոդը՝

import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;

import java.util.concurrent.ExecutionException;

public class Demo {
  private static Void nested(int id, Tracer tracer) throws InterruptedException {
    var span = tracer.spanBuilder("nested-test-span-" + id).startSpan();
    try (var scope = span.makeCurrent()) {
      Thread.sleep(500);
      // pretending to do some work—e.g. sending an HTTP request
    } finally {
      span.end();
    }

    return null;
  }

  private static void parent(Tracer tracer) throws InterruptedException {
    var span = tracer.spanBuilder("parent-test-span").startSpan();
    try (var scope = span.makeCurrent()) {
      nested(1, tracer);
      nested(2, tracer);
    } finally {
      span.end();
    }
  }

  public static void main(String[] args) throws InterruptedException, ExecutionException {
    var otel = AutoConfiguredOpenTelemetrySdk.initialize();

    // span
    var tracer = otel.getOpenTelemetrySdk().getTracer("otel-demo");
    parent(tracer);

    // make sure telemetry is sent
    Thread.sleep(1000);
  }
}

main մեթոդը OpenTelemetry-ն նախաձեռնում է շրջակա միջավայրի փոփոխականներից։ Դրանք հարմար են թեստավորման համար՝

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
OTEL_METRIC_EXPORT_INTERVAL=500
OTEL_SERVICE_NAME=demo

Exporter-ի endpoint-ը պետք է ցույց տա աշխատող ինստանսի վրա – օրինակ՝ Grafana-ի LGTM, պարզ մեկ կոնտեյներով Docker կարգավորում։ Ահա համապատասխան docker-compose.yml-ը՝

services:
  # OpenTelemetry Collector, Prometheus, Loki, Tempo, Grafana
  observability:
    image: 'grafana/otel-lgtm'
    ports:
      - '3000:3000' # Grafana's UI
      - '4317:4317' # Exporter

Սա մեզ տալիս է exporter, ինչպես նաև UI, որը հեշտացնում է թեստի արդյունքների վիզուալիզացիան։

parent մեթոդը սկսում է span և երկու անգամ կանչում է nested-ը, ընդ որում յուրաքանչյուր կանչ սկսում է ենթակա span։ Երբ գործարկեք օրինակը, UI-ը պետք է ցույց տա մոտավորապես այսպիսի բան՝

Առայժմ ամեն ինչ աշխատում է։ Հիմա ներմուծենք որոշակի զուգահեռություն։

Զուգահեռ կանչեր

Երբ ներդրված կանչերը կախված չեն միմյանցից և զգալի ժամանակ են խլում (օրինակ՝ քանի որ կատարում են որոշ I/O), մենք կարող ենք ցանկանալ դրանք գործարկել զուգահեռ։ Դա կարելի է անել մի քանի եղանակով, բայց մենք կհետևենք Java structured concurrency JEP-ի (հասանելի նախադիտման ռեժիմում Java 21-ից) դրած ճանապարհին։

Այստեղ մենք պարզապես կօգտագործենք StructuredTaskScope API-ն։ Structured concurrency-ի էական հատկությունն այն է, որ ենթախնդիրները կատարող թելերի կյանքի տևողությունը որոշվում է կոդի շարահյուսական կառուցվածքով։

Այլ կերպ ասած, քանի որ StructuredTaskScope-ը գտնվում է try (var scope = span.makeCurrent())-ի ներսում, task scope-ում սկսված յուրաքանչյուր թել երաշխավորված ավարտված է այն պահին, երբ դիտարկելիության scope-ը և span-ը փակվում են՝

private static Void nested(int id, Tracer tracer) throws InterruptedException {
  var span = tracer.spanBuilder("nested-test-span-" + id).startSpan();

  try (var scope = span.makeCurrent()) {
    Thread.sleep(500);
  } finally {
    span.end();
  }

  return null;
}

private static void parent(Tracer tracer) throws InterruptedException, ExecutionException {
  var span = tracer.spanBuilder("parent-test-span").startSpan();
  try (var scope = span.makeCurrent()) {
    try (var taskScope = new StructuredTaskScope.ShutdownOnFailure()) {
      Supplier<Void> n1 = taskScope.fork(() -> nested(1, tracer));
      Supplier<Void> n2 = taskScope.fork(() -> nested(2, tracer));

      taskScope.join().throwIfFailed();

      n1.get();
      n2.get();
    }
  } finally {
    span.end();
  }
}

Վերևի կոդը հետին պլանում գործարկում է երկու առաջադրանք և հետո .join()-ով սպասում է երկուսի ավարտին։ Այն նման է future-ների հետ աշխատելուն, բայց ավելացնում է մի երաշխիք. եթե մի առաջադրանք ձախողվում է, մյուսը «կախված» չի մնում, այլ ընդհատվում է։

Սակայն երբ այս օրինակը գործարկում ենք, դիտարկելիության համատեքստն այլևս չի փոխանցվում։ Մեկ փոխկապակցված trace-ի փոխարեն մենք ստանում ենք երեք առանձին trace՝

Շնորհիվ զուգահեռացման՝ ծնողի span-ը այժմ ընդհանուր առմամբ տևում է 500ms, բայց մենք կորցրել ենք ամբողջ գործընթացի դիտարկելիությունը։

Զուգահեռ կանչեր՝ դիտարկելիությամբ

Ի՞նչն է սխալ գնում։ Հիշեք, որ OpenTelemetry-ի Context-ը ճանապարհորդում է ThreadLocal-ների միջոցով։ Դա կատարյալ է մեկ թելի ներսում կանչերը և span-երը փոխկապակցելու համար, բայց փլվում է, հենց որ մի քանի թել է ներգրավվում – լինեն «նորմալ» թելեր (այսինքն՝ «platform» թելեր), թե վիրտուալ։ Պատճառն այն է, որ ThreadLocal-ները չեն ժառանգվում։

OpenTelemetry-ը փորձում է սա լուծել մի քանի եղանակով։ Օրինակ, կարող եք Executor-ը փաթաթել Context.taskWrapping()-ով, որպեսզի համատեքստը փոխանցվի այդ executor-ով գործարկվող յուրաքանչյուր առաջադրանքի։ Սակայն structured concurrency-ի համար այդպիսի օժանդակ գործիքներ (դեռ) չկան – և հիմնավոր պատճառով, քանի որ API-ն դեռ նախադիտման ռեժիմում է։

Այսպիսով, փոխանցումը պետք է իրականացնենք ինքներս։ Մի տարբերակ է StructuredTaskScope-ը կառուցելիս տրամադրել ThreadFactory։ Այդպիսի հատուկ factory-ն կարող է ձեռքով հոգալ համատեքստի փոխանցումը – փաստացի մենք ձեռքով իրականացնում ենք համատեքստը պահող thread-local արժեքի ժառանգումը՝

static class PropagatingVirtualThreadFactory implements ThreadFactory {
  private ThreadFactory delegate = Thread.ofVirtual().factory();
  @Override
  public Thread newThread(Runnable r) {
    var parentContext = Context.current();
    return delegate.newThread(() -> {
      parentContext.makeCurrent();
      r.run();
    });
  }
}

Մեր հատուկ factory-ն նախ ձեռք է բերում ընթացիկ համատեքստը Context.current()-ով նոր թել ստեղծվելու պահին։ Հետո այն ստեղծում է նոր վիրտուալ թել (պատվիրակելով JDK-ի տրամադրած Thread.ofVirtual().factory()-ին) և կոդի բլոկը կատարելուց առաջ գրավված համատեքստը դարձնում է «ընթացիկ» – այս անգամ նոր թելի ներսում։

parent մեթոդում պետք են միայն նվազագույն փոփոխություններ՝

private static void parent(Tracer tracer) throws InterruptedException, ExecutionException {
  var span = tracer.spanBuilder("parent-test-span-1").startSpan();
  try (var scope = span.makeCurrent()) {
    try (var taskScope = new StructuredTaskScope.ShutdownOnFailure(null, 
          new PropagatingVirtualThreadFactory())) {
      Supplier<Void> n1 = taskScope.fork(() -> nested(1, tracer));
      Supplier<Void> n2 = taskScope.fork(() -> nested(2, tracer));

      taskScope.join().throwIfFailed();

      n1.get();
      n2.get();
    }
  } finally {
    span.end();
  }
}

Օրինակը հիմա գործարկելը կրկին ցույց է տալիս span-երը փոխկապակցված մեկ trace-ում՝

Իսկ ի՞նչ ScopedValues-ի մասին

Structured concurrency JEP-ի հետ մեկտեղ Java-ն ներմուծեց նաև ScopedValue API-ն (տե՛ս JEP-ը) – հաջորդ սերնդի ThreadLocal, որը ժառանգվում է ենթակա վիրտուալ թելերի կողմից՝ դրանց ստեղծման պահին։

Scoped value-ները նախատեսված են կառուցվածքային եղանակով օգտագործելու համար՝ StructuredTaskScope-ների հետ միասին։ Ահա JEP-ից վերցված օրինակ՝

private static final ScopedValue<String> X = ScopedValue.newInstance();

void foo() {
  where(X, "hello").run(() -> bar());
}

void bar() {
  System.out.println(X.get()); // prints hello
  where(X, "goodbye").run(() -> baz());
  System.out.println(X.get()); // prints hello
}

void baz() {
  System.out.println(X.get()); // prints goodbye
}

Հիշեք, որ ScopedValue-ին նոր արժեք կարելի է տալ միայն այն ժամանակ, երբ where(...).run(...)-ով փոխանցված կոդի բլոկը կատարվում է։ Կրկին կյանքի տևողությունը թելադրվում է կոդի շարահյուսական կառուցվածքով – այս անգամ արժեքի կապակցման կյանքի տևողությունը, իսկ նախկինում դա թելինն էր։

Այս դիզայնն ունի որոշ գրավիչ հատկություններ, բայց այն չի տրամադրվում OpenTelemetry-ի այլընտրանքային ContextStorage-ի իրականացմանը։ Այդ ինտերֆեյսի իրականացումները պահում և փոխանցում են OpenTelemetry համատեքստը, և, ինչպես նշվեց ավելի վաղ, ThreadLocalContextStorage-ը լռելյայնն է։

ScopedValueContextStorage-ի իրականացում գրելը, որպեսզի համատեքստն ավտոմատ փոխանցվի նորաստեղծ ենթակա վիրտուալ թելերին, կարող է գրավիչ թվալ. սակայն context storage API-ն ոչ կառուցվածքային է՝

public interface ContextStorage {
  Scope attach(Context toAttach);
  Context current();
}

Storage-ին կցված համատեքստը պարտադիր չէ ապրի կոդի կառուցվածքին համահունչ (թեև սովորաբար հենց այդպես է լինում try-with-resources կառուցվածքի դեպքում)։ attach մեթոդը փոխարենը վերադարձնում է Scope, և կոդը կարող է այն փակել ցանկացած պահի։

Այս դիզայնի պատճառով scoped value-ները և context storage-ը սկզբունքորեն անհամատեղելի են։

Ամփոփելով

«Արկղից դուրս» OpenTelemetry Java SDK-ն Virtual Threads-ի հետ որևէ ինտեգրացիա չի առաջարկում, բացի համատեքստը մեկ թելի ներսում փոխանցելուց։

Սակայն Virtual Threads-ը նախագծված է խրախուսելու նոր fork-երի ազատ ստեղծումը, որոնք զուգահեռացնում են կոդի կատարումը և բարձրացնում են ներգրավված ծառայությունների արտադրողականությունը / թողունակությունը։ Արդյունքում թելեմետրիայի համատեքստը կորչում է, և չփոխկապակցված span-երը հաղորդվում են որպես առանձին trace-եր, այլ ոչ թե մեկ համակցված trace։

Համատեքստի ձեռքով փոխանցումը կանխում է սա։ Իր ամենապարզ տեսքով դուք ծնող համատեքստը ձեռք եք բերում հաշվարկը fork անելուց առաջ և նորից սահմանում եք ենթակա թելում։ Հատուկ ThreadFactory-ն, որն աշխատում է նաև StructuredTaskScope API-ի հետ, թույլ է տալիս այդ փոխանցումը որոշ չափով ավտոմատացնել։

Վերջում, եթե ContextStorage-ի դիզայնը չփոխվի, թվում է անհնար է իրականացում կառուցել առաջիկա ScopedValue-ների հիման վրա։ Դրանք լուծում են ժառանգման խնդիրը, բայց նաև պահանջում են կառուցվածքային օգտագործում, որը պետք է համապատասխանի կոդի շարահյուսական կառուցվածքին – ինչը հակասում է ContextStorage-ի աշխատանքի ձևին։