Google Cloud fournit un agent de surveillance personnalisé qui collecte des métriques personnalisées à partir de SAP HANA et les envoie à Cloud Monitoring, une solution de surveillance intégrée à Google Cloud. Avec Cloud Monitoring, vous pouvez créer des tableaux de bord pour visualiser vos métriques SAP HANA et configurer des alertes en fonction de seuils de métriques. Pour en savoir plus, consultez la documentation de Cloud Monitoring.
Pour obtenir une description des métriques SAP HANA collectées par la version 1 de l'agent de surveillance, consultez la section Métriques et requêtes par défaut dans la version 1.0.
Prérequis
Dans ce guide, nous partons du principe que vous avez déployé SAP HANA sur Google Cloud à l'aide de la méthode décrite dans le guide de déploiement de SAP HANA.
Définir les rôles IAM requis
Par défaut, l'agent de surveillance utilise le compte de service par défaut de votre instance de machine virtuelle (VM) Compute Engine. Ce compte de service permet aux binaires exécutés sur l'instance de VM d'écrire des métriques dans Cloud Monitoring.
Si vous choisissez d'utiliser un autre compte de service, vous devez ajouter manuellement le rôle IAM qui fournit ces autorisations à ce dernier.
Pour ajouter le rôle IAM requis au compte de service :
Accédez à la page IAM et administration de la console.
Sélectionnez le projet et cliquez sur Continuer.
Identifiez le compte de service auquel vous souhaitez ajouter un rôle.
- Si ce compte de service ne figure pas déjà sur la liste des comptes principaux, cela signifie qu'aucun rôle ne lui a encore été attribué. Cliquez sur Ajouter un compte principal, puis saisissez l'adresse e-mail du compte de service.
- Si le compte de service figure déjà sur la liste des comptes principaux, il possède des rôles. Cliquez sur la liste déroulante des rôles actuels pour le compte de service que vous souhaitez modifier.
Sélectionnez Monitoring > Rédacteur de métriques Monitoring dans la liste des rôles disponibles.
Cliquez sur Ajouter ou sur Enregistrer pour appliquer le ou les rôles sélectionnés au compte de service.
Installer l'agent
Choisir un emplacement de déploiement
L'agent de surveillance peut être exécuté directement sur un ou plusieurs nœuds de votre installation SAP HANA, ou indirectement en tant que service sur une autre instance de VM. Choisissez l'emplacement de déploiement en fonction de votre cas d'utilisation.
Télécharger et installer l'agent
Pour télécharger et installer l'agent :
- Établissez une connexion SSH avec votre instance de VM SAP HANA.
Téléchargez et exécutez le script d'installation :
sudo curl https://storage.googleapis.com/gcm-ext/gcm_install.sh | bash -x
Lorsque vous exécutez la commande précédente, le script d'installation effectue les opérations suivantes :Il crée les répertoires suivants :
/usr/local/lib/gcm
, qui contiendra le binaire de l'agent./etc/gcm.d
, qui contiendra les requêtes que l'agent doit exécuter./var/spool/gcm
, qui contient les métriques récemment collectées par l'agent et envoyées à terme par celui-ci à Cloud Monitoring. Une fois les métriques envoyées, elles sont supprimées de/var/spool/gcm
.
Il télécharge la dernière version de l'agent et l'enregistre dans
/usr/local/lib/gcm/
.Il crée un lien symbolique vers le binaire dans
/usr/local/bin/gcm
.Il crée un modèle de configuration de base,
/etc/default/gcm
.Il crée un fichier de configuration de daemon,
/etc/systemd/system/gcm.service
.Il actualise les définitions de service
systemd
.Il active l'agent de surveillance en tant que daemon.
Mettre à jour l'agent
Rechercher une nouvelle version de l'agent
Vérifiez la version de l'agent actuellement installé à l'aide de la commande suivante :
gcm --version
Vérifiez si une mise à jour est disponible à l'aide de la commande suivante :
curl https://storage.googleapis.com/gcm-ext/LATEST
Télécharger et mettre à jour l'agent
Pour mettre à jour l'agent lorsqu'une nouvelle version est disponible, procédez comme suit :
Arrêtez le processus de l'agent à l'aide de la commande suivante :
sudo systemctl stop gcm
Mettez à jour l'agent à l'aide de la commande ci-dessous. Les options
-C
et-U
permettent d'éviterla création du fichier de configuration par défaut et de la définition du service Linux systemd pour l'agent :sudo curl https://storage.googleapis.com/gcm-ext/gcm_install.sh | bash -s -- -C -U
Démarrez l'agent :
sudo systemctl start gcm
Configurer l'agent
Une fois que vous avez exécuté le script d'installation, configurez les instances de VM que l'agent surveillera et, éventuellement, les requêtes qu'il exécutera sur votre base de données.
Définir le fichier de configuration
Lorsque vous avez exécuté le script d'installation, celui-ci a créé un fichier de modèle de configuration à l'emplacement suivant :
/etc/default/gcm
À l'aide du fichier de configuration, vous pouvez configurer l'agent pour interroger SAP HANA sur une ou plusieurs instances de VM. Pour chaque instance de VM que vous souhaitez surveiller :
- Ajoutez une définition d'instance de VM dans le fichier de configuration sous
instances
. Pour chaque instance, définissez le nom, l'hôte, le port, l'utilisateur et le mot de passe. - Pour permettre à l'agent de collecter des métriques à partir de cette instance de VM, ajoutez le nom de cette dernière sous
enabled_instances
.
Définissez les attributs dans la configuration en utilisant le format suivant :
--- config: timestamps_in_output: no debug_messages: yes skip_default_queries: yes queries_directory: /etc/gcm.d spool_directory: /var/spool/gcm enabled_instances: - [INSTANCE_NAME] - [INSTANCE_NAME_2] project_id: [PROJECT_ID] instances: - name: [INSTANCE_NAME] host: [INSTANCE_IP] port: [PORT_NUMBER] user: [DB_USERNAME] password: [YOUR_PASSWORD] type: [INSTANCE_TYPE] - name: [INSTANCE_NAME_2] host: [INSTANCE_IP_2] ...
Les attributs suivants sont obligatoires dans le fichier de configuration :
[PROJECT_ID]
: ID du projet Google Cloud qui contient les instances de VM à surveiller. Indiquez un seul ID de projet.[INSTANCE_NAME]
: nom de l'instance de VM Compute Engine que vous souhaitez surveiller.[INSTANCE_IP]
: adresse IP interne ou externe de l'instance de VM Compute Engine que vous souhaitez surveiller. Nous recommandons d'utiliser si possible des adresses IP internes, car elles nécessitent moins d'opérations de configuration que les adresses IP externes, et elles sont privées et sécurisées par défaut.[DB_USERNAME]
: utilisateur de la base de données SAP HANA que vous souhaitez utiliser.[PORT_NUMBER]
: numéro de port de la base de données SAP HANA. Généralement, le numéro de port est39015
pour SAP HANA Express ou30015
pour SAP HANA Platform Edition.[YOUR_PASSWORD]
: mot de passe de l'utilisateur de la base de données.[INSTANCE_TYPE]
: saisissezsap_hana
pour ce champ.
Vous pouvez éventuellement configurer l'agent à l'aide des options suivantes. Ces options de paramètres doivent être définies avant l'élément config
:
timestamps_in_output
(booléen) : si vous exécutez l'agent en tant que daemon soussystemd
, définissez cette option surno
, carsystemd
fournit des horodatages. La valeur par défaut estno
.debug_messages
(booléen) : si cette option est définie, l'agent affiche des messages de débogage. La valeur par défaut estyes
.skip_default_queries
(booléen) : si cette option est définie, l'agent ignore l'ensemble de requêtes par défaut. Cela n'affecte pas les requêtes définies par l'utilisateur. La valeur par défaut estno
.queries_directory
(chaîne) : répertoire dans lequel rechercher les requêtes définies par l'utilisateur. La valeur par défaut est/etc/gcm.d
.spool_directory
(chaîne) : répertoire dans lequel collecter les métriques spoulées. La valeur par défaut est/var/spool/gcm
.
Définir des requêtes personnalisées
Par défaut, l'agent collecte un ensemble de métriques par défaut à partir de votre base de données SAP HANA. Pour obtenir une description de ces métriques, ainsi que des requêtes qui les génèrent, consultez la section Métriques et requêtes par défaut dans la version 1.0.
Vous pouvez ajouter des requêtes supplémentaires en créant un ou plusieurs fichiers YAML personnalisés dans le répertoire suivant :
/etc/gcm.d
Voici un exemple de fichier de requête :
- root: by_component type: sap_hana description: | Amount of memory (in MiB) used by service components query: | SELECT HOST AS "host", COMPONENT AS "component", SUM(USED_MEMORY_SIZE)/1024/1024 AS "mem_used_mb" FROM M_SERVICE_COMPONENT_MEMORY GROUP BY HOST, COMPONENT; columns: - type: LABEL value_type: STRING name: host - type: LABEL value_type: STRING name: component - type: GAUGE description: Amount of memory (in MiB) used by the service component value_type: DOUBLE name: mem_used_mb
Chaque fichier YAML comprend un ou plusieurs éléments représentant les résultats d'une requête SQL donnée dans les métriques de votre base de données SAP HANA. Chaque élément est doté des attributs suivants :
root
: espace de noms descriptif pour un groupe de métriques donné.query
: requête SQL.columns
: type de données, type de valeur et nom de colonne pour chaque champ de la requête.type
: indique comment les données sont transmises à Cloud Monitoring. Vous pouvez définirtype
surLABEL
, qui indique qu'il s'agit d'un en-tête de colonne, ou surGAUGE,
, l'un des types de métriques définis dans l'énumérationMetricKind
de l'API Cloud Monitoring. Actuellement,GAUGE
est le seul type de métrique accepté par l'agent.value_type
: type de valeur de la métrique. La valeur de ce paramètre peut être l'un des types définis dans l'énumérationValueType
de l'API Cloud Monitoring.name
: nom de la colonne.
Pour obtenir la liste complète des vues système mises à disposition par SAP HANA à des fins d'interrogation, consultez la page SAP HANA SQL and System Views Reference.
Les résultats de la requête sont limités à 1 000 enregistrements. Utilisez des fonctions d'agrégation SQL telles que SUM, AVG, COUNT, MIN et MAX pour limiter le nombre d'enregistrements renvoyés.
Effectuer des opérations de base
Cette section explique comment effectuer des opérations de base avec l'agent de surveillance SAP HANA. Pour obtenir la liste complète des options configurables, exécutez la commande gcm --help
.
Gérer le daemon de l'agent de surveillance
Lorsque vous avez exécuté le script d'installation, le programme d'installation a créé un fichier d'unité systemd
pour l'agent, vous permettant ainsi de gérer ce dernier à l'aide des commandes systemctl
standards. Les commandes suivantes démarrent l'agent, l'arrêtent et interrogent son état, respectivement :
sudo systemctl start gcm
sudo systemctl stop gcm
sudo systemctl status gcm
Pour lire les journaux générés par systemctl
, interrogez le contenu du journal systemd
à l'aide de la commande suivante :
sudo journalctl -u gcm
Pour voir les dernières lignes consignées, vous pouvez ajouter l'option -f
qui fonctionne comme un "pipe" établissant un chaînage avec tail -f
:
sudo journalctl -u gcm -f
Supprimer les requêtes par défaut
Par défaut, l'agent exécute ses requêtes par défaut en plus des requêtes personnalisées que vous avez définies. Vous pouvez désactiver cet ensemble de requêtes par défaut en définissant l'option skip_default_queries
sur yes
dans votre fichier de configuration ou en définissant l'option --no-defaults
lorsque vous exécutez l'outil manuellement. Pour en savoir plus, consultez la section Définir le fichier de configuration.
Collecter et envoyer manuellement des métriques
Pour vérifier que l'agent fonctionne comme prévu, vous pouvez exécuter manuellement des commandes permettant d'exécuter vos requêtes, de collecter les métriques obtenues, puis de les envoyer à Cloud Monitoring. Pour exécuter vos requêtes et collecter les métriques obtenues une seule fois, exécutez la commande suivante :
sudo gcm gather
Cette commande envoie également les métriques collectées à Cloud Monitoring.
Afficher vos métriques dans Cloud Monitoring
Procédez comme suit pour afficher les métriques recueillies par Cloud Monitoring dans vos propres graphiques et tableaux de bord :
Dans la console, accédez à la page Surveillance.
Sélectionnez Tableaux de bord > Créer un tableau de bord.
Cliquez sur Ajouter un graphique.
Dans le menu Type de ressource, sélectionnez Métriques personnalisées.
Dans le menu Métrique, sélectionnez by_component/mem_used_mb. Conservez les valeurs par défaut dans les autres champs. Vous voyez les données du graphique dans la section "Aperçu" du panneau.
Cliquez sur Enregistrer.
Vous disposez maintenant d'un tableau de bord simple qui affiche les métriques en temps réel de votre instance ou de vos instances de VM SAP HANA.
Dépannage
Les requêtes par défaut échouent
Assurez-vous que l'utilisateur de la base de données SAP HANA a accès aux vues système SAP HANA suivantes :
M_CS_ALL_COLUMNS
M_CS_TABLES
M_EXPENSIVE_STATEMENTS
M_HOST_RESOURCE_UTILIZATION
M_SERVICE_COMPONENT_MEMORY
M_SERVICE_MEMORY
Les métriques ne sont pas envoyées à Cloud Monitoring
Assurez-vous que votre compte de service Google Cloud est autorisé à écrire des métriques dans Cloud Monitoring. Pour en savoir plus, consultez la section Définir les rôles IAM requis.
Assistance
Pour les problèmes liés à l'infrastructure ou aux services Google Cloud, contactez l'assistance Customer Care. Ses coordonnées sont disponibles sur la page de présentation de l'assistance dans Google Cloud Console. Si l'assistance Customer Care détecte un problème dans vos systèmes SAP, vous serez redirigé vers l'assistance SAP.
Pour les problèmes liés au produit SAP, entrez votre demande d'assistance avec l'outil de l'assistance SAP. SAP évalue la demande d'assistance et, s'il semble s'agir d'un problème d'infrastructure Google Cloud, la transfère au composant Google Cloud BC-OP-LNX-GOOGLE ou BC-OP-NT-GOOGLE.
Exigences liées à l'assistance
Pour bénéficier d'une assistance pour les systèmes SAP ainsi que pour l'infrastructure et les services Google Cloud que ces systèmes utilisent, vous devez satisfaire aux exigences minimales de la formule d'assistance.
Pour en savoir plus sur les exigences minimales concernant l'assistance pour SAP sur Google Cloud, consultez les ressources suivantes :
- Obtenir de l'aide concernant SAP sur Google Cloud
- Note SAP 2456406 (compte utilisateur SAP requis)
Métriques et requêtes par défaut dans la version 1.0
Cette section décrit les métriques collectées par défaut par la version 1.0 de l'agent de surveillance pour SAP HANA, ainsi que les requêtes utilisées par l'agent pour collecter ces métriques.
Mémoire totale utilisée par les services
Métrique | Description |
---|---|
instance/mem_used_mb | Quantité de mémoire du pool de mémoire (en Mio) en cours d'utilisation par tous les services |
instance/resident_mem_used_mb | Quantité totale de mémoire (en Mio) utilisée par tous les services |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
SUM(TOTAL_MEMORY_USED_SIZE)/1024/1024 AS "mem_used_mb",
SUM(PHYSICAL_MEMORY_SIZE)/1024/1024 AS "resident_mem_used_mb"
FROM M_SERVICE_MEMORY;
Quantité totale de mémoire utilisée par toutes les tables de colonne
Métrique dans Cloud Monitoring | Description |
---|---|
instance/table_mem_used_mb | Quantité totale de mémoire (en Mio) utilisée (taille des mémoires principale, delta et historique cumulées) par toutes les tables de colonne |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
SUM(MEMORY_SIZE_IN_TOTAL)/1024/1024 AS "table_mem_used_mb"
FROM M_CS_TABLES;
Ressources utilisées par l'hôte
Métrique | Description |
---|---|
by_server/mem_available_percent | Quantité de mémoire disponible pour les processus (en Mio) |
by_server/mem_total_mb | Quantité totale de mémoire (en Mio) sur le serveur |
by_server/mem_available_mb | Mémoire physique disponible (en Mio) sur l'hôte |
by_server/mem_used_mb | Mémoire physique utilisée (en Mio) sur l'hôte |
by_server/swap_avail_mb | Mémoire d'échange disponible (en Mio) sur l'hôte |
by_server/swap_used_mb | Mémoire d'échange utilisée (en Mio) sur l'hôte |
by_server/instance_mem_used_mb | Quantité du pool de mémoire (en Mio) utilisée par les processus d'instance |
by_server/peak_instance_mem_used_mb | Quantité maximale du pool de mémoire (en Mio) ayant été utilisée par les processus d'instance |
by_server/instance_mem_pool_size_mb | Taille du pool de mémoire (en Mio) pour tous les processus d'instance |
by_server/instance_code_size_mb | Taille du code (en Mio), y compris les bibliothèques partagées des processus d'instance |
by_server/instance_shared_size_mb | Taille de la mémoire partagée des processus d'instance |
by_server/cpu_user_time_msec | Temps CPU passé (en ms) en mode utilisateur |
by_server/cpu_sys_time_msec | Temps CPU passé (en ms) en mode noyau |
by_server/cpu_wait_io_time_msec | Temps CPU passé (en ms) en attente E/S |
by_server/cpu_idle_time_msec | Temps CPU d'inactivité (en ms) |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
HOST AS "host",
FREE_PHYSICAL_MEMORY/(FREE_PHYSICAL_MEMORY + USED_PHYSICAL_MEMORY)*100 AS "mem_available_percent",
(FREE_PHYSICAL_MEMORY + USED_PHYSICAL_MEMORY)/1024/1024 AS "mem_total_mb",
FREE_PHYSICAL_MEMORY/1024/1024 AS "mem_available_mb",
USED_PHYSICAL_MEMORY/1024/1024 AS "mem_used_mb",
FREE_SWAP_SPACE/1024/1024 AS "swap_avail_mb",
USED_SWAP_SPACE/1024/1024 AS "swap_used_mb",
INSTANCE_TOTAL_MEMORY_USED_SIZE/1024/1024 AS "instance_mem_used_mb",
INSTANCE_TOTAL_MEMORY_PEAK_USED_SIZE/1024/1024 AS "peak_instance_mem_used_mb",
INSTANCE_TOTAL_MEMORY_ALLOCATED_SIZE/1024/1024 AS "instance_mem_pool_size_mb",
INSTANCE_CODE_SIZE/1024/1024 AS "instance_code_size_mb",
INSTANCE_SHARED_MEMORY_ALLOCATED_SIZE/1024/1024 AS "instance_shared_size_mb",
TOTAL_CPU_USER_TIME AS "cpu_user_time_msec",
TOTAL_CPU_SYSTEM_TIME AS "cpu_sys_time_msec",
TOTAL_CPU_WIO_TIME AS "cpu_wait_io_time_msec",
TOTAL_CPU_IDLE_TIME AS "cpu_idle_time_msec"
FROM M_HOST_RESOURCE_UTILIZATION;
Quantité de mémoire utilisée par les composants du service
Métrique | Description |
---|---|
by_component/mem_used_mb | Quantité de mémoire du pool de mémoire (en Mio) en cours d'utilisation |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
HOST AS "host",
COMPONENT AS "component",
SUM(USED_MEMORY_SIZE)/1024/1024 AS "mem_used_mb"
FROM M_SERVICE_COMPONENT_MEMORY
GROUP BY HOST, COMPONENT;
Mémoire utilisée par les services
Métrique | Description |
---|---|
by_service/mem_used_mb | Taille de la mémoire virtuelle (en Mio) |
by_service/virtual_mem_used_mb | Taille de la mémoire physique (en Mio) |
by_service/resident_mem_used_mb | Taille du code (en Mio), y compris les bibliothèques partagées |
by_service/code_size_mb | Taille de la pile (en Mio) |
by_service/stack_size_mb | Segments de mémoire du pool de mémoire (en Mio) |
by_service/heap_mem_allocated_mb | Quantité de segments de mémoire du pool en cours d'utilisation (en Mio) |
by_service/shared_mem_allocated_mb | Mémoire partagée du pool de mémoire (en Mio) |
by_service/shared_mem_used | Quantité de mémoire partagée du pool en cours d'utilisation (en Mio) |
by_service/compactors_allocated_mb | Partie du pool de mémoire (en Mio) pouvant être éventuellement libérée en cas de manque de mémoire |
by_service/compactors_freeable_mb | Mémoire pouvant être actuellement libérée (en Mio) en cas de manque de mémoire |
by_service/max_mem_pool_size_mb | Taille maximale du pool de mémoire configuré (en Mio) |
by_service/effective_max_mem_pool_size_mb | Taille maximale effective du pool de mémoire (en Mio) |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
HOST AS "host",
PORT AS "port",
SERVICE_NAME AS "service",
TOTAL_MEMORY_USED_SIZE/1024/1024 AS "mem_used_mb",
LOGICAL_MEMORY_SIZE/1024/1024 AS "virtual_mem_used_mb",
PHYSICAL_MEMORY_SIZE/1024/1024 AS "resident_mem_used_mb",
CODE_SIZE/1024/1024 AS "code_size_mb",
STACK_SIZE/1024/1024 AS "stack_size_mb",
HEAP_MEMORY_ALLOCATED_SIZE/1024/1024 AS "heap_mem_allocated_mb",
HEAP_MEMORY_USED_SIZE/1024/1024 AS "heap_mem_used_mb",
SHARED_MEMORY_ALLOCATED_SIZE/1024/1024 AS "shared_mem_allocated_mb",
SHARED_MEMORY_USED_SIZE/1024/1024 AS "shared_mem_used",
COMPACTORS_ALLOCATED_SIZE/1024/1024 AS "compactors_allocated_mb",
COMPACTORS_FREEABLE_SIZE/1024/1024 AS "compactors_freeable_mb",
ALLOCATION_LIMIT/1024/1024 AS "max_mem_pool_size_mb",
EFFECTIVE_ALLOCATION_LIMIT/1024/1024 AS "effective_max_mem_pool_size_mb"
FROM M_SERVICE_MEMORY;
Données d'exécution pour les tables de colonne par schéma
Métrique | Description |
---|---|
by_schema/mem_total_mb | Mémoire totale utilisée (en Mio) par les partie principale, delta et historique |
by_schema/mem_main_mb | Consommation actuelle de mémoire (en Mio) dans la partie principale |
by_schema/mem_delta_mb | Consommation actuelle de mémoire (en Mio) dans la partie delta |
by_schema/mem_hist_main_mb | Consommation actuelle de mémoire (en Mio) dans la partie historique/principale |
by_schema/mem_hist_detla_mb | Consommation actuelle de mémoire (en Mio) dans la partie historique/delta |
by_schema/est_max_mem_total_mb | Estimation de la consommation de mémoire maximale (en Mio) |
by_schema/records | Nombre d'enregistrements |
by_schema/records_main | Nombre d'enregistrements dans la partie principale des tables du schéma |
by_schema/records_delta | Nombre d'enregistrements dans la partie delta des tables du schéma |
by_schema/records_hist_main | Nombre d'enregistrements dans la partie historique/principale des tables du schéma |
by_schema/records_hist_delta | Nombre d'enregistrements dans la partie historique/delta des tables du schéma |
by_schema/last_compressed_record_count | Nombre d'entrées dans la partie principale lors de la dernière compression optimisée |
by_schema/reads | Nombre d'accès en lecture |
by_schema/writes | Nombre d'accès en écriture |
by_schema/merges | Nombre de fusions delta |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
HOST AS "host",
PORT AS "port",
SCHEMA_NAME AS "schema",
SUM(MEMORY_SIZE_IN_TOTAL)/1024/1024 AS "mem_total_mb",
SUM(MEMORY_SIZE_IN_MAIN)/1024/1024 AS "mem_main_mb",
SUM(MEMORY_SIZE_IN_DELTA)/1024/1024 AS "mem_delta_mb",
SUM(MEMORY_SIZE_IN_HISTORY_MAIN)/1024/1024 AS "mem_hist_main_mb",
SUM(MEMORY_SIZE_IN_HISTORY_DELTA)/1024/1024 AS "mem_hist_delta_mb",
SUM(ESTIMATED_MAX_MEMORY_SIZE_IN_TOTAL)/1024/1024 AS "est_max_mem_total_mb",
SUM(RECORD_COUNT) AS "records",
SUM(RAW_RECORD_COUNT_IN_MAIN) AS "records_main",
SUM(RAW_RECORD_COUNT_IN_DELTA) AS "records_delta",
SUM(RAW_RECORD_COUNT_IN_HISTORY_MAIN) AS "records_hist_main",
SUM(RAW_RECORD_COUNT_IN_HISTORY_DELTA) AS "records_hist_delta",
SUM(LAST_COMPRESSED_RECORD_COUNT) AS "last_compressed_record_count",
SUM(READ_COUNT) AS "reads",
SUM(WRITE_COUNT) AS "writes",
SUM(MERGE_COUNT) AS "merges"
FROM M_CS_TABLES
GROUP BY HOST, PORT, SCHEMA_NAME;
Instructions dont la durée est supérieure au seuil configuré par l'instance
Métrique | Description |
---|---|
expensive_statements/duration_msec | Temps écoulé (en ms) pendant l'exécution de l'instruction |
expensive_statements/records | Nombre d'enregistrements |
expensive_statements/lock_waits | Nombre cumulé d'appels de la méthode lock.wait() |
expensive_statements/lock_duration_msec | Durée cumulée des appels de la méthode lock.wait() (en ms) |
expensive_statements/cpu_time_msec | Temps CPU (en ms) utilisé pour calculer l'instruction |
L'agent de surveillance de Google pour SAP HANA exécute la requête suivante pour recueillir les métriques ci-dessus à partir de SAP HANA :
SELECT
HOST AS "host",
PORT AS "port",
CONNECTION_ID AS "connection_id",
TRANSACTION_ID AS "transaction_id",
STATEMENT_HASH AS "statement_hash",
DB_USER AS "db_user",
SCHEMA_NAME AS "schema",
APP_USER AS "app_user",
ERROR_CODE AS "error_code",
DURATION_MICROSEC/1000 AS "duration_msec",
RECORDS AS "records",
LOCK_WAIT_COUNT AS "lock_waits",
LOCK_WAIT_DURATION/1000 AS "lock_duration_msec",
CPU_TIME/1000 AS "cpu_time_msec"
FROM M_EXPENSIVE_STATEMENTS;
Étapes suivantes
- Découvrez la version 2 de l'agent de surveillance pour SAP HANA.
- Obtenez davantage d'informations sur Cloud Monitoring.