DataDog · ygree · Oct 24, 2025 · Oct 25, 2025 · Oct 29, 2025 · Oct 29, 2025
@@ -5,6 +5,7 @@
 import datadog.trace.api.DDTraceId;
 import datadog.trace.api.WellKnownTags;
 import datadog.trace.api.llmobs.LLMObs;
+import datadog.trace.api.llmobs.LLMObsContext;
 import datadog.trace.api.llmobs.LLMObsSpan;
 import datadog.trace.api.llmobs.LLMObsTags;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
@@ -81,8 +82,8 @@ public DDLLMObsSpan(
       this.span.setTag(LLMOBS_TAG_PREFIX + LLMObsTags.SESSION_ID, sessionId);
     }
 
-    AgentSpanContext parent = LLMObsState.getLLMObsParentContext();
-    String parentSpanID = LLMObsState.ROOT_SPAN_ID;
+    AgentSpanContext parent = LLMObsContext.current();
+    String parentSpanID = LLMObsContext.ROOT_SPAN_ID;
     if (null != parent) {
       if (parent.getTraceId() != this.span.getTraceId()) {
         LOGGER.error(
@@ -96,8 +97,7 @@ public DDLLMObsSpan(
       }
     }
     this.span.setTag(LLMOBS_TAG_PREFIX + PARENT_ID_TAG_INTERNAL, parentSpanID);
-    this.scope = LLMObsState.attach();
-    LLMObsState.setLLMObsParentContext(this.span.context());
+    this.scope = LLMObsContext.attach(this.span.context());
   }
 
   @Override

@@ -112,7 +112,12 @@ public static ReferenceMatcher loadStaticMuzzleReferences(
   }
 
   /**
-   * @return Class names of helpers to inject into the user's classloader
+   * @return Class names of helpers to inject into the user's classloader.
+   *     <p><b>NOTE:</b> The order of the returned helper classes matters. If a muzzle check fails
+   *     with a NoClassDefFoundError, as logged in build/reports/muzzle-*.txt, it is likely that one
+   *     helper class depends on another that appears later in the list. In this case, the returned
+   *     list must be reordered so that the referred helper class appears before the one that refers
+   *     to it.
    */
   public String[] helperClassNames() {
     return NO_HELPERS;

@@ -0,0 +1,25 @@
+apply from: "$rootDir/gradle/java.gradle"
+apply plugin: 'idea'
+
+def minVer = '3.0.0'
+
+muzzle {
+  pass {
+    group = "com.openai"
+    module = "openai-java"
+    versions = "[$minVer,)"
+  }
+}
+
+addTestSuiteForDir('latestDepTest', 'test')
+
+dependencies {
+  compileOnly group: 'com.openai', name: 'openai-java', version: minVer
+  implementation project(':internal-api')
+
+  testImplementation group: 'com.openai', name: 'openai-java', version: minVer
+  latestDepTestImplementation group: 'com.openai', name: 'openai-java', version: '+'
+
+  testImplementation project(':dd-java-agent:instrumentation:okhttp:okhttp-3.0')
+}
+
@@ -0,0 +1,157 @@
+package datadog.trace.instrumentation.openai_java;
+
+import static datadog.trace.instrumentation.openai_java.OpenAiDecorator.REQUEST_MODEL;
+import static datadog.trace.instrumentation.openai_java.OpenAiDecorator.RESPONSE_MODEL;
+
+import com.openai.helpers.ChatCompletionAccumulator;
+import com.openai.models.chat.completions.ChatCompletion;
+import com.openai.models.chat.completions.ChatCompletionChunk;
+import com.openai.models.chat.completions.ChatCompletionCreateParams;
+import com.openai.models.chat.completions.ChatCompletionMessage;
+import com.openai.models.chat.completions.ChatCompletionMessageParam;
+import com.openai.models.chat.completions.ChatCompletionMessageToolCall;
+import datadog.trace.api.Config;
+import datadog.trace.api.llmobs.LLMObs;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.Tags;
+import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class ChatCompletionDecorator {
+  public static final ChatCompletionDecorator DECORATE = new ChatCompletionDecorator();
+  private static final CharSequence CHAT_COMPLETIONS_CREATE =
+      UTF8BytesString.create("createChatCompletion");
+
+  private final boolean llmObsEnabled = Config.get().isLlmObsEnabled();
+
+  public void withChatCompletionCreateParams(
+      AgentSpan span, ChatCompletionCreateParams params, boolean stream) {
+    span.setResourceName(CHAT_COMPLETIONS_CREATE);
+    span.setTag("openai.request.endpoint", "v1/chat/completions");
+    span.setTag("openai.request.method", "POST");
+    if (!llmObsEnabled) {
+      return;
+    }
+
+    span.setTag("_ml_obs_tag.span.kind", Tags.LLMOBS_LLM_SPAN_KIND);
+    if (params == null) {
+      return;
+    }
+    params.model()._value().asString().ifPresent(str -> span.setTag(REQUEST_MODEL, str));
+
+    span.setTag(
+        "_ml_obs_tag.input",
+        params.messages().stream()
+            .map(ChatCompletionDecorator::llmMessage)
+            .collect(Collectors.toList()));
+
+    Map<String, Object> metadata = new HashMap<>();
+    // maxTokens is deprecated but integration tests missing to provide maxCompletionTokens
+    params.maxTokens().ifPresent(v -> metadata.put("max_tokens", v));
+    params.temperature().ifPresent(v -> metadata.put("temperature", v));
+    if (stream) {
+      metadata.put("stream", true);
+    }
+    params
+        .streamOptions()
+        .ifPresent(
+            v -> {
+              if (v.includeUsage().orElse(false)) {
+                metadata.put("stream_options", Collections.singletonMap("include_usage", true));
+              }
+            });
+    span.setTag("_ml_obs_tag.metadata", metadata);
+  }
+
+  private static LLMObs.LLMMessage llmMessage(ChatCompletionMessageParam m) {
+    String role = "unknown";
+    String content = null;
+    if (m.isAssistant()) {
+      role = "assistant";
+      content = m.asAssistant().content().map(v -> v.text().orElse(null)).orElse(null);
+    } else if (m.isDeveloper()) {
+      role = "developer";
+      content = m.asDeveloper().content().text().orElse(null);
+    } else if (m.isSystem()) {
+      role = "system";
+      content = m.asSystem().content().text().orElse(null);
+    } else if (m.isTool()) {
+      role = "tool";
+      content = m.asTool().content().text().orElse(null);
+    } else if (m.isUser()) {
+      role = "user";
+      content = m.asUser().content().text().orElse(null);
+    }
+    return LLMObs.LLMMessage.from(role, content);
+  }
+
+  public void withChatCompletion(AgentSpan span, ChatCompletion completion) {
+    if (!llmObsEnabled) {
+      return;
+    }
+    String modelName = completion.model();
+    span.setTag(RESPONSE_MODEL, modelName);
+    span.setTag("_ml_obs_tag.model_name", modelName);
+    span.setTag("_ml_obs_tag.model_provider", "openai");
+
+    List<LLMObs.LLMMessage> output =
+        completion.choices().stream()
+            .map(ChatCompletionDecorator::llmMessage)
+            .collect(Collectors.toList());
+    span.setTag("_ml_obs_tag.output", output);
+
+    completion
+        .usage()
+        .ifPresent(
+            usage -> {
+              span.setTag("_ml_obs_metric.input_tokens", usage.promptTokens());
+              span.setTag("_ml_obs_metric.output_tokens", usage.completionTokens());
+              span.setTag("_ml_obs_metric.total_tokens", usage.totalTokens());
+            });
+  }
+
+  private static LLMObs.LLMMessage llmMessage(ChatCompletion.Choice choice) {
+    ChatCompletionMessage msg = choice.message();
+    Optional<?> roleOpt = msg._role().asString();
+    String role = "unknown";
+    if (roleOpt.isPresent()) {
+      role = String.valueOf(roleOpt.get());
+    }
+    String content = msg.content().orElse(null);
+
+    Optional<List<ChatCompletionMessageToolCall>> toolCallsOpt = msg.toolCalls();
+    if (toolCallsOpt.isPresent() && !toolCallsOpt.get().isEmpty()) {
+      List<LLMObs.ToolCall> toolCalls = new ArrayList<>();
+      for (ChatCompletionMessageToolCall toolCall : toolCallsOpt.get()) {
+        LLMObs.ToolCall llmObsToolCall = ToolCallExtractor.getToolCall(toolCall);
+        if (llmObsToolCall != null) {
+          toolCalls.add(llmObsToolCall);
+        }
+      }
+
+      if (!toolCalls.isEmpty()) {
+        return LLMObs.LLMMessage.from(role, content, toolCalls);
+      }
+    }
+
+    return LLMObs.LLMMessage.from(role, content);
+  }
+
+  public void withChatCompletionChunks(AgentSpan span, List<ChatCompletionChunk> chunks) {
+    if (!llmObsEnabled) {
+      return;
+    }
+    ChatCompletionAccumulator accumulator = ChatCompletionAccumulator.create();
+    for (ChatCompletionChunk chunk : chunks) {
+      accumulator.accumulate(chunk);
+    }
+    ChatCompletion chatCompletion = accumulator.chatCompletion();
+    withChatCompletion(span, chatCompletion);
+  }
+}
@@ -0,0 +1,34 @@
+package datadog.trace.instrumentation.openai_java;
+
+import com.google.auto.service.AutoService;
+import datadog.trace.agent.tooling.Instrumenter;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import java.util.Arrays;
+import java.util.List;
+
+@AutoService(InstrumenterModule.class)
+public class ChatCompletionModule extends InstrumenterModule.Tracing {
+  public ChatCompletionModule() {
+    super("openai-java");
+  }
+
+  @Override
+  public String[] helperClassNames() {
+    return new String[] {
+      packageName + ".ChatCompletionDecorator",
+      packageName + ".OpenAiDecorator",
+      packageName + ".HttpResponseWrapper",
+      packageName + ".HttpStreamResponseWrapper",
+      packageName + ".HttpStreamResponseStreamWrapper",
+      packageName + ".ToolCallExtractor",
+      packageName + ".ToolCallExtractor$1"
+    };
+  }
+
+  @Override
+  public List<Instrumenter> typeInstrumentations() {
+    return Arrays.asList(
+        new ChatCompletionServiceAsyncInstrumentation(),
+        new ChatCompletionServiceInstrumentation());
+  }
+}