|
| 1 | +package dev.braintrust.instrumentation.openai.v2_15_0; |
| 2 | + |
| 3 | +import com.openai.core.Params; |
| 4 | +import io.opentelemetry.api.trace.Span; |
| 5 | +import io.opentelemetry.api.trace.SpanContext; |
| 6 | +import java.lang.reflect.InvocationHandler; |
| 7 | +import java.lang.reflect.InvocationTargetException; |
| 8 | +import java.lang.reflect.Method; |
| 9 | +import java.lang.reflect.Proxy; |
| 10 | +import java.util.Map; |
| 11 | +import java.util.concurrent.ConcurrentHashMap; |
| 12 | +import lombok.extern.slf4j.Slf4j; |
| 13 | + |
| 14 | +/** |
| 15 | + * Captures the caller's OTel context at the service-call boundary of a wrapped openai-java client. |
| 16 | + * |
| 17 | + * <p>openai-java dispatches async requests through CompletableFuture continuations on the common |
| 18 | + * pool, so by the time {@link TracingHttpClient#executeAsync} runs, the caller's thread-local |
| 19 | + * context (e.g. an active application span) is gone. The service-method invocation itself, however, |
| 20 | + * happens on the caller's thread — and the only data that travels from there into the HTTP layer is |
| 21 | + * the request. So this proxy rewrites any {@link Params} argument to carry the current span as an |
| 22 | + * internal {@code traceparent}-format header, which {@link TracingHttpClient} extracts (and strips |
| 23 | + * from the outgoing request) to parent the LLM span. |
| 24 | + * |
| 25 | + * <p>Purely reflective and API-shape based, so it works for every service and endpoint: methods |
| 26 | + * returning other {@code com.openai} interfaces (service accessors like {@code chat()}, {@code |
| 27 | + * async()}) return proxied instances, so context capture follows the whole call graph. |
| 28 | + */ |
| 29 | +@Slf4j |
| 30 | +final class ContextCapturingProxy implements InvocationHandler { |
| 31 | + |
| 32 | + /** Internal correlation header; never sent — TracingHttpClient removes it. */ |
| 33 | + static final String CONTEXT_HEADER = "x-braintrust-otel-traceparent"; |
| 34 | + |
| 35 | + /** Per-params-class reflection handles: [toBuilder, putAdditionalHeader, build]. */ |
| 36 | + private static final Map<Class<?>, Method[]> PARAMS_METHODS = new ConcurrentHashMap<>(); |
| 37 | + |
| 38 | + private static final Method[] UNSUPPORTED = new Method[0]; |
| 39 | + |
| 40 | + private final Object delegate; |
| 41 | + |
| 42 | + private ContextCapturingProxy(Object delegate) { |
| 43 | + this.delegate = delegate; |
| 44 | + } |
| 45 | + |
| 46 | + /** Wraps {@code delegate} in a context-capturing proxy of {@code iface}. Idempotent. */ |
| 47 | + @SuppressWarnings("unchecked") |
| 48 | + static <T> T wrap(T delegate, Class<T> iface) { |
| 49 | + if (delegate == null || isContextCapturingProxy(delegate)) { |
| 50 | + return delegate; |
| 51 | + } |
| 52 | + return (T) |
| 53 | + Proxy.newProxyInstance( |
| 54 | + iface.getClassLoader(), |
| 55 | + new Class<?>[] {iface}, |
| 56 | + new ContextCapturingProxy(delegate)); |
| 57 | + } |
| 58 | + |
| 59 | + private static boolean isContextCapturingProxy(Object o) { |
| 60 | + return Proxy.isProxyClass(o.getClass()) |
| 61 | + && Proxy.getInvocationHandler(o) instanceof ContextCapturingProxy; |
| 62 | + } |
| 63 | + |
| 64 | + @Override |
| 65 | + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { |
| 66 | + Object[] invokeArgs = injectContextHeader(args); |
| 67 | + Object result; |
| 68 | + try { |
| 69 | + result = method.invoke(delegate, invokeArgs); |
| 70 | + } catch (InvocationTargetException e) { |
| 71 | + throw e.getCause(); |
| 72 | + } |
| 73 | + // Follow the service graph: accessors like chat(), completions(), async() return |
| 74 | + // com.openai interfaces whose methods must also capture context. |
| 75 | + Class<?> returnType = method.getReturnType(); |
| 76 | + if (result != null |
| 77 | + && returnType.isInterface() |
| 78 | + && returnType.getName().startsWith("com.openai.")) { |
| 79 | + return Proxy.newProxyInstance( |
| 80 | + returnType.getClassLoader(), |
| 81 | + new Class<?>[] {returnType}, |
| 82 | + new ContextCapturingProxy(result)); |
| 83 | + } |
| 84 | + return result; |
| 85 | + } |
| 86 | + |
| 87 | + /** Rewrites any {@link Params} argument to carry the current span as an internal header. */ |
| 88 | + private Object[] injectContextHeader(Object[] args) { |
| 89 | + if (args == null) { |
| 90 | + return null; |
| 91 | + } |
| 92 | + String traceparent = currentTraceparent(); |
| 93 | + if (traceparent == null) { |
| 94 | + return args; |
| 95 | + } |
| 96 | + Object[] result = args; |
| 97 | + for (int i = 0; i < args.length; i++) { |
| 98 | + if (args[i] instanceof Params params) { |
| 99 | + Object rewritten = withContextHeader(params, traceparent); |
| 100 | + if (rewritten != null) { |
| 101 | + if (result == args) { |
| 102 | + result = args.clone(); |
| 103 | + } |
| 104 | + result[i] = rewritten; |
| 105 | + } |
| 106 | + } |
| 107 | + } |
| 108 | + return result; |
| 109 | + } |
| 110 | + |
| 111 | + private static String currentTraceparent() { |
| 112 | + SpanContext spanContext = Span.current().getSpanContext(); |
| 113 | + if (!spanContext.isValid()) { |
| 114 | + return null; |
| 115 | + } |
| 116 | + return "00-" |
| 117 | + + spanContext.getTraceId() |
| 118 | + + "-" |
| 119 | + + spanContext.getSpanId() |
| 120 | + + "-" |
| 121 | + + spanContext.getTraceFlags().asHex(); |
| 122 | + } |
| 123 | + |
| 124 | + /** |
| 125 | + * {@code params.toBuilder().putAdditionalHeader(CONTEXT_HEADER, traceparent).build()}, done |
| 126 | + * reflectively so it works for every generated params type. Returns {@code null} (leaving the |
| 127 | + * original untouched) when the shape doesn't match. |
| 128 | + */ |
| 129 | + private static Object withContextHeader(Params params, String traceparent) { |
| 130 | + Method[] methods = |
| 131 | + PARAMS_METHODS.computeIfAbsent( |
| 132 | + params.getClass(), ContextCapturingProxy::resolveParamsMethods); |
| 133 | + if (methods == UNSUPPORTED) { |
| 134 | + return null; |
| 135 | + } |
| 136 | + try { |
| 137 | + Object builder = methods[0].invoke(params); |
| 138 | + methods[1].invoke(builder, CONTEXT_HEADER, traceparent); |
| 139 | + return methods[2].invoke(builder); |
| 140 | + } catch (Exception e) { |
| 141 | + log.debug("failed to inject context header into {}", params.getClass().getName(), e); |
| 142 | + return null; |
| 143 | + } |
| 144 | + } |
| 145 | + |
| 146 | + private static Method[] resolveParamsMethods(Class<?> paramsClass) { |
| 147 | + try { |
| 148 | + Method toBuilder = paramsClass.getMethod("toBuilder"); |
| 149 | + Class<?> builderClass = toBuilder.getReturnType(); |
| 150 | + Method putHeader = |
| 151 | + builderClass.getMethod("putAdditionalHeader", String.class, String.class); |
| 152 | + Method build = builderClass.getMethod("build"); |
| 153 | + return new Method[] {toBuilder, putHeader, build}; |
| 154 | + } catch (NoSuchMethodException e) { |
| 155 | + log.debug("params type {} has no header builder shape", paramsClass.getName()); |
| 156 | + return UNSUPPORTED; |
| 157 | + } |
| 158 | + } |
| 159 | +} |
0 commit comments