Instrumentation automatique pour l'observabilité LLM
Ce produit n'est pas pris en charge par le
site Datadog que vous avez sélectionné. (
).
Aperçu
L’observabilité LLM de Datadog peut automatiquement tracer et annoter les appels aux frameworks et bibliothèques LLM pris en charge via diverses intégrations LLM. Lorsque vous exécutez votre application LLM avec le SDK d’observabilité LLM, ces intégrations LLM sont activées par défaut et fournissent des traces et une observabilité prêtes à l’emploi, sans que vous ayez à modifier votre code.
Frameworks et bibliothèques pris en charge
| Framework | Versions prises en charge | Version du traceur |
|---|
| Amazon Bedrock | >= 3.422.0 | >= 5.35.0 (CJS), >=5.35.0 (ESM) |
| Anthropic | >= 0.14.0 | >= 5.71.0 (CJS), >=5.71.0 (ESM) |
| LangChain | >= 0.1.0 | >= 5.32.0 (CJS), >=5.38.0 (ESM) |
| OpenAI, Azure OpenAI | >= 3.0.0 | >= 4.49.0, >= 5.25.0 (CJS), >= 5.38.0 (ESM) |
| Vercel AI SDK | >=4.0.0 | >= 5.63.0 (CJS), >=5.63.0 (ESM) |
| VertexAI | >= 1.0.0 | >= 5.44.0 (CJS), >=5.44.0 (ESM) |
| Google GenAI | >= 1.19.0 | >= 5.81.0 (CJS), >=5.81.0 (ESM) |
L’instrumentation automatique pour les projets ESM est prise en charge à partir de dd-trace@>=5.38.0. Pour activer l’instrumentation automatique dans vos projets ESM, exécutez votre application avec l’option Node suivante :
--import dd-trace/register.js
Pour la configuration en ligne de commande, utilisez l’option suivante :
--import dd-trace/initialize.mjs
# or
--loader dd-trace/initialize.mjs
Dépannage : Chargeur personnalisé pour incompatibilité de module
S’il y a des erreurs lors du lancement de votre application en utilisant cette option, il s’agit probablement d’une incompatibilité de module. Vous pouvez créer votre propre fichier de hook avec le module et le fichier en question exclus :
// hook.mjs
import { register } from 'node:module';
register('import-in-the-middle/hook.mjs', import.meta.url, {
parentURL: import.meta.url,
data: { exclude: [
/langsmith/,
/openai\/_shims/,
/openai\/resources\/chat\/completions\/messages/,
// Add any other modules you want to exclude
]}
});
Pour utiliser ce chargeur personnalisé, exécutez votre application avec l’option Node suivante :
Pour utiliser les intégrations LLM Observability dans les applications empaquetées (esbuild, Webpack), vous devez exclure les modules de ces intégrations de l’empaquetage.
esbuild
Si vous utilisez esbuild, consultez L’empaquetage avec le traceur Node.js.
Webpack
Pour Webpack, spécifiez l’intégration correspondante dans la section externals de la configuration webpack :
// webpack.config.js
module.exports = {
resolve: {
fallback: {
graphql: false,
}
},
externals: {
openai: 'openai'
}
}
Initialisez correctement le traceur dans votre application pour garantir que l’auto-instrumentation fonctionne correctement. Si vous utilisez TypeScript ou ESM pour votre application Next.js, initialisez le traceur dans un fichier instrumentation.{ts/js} comme suit, en spécifiant vos options de configuration en tant que variables d’environnement :
// instrumentation.ts
export async function register() {
if (process.env.NEXT_RUNTIME === 'nodejs') {
const initializeImportName = 'dd-trace/initialize.mjs';
await import(/* webpackIgnore: true */ initializeImportName as 'dd-trace/initialize.mjs')
}
// ...
}
Sinon, pour les applications Next.js en CommonJS, vous pouvez utiliser la fonction init directement :
// instrumentation.js
const tracer = require('dd-trace')
function register () {
if (process.env.NEXT_RUNTIME === 'nodejs') {
tracer.init({}); // specify options here or they will be read from environment variables
}
// ...
}
module.exports = register;
Ensuite, assurez-vous de spécifier dd-trace et toutes les autres intégrations prises en charge dans serverExternalPackages dans votre fichier next.config.{ts/js} :
// next.config.ts
module.exports = {
serverExternalPackages: ['dd-trace', 'openai'], // add any other supported integrations here to be auto-instrumented
}
Intégrations LLM
Les intégrations LLM de Datadog capturent la latence, les erreurs, les paramètres d’entrée, les messages d’entrée et de sortie, ainsi que l’utilisation des tokens (lorsqu’elle est disponible) pour les appels tracés.
L’intégration Amazon Bedrock fournit une instrumentation automatique pour les appels du modèle de chat du SDK Python d’Amazon Bedrock Runtime (utilisant Boto3/Botocore).
Méthodes tracées
L’intégration Amazon Bedrock instrumente les méthodes suivantes :
L'intégration Amazon Bedrock ne prend pas en charge le traçage des appels d'embedding.
L’intégration Amazon Bedrock fournit un traçage automatique pour les appels du modèle de chat du SDK Node.js d’Amazon Bedrock (en utilisant BedrockRuntimeClient).
Méthodes tracées
L’intégration Amazon Bedrock instrumente les méthodes suivantes :
L’intégration des Agents Amazon Bedrock fournit un traçage automatique pour les appels d’invocation d’agent du SDK Python d’Amazon Bedrock Agents (en utilisant Boto3/Botocore).
Méthodes tracées
L’intégration des Agents Amazon Bedrock instrumente les méthodes suivantes :
L'intégration des Agents Amazon Bedrock, par défaut, ne trace que la méthode globale InvokeAgent. Pour activer
Pour activer le traçage des étapes intra-agent, vous devez définir enableTrace=True dans les paramètres de requête de InvokeAgent.
L’intégration Anthropic fournit un traçage automatique pour les appels de messages de chat du SDK Python d’Anthropic .
Méthodes tracées
L’intégration Anthropic instrumente les méthodes suivantes :
L’intégration CrewAI trace automatiquement l’exécution des lancements de Crew, y compris les invocations de tâches/agents/outils, effectuées via l’SDK Python de CrewAI .
Méthodes tracées
L’intégration CrewAI instrumente les méthodes suivantes :
L’intégration Google ADK fournit un traçage automatique pour les exécutions d’agents, les appels d’outils et les exécutions de code effectuées via l’SDK Python de Google ADK .
Méthodes tracées
L’intégration Google ADK instrumente les méthodes suivantes :
Les méthodes run_live et run_async sont toutes deux prises en charge.
L’intégration de Google GenAI trace automatiquement les méthodes dans le SDK Python de Google GenAI .
Remarque : Le SDK Python de Google GenAI succède au SDK Google GenerativeAI et expose à la fois l’API développeur Gemini et Vertex.
Méthodes tracées
L’intégration de Google GenAI instrumente les méthodes suivantes :
- Génération de contenu (y compris les appels en streaming) :
models.generate_content() (Capture également chat.send_message())aio.models.generate_content() (Capture également aio.chat.send_message())
- Intégration de contenu
-
models.embed_content()
-aio.models.embed_content()
L’intégration LangChain fournit un traçage automatique pour le SDK Python de LangChain, le modèle LLM, et les appels de chaîne.
Méthodes tracées
L’intégration LangChain instrumente les méthodes suivantes :
L’intégration LangGraph trace automatiquement les invocations Pregel/CompiledGraph et RunnableSeq (node) effectuées via le SDK LangGraph Python.
Méthodes tracées
L’intégration LangGraph instrumente les versions synchrones et asynchrones des méthodes suivantes :
L’intégration LiteLLM fournit un traçage automatique pour le SDK LiteLLM Python et les méthodes de routeur de serveur proxy.
Méthodes tracées
L’intégration LiteLLM instrumente les méthodes suivantes :
- Chat Completions (y compris les appels en streaming) :
litellm.completionlitellm.acompletion
- Completions (y compris les appels en streaming) :
litellm.text_completionlitellm.atext_completion
- Chat Completions de routeur (y compris les appels en streaming) :
router.Router.completionrouter.Router.acompletion
- Completions de routeur (y compris les appels en streaming) :
router.Router.text_completionrouter.Router.atext_completion
L’intégration du Protocole de Contexte de Modèle (MCP) instrumente les appels d’outils client et serveur dans le SDK MCP.
Méthodes tracées
L’intégration MCP instrumente les méthodes suivantes :
L’intégration OpenAI fournit un traçage automatique pour les points de terminaison de complétions et de complétions de chat du SDK Python OpenAI vers OpenAI et Azure OpenAI.
Méthodes tracées
L’intégration OpenAI instrumente les méthodes suivantes, y compris les appels en continu :
- Complétions :
OpenAI().completions.create(), AzureOpenAI().completions.create()AsyncOpenAI().completions.create(), AsyncAzureOpenAI().completions.create()
- Complétions de chat :
OpenAI().chat.completions.create(), AzureOpenAI().chat.completions.create()AsyncOpenAI().chat.completions.create(), AsyncAzureOpenAI().chat.completions.create()
- Réponses :
OpenAI().responses.create()AsyncOpenAI().responses.create()OpenAI().responses.parse() (à partir de ddtrace==3.17.0)AsyncOpenAI().responses.parse() (à partir de ddtrace==3.17.0)
- Appels effectués à DeepSeek via le SDK Python OpenAI (à partir de
ddtrace==3.1.0)
L’intégration OpenAI fournit un traçage automatique pour les points de terminaison de complétion, de complétion de chat, d’embeddings et de réponses du SDK Java OpenAI vers OpenAI et Azure OpenAI.
Méthodes tracées
L’intégration OpenAI instrumente les méthodes suivantes sur OpenAIClient, y compris les appels en continu :
- Complétions :
openAiClient.completions().create()openAiClient.completions().createStreaming()openAiClient.async().completions().create()openAiClient.async().completions().createStreaming()
- Complétions de chat :
openAiClient.chat().completions().create()openAiClient.chat().completions().createStreaming()openAiClient.async().chat().completions().create()openAiClient.async().chat().completions().createStreaming()
- Embeddings :
openAiClient.embeddings().create()openAiClient.async().embeddings().create()
- Réponses :
openAiClient.responses().create()openAiClient.responses().createStreaming()openAiClient.async().responses().create()openAiClient.async().responses().createStreaming()
Le fournisseur (OpenAI vs Azure OpenAI) est automatiquement détecté en fonction du baseUrl configuré dans ClientOptions. Toutes les méthodes prennent en charge à la fois les variantes bloquantes et asynchrones (basées sur CompletableFuture).
L’intégration OpenAI Agents convertit le traçage intégré du OpenAI Agents SDK en
Le format LLM Observability et l’envoi au produit LLM Observability de Datadog s’effectuent en ajoutant un processeur de trace Datadog.
Les opérations suivantes sont prises en charge :
L’intégration Pydantic AI instrumente les invocations d’agents et les appels d’outils effectués en utilisant le cadre d’agents Pydantic AI.
Méthodes tracées
L’intégration Pydantic AI instrumente les méthodes suivantes :
- Invocations d’agents (y compris tous les outils ou ensembles d’outils associés à l’agent) :
agent.Agent.iter (trace également agent.Agent.run et agent.Agent.run_sync)agent.Agent.run_stream
L’intégration Vercel AI SDK trace automatiquement la génération de texte et d’objets, les embeddings et les appels d’outils en interceptant les spans OpenTelemetry créés par le cœur sous-jacent Vercel AI SDK et en les convertissant en spans Datadog LLM Observability.
Méthodes tracées
Télémétrie du Vercel AI Core SDK
Cette intégration applique automatiquement les correctifs au traceur passé dans chacune des méthodes tracées sous l’option experimental_telemetry. Si aucune configuration experimental_telemetry n’est passée, l’intégration permet d’envoyer tout de même des spans LLM Observability.
require('dd-trace').init({
llmobs: {
mlApp: 'my-ml-app',
}
});
const { generateText } = require('ai');
const { openai } = require('@ai-sdk/openai');
async function main () {
let result = await generateText({
model: openai('gpt-4o'),
...
experimental_telemetry: {
isEnabled: true,
tracer: someTracerProvider.getTracer('ai'), // this tracer will be patched to format and send created spans to Datadog LLM Observability
}
});
result = await generateText({
model: openai('gpt-4o'),
...
}); // since no tracer is passed in, the integration will enable it to still send LLM Observability spans
}
Remarque : Si experimental_telemetry.isEnabled est défini sur false, l’intégration ne l’active pas et n’envoie pas de spans LLM Observability.
Activer ou désactiver les intégrations LLM
Toutes les intégrations sont activées par défaut.
Désactiver toutes les intégrations LLM
Utilisez la configuration du SDK en code et spécifiez integrations_enabled=False.
Exemple : Configuration du SDK en code qui désactive toutes les intégrations LLM
from ddtrace.llmobs import LLMObs
LLMObs.enable(
ml_app="<YOUR_ML_APP_NAME>",
api_key="<YOUR_DATADOG_API_KEY>",
integrations_enabled=False
)
Utilisez la configuration du SDK en code et spécifiez plugins: false.
Exemple : Configuration du SDK en code qui désactive toutes les intégrations LLM
const tracer = require('dd-trace').init({
llmobs: { ... },
plugins: false
});
const { llmobs } = tracer;
Activez uniquement les intégrations LLM spécifiques
- Utilisez la configuration du SDK en code et désactivez toutes les intégrations avec
integrations_enabled=False. - Activez manuellement certaines intégrations avec
ddtrace.patch().
Exemple : Configuration du SDK en code qui active uniquement l’intégration LangChain
from ddtrace import patch
from ddtrace.llmobs import LLMObs
LLMObs.enable(
ml_app="<YOUR_ML_APP_NAME>",
api_key="<YOUR_DATADOG_API_KEY>",
integrations_enabled=False
)
patch(langchain=True)
- Utilisez la configuration du SDK en code et désactivez toutes les intégrations avec
plugins: false. - Activez manuellement certaines intégrations avec
use().
Exemple : Configuration du SDK en code qui active uniquement l’intégration LangChain
const tracer = require('dd-trace').init({
llmobs: { ... },
plugins: false
});
const { llmobs } = tracer;
tracer.use('langchain', true);
Pour un contrôle plus spécifique sur le patching de la bibliothèque et l’intégration qui démarre le span, vous pouvez définir les variables d’environnement suivantes :
DD_TRACE_DISABLED_PLUGINS- Une chaîne de noms d’intégration séparés par des virgules qui sont automatiquement désactivés lors de l’initialisation du tracer.
Exemple : DD_TRACE_DISABLED_PLUGINS=openai,http DD_TRACE_DISABLED_INSTRUMENTATIONS- Une chaîne de noms de bibliothèques séparés par des virgules qui ne sont pas patchées lors de l’initialisation du tracer.
Exemple : DD_TRACE_DISABLED_INSTRUMENTATIONS=openai,http
Pour aller plus loin
Documentation, liens et articles supplémentaires utiles:
