OpenTelemetry համատեքստի փոխանցումը Virtual Threads և Structured Concurrency-ի հետ
Իմացեք, թե ինչպես փոխանցել OpenTelemetry համատեքստը՝ Virtual Threads և Structured 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-ի աշխատանքի ձևին։