> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Acheminez les métriques Auth0 vers des plateformes de surveillance comme Datadog, New Relic et Splunk pour une observabilité en temps réel.
# Metric Streams
# Metric Streams (bêta)
Metric Streams est actuellement offert en bêta. Pour utiliser cette fonctionnalité, vous devez avoir un forfait Enterprise. En utilisant cette fonctionnalité, vous acceptez les conditions d’essai gratuit applicables énoncées dans le [Master Subscription Agreement](https://www.okta.com/legal) d’Okta. Pour en savoir plus sur le cycle de lancement des produits d’Auth0, consultez [les étapes de lancement du produit](https://auth0.com/docs/troubleshoot/product-lifecycle/product-release-stages).
Diffusez en continu les métriques Auth0 en temps réel vers votre plateforme de surveillance afin de suivre les performances de l’API, de repérer les problèmes liés aux limites de débit et de résoudre les erreurs plus rapidement. Metric Streams prend en charge à la fois l’intégration native de Datadog et le protocole OpenTelemetry (OTLP) pour des plateformes comme New Relic et Splunk.
## Ce que vous pouvez surveiller
Suivez des métriques clés liées à l’utilisation de votre API Auth0 :
* **Volume de requêtes API** : Surveillez le nombre total de requêtes adressées aux API d’authentification et de gestion d’Auth0.
* **Taux d’erreur** : Repérez les erreurs côté client et côté serveur qui affectent votre intégration.
* **Occurrences de limites de débit** : Détectez quand votre application atteint ses limites de débit.
* **Répartition géographique** : Analysez les tendances du trafic par pays.
* **Flux d’authentification** : Suivez les types d’octroi et l’utilisation des connexions.
## Cas d’utilisation
### Repérer les problèmes de limites de débit
Surveillez les API et les points de terminaison qui atteignent les limites de débit afin d’ajuster votre intégration ou de passer à un niveau de limite de débit supérieur.
### Diagnostiquer les échecs de l’API
Repérez rapidement la cause première des erreurs en filtrant les métriques par API, opération et type d’échec (limites de débit, détection d’anomalies ou erreurs générales).
### Capacité du forfait
Analysez les pics d’utilisation, le RPS moyen et les métriques de percentile afin de déterminer le palier de limite de débit approprié pour votre charge de travail.
## Prérequis
Avant de configurer un flux de métriques, vous devez disposer des éléments suivants :
* **accès à l’Auth0 Management API** : créez une application machine-to-machine (M2M) avec les permissions suivantes :
* `read:event_streams`
* `create:event_streams`
* `update:event_streams`
* `delete:event_streams`
* `read:event_deliveries`
* `update:event_deliveries`
Pour obtenir des instructions détaillées, consultez [Obtenir des jetons d’accès à la Management API](docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production).
* **Auth0 CLI** : installez [Auth0 CLI](https://auth0.github.io/auth0-cli/) pour configurer les flux de métriques à l’aide de commandes d’API.
* **compte sur une plateforme de surveillance** : un compte actif auprès de l’une des [destinations prises en charge](#supported-destinations).
## Référence des métriques
### auth0.api\_request.count
Calcule le nombre de requêtes d’API vers votre tenant Auth0 à l’aide de balises de filtrage et d’agrégation détaillées. Une nouvelle métrique est émise toutes les 10 secondes et offre une granularité d’une seconde.
#### Balises disponibles
| Nom de la balise | Obligatoire | Description |
| ------------------ | ----------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `api` | Oui | Type d’API : `AUTHENTICATION` ou `MANAGEMENT` |
| `operation_name` | Oui | Méthode HTTP et chemin (p. ex., `POST /oauth/token`) |
| `operation_result` | Oui | Résultat : `SUCCESS` ou `FAILURE` |
| `tenant` | Oui | Nom de votre tenant Auth0 |
| `failure_code` | Non | Motif de l’échec : `RATE_LIMIT`, `ANOMALY_DETECTION` ou `CLIENT_SERVER_ERROR` |
| `country_code` | Non | Code de pays ISO associé à l’adresse IP de la requête |
| `client_id` | Non | Client ID de l’application (Authentication API seulement) |
| `connection_id` | Non | ID de la connexion (Authentication API seulement) |
| `grant_type` | Non | Type de grant OAuth 2.0 (Authentication API seulement) |
| `batch_seq` | Oui | Numéro de séquence pour les métriques ayant les mêmes balises et le même horodatage (temporaire, sera supprimé après la bêta) |
Les balises `client_id` et `connection_id` peuvent générer une cardinalité élevée dans les environnements comptant un grand nombre de clients ou de connexions uniques, ce qui risque d’augmenter les coûts de surveillance. Utilisez ces balises avec discernement.
Metric Streams n’inclut pas les appels d’API mis en cache ou bloqués par le Web Application Firewall (WAF) d’Auth0 en périphérie afin d’éviter une surcharge du système.
#### Valeurs d’énumération
**api**
* `AUTHENTICATION` - requêtes de l’Authentication API
* `MANAGEMENT` - requêtes de la Management API
**operation\_result**
* `SUCCESS` - Requête traitée avec succès
* `FAILURE` - La requête a échoué en raison d’une erreur côté client ou côté serveur
**failure\_code** (présent uniquement lorsque `operation_result` est `FAILURE`)
* `RATE_LIMIT` - La requête a dépassé la limite de débit
* `ANOMALY_DETECTION` - Bloqué par la protection contre les attaques d’Auth0
* `CLIENT_SERVER_ERROR` - Erreur HTTP 4xx ou 5xx
## Destinations prises en charge
Metric Streams prend en charge les plateformes de surveillance suivantes :
Intégration native à l’API de métriques de Datadog
Diffusion via OpenTelemetry Protocol (OTLP)
Diffusion via OpenTelemetry Protocol (OTLP)
## Configurer Datadog
Transmettez directement les métriques Auth0 à Datadog au moyen de son API de métriques native.
### Prérequis
* Compte [Datadog](https://www.datadoghq.com/) actif
* Clé d’API Datadog (générez-la dans **Paramètres de l’organisation > Clés API** dans Datadog)
* Votre site Datadog (identifiant de région, comme `US1` pour app.datadoghq.com, `EU` pour app.datadoghq.eu, `US3` pour us3.datadoghq.com)
### Créer un flux de métriques
**Accéder à Metric Streams :**
1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) > **Monitoring** > **Metric Streams**.
2. Sélectionnez **+ Create Metric Stream**.
3. Sélectionnez **Datadog**.
**Configurer le flux :**
1. **Name**: Entrez un nom descriptif (p. ex., `datadog-production`).
2. **Datadog Site**: Sélectionnez votre région Datadog dans la liste déroulante :
* `US1` pour app.datadoghq.com
* `US3` pour us3.datadoghq.com
* `US5` pour us5.datadoghq.com
* `EU` pour app.datadoghq.eu
* `AP1` pour ap1.datadoghq.com
3. **Datadog API Key**: Collez votre clé API Datadog.
4. Sélectionnez **Save**.
Cette opération crée votre flux de métriques et l’active automatiquement.
Utilisez l’Auth0 CLI pour créer un flux de métriques Datadog :
```bash theme={null}
auth0 api post metric-streams \
--data '{
"name": "datadog-production",
"subscriptions": [{ "metric_type": "auth0.api_request.count" }],
"destination": {
"type": "datadog",
"configuration": {
"api_key": "YOUR_DATADOG_API_KEY",
"site": "app.datadoghq.com"
}
}
}'
```
**Réponse :**
```json theme={null}
{
"id": "mst_abc123xyz",
"status": "enabled",
"name": "datadog-production",
"created_at": "2024-02-12T10:30:00Z",
"updated_at": "2024-02-12T10:30:00Z",
"destination": {
"type": "datadog",
"configuration": {
"api_key": "***",
"site": "app.datadoghq.com"
}
}
}
```
Conservez la valeur `id` pour gérer ce flux plus tard.
### Vérifiez dans Datadog
En quelques minutes, les métriques d’Auth0 apparaissent dans Datadog. Accédez à **Metrics > Explorer** et recherchez `auth0.api_request.count` pour afficher vos données.
### Gérer les flux
**Afficher tous les flux :**
1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) > **Monitoring** > **Metric Streams**.
2. Tous les flux configurés sont répertoriés avec leur **Destination**, **Status**, **Name** et **Subscriptions**.
**Modifier un flux :**
1. Sélectionnez le nom du flux dans la liste.
2. Mettez la configuration à jour.
3. Sélectionnez **Save**.
**Activer ou désactiver un flux :**
1. Utilisez le commutateur dans la colonne **Status** pour activer ou désactiver le flux.
2. Les flux désactivés cessent d’envoyer des métriques, mais conservent leur configuration.
**Supprimer un flux :**
1. Sélectionnez le nom du flux dans la liste.
2. Sélectionnez **Delete** au bas de la page de configuration.
3. Confirmez la suppression.
**Lister tous les flux :**
```bash theme={null}
auth0 api get /api/v2/metric-streams
```
**Désactiver un flux :**
```bash theme={null}
auth0 api patch /api/v2/metric-streams/YOUR_STREAM_ID \
--data '{"status":"disabled"}'
```
**Réactiver un flux :**
```bash theme={null}
auth0 api patch /api/v2/metric-streams/YOUR_STREAM_ID \
--data '{"status":"enabled"}'
```
## Configurer New Relic
Transmettez les métriques Auth0 à New Relic à l’aide d’OpenTelemetry Protocol (OTLP).
### Obtenir les identifiants New Relic
Consultez la [documentation OTLP de New Relic](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp/#configure-endpoint-port-protocol) pour trouver le point de terminaison propre à votre région :
* **US :** `https://otlp.nr-data.net`
* **EU :** `https://otlp.eu01.nr-data.net`
Enregistrez l’URL de ce point de terminaison.
1. Allez dans **\[votre menu utilisateur]** > **API Keys**.
2. Sélectionnez **Create a key**.
3. Sélectionnez **Key Type** = **Ingest - License**.
4. Entrez un nom descriptif et une note facultative.
5. Sélectionnez **Create a key**.
6. Copiez la clé API immédiatement. Vous en aurez besoin pour les étapes suivantes, et elle ne sera plus affichée par la suite.
### Créer un flux de métriques
**Accédez à Metric Streams :**
1. Dans [Auth0 Dashboard](https://manage.auth0.com), allez à **Monitoring** > **Metric Streams**.
2. Sélectionnez **+ Create Metric Stream**.
3. Sélectionnez **OpenTelemetry**.
**Configurer le flux :**
1. **Name** : Saisissez un nom descriptif (p. ex., `newrelic-production`).
2. **Protocol** : Sélectionnez **HTTP** dans la liste déroulante.
3. **OTLP Endpoint** : Collez votre point de terminaison OTLP New Relic (p. ex., `https://otlp.nr-data.net`).
4. **Authentication Method** : Sélectionnez **API Key** dans la liste déroulante.
5. **Header Name** : Saisissez `api-key`.
6. **API Key** : Collez votre clé de licence d’ingestion New Relic que vous avez copiée aux étapes précédentes.
7. Sélectionnez **Save**.
Cette opération crée votre flux de métriques et l’active automatiquement.
```bash theme={null}
auth0 api post metric-streams \
--data '{
"name": "newrelic-production",
"subscriptions": [{ "metric_type": "metrics_bridge.api_request" }],
"destination": {
"type": "otlp",
"configuration": {
"endpoint": "YOUR_NEW_RELIC_ENDPOINT",
"protocol": "http",
"auth_type": "api_key",
"api_key": "YOUR_INGEST_LICENSE_KEY",
"auth_header_name": "api-key"
}
}
}'
```
## Configurer Splunk
Transmettez les métriques Auth0 vers Splunk Observability Cloud à l’aide d’OpenTelemetry Protocol (OTLP).
### Obtenir les identifiants Splunk
Consultez la [documentation de l’exportateur HTTP OTLP de Splunk](https://help.splunk.com/en/splunk-observability-cloud/manage-data/splunk-distribution-of-the-opentelemetry-collector/get-started-with-the-splunk-distribution-of-the-opentelemetry-collector/collector-components/exporters/otlphttp-exporter) pour trouver votre point de terminaison.
Le format du point de terminaison est :
```
https://ingest..signalfx.com/v2/datapoint/otlp
```
Remplacez `` par votre realm Splunk (p. ex. : `us1`, `eu0`, `jp0`).
1. Accédez à **Settings** > **Jetons d’accès** > **Nouveau jeton**.
2. Saisissez un nom descriptif.
3. Réglez **Portée d’autorisation** sur **INGEST** (obligatoire).
4. Définissez l’expiration du jeton.
5. Sélectionnez **Créer**.
6. Copiez la valeur du jeton et conservez-la en lieu sûr. Vous en aurez besoin aux étapes suivantes.
### Créer un flux de métriques
**Accédez à Metric Streams :**
1. Allez dans [Auth0 Dashboard](https://manage.auth0.com) > **Monitoring** > **Metric Streams**.
2. Sélectionnez **+ Create Metric Stream**.
3. Sélectionnez **OpenTelemetry**.
**Configurer le flux :**
1. **Name** : Entrez un nom descriptif (p. ex., `splunk-production`).
2. **Protocol** : Sélectionnez **HTTP** dans la liste déroulante.
3. **OTLP Endpoint** : Collez votre point de terminaison OTLP Splunk (p. ex., `https://ingest.us1.signalfx.com/v2/datapoint/otlp`).
4. **Authentication Method** : Sélectionnez **API Key** dans la liste déroulante.
5. **Header Name** : Entrez `X-SF-TOKEN`.
6. **API Key** : Collez votre jeton d’accès Splunk (de l’étape 2 ci-dessus).
7. Sélectionnez **Save**.
Le flux de métriques est créé et activé automatiquement.
```bash theme={null}
auth0 api post metric-streams \
--data '{
"name": "splunk-production",
"subscriptions": [{ "metric_type": "metrics_bridge.api_request" }],
"destination": {
"type": "otlp",
"configuration": {
"endpoint": "YOUR_SPLUNK_ENDPOINT",
"protocol": "http",
"auth_type": "api_key",
"api_key": "YOUR_SPLUNK_ACCESS_TOKEN",
"auth_header_name": "X-SF-TOKEN"
}
}
}'
```
## Comprendre la cardinalité des métriques
La cardinalité correspond au nombre de séries chronologiques uniques générées par vos métriques. Plus la cardinalité est élevée, plus les coûts de monitoring augmentent.
| Balise | Cardinalité | Impact |
| ------------------ | ---------------- | ----------------------------------------------- |
| `api` | Faible | 2 valeurs uniques (Authentication, Management) |
| `operation_name` | Moyenne | Varie selon les opérations d’API utilisées |
| `operation_result` | Faible | 2 valeurs uniques (Success, Failure) |
| `tenant` | Moyenne | 1 par tenant Auth0 |
| `failure_code` | Faible | 3 valeurs uniques (uniquement en cas d’échec) |
| `country_code` | Moyenne à élevée | Varie selon la répartition géographique |
| `client_id` | **Élevée** | 1 par application cliente |
| `connection_id` | **Élevée** | 1 par connexion de fournisseur d’identité |
| `grant_type` | Faible | Nombre limité de types d’autorisation OAuth 2.0 |
| `batch_seq` | Faible | Balise temporaire (retirée après la Beta) |
Utilisez les balises `client_id` et `connection_id` avec prudence. Dans les environnements qui comptent de nombreuses applications ou connexions, ces balises peuvent faire augmenter considérablement les coûts. Envisagez de filtrer certains clients ou d’agréger ces balises si une granularité détaillée n’est pas nécessaire.
## Dépannage
### Les métriques n’apparaissent pas
**Vérifiez le statut du stream :**
1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) > **Monitoring** > **Metric Streams**.
2. Repérez votre flux de métriques dans la liste.
3. Vérifiez que la colonne **Status** affiche **Enabled**.
4. Sélectionnez le nom du stream pour afficher la configuration détaillée et vérifier les paramètres.
```bash theme={null}
auth0 api get /api/v2/metric-streams/YOUR_STREAM_ID
```
Vérifiez que le champ `status` est `enabled`.
**Vérifiez les identifiants de la destination :**
* **Datadog** : Confirmez que votre clé API est valide et que l’URL du site correspond à votre région Datadog
* **Destinations OTLP** : Vérifiez que l’URL du endpoint, le jeton d’authentification et le nom de l’en-tête sont corrects
**Vérifiez la mise en cache à la périphérie :**
N’oubliez pas que les requêtes mises en cache et les requêtes bloquées par le WAF ne sont pas incluses dans les flux de métriques.
### Coûts de surveillance élevés
Si vous constatez des coûts anormalement élevés :
1. Vérifiez quelles balises vous utilisez dans les requêtes et les tableaux de bord.
2. Envisagez de retirer `client_id` et `connection_id` des agrégations.
3. Utilisez l’échantillonnage ou le filtrage dans votre plateforme de surveillance pour réduire le volume de métriques ingérées.
4. Regroupez les données à l’aide de balises de niveau supérieur comme `api` et `operation_result` plutôt qu’avec des balises granulaires.