> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Définir et journaliser des attributs

> Utilisez des attributs pour ajouter des métadonnées à vos traces et évaluations.

<Note>
  Cette page décrit les attributs des fonctions tracées avec le décorateur `@weave.op`. Si vous instrumentez un agent avec le SDK d’agent Weave, définissez plutôt des attributs et des événements sur les spans d’agent (`Turn`, `LLM`, `Tool` et `SubAgent`). Voir [Définir des attributs et des événements sur les spans d’agent](/fr/products/wandb/weave/guides/tracking/trace-agents-attributes).
</Note>

Dans Weave, les attributs vous permettent de joindre des métadonnées personnalisées à vos traces et évaluations. Ces métadonnées peuvent inclure des informations telles que des noms d’environnement, des versions de modèle, des ID d’expérience, des ID d’utilisateur ou toute autre information contextuelle utile pour organiser, filtrer et analyser vos données Weave.

Les attributs sont particulièrement utiles pour regrouper ou filtrer les traces par :

* déploiement ;
* locataire ;
* expérience.

Weave propose deux façons d’ajouter des attributs :

* **Attributs par appel** : utilisez le gestionnaire de contexte `weave.attributes()` pour ajouter des métadonnées à des opérations ou à des blocs de code précis.
* **Attributs globaux** : utilisez le champ `global_attributes` pour définir, dès l’initialisation, des attributs qui s’appliquent à toutes les traces et évaluations de votre projet.

Vous pouvez consulter dans l’interface utilisateur tous les attributs journalisés pendant les traces et les évaluations, puis vous en servir pour filtrer et regrouper les données.

Ce guide s’adresse aux utilisateurs de Weave qui souhaitent enrichir leurs traces et évaluations de métadonnées personnalisées. Il explique comment joindre des attributs à des appels individuels, définir des valeurs par défaut pour l’ensemble du projet lors de l’initialisation, combiner les deux approches et lire l’ensemble d’attributs actif pendant l’exécution.

<h2 id="per-call-attributes">
  Attributs par appel
</h2>

Le gestionnaire de contexte `weave.attributes()` vous permet d’ajouter des métadonnées à certaines opérations tracées. Utilisez-le pour associer des informations contextuelles à des appels de fonction ou à des runs d’évaluation précis.

<Tip>
  Vous ne pouvez plus modifier `call.attributes` une fois l’appel démarré. Utilisez ce
  gestionnaire de contexte pour définir les métadonnées avant d’invoquer l’op.
</Tip>

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    weave.init("[TEAM-NAME]/[PROJECT-NAME]")

    @weave.op
    def my_function(name: str):
        return f"Hello, {name}!"

    # Ajouter des attributs à un appel spécifique
    with weave.attributes({'env': 'production', 'user_id': '12345'}):
        result = my_function("World")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import {init, op, withAttributes} from 'weave';

    async function main() {
      await init('your-team/attribute-example');

      const myFunction = op(async function myFunction(name: string) {
        return `Hello, ${name}!`;
      });

      // Ajouter des attributs à un appel spécifique
      const result = await withAttributes(
        {env: 'production', user_id: '12345'},
        async () => myFunction('World')
      );

      console.log('Result:', result);
    }

    main().catch(console.error);
    ```
  </Tab>
</Tabs>

La fonction joint les attributs à toutes les opérations tracées dans le bloc du gestionnaire de contexte (Python) ou dans la fonction de rappel (TypeScript).

Vous pouvez également imbriquer des contextes `weave.attributes()`. Pour une même clé, la valeur du contexte interne remplace celle du contexte externe :

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    @weave.op
    def process_data(data: str):
        return data.upper()

    # Contexte externe
    with weave.attributes({
        "env": "production",
        "version": "1.0.0",
        "region": "us-west-2"
    }):
        process_data("hello")  # Possède les trois attributs
        
        # Le contexte interne redéfinit 'version'
        with weave.attributes({
            "version": "1.1.0",
            "experiment": "exp-456"
        }):
            process_data("world")  # Possède env='production', version='1.1.0', region='us-west-2', experiment='exp-456'
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import {init, op, withAttributes} from 'weave';

    async function main() {
      await init('your-team/attribute-example');

      const processData = op(async function processData(data: string) {
        return data.toUpperCase();
      });
      
      // Contexte externe
      await withAttributes(
        {
          env: 'production',
          version: '1.0.0',
          region: 'us-west-2'
        },
        async () => {
          await processData('hello');  // Possède les trois attributs
          
          // Le contexte interne redéfinit 'version'
          await withAttributes(
            {
              version: '1.1.0',
              experiment: 'exp-456'
            },
            async () => {
              await processData('world');  // Possède env='production', version='1.1.0', region='us-west-2', experiment='exp-456'
            }
          );
        }
      );
    }

    main().catch(console.error);
    ```
  </Tab>
</Tabs>

<h2 id="global-attributes">
  Attributs globaux
</h2>

Les attributs globaux définis lors de l’initialisation de Weave s’appliquent automatiquement à toutes les traces et évaluations de votre projet. Ils permettent de propager des métadonnées communes à l’ensemble du projet, comme l’environnement, la version du déploiement ou des informations sur l’équipe.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    weave.init(
        "my-project",
        global_attributes={
            "env": "production",
            "app_version": "2.1.0",
            "region": "us-west-2",
            "team": "ml-platform"
        }
    )

    # Le dictionnaire global_attributes applique désormais ces attributs à toutes les opérations suivantes
    @weave.op
    def my_function():
        return "Hello"

    my_function()  # Reçoit automatiquement tous les attributs globaux

    # Les évaluations reçoivent elles aussi les attributs globaux
    evaluation = weave.Evaluation(dataset=examples, scorers=[scorer])
    asyncio.run(evaluation.evaluate(model))  # Reçoit tous les attributs globaux
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import {init, op, withAttributes} from 'weave';

    async function main() {
        await init('your-team/attribute-example', {
            globalAttributes: {
                env: 'production',
                app_version: '2.1.0',
                region: 'us-west-2',
                team: 'ml-platform'
            }
        });
        
        // L’objet globalAttributes applique désormais ces attributs à toutes les opérations suivantes
        const myFunction = op(async function myFunction() {
            return 'Hello';
        });
        
        const result = await myFunction();  // Reçoit automatiquement tous les attributs globaux
        console.log('Result:', result);
    }
    main().catch(console.error);
    ```
  </Tab>
</Tabs>

<h3 id="combine-global-and-per-call-attributes">
  Combiner attributs globaux et attributs par appel
</h3>

Vous pouvez combiner attributs globaux et attributs par appel. Lorsqu’ils partagent la même clé, les attributs par appel remplacent les attributs globaux :

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    # Définir les attributs globaux
    weave.init(
        "my-project",
        global_attributes={
            "env": "production",
            "app_version": "2.1.0"
        }
    )

    @weave.op
    def process(data: str):
        return data

    # Attributs de cet appel : env='production', app_version='2.1.0'
    process("test1")

    # Attributs de cet appel : env='staging', app_version='2.1.0', experiment='A'
    with weave.attributes({'env': 'staging', 'experiment': 'A'}):
        process("test2")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import {init, op, withAttributes} from 'weave';

    async function main() {
        // Définir les attributs globaux
        await init('your-team/attribute-example', {
        globalAttributes: {
            env: 'production',
            app_version: '2.1.0'
        }
        });

        const process = op(async function process(data: string) {
        return data;
        });

        // Attributs de cet appel : env='production', app_version='2.1.0'
        await process('test1');

        // Attributs de cet appel : env='staging', app_version='2.1.0', experiment='A'
        await withAttributes(
        {env: 'staging', experiment: 'A'},
        async () => process('test2')
        );
    }
    main().catch(console.error);
    ```
  </Tab>
</Tabs>

<h2 id="get-attributes-during-execution">
  Obtenir les attributs pendant l’exécution
</h2>

Lors de l’exécution, vous pouvez inspecter les attributs appliqués à un Appel. Cela s’avère utile pour déboguer les métadonnées que Weave joint, ou lorsque votre code doit adopter un comportement différent selon des informations contextuelles définies par un appelant externe.

<Tabs>
  <Tab title="Python">
    L’exemple suivant utilise le décorateur Weave pour journaliser la fonction `process_data`, configure les attributs à journaliser, puis les renvoie lors de l’exécution.

    ```python lines  theme={"system"}
    import weave

    weave.init("your-team/your-project")

    @weave.op
    def process_data(data: str):
        # Obtenir l'appel en cours à l'intérieur de l'op
        call = weave.get_current_call()
        if call:
            print(f"Attributes: {call.attributes}")
        return data.upper()

    # Définir les attributs et exécuter la fonction
    with weave.attributes({
        "env": "production",
        "version": "1.0.0",
        "region": "us-west-2"
    }):
        process_data("hello")
        
        with weave.attributes({
            "version": "1.1.0",
            "experiment": "exp-456"
        }):
            process_data("world")
    ```

    Ce code produit la sortie suivante :

    ```text theme={"system"}
    Attributes: {'env': 'production', 'version': '1.0.0', 'region': 'us-west-2'}
    Attributes: {'env': 'production', 'version': '1.1.0', 'region': 'us-west-2', 'experiment': 'exp-456'}
    ```

    <Note>
      `weave.get_current_call()` ne fonctionne qu’à l’intérieur d’une fonction décorée avec `@weave.op`. En dehors d’un op, elle renvoie `None`.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    Avec le SDK TypeScript de Weave, vous pouvez obtenir les attributs actuels avec `client.getCurrentAttributes()`. Contrairement au SDK Python de Weave, le SDK TypeScript vous permet d’accéder aux attributs dans tout contexte `withAttributes()`, et pas uniquement à l’intérieur d’un op.

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import * as weave from 'weave';
    import { withAttributes } from 'weave';

    async function main() {
      const client = await weave.init('your-team/your-project');

      const processData = weave.op(async function processData(data: string) {
        // Vous pouvez aussi accéder aux attributs à l'intérieur d'un op
        const attrs = client.getCurrentAttributes();
        console.log('Attributes inside op:', attrs);
        return data.toUpperCase();
      });

      // Définir les attributs et exécuter la fonction
      await withAttributes(
        {
          env: 'production',
          version: '1.0.0',
          region: 'us-west-2'
        },
        async () => {
          // Obtenir les attributs depuis n'importe quel endroit du contexte
          console.log('Current attributes:', client.getCurrentAttributes());
          await processData('hello');

          await withAttributes(
            {
              version: '1.1.0',
              experiment: 'exp-456'
            },
            async () => {
              console.log('Nested attributes:', client.getCurrentAttributes());
              await processData('world');
            }
          );
        }
      );
    }

    main().catch(console.error);
    ```

    Ce code produit la sortie suivante :

    ```text theme={"system"}
    Current attributes: { env: 'production', version: '1.0.0', region: 'us-west-2' }
    Attributes inside op: { env: 'production', version: '1.0.0', region: 'us-west-2' }
    Nested attributes: { env: 'production', version: '1.1.0', region: 'us-west-2', experiment: 'exp-456' }
    Attributes inside op: { env: 'production', version: '1.1.0', region: 'us-west-2', experiment: 'exp-456' }
    ```
  </Tab>
</Tabs>


## Related topics

- [Tracer des fonctions imbriquées](/fr/products/wandb/weave/tutorial-tracing_2.md)