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

# How to Use getRecentPerformanceSamples

> Erfahren Sie mehr über Anwendungsfälle, Codebeispiele, Anfrageparameter, Antwortstruktur und Tipps zu getRecentPerformanceSamples.

Die [`getRecentPerformanceSamples`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentperformancesamples) RPC-Methode bietet einen Snapshot der aktuellen Leistung des Solana-Netzwerks. Sie gibt eine Liste von Samples zurück, die ungefähr alle 60 Sekunden aufgenommen werden und die Anzahl der in diesen Perioden verarbeiteten Transaktionen und Slots detaillieren. Diese Daten sind von unschätzbarem Wert für die Überwachung des Netzwerkdurchsatzes und der Gesundheit. Für mehr Kontext zu den Leistungsmetriken von Solana wie TPS und Slotzeiten können Sie den [Solana für Unternehmen Leitfaden](https://www.helius.dev/blog/solana-for-enterprise) lesen.

## Häufige Anwendungsfälle

* **Überwachung der Netzwerkgesundheit:** Verfolgen Sie die Transaktionsverarbeitungsraten und die Slotproduktion, um die allgemeine Netzwerkgesundheit zu bewerten und mögliche Engpässe oder Verlangsamungen zu identifizieren.
* **Leistungsanalyse:** Analysieren Sie historische Leistungsdaten, um das Netzwerkverhalten unter verschiedenen Bedingungen zu verstehen.
* **Dashboarding:** Anzeigen von Schlüsselkennzahlen (KPIs) wie Transaktionen pro Sekunde (TPS) und Slots pro Minute auf Überwachungs-Dashboards.
* **Kapazitätsplanung:** Beobachten Sie Trends in der Netzwerkauslastung, um Skalierungsentscheidungen für Anwendungen oder Infrastruktur zu treffen.

## Anfrageparameter

1. **`limit`** (`usize`, optional):
   * Die Anzahl der neuesten Leistungssamples, die zurückgegeben werden sollen.
   * Maximalwert: `720` (entspricht ungefähr 12 Stunden Daten, da Samples alle 60 Sekunden aufgenommen werden).
   * Wenn ausgelassen, gibt der RPC-Knoten eine Standardanzahl von Samples zurück (die genaue Standardeinstellung kann je nach RPC-Anbieter variieren).

## Antwortstruktur

Das `result`-Feld der JSON-RPC-Antwort ist ein Array von Leistungssample-Objekten, die in umgekehrter chronologischer Reihenfolge zurückgegeben werden (das neueste Sample zuerst). Jedes Objekt hat die folgende Struktur:

* **`slot`** (`u64`): Die Slotnummer, in der dieses Leistungssample aufgezeichnet wurde.
* **`numTransactions`** (`u64`): Die Gesamtanzahl der innerhalb des `samplePeriodSecs` verarbeiteten Transaktionen (einschließlich Abstimmungs- und Nicht-Abstimmungstransaktionen) bis zu diesem `slot`.
* **`numSlots`** (`u64`): Die Anzahl der Slots, die innerhalb des `samplePeriodSecs` bis zu diesem `slot` verarbeitet wurden.
* **`samplePeriodSecs`** (`u16`): Die Dauer in Sekunden, über die dieses Sample aufgenommen wurde (typisch `60`).
* **`numNonVoteTransactions`** (`u64`): Die Anzahl der Transaktionen, die keine Konsensabstimmungstransaktionen waren und innerhalb des `samplePeriodSecs` verarbeitet wurden.

## Beispiele

### 1. Abrufen der letzten 5 Leistungssamples

Dieses Beispiel fordert die fünf neuesten Leistungssamples vom Netzwerk an.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getRecentPerformanceSamples",
      "params": [5]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function fetchRecentPerformance() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const samples = await connection.getRecentPerformanceSamples(5);
      if (samples && samples.length > 0) {
        console.log(`Fetched ${samples.length} performance samples:`);
        samples.forEach((sample, index) => {
          console.log(`--- Sample ${index + 1} ---`);
          console.log(`  Slot: ${sample.slot}`);
          console.log(`  Number of Slots in Period: ${sample.numSlots}`);
          console.log(`  Total Transactions: ${sample.numTransactions}`);
          console.log(`  Non-Vote Transactions: ${sample.numNonVoteTransactions}`);
          console.log(`  Sample Period (seconds): ${sample.samplePeriodSecs}`);
          const tps = sample.numTransactions / sample.samplePeriodSecs;
          const nonVoteTps = sample.numNonVoteTransactions / sample.samplePeriodSecs;
          console.log(`  Average TPS (Total): ${tps.toFixed(2)}`);
          console.log(`  Average TPS (Non-Vote): ${nonVoteTps.toFixed(2)}`);
        });
      } else {
        console.log('No performance samples returned.');
      }
    } catch (error) {
      console.error('Error fetching recent performance samples:', error);
    }
  }

  fetchRecentPerformance();
  ```
</CodeGroup>

### 2. Abrufen der Standardanzahl von Leistungssamples

In diesem Beispiel wird der Parameter `limit` weggelassen und die Standardanzahl von Samples des RPC-Knotens angefordert.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getRecentPerformanceSamples"
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function fetchDefaultPerformanceSamples() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const samples = await connection.getRecentPerformanceSamples(); // No limit parameter
      if (samples && samples.length > 0) {
        console.log(`Fetched ${samples.length} (default) performance samples:`);
        // Process or log samples as needed - e.g., the first one
        const sample = samples[0];
        console.log(`--- Most Recent Sample ---`);
        console.log(`  Slot: ${sample.slot}`);
        console.log(`  Total Transactions: ${sample.numTransactions}`);
        console.log(`  Non-Vote Transactions: ${sample.numNonVoteTransactions}`);
        console.log(`  Slots in Period: ${sample.numSlots}`);
        console.log(`  Sample Period (seconds): ${sample.samplePeriodSecs}`);
      } else {
        console.log('No performance samples returned.');
      }
    } catch (error) {
      console.error('Error fetching default performance samples:', error);
    }
  }

  fetchDefaultPerformanceSamples();
  ```
</CodeGroup>

## Entwicklertipps

* **Abtastintervall:** Samples werden typischerweise alle 60 Sekunden aufgenommen, aber dies ist eine Annäherung. Das `samplePeriodSecs`-Feld in der Antwort gibt die tatsächliche Dauer für jedes Sample an.
* **Historische Datenlimitierung:** Der maximale `limit` von 720 Samples bietet ein Fenster von ungefähr 12 Stunden historischer Daten. Für eine langfristige Leistungsanalyse sind externes Datenlogging und Aggregation erforderlich.
* **Abstimmungs- vs. Nicht-Abstimmungstransaktionen:** `numTransactions` umfasst alle Transaktionen, während `numNonVoteTransactions` speziell die zählt, die nicht Teil des Konsensabstimmungsprozesses sind. Letzteres ist oft ein besserer Indikator für benutzergesteuerte Netzwerkaktivität.
* **Knotenvariabilität:** Die genauen Daten können leicht zwischen unterschiedlichen RPC-Knoten variieren, abhängig von ihrem Synchronisationsstatus und ihrer lokalen Sicht auf das Netzwerk, wenn ein Sample aufgenommen wird.

Durch die Nutzung von `getRecentPerformanceSamples` können Entwickler und Netzwerkbeobachter wertvolle Einblicke in den Betriebsstatus und den Durchsatz des Solana-Netzwerks gewinnen.