Intégration monitoring temporelle auto-hébergée

Notre intégration temporelle monitore les performances de vos données temporelles, vous aidant à diagnostiquer les problèmes dans vos applications distribuées en écriture, tolérantes aux pannes et évolutives. Notre intégration temporelle vous offre un dashboard prédéfini avec les métriques les plus importantes de votre application Temporal SDK.

A screenshot depicting the Temporal dashboard

Après avoir configuré l'intégration avec New Relic, visualisez vos données dans un dashboard comme celui-ci, dès la sortie de la boîte.

Installer l' agent d'infrastructure

Pour utiliser l’intégration temporelle, vous devez d’abord installer l’agent d’infrastructure sur le même hôte. L'agent infrastructure monitore l'hôte lui-même, tandis que l'intégration que vous installerez à l'étape suivante étend votre monitoring avec des données spécifiques au temps telles que la base de données et les métriques instance .

exposer les métriques temporelles

Les étapes suivantes exécuteront une instance locale du serveur temporaire à l'aide du fichier de configuration par défaut docker-compose.yml:

Si vous ne l'avez pas déjà, installez docker et docker-compose sur votre hôte :
bash
```
$sudo apt install docker
$sudo apt install docker-compose
```

Cloner le référentiel :

bash

$git clone https://github.com/temporalio/docker-compose.git

Changer de répertoire vers la racine du projet :
bash
```
$sudo nano docker-compose/docker-compose.yml
```
Ajoutez le point de terminaison et le port Prometheus au fichier docker-compose.yml .
```
Environment:
- PROMETHEUS_ENDPOINT=0.0.0.0:8000
ports:
- 8000:8000
```
Exécutez la commande docker-compose up pour créer votre instance :
bash
```
$sudo docker-compose up
```
Confirmez que votre instance fonctionne correctement sur les URL suivantes :
- Le serveur Temporel sera disponible le localhost:7233.
- L'UI Web temporelle sera disponible à l'adresse http://YOUR_DOMAIN:8080
- Les métriques du serveur temporel seront disponibles sur le http://YOUR_DOMAIN:8000/metrics

exposer les métriques du SDK Java

Vous allez maintenant exposer les métriques du client SDK que Prometheus va récupérer :

Créez un fichier MetricsWorker.java dans le dossier principal de votre projet :

//...
// You need to import the following packages to set up metrics in Java.
// See the Developer's guide for packages required for the other SDKs.
import com.sun.net.httpserver.HttpServer;
import com.uber.m3.tally.RootScopeBuilder;
import com.uber.m3.tally.Scope;
import com.uber.m3.util.Duration;
import com.uber.m3.util.ImmutableMap;

// See the Micrometer documentation for configuration details on other supported monitoring systems.
// This example shows how to set up the Prometheus registry and stats reported.

PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
StatsReporter reporter = new MicrometerClientStatsReporter(registry);

// set up a new scope, report every 10 seconds
    Scope scope = new RootScopeBuilder()
            .tags(ImmutableMap.of(
                        "workerCustomTag1",
                        "workerCustomTag1Value",
                        "workerCustomTag2",
                        "workerCustomTag2Value"))
            .reporter(reporter)
            .reportEvery(com.uber.m3.util.Duration.ofSeconds(10));

// For Prometheus collection, expose the scrape endpoint at port 8077. See Micrometer documentation for details on starting the Prometheus scrape endpoint. For example,
HttpServer scrapeEndpoint = MetricsUtils.startPrometheusScrapeEndpoint(registry, 8077); //note: MetricsUtils is a utility file with the scrape endpoint configuration. See Micrometer docs for details on this configuration.
// Stopping the starter stops the HTTP server that exposes the scrape endpoint.
//Runtime.getRuntime().addShutdownHook(new Thread(() -> scrapeEndpoint.stop(1)));

//Create Workflow service stubs to connect to the Frontend Service.
WorkflowServiceStubs service = WorkflowServiceStubs.newServiceStubs(
        WorkflowServiceStubsOptions.newBuilder()
                .setMetricsScope(scope) //set the metrics scope for the WorkflowServiceStubs
                .build());

//Create a Workflow service client, which can be used to start, signal, and query Workflow Executions.
WorkflowClient yourClient = WorkflowClient.newInstance(service,
        WorkflowClientOptions.newBuilder().build());

//...

Accédez à votre répertoire de projet et créez votre projet :
bash
```
$./gradlew build
```

Démarrer le travailleur :

bash

$./gradlew -q execute -PmainClass=<YOUR_METRICS_FILE>

Vérifiez vos métriques de travail sur le point de terminaison Prometheus Scrape exposé : http://YOUR_DOMAIN:8077/metrics.
Note
Pour plus d'informations sur la configuration des métriques du SDK, consultez la documentation officielle de Temporal.

Configurer NRI-Prometheus

Après une installation réussie, effectuez ces configurations NRI-Prometheus :

Créez un fichier nommé nri-prometheus-temporal-config.yml dans ce chemin :
bash
```
$cd /etc/newrelic-infra/integrations.d/
```

Voici un exemple de fichier de configuration. Assurez-vous de mettre à jour les URL d'espace réservé :

integrations:
- name: nri-prometheus
    config:
    standalone: false
    # Defaults to true. When standalone is set to `false`, `nri-prometheus` requires an infrastructure agent to send data.
    emitters: infra-sdk
    # When running with infrastructure agent emitters will have to include infra-sdk
    cluster_name: Temporal_Server_Metrics
    # Match the name of your cluster with the name seen in New Relic.
    targets:
        - description: Temporal_Server_Metrics
        urls: ["http://<YOUR_DOMAIN>:8000/metrics", "http://<YOUR_DOMAIN>:8077/metrics"]
    #    tls_config:
    #      ca_file_path: "/etc/etcd/etcd-client-ca.crt"
    #      cert_file_path: "/etc/etcd/etcd-client.crt"
    #      key_file_path: "/etc/etcd/etcd-client.key"
    verbose: false
    # Defaults to false. This determines whether or not the integration should run in verbose mode.
    audit: false
    # Defaults to false and does not include verbose mode. Audit mode logs the uncompressed data sent to New Relic and can lead to a high log volume.
    # scrape_timeout: "YOUR_TIMEOUT_DURATION"
    # `scrape_timeout` is not a mandatory configuration and defaults to 30s. The HTTP client timeout when fetching data from endpoints.
    scrape_duration: "5s"
    # worker_threads: 4
    # `worker_threads` is not a mandatory configuration and defaults to `4` for clusters with more than 400 endpoints. Slowly increase the worker thread until scrape time falls between the desired `scrape_duration`. Note: Increasing this value too much results in huge memory consumption if too many metrics are scraped at once.
    insecure_skip_verify: false
    # Defaults to false. Determins if the integration should skip TLS verification or not.
    timeout: 10s

Configurer le log temporel

Pour configurer le log temporel, suivez les étapes décrites ci-dessous.

Exécutez cette commande Docker pour vérifier l’état d’exécution du conteneur :
bash
```
$sudo docker ps
```
Copiez l'ID du conteneur pour le conteneur temporalio/UI et exécutez cette commande :
bash
```
$sudo docker logs -f <container_id> &> /tmp/temporal.log &
```
Vérifiez ensuite qu'il existe un fichier de log nommé temporal.log situé dans le répertoire /tmp/.

Transférer le log vers New Relic

Vous pouvez utiliser notre transfert de log pour transférer les logs temporels vers New Relic.

Sur les machines Linux, assurez-vous que votre fichier de log nommé logging.yml se trouve dans ce chemin :
bash
```
$cd /etc/newrelic-infra/logging.d/
```
Une fois que vous avez trouvé le fichier de log dans le chemin ci-dessus, incluez ce script dans le fichier logging.yml :
```
logs:
- name: temporal.log
    file: /tmp/temporal.log
    attributes:
    logtype: temporal_logs
```
Utilisez nos instructions pour redémarrer votre agent d'infrastructure:
bash
```
$sudo systemctl restart newrelic-infra.service
```
Attendez quelques minutes jusqu'à ce que les données commencent à arriver sur votre compte New Relic.

Trouvez vos données

Vous pouvez choisir notre modèle dashboard prédéfini nommé Temporal pour monitorer vos métriques temporelles. Suivez ces étapes pour utiliser notre modèle dashboard prédéfini :

De one.newrelic.com, allez sur la page + Integrations & Agents .
Cliquez sur Dashboards.
Dans la barre de recherche, tapez Temporal.
Lorsque le dashboard temporel apparaît, cliquez pour l'installer.
Votre temporel dashboard est considéré comme un dashboard personnalisé et peut être trouvé dans l'UI Dashboards. Pour obtenir des documents sur l'utilisation et la modification du dashboard, consultez notre documentation dashboard .
Voici une requête NRQL pour vérifier la somme de latence de la requête temporelle :
```
SELECT sum(temporal_request_latency_sum) FROM Metric WHERE scrapedTargetURL = 'http://<YOUR_DOMAIN>:8000/metrics'
```

Cette traduction automatique est fournie pour votre commodité.