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

# Comment utiliser getRecentPerformanceSamples

> Découvrez les cas d'utilisation, exemples de code, paramètres de requête, structure de réponse et astuces pour getRecentPerformanceSamples.

La méthode RPC [`getRecentPerformanceSamples`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentperformancesamples) fournit un instantané des performances récentes du réseau Solana. Elle renvoie une liste d'échantillons, pris environ toutes les 60 secondes, détaillant le nombre de transactions et de slots traités au cours de ces périodes. Ces données sont inestimables pour surveiller le débit et la santé du réseau. Pour plus de contexte sur les métriques de performance de Solana comme TPS et les temps des slots, vous pouvez lire le [guide Solana pour les entreprises](https://www.helius.dev/blog/solana-for-enterprise).

## Cas d'utilisation courants

* **Surveillance de la santé du réseau :** Suivez les taux de traitement des transactions et la production de slots pour évaluer la santé générale du réseau et identifier les éventuels engorgements ou ralentissements.
* **Analyse de performance :** Analysez les données de performance historiques pour comprendre le comportement du réseau dans différentes conditions.
* **Tableaux de bord :** Affichez les indicateurs clés de performance (KPI) comme les transactions par seconde (TPS) et les slots par minute sur les tableaux de bord de surveillance.
* **Planification de capacité :** Observez les tendances de charge du réseau pour éclairer les décisions de mise à l'échelle pour les applications ou l'infrastructure.

## Paramètres de la requête

1. **`limit`** (`usize`, optionnel) :
   * Le nombre d'échantillons de performance les plus récents à renvoyer.
   * Valeur maximale : `720` (représentant environ 12 heures de données, car les échantillons sont pris toutes les 60 secondes).
   * Si omis, le nœud RPC renverra un nombre par défaut d'échantillons (le défaut exact peut varier selon le fournisseur RPC).

## Structure de la réponse

Le champ `result` de la réponse JSON-RPC est un tableau d'objets d'échantillons de performance, renvoyés dans l'ordre chronologique inverse (échantillon le plus récent en premier). Chaque objet a la structure suivante :

* **`slot`** (`u64`) : Le numéro de slot dans lequel cet échantillon de performance a été enregistré.
* **`numTransactions`** (`u64`) : Le nombre total de transactions (y compris les transactions de vote et non-vote) traitées pendant le `samplePeriodSecs` menant à ce `slot`.
* **`numSlots`** (`u64`) : Le nombre de slots qui ont été traités pendant le `samplePeriodSecs` menant à ce `slot`.
* **`samplePeriodSecs`** (`u16`) : La durée, en secondes, pendant laquelle cet échantillon a été pris (typiquement `60`).
* **`numNonVoteTransactions`** (`u64`) : Le nombre de transactions qui n'étaient pas des transactions de vote de consensus, traitées pendant le `samplePeriodSecs`.

## Exemples

### 1. Obtenir les 5 derniers échantillons de performance

Cet exemple demande les cinq derniers échantillons de performance du réseau.

<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. Obtenir le nombre par défaut d'échantillons de performance

Cet exemple omet le paramètre `limit`, demandant le nombre par défaut d'échantillons du nœud RPC.

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

## Conseils pour les développeurs

* **Intervalle d'échantillonnage :** Les échantillons sont généralement pris toutes les 60 secondes, mais c'est une approximation. Le champ `samplePeriodSecs` dans la réponse indique la durée réelle de chaque échantillon.
* **Limite des données historiques :** Le maximum `limit` de 720 échantillons fournit une fenêtre d'environ 12 heures de données historiques. Pour une analyse de performance à long terme, l'enregistrement et l'agrégation des données externes sont nécessaires.
* **Transactions de vote vs non-vote :** `numTransactions` inclut toutes les transactions, tandis que `numNonVoteTransactions` compte spécifiquement celles qui ne font pas partie du processus de vote de consensus. Ces dernières sont souvent un meilleur indicateur de l'activité réseau initiée par les utilisateurs.
* **Variabilité du nœud :** Les données exactes peuvent varier légèrement d'un nœud RPC à l'autre en fonction de leur état de synchronisation et de leur vue locale du réseau lors de la prise d'un échantillon.

En utilisant `getRecentPerformanceSamples`, les développeurs et observateurs du réseau peuvent obtenir des insights précieux sur l'état opérationnel et le débit du réseau Solana.