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

# Installation OpenTelemetry pour Node.js

Assurez-vous d'[installer l'AppSignal collector](/opentelemetry/installation) avant de poursuivre avec ces instructions.

## Installer les paquets OpenTelemetry

Utilisez npm pour ajouter le SDK OpenTelemetry et l'exportateur OTLP aux dépendances de votre application :

<CodeGroup>
  ```shell Shell theme={null}
  npm install @opentelemetry/sdk-node \
    @opentelemetry/api \
    @opentelemetry/sdk-trace-node \
    @opentelemetry/sdk-metrics \
    @opentelemetry/exporter-trace-otlp-proto \
    @opentelemetry/exporter-metrics-otlp-proto \
    @opentelemetry/auto-instrumentations-node \
    @opentelemetry/semantic-conventions \
    @opentelemetry/resources
  ```
</CodeGroup>

Le paquet `@opentelemetry/auto-instrumentations-node` instrumentera automatiquement la plupart des applications et bibliothèques. Consultez [le README du paquet pour une liste des bibliothèques et frameworks qu'il instrumente](https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node). Vous pouvez [trouver des instrumentations supplémentaires pour les bibliothèques et frameworks dans le registre OpenTelemetry](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=js\&flag=all).

## Configurer OpenTelemetry dans votre application

Ajoutez ce fichier `opentelemetry.cjs` à votre application avec l'exportateur OpenTelemetry et la configuration AppSignal.

Veillez à mettre à jour les valeurs ci-dessous avec le nom de votre application AppSignal, l'environnement et la clé Push API, et à remplacer l'endpoint de l'exportateur par l'adresse de votre AppSignal collector si nécessaire.

<CodeGroup>
  ```javascript JavaScript theme={null}
  const os = require("os");
  const { NodeSDK } = require("@opentelemetry/sdk-node");
  const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
  const {
    PeriodicExportingMetricReader,
    AggregationTemporality,
  } = require("@opentelemetry/sdk-metrics");
  const { resourceFromAttributes } = require("@opentelemetry/resources");
  const { ATTR_SERVICE_NAME } = require("@opentelemetry/semantic-conventions");
  const {
    OTLPTraceExporter,
  } = require("@opentelemetry/exporter-trace-otlp-proto");
  const {
    OTLPMetricExporter,
  } = require("@opentelemetry/exporter-metrics-otlp-proto");
  const {
    getNodeAutoInstrumentations,
  } = require("@opentelemetry/auto-instrumentations-node");

  // Replace these values with your AppSignal application name, environment
  // and push API key. These are used by the resource attributes configuration below.
  const name = "My app";
  const pushApiKey = "0000-0000-0000-0000";

  const environment = process.env.NODE_ENV || "production";

  // Set the name of the service that is being monitored. A common choice is the
  // name of the framework used. This is used to group traces and metrics in AppSignal.
  const serviceName = "My service name";

  // Replace `http://localhost:8099` with the address of your AppSignal collector
  // if it's running on another host.
  const endpoint = "http://localhost:8099";

  const revision = childProcess.execSync("git rev-parse --short HEAD").toString();

  const resource = new resourceFromAttributes({
    "appsignal.config.name": name,
    "appsignal.config.environment": environment,
    "appsignal.config.push_api_key": "0000-0000-0000-0000",
    "appsignal.config.revision": revision,
    "appsignal.config.language_integration": "node.js",
    "appsignal.config.app_path": process.cwd(),
    "host.name": os.hostname(),
    [ATTR_SERVICE_NAME]: "My service name",
  });

  const sdk = new NodeSDK({
    resource,
    traceExporter: new OTLPTraceExporter({
      url: `${endpoint}/v1/traces`,
    }),
    metricReader: new PeriodicExportingMetricReader({
      exportIntervalMillis: 10000,
      exporter: new OTLPMetricExporter({
        url: `${endpoint}/v1/metrics`,
      }),
    }),
    instrumentations: [getNodeAutoInstrumentations()],
  });

  sdk.start();
  ```
</CodeGroup>

## Démarrer votre application avec OpenTelemetry

Pour exécuter votre application avec OpenTelemetry, vous devez utiliser le drapeau `--require` afin de charger le fichier `opentelemetry.cjs` avant de démarrer votre application :

<CodeGroup>
  ```bash Bash theme={null}
  node --require ./opentelemetry.cjs index.js
  ```
</CodeGroup>

Mettez à jour votre fichier `package.json` pour ajouter `--require` à la commande qui démarre votre application.

<CodeGroup>
  ```json JSON theme={null}
  {
    // other configuration...
    "scripts": {
      "server": "node --require ./opentelemetry.cjs index.js"
    }
  }
  ```
</CodeGroup>

Vous pouvez également utiliser le drapeau `--require` avec des outils tels que `ts-node` et `nodemon`.

Lorsque vous utilisez une CLI wrapper, telle que `nest start` ou `fastify start`, pour démarrer votre application, utilisez la variable d'environnement `NODE_OPTIONS` pour passer le drapeau à l'environnement d'exécution Node.js :

<CodeGroup>
  ```sh Shell theme={null}
  NODE_OPTIONS='--require ./appsignal.cjs' nest start
  ```
</CodeGroup>

## Testez l'application !

Maintenant que tous les composants sont connectés, démarrez votre application avec les arguments de ligne de commande requis et vérifiez si des données arrivent dans AppSignal. Consultez en particulier les pages [« Errors > Issue list »](https://appsignal.com/redirect-to/app?to=exceptions) et [« Performance > Traces »](https://appsignal.com/redirect-to/app?to=performance/traces).

Si après avoir suivi nos instructions d'installation vous ne voyez toujours pas de données dans AppSignal, [faites-le-nous savoir](mailto:support@appsignal.com?subject=OpenTelemetry%20issue) et nous vous aiderons à finaliser votre installation OpenTelemetry !