> ## 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.

# OpenTelemetry-Installation für Node.js

Stellen Sie sicher, dass Sie [den AppSignal Collector installieren](/opentelemetry/installation), bevor Sie mit diesen Anweisungen fortfahren.

## Die OpenTelemetry-Pakete installieren

Verwenden Sie npm, um das OpenTelemetry-SDK und den OTLP-Exporter zu den Abhängigkeiten Ihrer Anwendung hinzuzufügen:

<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>

Das Paket `@opentelemetry/auto-instrumentations-node` instrumentiert die meisten Anwendungen und Bibliotheken automatisch. In der [README des Pakets finden Sie eine Liste der Bibliotheken und Frameworks, die es instrumentiert](https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node). Sie können [zusätzliche Instrumentierungen für Bibliotheken und Frameworks im OpenTelemetry Registry finden](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=js\&flag=all).

## OpenTelemetry in Ihrer Anwendung konfigurieren

Fügen Sie diese Datei `opentelemetry.cjs` mit der OpenTelemetry-Exporter- und AppSignal-Konfiguration zu Ihrer Anwendung hinzu.

Stellen Sie sicher, dass Sie die folgenden Werte mit Ihrem AppSignal-Anwendungsnamen, der Umgebung und dem Push API-Schlüssel aktualisieren und den Exporter-Endpunkt durch die Adresse Ihres AppSignal Collectors ersetzen, falls erforderlich.

<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>

## Ihre Anwendung mit OpenTelemetry starten

Um Ihre Anwendung mit OpenTelemetry auszuführen, müssen Sie die Option `--require` verwenden, um die Datei `opentelemetry.cjs` vor dem Start Ihrer Anwendung zu laden:

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

Aktualisieren Sie Ihre `package.json`-Datei, um `--require` zu dem Befehl hinzuzufügen, der Ihre App startet.

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

Sie können die Option `--require` auch mit Tools wie `ts-node` und `nodemon` verwenden.

Wenn Sie eine Wrapper-CLI wie `nest start` oder `fastify start` zum Starten Ihrer Anwendung verwenden, verwenden Sie die Umgebungsvariable `NODE_OPTIONS`, um die Option an die Node.js-Laufzeit zu übergeben:

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

## Die App testen!

Nachdem nun alle Komponenten verbunden sind, starten Sie Ihre App mit den erforderlichen Befehlszeilenargumenten und testen Sie, ob Daten in AppSignal eintreffen. Überprüfen Sie insbesondere die Seiten [„Errors > Issue list"](https://appsignal.com/redirect-to/app?to=exceptions) und [„Performance > Traces"](https://appsignal.com/redirect-to/app?to=performance/traces).

Wenn Sie nach dem Befolgen unserer Installationsanweisungen immer noch keine Daten in AppSignal sehen, [lassen Sie es uns wissen](mailto:support@appsignal.com?subject=OpenTelemetry%20issue), und wir helfen Ihnen, Ihre OpenTelemetry-Installation abzuschließen!