Le Guide Complet de l'Observabilite IA

Pourquoi les systemes IA ont besoin d'une observabilite differente

Voici le truc avec les systemes IA : le monitoring traditionnel ne suffit pas. Quand ton API REST renvoie une erreur 500, tu sais que quelque chose a casse. Quand ton IA renvoie des informations fausses avec assurance, techniquement tout semble normal. Dashboards verts, latence saine, reponses HTTP reussies. Mais tes utilisateurs recoivent n'importe quoi.

On a appris ca de la maniere difficile. Un de nos clients avait un agent de support client qui a commence a recommander des produits concurrents. Aucune erreur dans les logs. Pas de pics de latence. Juste des conseils terribles donnes discretement pendant trois jours avant que quelqu'un le remarque. C'est la qu'on a realise : observer l'IA, ce n'est pas verifier si elle tourne. C'est verifier si elle fonctionne vraiment.

Le monitoring traditionnel te dit si ton systeme est vivant. L'observabilite IA te dit si ton systeme est sense.

Ce guide couvre tout ce qu'on a appris sur l'observation des systemes IA. Pas de theorie - des pratiques reelles qu'on utilise en production tous les jours.

Les quatre piliers de l'observabilite IA

Decomposons ce que tu dois vraiment tracker :

La plupart des equipes commencent par le logging, realisent qu'elles ont besoin de metriques pour controler les couts, ajoutent le tracing quand le debugging devient penible, et finalement implementent le monitoring qualite apres un incident grave. Epargne-toi les ennuis et construis les quatre des le depart.

Logging : Ta premiere ligne de defense

Quoi logger

Chaque interaction IA devrait capturer :

const aiCallLog = {
  // Identite
  requestId: "uuid-v4",
  sessionId: "user-session-id",
  userId: "identifiant-utilisateur-optionnel",

  // Input
  prompt: {
    system: "Tu es un assistant serviable...",
    user: "Quelle est la politique de remboursement ?",
    context: ["doc_recupere_1", "doc_recupere_2"]
  },

  // Configuration modele
  model: "gpt-4-turbo",
  temperature: 0.7,
  maxTokens: 1000,

  // Output
  response: {
    content: "Notre politique de remboursement permet...",
    finishReason: "stop",
    toolCalls: []
  },

  // Performance
  latencyMs: 2340,
  inputTokens: 456,
  outputTokens: 234,
  totalTokens: 690,

  // Cout
  estimatedCostUsd: 0.0138,

  // Metadonnees
  timestamp: "2025-10-15T14:30:00Z",
  environment: "production",
  version: "1.2.3"
};

Implementation du logging structure

Ne balance pas juste des strings vers stdout. Structure tes logs pour pouvoir vraiment les interroger :

interface AILogEntry {
  level: 'debug' | 'info' | 'warn' | 'error';
  event: string;
  requestId: string;
  data: {
    model: string;
    promptHash: string;  // Pour grouper les prompts similaires
    inputTokens: number;
    outputTokens: number;
    latencyMs: number;
    success: boolean;
    errorType?: string;
  };
  context?: {
    userId?: string;
    feature?: string;
    experimentId?: string;
  };
}

function logAICall(entry: AILogEntry) {
  // Envoyer a ton infrastructure de logging
  // On utilise une combinaison de logs JSON structures + metriques time-series
  console.log(JSON.stringify({
    ...entry,
    timestamp: new Date().toISOString(),
    service: 'ai-gateway'
  }));
}

Logger les donnees sensibles

C'est la que ca devient delicat. Tu dois logger les prompts pour le debugging, mais les prompts contiennent souvent des donnees utilisateur. Notre approche :

1. Hasher les champs sensibles - Stocke un hash des PII, pas les valeurs reelles
2. Stockage separe - Les prompts complets vont dans un stockage restreint et chiffre avec courte retention
3. Echantillonnage - Ne logge les prompts complets que pour un pourcentage des requetes en production
4. Redaction - Utilise des patterns regex pour retirer les patterns PII courants avant le logging

const sensitivePatterns = [
  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,  // Email
  /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,  // Telephone
  /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,  // Carte de credit
];

function redactPII(text: string): string {
  let redacted = text;
  sensitivePatterns.forEach(pattern => {
    redacted = redacted.replace(pattern, '[REDIGE]');
  });
  return redacted;
}

Metriques : Les chiffres qui comptent vraiment

Metriques cles a tracker

Mettre en place la collecte de metriques

Voici comment on instrumente notre gateway IA :

import { Counter, Histogram, Gauge } from 'prom-client';

const aiLatency = new Histogram({
  name: 'ai_request_latency_ms',
  help: 'Latence des requetes IA en millisecondes',
  labelNames: ['model', 'feature', 'status'],
  buckets: [100, 250, 500, 1000, 2500, 5000, 10000]
});

const aiTokens = new Counter({
  name: 'ai_tokens_total',
  help: 'Total de tokens consommes',
  labelNames: ['model', 'type', 'feature']  // type: input/output
});

const aiCost = new Counter({
  name: 'ai_cost_usd',
  help: 'Cout estime en USD',
  labelNames: ['model', 'feature']
});

async function instrumentedAICall(params: AICallParams) {
  const startTime = Date.now();

  try {
    const result = await makeAICall(params);

    const latency = Date.now() - startTime;
    aiLatency.observe({
      model: params.model,
      feature: params.feature,
      status: 'success'
    }, latency);

    aiTokens.inc({
      model: params.model,
      type: 'input',
      feature: params.feature
    }, result.usage.inputTokens);

    aiTokens.inc({
      model: params.model,
      type: 'output',
      feature: params.feature
    }, result.usage.outputTokens);

    const cost = calculateCost(params.model, result.usage);
    aiCost.inc({
      model: params.model,
      feature: params.feature
    }, cost);

    return result;
  } catch (error) {
    aiLatency.observe({
      model: params.model,
      feature: params.feature,
      status: 'error'
    }, Date.now() - startTime);

    throw error;
  }
}

Suivi des couts : La metrique qui attire l'attention des executives

Soyons honnetes - les couts sont generalement ce qui met l'observabilite sur la table. Voici comment les tracker correctement :

const MODEL_PRICING = {
  'gpt-4-turbo': { input: 0.01, output: 0.03 },      // par 1K tokens
  'gpt-4o': { input: 0.005, output: 0.015 },
  'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
  'claude-3-opus': { input: 0.015, output: 0.075 },
  'claude-3-sonnet': { input: 0.003, output: 0.015 },
  'claude-3-haiku': { input: 0.00025, output: 0.00125 }
};

function calculateCost(model: string, usage: TokenUsage): number {
  const pricing = MODEL_PRICING[model];
  if (!pricing) return 0;

  return (usage.inputTokens / 1000 * pricing.input) +
         (usage.outputTokens / 1000 * pricing.output);
}

// Agreger les couts par feature, equipe, client
interface CostAllocation {
  feature: string;
  team: string;
  customerId?: string;
  dailyCost: number;
  monthlyProjection: number;
}

Construis des dashboards qui montrent :

• Depenses quotidiennes/hebdomadaires/mensuelles par modele
• Cout par feature ou cas d'usage
• Cout par client (pour le B2B)
• Depenses mensuelles projetees basees sur la trajectoire actuelle
• Detection d'anomalies pour les pics de couts soudains

Tracing : Suivre le fil

Les workflows IA ne sont plus des appels uniques. Ce sont des chaines, des agents et des processus multi-etapes complexes. Le tracing te permet de suivre une requete a travers tout le systeme.

Implementation du tracing distribue

import { trace, SpanKind, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.getTracer('ai-service');

async function tracedAgentExecution(task: string, context: RequestContext) {
  return tracer.startActiveSpan('agent.execute', async (span) => {
    span.setAttributes({
      'ai.task': task,
      'ai.session_id': context.sessionId,
      'ai.user_id': context.userId
    });

    try {
      // Etape 1: Planification
      const plan = await tracer.startActiveSpan('agent.plan', async (planSpan) => {
        const result = await planTask(task);
        planSpan.setAttributes({
          'ai.model': 'gpt-4-turbo',
          'ai.tokens.input': result.usage.input,
          'ai.tokens.output': result.usage.output,
          'ai.plan.steps': result.steps.length
        });
        return result;
      });

      // Etape 2: Executer chaque etape
      for (const step of plan.steps) {
        await tracer.startActiveSpan(`agent.step.${step.type}`, async (stepSpan) => {
          stepSpan.setAttributes({
            'ai.step.type': step.type,
            'ai.step.tool': step.tool
          });

          if (step.type === 'llm_call') {
            await tracedLLMCall(step.params, stepSpan);
          } else if (step.type === 'tool_call') {
            await tracedToolCall(step.tool, step.params, stepSpan);
          }
        });
      }

      span.setStatus({ code: SpanStatusCode.OK });
    } catch (error) {
      span.setStatus({
        code: SpanStatusCode.ERROR,
        message: error.message
      });
      span.recordException(error);
      throw error;
    }
  });
}

Ce que les bons traces te montrent

Un trace IA bien instrumente revele :

[Execution Agent] 4.2s
├── [Planification] 1.1s
│   └── [Appel LLM: gpt-4] 1.0s - 234 tokens entree, 156 tokens sortie
├── [Etape 1: RAG Retrieval] 0.3s
│   ├── [Generation Embedding] 0.1s
│   └── [Recherche Vectorielle] 0.2s - 5 documents recuperes
├── [Etape 2: Synthese LLM] 2.1s
│   └── [Appel LLM: gpt-4] 2.0s - 1,456 tokens entree, 523 tokens sortie
└── [Etape 3: Formatage Reponse] 0.7s
    └── [Appel LLM: gpt-4o-mini] 0.6s - 678 tokens entree, 234 tokens sortie

Maintenant quand quelqu'un signale une reponse lente, tu peux voir exactement ou le temps est passe.

Debugging de prompts : La partie difficile

C'est la que l'observabilite IA diverge le plus du monitoring traditionnel. Comment debugges-tu quelque chose qui fonctionne differemment a chaque fois ?

Versioning des prompts

Traite les prompts comme du code. Versionne-les :

interface PromptVersion {
  id: string;
  name: string;
  version: string;
  template: string;
  variables: string[];
  model: string;
  temperature: number;
  createdAt: Date;
  createdBy: string;
  parentVersion?: string;
}

const promptRegistry = {
  'customer-support-v2.3': {
    id: 'cs-001',
    name: 'Agent Support Client',
    version: '2.3',
    template: `Tu es un agent de support client serviable pour {{company_name}}.

Ton role est d'aider les clients avec leurs questions sur {{product_area}}.

Directives:
- Verifie toujours l'identite du client avant de discuter des details du compte
- Ne promets jamais de remboursements sans verifier la politique
- Escalade a un agent humain si le client exprime de la frustration

Question client: {{query}}
Contexte: {{context}}`,
    variables: ['company_name', 'product_area', 'query', 'context'],
    model: 'gpt-4-turbo',
    temperature: 0.3
  }
};

A/B Testing des prompts

Tu ne peux pas ameliorer ce que tu ne mesures pas. Lance des experiences sur les variations de prompts :

interface PromptExperiment {
  id: string;
  name: string;
  variants: {
    id: string;
    promptVersion: string;
    trafficPercentage: number;
  }[];
  metrics: string[];  // Quoi mesurer
  startDate: Date;
  endDate?: Date;
}

function selectPromptVariant(experimentId: string, userId: string): string {
  const experiment = getExperiment(experimentId);

  // Assignation deterministe basee sur l'ID utilisateur
  const hash = hashString(userId + experimentId);
  const bucket = hash % 100;

  let cumulative = 0;
  for (const variant of experiment.variants) {
    cumulative += variant.trafficPercentage;
    if (bucket < cumulative) {
      return variant.promptVersion;
    }
  }

  return experiment.variants[0].promptVersion;
}

Debugger les reponses echouees

Quand une reponse IA tourne mal, tu dois repondre a :

1. Quel etait l'input ? - Prompt complet incluant message systeme, contexte et input utilisateur
2. Quel contexte a ete recupere ? - Pour les systemes RAG, quels documents ont influence la reponse
3. Quel etait le raisonnement du modele ? - Si chain-of-thought, quelles etapes a-t-il suivies
4. Comment les parametres ont affecte l'output ? - Temperature, top_p, frequency penalty
5. Etait-ce ponctuel ou un pattern ? - Chercher des inputs similaires qui ont produit des echecs similaires

Construis une interface de debugging qui te permet :

-- Trouver des echecs similaires
SELECT
  request_id,
  prompt_hash,
  response_content,
  error_type,
  timestamp
FROM ai_logs
WHERE
  feature = 'customer-support'
  AND (
    response_content LIKE '%concurrent%'      -- Mentionne concurrents
    OR quality_score < 0.5                     -- Score qualite bas
    OR user_feedback = 'negative'              -- Utilisateur a signale
  )
  AND timestamp > NOW() - INTERVAL '7 days'
ORDER BY timestamp DESC
LIMIT 100;

Monitoring qualite : L'IA est-elle vraiment bonne ?

C'est la partie la plus difficile de l'observabilite IA. Les metriques techniques peuvent etre vertes pendant que l'IA produit des dechets.

Controles qualite automatises

interface QualityCheck {
  name: string;
  check: (response: AIResponse, context: RequestContext) => QualityResult;
}

const qualityChecks: QualityCheck[] = [
  {
    name: 'response_length',
    check: (response) => ({
      pass: response.content.length > 50 && response.content.length < 5000,
      score: normalizeLength(response.content.length),
      reason: 'Longueur de reponse dans la plage acceptable'
    })
  },
  {
    name: 'no_hallucinated_urls',
    check: (response) => {
      const urls = extractUrls(response.content);
      const validUrls = urls.filter(url => isKnownValidUrl(url));
      return {
        pass: urls.length === validUrls.length,
        score: urls.length === 0 ? 1 : validUrls.length / urls.length,
        reason: `${urls.length - validUrls.length} URLs potentiellement hallucinees`
      };
    }
  },
  {
    name: 'factual_grounding',
    check: (response, context) => {
      // Verifier si les affirmations cles sont supportees par le contexte recupere
      const claims = extractClaims(response.content);
      const groundedClaims = claims.filter(claim =>
        isClaimSupportedByContext(claim, context.retrievedDocuments)
      );
      return {
        pass: groundedClaims.length / claims.length > 0.8,
        score: groundedClaims.length / claims.length,
        reason: `${groundedClaims.length}/${claims.length} affirmations ancrees dans le contexte`
      };
    }
  },
  {
    name: 'safety_check',
    check: (response) => {
      const safetyResult = runSafetyClassifier(response.content);
      return {
        pass: safetyResult.safe,
        score: safetyResult.confidence,
        reason: safetyResult.category || 'Reponse a passe le controle de securite'
      };
    }
  }
];

async function evaluateResponse(
  response: AIResponse,
  context: RequestContext
): Promise<QualityReport> {
  const results = await Promise.all(
    qualityChecks.map(check => ({
      check: check.name,
      ...check.check(response, context)
    }))
  );

  return {
    overallScore: average(results.map(r => r.score)),
    allPassed: results.every(r => r.pass),
    details: results
  };
}

Evaluation humaine dans la boucle

Les controles automatises attrapent les problemes evidents. Pour les problemes de qualite subtils, tu as besoin d'une revue humaine :

interface HumanEvaluationQueue {
  // Echantillonner un pourcentage de reponses pour revue humaine
  sampleRate: number;

  // Toujours revoir certains types
  alwaysReviewWhen: {
    lowConfidence: boolean;           // Incertitude du modele
    userFeedbackNegative: boolean;
    automatedChecksFailed: boolean;
    highValueCustomer: boolean;
  };

  // Criteres d'evaluation pour les reviewers
  criteria: {
    accuracy: 'La reponse contenait-elle des informations correctes ?';
    relevance: 'La reponse a-t-elle traite la question de l utilisateur ?';
    completeness: 'La reponse etait-elle assez complete ?';
    tone: 'Le ton etait-il approprie pour le contexte ?';
    safety: 'Y avait-il des elements preoccupants ?';
  };
}

Alerting : Savoir quand ca tourne mal

Seuils d'alerte pour les systemes IA

Implementation d'alertes intelligentes

interface AIAlert {
  name: string;
  condition: (metrics: AIMetrics) => boolean;
  severity: 'info' | 'warning' | 'critical';
  cooldown: number;  // Minutes avant de re-alerter
  notification: {
    slack?: string;
    pagerduty?: string;
    email?: string[];
  };
}

const alerts: AIAlert[] = [
  {
    name: 'high_latency',
    condition: (m) => m.latencyP95 > 10000,
    severity: 'warning',
    cooldown: 30,
    notification: { slack: '#ai-alerts' }
  },
  {
    name: 'quality_degradation',
    condition: (m) => m.qualityScore < 0.7 && m.previousQualityScore > 0.85,
    severity: 'critical',
    cooldown: 60,
    notification: {
      slack: '#ai-alerts',
      pagerduty: 'ai-oncall'
    }
  },
  {
    name: 'cost_anomaly',
    condition: (m) => m.hourlyCost > m.expectedHourlyCost * 3,
    severity: 'warning',
    cooldown: 60,
    notification: {
      slack: '#ai-alerts',
      email: ['ai-team@company.com']
    }
  }
];

Construire ton stack d'observabilite

Architecture recommandee

┌─────────────────────────────────────────────────────────────────┐
│                        Application IA                            │
├─────────────────────────────────────────────────────────────────┤
│                     Couche d'Instrumentation                     │
│  (OpenTelemetry SDK, Metriques Custom, Logging Structure)       │
└─────────────────────────────┬───────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
        ▼                     ▼                     ▼
┌───────────────┐   ┌─────────────────┐   ┌───────────────┐
│    Traces     │   │    Metriques    │   │     Logs      │
│   (Jaeger/    │   │  (Prometheus/   │   │ (Elasticsearch│
│    Tempo)     │   │   Datadog)      │   │   /Loki)      │
└───────┬───────┘   └────────┬────────┘   └───────┬───────┘
        │                    │                    │
        └────────────────────┼────────────────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │   Dashboards    │
                    │    (Grafana)    │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │    Alerting     │
                    │  (PagerDuty/    │
                    │   Slack/OpsGenie│
                    └─────────────────┘

Outils qu'on recommande

Exemple concret : Setup d'observabilite complet

Voici comment on instrumente une feature IA en production de bout en bout :

import { trace, metrics, context } from '@opentelemetry/api';
import { logger } from './logging';
import { qualityChecker } from './quality';
import { costTracker } from './costs';

class ObservableAIService {
  private tracer = trace.getTracer('ai-service');
  private meter = metrics.getMeter('ai-service');

  private latencyHistogram = this.meter.createHistogram('ai.latency');
  private tokenCounter = this.meter.createCounter('ai.tokens');
  private costCounter = this.meter.createCounter('ai.cost');
  private qualityGauge = this.meter.createObservableGauge('ai.quality');

  async complete(request: AIRequest): Promise<AIResponse> {
    const span = this.tracer.startSpan('ai.complete');
    const startTime = Date.now();

    const requestId = generateRequestId();
    span.setAttribute('request_id', requestId);
    span.setAttribute('model', request.model);
    span.setAttribute('feature', request.feature);

    try {
      // Logger la requete
      logger.info('ai.request.start', {
        requestId,
        model: request.model,
        feature: request.feature,
        promptHash: hashPrompt(request.prompt),
        inputTokenEstimate: estimateTokens(request.prompt)
      });

      // Faire l'appel IA
      const response = await this.makeAICall(request);

      const latency = Date.now() - startTime;
      const cost = costTracker.calculate(request.model, response.usage);

      // Enregistrer les metriques
      this.latencyHistogram.record(latency, {
        model: request.model,
        feature: request.feature,
        status: 'success'
      });

      this.tokenCounter.add(response.usage.inputTokens, {
        model: request.model,
        type: 'input'
      });

      this.tokenCounter.add(response.usage.outputTokens, {
        model: request.model,
        type: 'output'
      });

      this.costCounter.add(cost, {
        model: request.model,
        feature: request.feature
      });

      // Lancer les controles qualite
      const quality = await qualityChecker.evaluate(response, request);

      // Logger la reponse
      logger.info('ai.request.complete', {
        requestId,
        latencyMs: latency,
        inputTokens: response.usage.inputTokens,
        outputTokens: response.usage.outputTokens,
        costUsd: cost,
        qualityScore: quality.overallScore,
        qualityPassed: quality.allPassed
      });

      // Stocker pour debugging (avec retention appropriee)
      await this.storeForDebugging(requestId, request, response, quality);

      span.setStatus({ code: SpanStatusCode.OK });
      return response;

    } catch (error) {
      const latency = Date.now() - startTime;

      this.latencyHistogram.record(latency, {
        model: request.model,
        feature: request.feature,
        status: 'error'
      });

      logger.error('ai.request.error', {
        requestId,
        error: error.message,
        errorType: error.constructor.name,
        latencyMs: latency
      });

      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      span.recordException(error);

      throw error;
    } finally {
      span.end();
    }
  }
}

Demarrer : Ta premiere semaine

Jour 1-2 : Logging de base

• Ajouter du logging structure a tous les appels IA
• Inclure : modele, latence, compteurs de tokens, nom de feature
• Stocker les logs quelque part d'interrogeable

Jour 3-4 : Metriques de base

• Mettre en place les compteurs de tokens et couts
• Creer des histogrammes de latence par modele et feature
• Construire ton premier dashboard

Jour 5 : Alerting

• Alerter sur les pics de taux d'erreur
• Alerter sur les anomalies de couts
• Alerter sur la degradation de latence

Semaine 2 : Qualite et Tracing

• Implementer les controles qualite de base
• Ajouter le tracing distribue pour les workflows IA multi-etapes
• Commencer a collecter le feedback utilisateur

Conclusion

L'observabilite IA n'est plus optionnelle. Alors que les systemes IA gerent des workflows de plus en plus critiques, tu dois savoir non seulement s'ils tournent, mais s'ils fonctionnent vraiment correctement.

La bonne nouvelle : la plupart de ce dont tu as besoin peut etre construit sur l'infrastructure d'observabilite existante. OpenTelemetry, Prometheus, logging structure - ces outils marchent aussi pour l'IA. La difference, c'est de savoir quoi mesurer et comment l'interpreter.

Commence simple. Logge tout. Tracke les couts. Ajoute des controles qualite. Construis a partir de la.

Le meilleur moment pour ajouter l'observabilite etait avant le lancement. Le deuxieme meilleur moment, c'est maintenant.

On a aide des equipes a passer de "on n'a aucune idee de ce que fait notre IA" a "on a detecte ce probleme en 3 minutes" en quelques semaines. L'investissement se rentabilise des la premiere fois que tu debugges un probleme de production en minutes au lieu d'heures.

Si tu construis des systemes IA et que tu veux parler de strategies d'observabilite, contacte-nous. On a vu beaucoup de modes de defaillance et on est contents de partager ce qu'on a appris.